提供java介面

A. java 類 提供介面 什麼意思

這個介面並非java中interface,而是說提供調用方法，叫介面。比如B可以調用A，C又不能直接訪問A，那麼就可以通過B提供的方法訪問A了，這就叫介面，在現實中B叫介面人。

B. Java如何向外提供介面

java向外提供介面的話，我們公司中用的是springmvc，提供介面，然後介面的文檔使用swagger來生成的。

C. 給講講java介面的概念！

希望你仔細閱讀。對初學者來說，介面不是很好理解。我教過的學生也都提出過這個問題。

我們來看一個類

class A {
private int a;
public int getA() {
return a;
}
}

這個類的屬性是私有的，外界不能訪問，而外界可以通過公有方法來訪問這個類。我們說一個類的公有方法就是這個類的對外介面。通常

一個類的屬性都是私有的，方法大多是公有的。外界只能過個這些公有方法來訪問類。這也是Java封裝性的體現。如果一個類沒有公有屬性，

也沒有公有方法，這個類就是無法使用的類了。所以我們需要為一個類提供對外介面。
一個類中的方法，不只是說明了它要「做什麼」，而且方法的內容也說明了「怎麼做」。打個不太恰當的例子，一個殺人方法。從名字上

看，你知道了「做什麼」，但沒有辦法看到「怎麼做」。而方法的內容說明了「怎麼做」。

class killer {
private String name;
private int age;
private String phone;
private String addr;

......

public void kill(Person p) {
Qiang qiang = new Qiang("ak47");
qiang.fire(p);
}
}

這個類的kill方法內容說明了殺人的過程。如果你不想用這種方式殺人。因為你很BT，你想用毒葯殺人。那麼這個類的內容就需要改。但

是，還有很多其它的「客戶」，需要用不同的方式殺人。怎麼辦呢？一個很好的辦法就是，我們只定義「做什麼」，而不定義「怎麼做」。

interface Killer {
public void kill(Person p);
}

介面說明了「做什麼」，而實現這個介面的類，也就是實現類需要說明「怎麼做」。

class Killer1 implements Killer {
public void kill(Person p) {
Qiang qiang = new Qiang("ak47");
qiang.fire(p);
}
}

class Killer2 implements Killer {
public void kill(Person p) {
Bane bane = new Bane();
p.eat(bane);
}
}

public class Test {
public static void main(String[] args) {
Killer jingKe = new Killer1();
Person yingZheng = new Person();
jingKe.kill(yingZheng);
}
}

介面可以把「做什麼」和「怎麼做」分離開來。這給Java帶來了很多好處。雖然代碼量增加了，可我們的程序的可維護性加強了。我們的程序是可以拆分的。就象電腦一樣，可以拆分成很多組件。我一直在想，如果我的MP3耳機可以拆分就好了，那樣在耳機只壞掉一個的時候就不用重新買一個了。
不過上面的例子看不到什麼太大的好處。你可能會說，如果你

的目的是為了不修改代碼，那麼，如果我想使用Killer2來完成任務，還是需要修改main方法為：Killer jingKe = new Killer2();。沒有錯，

不過你可以通過一個工廠來完成上面的任務。也就是說，不通過new語句來獲得Killer對象，而是通過工廠來獲得Killer對象。

public class KillerFactory {
public static killer getKiller() {
return new Killer1();
}

public static Killer getKiller(String path) throws Exception {
Properties prop = new Properties();
prop.load(new FileInputStream(path));
String className = prop.getProperty("killer");
Class clazz = Class.forName(className);
return (Killer)clazz.newInstance();
}
}

代碼確實增加了很多，可是這對後期的系統維修和系統升級帶來了很多好處。

水龍頭與出水管的關系，我們需要把水龍頭安裝到出水管上。如果有一天我們需要更換水龍頭時，只需要把老的水龍頭拆卸下來，把新的

水龍頭安裝到出水管上既可。如果水龍頭與出水管是一體的，就是無法拆卸的怎麼辦呢？或是說出水管只能安裝水龍頭，而不能安裝淋浴器，

這就使我們生活很不方便。我們可以理解為出水管的連接方法，連接的對象是「出水設備」，而這個「出水設備」是一個介面。而水龍頭與淋

浴器都是這個介面的實現類。但是介面在哪裡呢？它長什麼樣子？我們沒看到。它是一個標准，連接處的內徑與外徑。螺絲摳的密度等。這就

和你的電腦上為什麼可以連接USB設備一樣。如果電腦和某一個USB設備電焊到一起，那麼其它的USB設備就無法使用了。電腦使用的是實現了

USB介面的電子設備，而我們的U盤、MP3、移動硬碟及滑鼠都是USB介面的實現類。
用Java寫出來的程序也和我們現實生活中的設備一樣。如電腦，我們希望電腦的所有部件都可以更換，如果主板上的內存插槽與內存條不

附。我們說，內存條沒有實現某某介面。Java是完全面向對象的，而面向對象是我們最為熟悉的東東。面向對象並不簡單，而是我們太熟悉它

了。所以我們學習Java會很方便。在現實社會中，所有的標准到了Java中都是介面。一盒香煙多少支煙，煙的長度等都是標准。一個光碟的大

小。Java中的JDBC就是一個標准，而各大資料庫廠商及第三方廠商實現了這一標准。JDBC只說明了目的，沒有說明怎麼完成的目的。
面向對象就在我們眼前，不過我們有時不太注意它。希望你在今後學習Java時，多與現實社會聯系。這樣可以有利與你的理解。
代碼量加大了，但對後期的維護與升級提供了方便。軟體公司賣給客戶的是class文件，而不是java文件。如果你的客戶需要更換Killer對

象，只需修改資源文件既可。

下面我們來看一個定時器類。現在什麼都是自動化的，如空調、電視、洗衣機等等。都要用到定時器這個類。對了，還有定時炸彈也要用

它。那我們可不可以只寫一個定時器類，應用到所有的需要定時器的設備上呢？答案是肯定的，我們需要這個類。
好了，我們來分析一下定時器需要完成什麼工作吧。定時器應該有啟動、停止方法。定時器啟動之後，每過一定時間就執行某個動作。其

中時間間隔為long型，而要執行的動作可能是輸出一個字元串，也可能是列印作業。具體要干什麼由使用定時器的用戶來完成。而定義定時器

時，根本就不知道要干什麼。

public class Timmer {
private long time;
private Action action;

public Timmer() {}

public Timmer(long time, Action action) {
this.time = time;
this.action = action;
}

public void start() {
state = START;
if(th == null) {
th = new Thread() {
public void run() {
while(state == START) {
try {
Thread.sleep(time);
action.action();
} catch(Exception e) {
}
}
}
};
}
th.start();
}

public void stop() {
state = STOP;
}

public void setTime(long time) {
this.time = time;
}

public void setAction(Action action) {
this.action = action;
}

public long getTime() {
return (this.time);
}

public Action getAction() {
return (this.action);
}
}

Action是一個介面，它只有一個方法，就是要完成的任務。我們在定時器啟動時調用這個介面的方法。而這個Action介面的對象，代表一

個動作，這個動作就是用戶要完成的動作。

public interface Action {
public void action();
}

public static void main(String[] args) {
Timer t = new Timer(2000, new Action() {
public void action() {
System.out.println("Hello World!");
}
});
t.start();
javax.swing.JOptionPane.showMessageDialog(null, "點擊確定按鈕停止定時器");
t.stop();
System.exit(0);
}

這是一個典型的回調方法例子。在AWT中，java使用了大量的監聽器。這些監聽器都是回調方法。在XML解析器SAX中，也使用了回調方法來解析XML文檔。

介面要比抽象類還要抽象。抽象類需要子類繼承，而Java是單繼承，所以抽象類被限制了。而介面不同，一個類可以實現多個介面。好比人類與程序員類之間的關系。可以說程序員是人類的子類，如果程序員是一個介面。用人類的子類來實現它就會更好。這個子類還可以去實現會計介面、音樂家介面等等。

在struts2.0、spring、hibernate等框架中，都大量使用介面。我們關心的是某個介面與另一個介面之間的關系。而不關心某個實現類與另一個介面實現類的關系。在客觀世界中，我們交談時都大量使用介面，只是我們沒有注意罷了。如：我公司需要一個程序員(一個實現了程序員介面的對象)。上課時，講師有一台計算機，用白板筆在白板上寫字(計算機是介面，白板及白板筆也是介面)。講師希望學生能學會所有的知識(講師及學生都是介面)。

就說這么多了，還有什麼不明白可以與我聯系。QQ:51038648

我在北京中科院計算所培訓中心做兼職java講師。我的經驗是，要想學好Java，一定要多打代碼、吃透代碼。如果不勤奮，就一定學不好。看來你是剛剛開始學習Java，你後面的路還很長，而且不是很好走。

D. Java中介面到底是什麼，老是聽到什麼你給我提供一個介面之類的話語。

我們知道介面裡面是沒有實際的東西的，也就是說他沒有任何實際價值，可是他一直存在，那麼就一定有他存在的原因。
你可以這么理解，你想一下，插銷和插座，真的有存在的價值嗎？不就是兩根線接一起嘛，為什麼要插銷和插座？但是沒有能行嗎？顯然不行，為什麼不行？因為接線費勁，有一個統一的標准，只要大家都按照同一個標准來設計電線頭子，那麼接線的時候一定能通電，對吧！介面的價值也一樣，定義了介面就是為了制定規范的，所以說實現介面的時候強制要求實現介面方法，因為那是標准，你生產的是插座，就一定要帶倆插孔，不然你就不是插座了。同樣的，我說我生產的插座好，我的插座不光帶倆插孔，還帶花的，那沒人管了。所以說實現類裡面必須實現介面方法，之後還可以跟帶花的插座一樣，可以拓展他自己獨有的東西。
明白介面的價值了嗎？

其實介面就是一個標准別人說讓你提供一個介面，就是讓你提供一個標准，讓他知道他該以一個什麼樣的格式來調用你的方法。這樣他就可以在你方法還沒寫完的時候就可以寫他自己的代碼了，他只需要按照這個標准來調用你的方法就可以了，你也同樣按照這個標准來寫，你倆可以一起寫，寫完了就直接可以用，不然的話他要等你寫完了之後才能開始自己的工作，豈不是很浪費時間嗎

E. java 介面怎麼用應該怎麼實現

java語言不支持一個類有多個直接的父類(多繼承),但可以實現（implements）多個介面,間接的實現了多繼承
用法public class test implements 介面名稱
當類實現了某個Java介面時,它必須實現介面中的所有抽象方法,否則這個類必須聲明為抽象的

比較抽象類與介面
1, 抽象類與介面都位於繼承樹的上層
相同點
1, 代表系統的抽象層,當一個系統使用一顆繼承樹上的類時,應該盡量把引用變數聲明為繼承樹的上層抽象類型,這樣可以提高兩個系統之間的送耦合
2, 都不能被實例化
3, 都包含抽象方法,這些抽象方法用於描述系統能提供哪些服務,但不提供具體的實現
不同點:
1, 在抽象類中可以為部分方法提供默認的實現,從而避免在子類中重復實現它們,這是抽象類的優勢,但這一優勢限制了多繼承,而介面中只能包含抽象方法.由於在抽象類中允許加入具體方法,因此擴展抽象類的功能,即向抽象類中添加具體方法,不會對它的子類造成影響,而對於介面,一旦介面被公布,就必須非常穩定,因為隨意在介面中添加抽象方法,會影響到所有的實現類,這些實現類要麼實現新增的抽象方法,要麼聲明為抽象類
2, 一個類只能繼承一個直接的父類,這個父類可能是抽象類,但一個類可以實現多個介面,這是介面的優勢,但這一優勢是以不允許為任何方法提供實現作為代價的三, 為什麼Java語言不允許多重繼承呢?當子類覆蓋父類的實例方法或隱藏父類的成員變數及靜態方法時,Java虛擬機採用不同的綁定規則,假如還允許一個類有多個直接的父類,那麼會使綁定規則更加復雜,
因此,為了簡化系統結構設計和動態綁定機制,Java語言禁止多重繼承.而介面中只有抽象方法,沒有實例變數和靜態方法,只有介面的實現類才會實現介面的抽象方法(介面中的抽象方法是通過類來實現的),因此,一個類即使有多個介面,也不會增加Java虛擬機進行動態綁定的復雜度.因為Java虛擬機永遠不會把方法與介面綁定,而只會把方法與它的實現類綁定.四, 使用介面和抽象類的總體原則:
1, 用介面作為系統與外界交互的窗口站在外界使用者(另一個系統)的角度,介面向使用者承諾系統能提供哪些服務,站在系統本身的角度,介面制定系統必須實現哪些服務,介面是系統中最高層次的抽象類型.通過介面交互可以提高兩個系統之間的送耦合系統A通過系統B進行交互,是指系統A訪問系統B時,把引用變數聲明為系統B中的介面類型,該引用變數引用系統B中介面的實現類的實例。
public interface B
{
}
public class C implements B
{
}
public class A
{
}
B a = new C();
2, Java介面本身必須非常穩定,Java介面一旦制定,就不允許隨遇更加,否則對外面使用者及系統本身造成影響
3, 用抽象類來定製系統中的擴展點
抽象類來完成部分實現,還要一些功能通過它的子類來實現

F. Java如何向外提供介面

publicstaticStringsendPostUrl(Stringurl,Stringparam,Stringcharset){

PrintWriterout=null;
BufferedReaderin=null;
Stringresult="";
try{
URLrealUrl=newURL(url);
//打開和URL之間的連接
URLConnectionconn=realUrl.openConnection();
//設置通用的請求屬性
conn.setRequestProperty("accept","*/*");
conn.setRequestProperty("connection","Keep-Alive");
conn.setRequestProperty("user-agent","Mozilla/4.0(compatible;MSIE6.0;WindowsNT5.1;SV1)");
//發送POST請求必須設置如下兩行
conn.setDoOutput(true);
conn.setDoInput(true);
//獲取URLConnection對象對應的輸出流
out=newPrintWriter(conn.getOutputStream());
//發送請求參數
out.print(param);
//flush輸出流的緩沖
out.flush();
//定義BufferedReader輸入流來讀取URL的響應
in=newBufferedReader(newInputStreamReader(conn.getInputStream(),charset));
Stringline;
while((line=in.readLine())!=null){
result+=line;
}
}catch(Exceptione){
System.out.println("發送POST請求出現異常！"+e);
e.printStackTrace();
}
//使用finally塊來關閉輸出流、輸入流
finally{
try{
if(out!=null){
out.close();
}
if(in!=null){
in.close();
}
}catch(IOExceptionex){
ex.printStackTrace();
}
}
returnresult;
}

G. java 介面

[編輯本段]什麼是介面
Java中的介面是一系列方法的聲明，是一些方法特徵的集合，一個介面只有方法的特徵沒有方法的實現，因此這些方法可以在不同的地方被不同的類實現，而這些實現可以具有不同的行為(功能)。
介面的兩種含義：一，Java介面，Java語言中存在的結構，有特定的語法和結構;二，一個類所具有的方法的特徵集合，是一種邏輯上的抽象。前者叫做「Java介面」，後者叫做「介面」。
在Java語言規范中，一個方法的特徵僅包括方法的名字，參數的數目和種類，而不包括方法的返回類型，參數的名字以及所拋出來的異常。在Java編譯器檢查方法的重載時，會根據這些條件判斷兩個方法是否是重載方法。但在Java編譯器檢查方法的置換時，則會進一步檢查兩個方法(分處超類型和子類型)的返還類型和拋出的異常是否相同。
介面繼承和實現繼承的規則不同，一個類只有一個直接父類，但可以實現多個介面。
Java介面本身沒有任何實現，因為Java介面不涉及表象，而只描述public行為，所以Java介面比Java抽象類更抽象化。
Java介面的方法只能是抽象的和公開的，Java介面不能有構造器，Java介面可以有public，靜態的和final屬性。
介面把方法的特徵和方法的實現分割開來。這種分割體現在介面常常代表一個角色，它包裝與該角色相關的操作和屬性，而實現這個介面的類便是扮演這個角色的演員。一個角色由不同的演員來演，而不同的演員之間除了扮演一個共同的角色之外，並不要求其它的共同之處。
[編輯本段]為什麼使用介面
兩個類中的兩個類似的功能，調用他們的類動態的決定一種實現，那他們提供一個抽象父類，子類分別實現父類所定義的方法。
問題的出現：Java是一種單繼承的語言，一般情況下，哪個具體類可能已經有了一個超類，解決是給它的父類加父類，或者給它父類的父類加父類，只到移動到類等級結構的最頂端。這樣一來，對一個具體類的可插入性的設計，就變成了對整個等級結構中所有類的修改。
介面是可插入性的保證。
在一個等級結構中的任何一個類都可以實現一個介面，這個介面會影響到此類的所有子類，但不會影響到此類的任何超類。此類將不得不實現這個介面所規定的方法，而其子類可以從此類自動繼承這些方法，當然也可以選擇置換掉所有的這些方法，或者其中的某一些方法，這時候，這些子類具有了可插入性(並且可以用這個介面類型裝載，傳遞實現了他的所有子類)。
我們關心的不是那一個具體的類，而是這個類是否實現了我們需要的介面。
介面提供了關聯以及方法調用上的可插入性，軟體系統的規模越大，生命周期越長，介面使得軟體系統的靈活性和可擴展性，可插入性方面得到保證。
類型
使用Java介面將軟體單位與內部和外部耦合起來。使用Java介面不是具體的類進行變數的類型聲明，方法的返還類型聲明，參量的類型聲明，以及數據類型的轉換。
在理想的情況下，一個具體的Java類應當只實現Java介面和抽象Java類中聲明的方法，而不應當給多餘方法。
類型等級結構
Java介面(以及抽象類)一般用來作為一個類型的等級結構的起點。
如果一個類已經有了一個主要的超類型，那麼通過實現一個介面，這個類可以擁有另一個次要的超類型，這種次要的超類型叫做混合類型。
[編輯本段]Java介面常用方法
單方法介面
以下是引用片段：
public interface Actionlistener{
public abstract void actionPerformed(ActionEvent event);
}
僅且只有一個方法，只有實現了這個介面(重寫這個介面中的唯一一個方法)，你才有資格去事件監聽器列表裡注冊(參數為Actionlistener類型)，當事件源變動時，自動調用這個唯一的actionPerformed方法.
標識介面
是沒有任何方法和屬性的介面。標識介面不對實現它的類有任何語意上的要求，它僅僅表明了實現它的類屬於一個特定的類型(傳遞)。
不推薦過多的使用標識介面。
常量介面
用Java介面來聲明一些常量，然後由實現這個介面的類使用這些常量(以前在做畫板的時候這么干過)。建議不要模仿這種常量介面的做法。

H. Java中的介面怎麼實現

舉個面積的例子：在java中，定義一個介面，聲明計算長方形面積和周長的抽象方法，再用一個類去實現這個介面，再編寫一個測試類去使用這個介面。首先，介面必須單獨存放，如果我們用eclipse編程的話，它們提示：The public type **** must be defined in its own file，意思是必須要定義在其自己的文件中，所以要為介面文件單獨存放起來，舉例，我們的介面要實現獲到矩形的長，寬，面積，周長，所以定義以下的介面。public interface calrect {x0dx0apublic abstract int calarea();x0dx0apublic abstract int calgirth();x0dx0apublic abstract int getx();x0dx0apublic abstract int gety();x0dx0a}注意，定義介面就像定義類一樣，介面的訪問控制符只能用public，用public定義的介面可以被所有的類和包引用，而預設的則只能被同一個包中的其他類和介面引用，這符合JAVA中訪問控制符的一般要求，關於介面再引用其他介面則是後話。以上介面文件名為calrect.java.另外需要指出的是介面中不能給方法給出方法體。接下來，需要定義一個類來實現介面，因為不知道JAVA的內置矩形類是什麼名，所以為了安全，將該類定義為RRect，這可以認為是一種安全策略。關於implements，可以參考其他資料。該類引用了介面calrect，所以必須對calrect中的方法一一實現。//定義矩形類 應用介面class RRect implements calrect{private int x;x0dx0aprivate int y;public RRect (){x0dx0a x=3;y=4;x0dx0a}x0dx0apublic int calarea(){x0dx0a return x*y;x0dx0a}x0dx0apublic int calgirth(){x0dx0a return x*2+y*2;x0dx0a}x0dx0apublic int getx(){x0dx0a return x;x0dx0a}x0dx0apublic int gety(){x0dx0a return y;x0dx0a}x0dx0a}//接下來，定義一個測試類，所謂測試類，我理解為定義一個類，在其定義類RRect的對象，並驗證其中的方法，看看是不是可以正常使用//定義Class1類x0dx0apublic class Class1{x0dx0aRRect rect;x0dx0apublic static void main(String []args){x0dx0a RRect rect=new RRect();x0dx0a System.out.println("矩陣的長"+ rect.getx());x0dx0a System.out.println("矩陣的寬"+ rect.calarea());x0dx0a System.out.println("矩陣的面積"+ rect.calarea());x0dx0a System.out.println("矩形的周長 "+rect.calgirth());x0dx0a}x0dx0ax0dx0a}運行結果：矩陣的長3x0dx0a矩陣的寬12x0dx0a矩陣的面積12x0dx0a矩形的周長 14註：介面單存放，介面實現類和測試類可以存放在一個文件中

I. java給別人提供介面，介面安全怎麼保證

我們在開發過程中，肯定會有和第三方或者app端的介面調用。在調用的時候，下面的方法可以來防止非法鏈接或者惡意攻擊。

一、簽名

根據用戶名或者用戶id，結合用戶的ip或者設備號，生成一個token。在請求後台，後台獲取http的head中的token，校驗是否合法（和資料庫或者Redis中記錄的是否一致，在登錄或者初始化的時候，存入資料庫/redis）

在使用Base64方式的編碼後，Token字元串還是有20多位，有的時候還是嫌它長了。由於GUID本身就有128bit，在要求有良好的可讀性的前提下，很難進一步改進了。那我們如何產生更短的字元串呢？還有一種方式就是較少Token的長度，不用GUID，而採用一定長度的隨機數，例如64bit，再用Base64編碼表示：

varrnd =newRandom();
vartokenData =userIp+userId;
rnd.NextBytes(tokenData);
vartoken =Convert.ToBase64String(tokenData).TrimEnd('=');

由於這里只用了64bit，此時得到的字元串為Onh0h95n7nw的形式，長度要短一半。這樣就方便攜帶多了。但是這種方式是沒有唯一性保證的。不過用來作為身份認證的方式還是可以的（如網盤的提取碼）。

二、加密

客戶端和伺服器都保存一個秘鑰，每次傳輸都加密，服務端根據秘鑰解密。

客戶端：

1、設置一個key（和伺服器端相同）

2、根據上述key對請求進行某種加密（加密必須是可逆的，以便伺服器端解密）

3、發送請求給伺服器

伺服器端：

1、設置一個key

2、根據上述的key對請求進行解密（校驗成功就是「信任」的客戶端發來的數據，否則拒絕響應）

3、處理業務邏輯並產生結果

4、將結果反饋給客戶端

三、第三方支持

比如springsecurity－oauth

J. java中什麼是介面介面的作用是什麼

java介面：

1、Java語言中存在的結構，有特定的語法和結構。

2、Java語言中一個類所具有的方法的特徵集合，是一種邏輯上的抽象。

java介面作用：

1、利於代碼的規范

這樣做的目的一方面是為了給開發人員一個清晰的指示，告訴他們哪些業務需要實現；同時也能防止由於開發人員隨意命名而導致的命名不清晰和代碼混亂，影響開發效率。

2、有利於對代碼進行維護

可以一開始定義一個介面，把功能菜單放在介面里，然後定義類時實現這個介面，以後要換的話只不過是引用另一個類而已，這樣就達到維護、拓展的方便性。

3、保證代碼的安全和嚴密

一個好的程序一定符合高內聚低耦合的特徵，能夠讓系統的功能較好地實現，而不涉及任何具體的實現細節。這樣就比較安全、嚴密一些，這一思想一般在軟體開發中較為常見。

(10)提供java介面擴展閱讀：

關於java介面的使用規范：

1、介面中可以定義常量，不能定義變數，介面中的屬性都是全局靜態常量，介面中的常量必須在定義時指定初始值。

2、 介面中所有的方法都是抽象方法，介面中方法都會自動用public abstract 修飾，即介面中只有全局抽象方法。

3、 介面不能實例化，介面中不能有構造。

4、 介面之間可以通過extends實現繼承關系，一個介面可以繼承多個介面，但介面不能繼承類。

5、 介面的實現類必須實現介面的全部方法，否則必須定義為抽象類。

參考資料來源：網路：java介面