介面 - IT人

介面（核心）

轉自：https://blog.csdn.net/a584898/article/details/80637538

基本概念：在之前講解的類結構都包含有：普通屬性，常量（全域性常量），構造方法，抽象方法，但是如果說設計一個類的時候發現這個類的內部只存有全域性常量和抽象方法的話，則這個類就能將其定義為介面

介面就是全域性常量和抽象方法的集合，在java裡面使用interface關鍵字可以進行介面的定義

範例：定義介面

interface A{//定義的是介面
public static String MSG="HELLO WORLD";
public abstract void fun();
}

定義的關鍵字是有區別，但是其它的常量和抽象方法與之前沒有區別，但是對於介面也可以發現，裡面包含有抽象方法，所以一定無法直接使用關鍵字new進行介面物件的例項化，那麼介面的使用原則如下：

介面必須有子類，子類使用用implements進行介面實現，一個子類可以同時實現多個介面

**介面的子類（如果不是抽象類），則一定要重寫介面之中的全部抽象方法；

介面物件可以利用子類的向上轉型，進行例項化操作**

範例：使用介面

package polymorphic;
interface Aaa{//定義的是介面
    public static String MSG="HELLO WORLD";
    public abstract void fun();//抽象方法
}
interface Bbb{
    public abstract void print();
}
class Xxx implements Aaa,Bbb{//X類同時實現了A,B兩個介面
    public void fun() {

        System.out.println("HELLO");
    }
    public void print() {
        System.out.println(MSG);
    }
}
public class Interface {
    public static void main(String[] args) {
            // TODO Auto-generated method stub
            Aaa a=new Xxx();//子類為父介面例項化
            Bbb b=new Xxx();//子類為父介面例項化
            a.fun();
            b.print();
    }
}

現在已經學習了普通類，抽象類，介面，三個概念，那麼一定要記住的是，如果說現在一個類既要繼承抽象類又要實現介面的話，則應該先繼承（extends）父類，後實現（implements）介面

範例：讓子類繼承抽象類和實現介面

package polymorphic;
interface Aaa{//定義的是介面
    public static String MSG="HELLO WORLD";
    public abstract void fun();//抽象方法
}
interface Bbb{
    public abstract void print();
}
abstract class C{//抽象類
    public abstract void get();//抽象方法
}
class Xxx extends C implements Aaa,Bbb{//X類同時實現了A,B兩個介面
    public void get() {
        System.out.println("你好");
    }
    public void fun() {
        System.out.println("HELLO");
    }
    public void print() {
        System.out.println(MSG);
    }
}
public class Interface {
    public static void main(String[] args) {
            // TODO Auto-generated method stub
            Aaa a=new Xxx();//子類為父介面例項化
            Bbb b=new Xxx();//子類為父介面例項化
            C c=new Xxx();//子類為父抽象類例項化
            a.fun();
            b.print();
            c.get();
    }


}

需要有幾個說明

說明一：介面之中全部方法訪問許可權都是public，不管寫與不寫都一樣，在以後工作之中，大部分的方法規範都是由介面規定的，所以這才有了只要是方法大部分都使用public定義的原因。

說明二：在介面裡面既然全部都是由抽象方法和全域性常量組成，所以在定義的時候以下兩種定義方式都是一樣的

interface A{//定義的是介面 interface A{//定義的是介面 public static String MSG="HELLO WORLD"; String MSG="HELLO WORLD"; public abstract void fun();//抽象方法 void fun();//抽象方法 } }

說明三：一般在定義介面的時候定義方法是比較多的，而定義全域性常量相對少一些。

說明四：一個抽象類可以使用implements實現介面

範例：抽象類實現介面

interface Aaa{//定義的是介面
    public static String MSG="HELLO WORLD";
    public abstract void fun();//抽象方法
}
interface Bbb{
    public abstract void print();
}
abstract class C implements Aaa,Bbb{//抽象類
    public abstract void get();//抽象方法
}
class Xxx extends C {//X類同時實現了A,B兩個介面
    public void get() {
        System.out.println("你好");
    }
    public void fun() {
        System.out.println("HELLO");
    }
    public void print() {
        System.out.println(MSG);
    }
}

但是一個介面卻不能夠繼承一個抽象類，可是一個介面卻可以使用extends關鍵字繼承多個父介面

範例：介面多繼承

interface D{
    public void printA();
}
interface E{
    public void printB();
}
interface F extends D,E{//F繼承D,E兩個介面
    public void printC();
}
class XA implements F{//XA要重寫三個抽象方法
    public void printA() {}
    public void printB() {}
    public void printC() {}
}

說明五：任何內部的結構實際上都不受定義的限制，所以在一個介面裡面也可以繼續定義內部介面或內部抽象類，而且用static定義的內部介面就是一個外部介面

package polymorphic;
interface D{
    static interface B{//內部介面加上static等於外部介面
        public void fun();
    }
}
class Xa implements D.B{//實現內部介面
    public void fun() {
        System.out.println("hello world");
    }
}
public class Interfacea {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        D.B d=new Xa();
        d.fun();
    }

}

介面有三個核心功能

使用介面定義規範標準

介面表示一種能力

將伺服器的遠端檢視暴露給客戶端。

介面引用--定義規範標準

“介面”這一名詞是到處可見，例如：插座，交流語言，USB

如：印表機，U盤都可以插在電腦的USB介面上使用，而使用的規則假設就只有兩個：工作，退出。

兩個無關的類之間的連線一定依靠介面完成，由介面定義出操作的標準

範例：定義介面標準

interface USB{
    public void work();//USB裝置工作
    public void exit();//退出USB裝置
}

範例：定義電腦

class Computer{
    public void plugin(USB usb) {//接收USB裝置
        usb.work();//呼叫usb介面方法，這個方法是由子類實現的
        usb.exit();//完事後退出
    }
}

範例：定義USB裝置

class Flash implements USB{
    public void work() {
        System.out.println("U盤開始實現拷貝操作");
    }
    public void exit() {
        System.out.println("U盤結束操作");
    }
}
class Print implements USB{
    public void work() {
        System.out.println("印表機開始進行文件列印");
    }
    public void exit() {
        System.out.println("列印結束，結束工作");
    }
}

範例：測試程式：

public class Interfaceb {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Computer com=new Computer();
        com.plugin(new Flash());
        com.plugin(new Print());
    }
}

發現電腦和印表機還是兩個彼此獨立的類，沒有直接的定義聯絡，但是有標準聯絡

這種的形式在生活中隨處可見

如：高速上不允許非機動車行駛

如:本商城不允許寵物入內

介面（和抽象類）就是對類的再次抽象，但是以介面為主（抽象類具備單繼承侷限，而介面沒有）

介面應用（工廠設計模式（Factory，背））

觀察程式碼：：

package polymorphic;
interface Fruit{//水果
    public void eat();//吃
}
class Apple implements Fruit{
    public void eat() {
        System.out.println("吃蘋果");
    }
}
class Orange implements Fruit{
    public void eat() {
        System.out.println("吃橘子");
    }
}
public class Interfacec {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Fruit f=new Apple();
        f.eat();
    }
}

本程式在實際中不可能用，因為客戶端（主方法）應該不可動，客戶端直接用了關鍵字new例項化了介面的子類物件，那麼就表示這個時候在客戶端，Fruit介面就與Apple子類繫結在一定，如果要更改子類，則需要修改客戶端程式碼，最好就是客戶端不要動。（加入第三個方）

修改程式碼

package polymorphic;
interface Fruit{//水果
    public void eat();//吃
}
class Apple implements Fruit{
    public void eat() {
        System.out.println("吃蘋果");
    }
}
class Orange implements Fruit{
    public void eat() {
        System.out.println("吃橘子");
    }
}
class Factory{
    public static Fruit getInstance(String className)
    {
        if("apple".equals(className)) {
                return new Apple;
        }
        if("orange".equals(className)) {
                return new Orange;
        }
        return null;
    }
}
public class Interfacec {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Fruit f=Factory.getInstance(args[0]);
        f.eat();
    }
}

介面定義--代理設計模式

實現程式

package polymorphic;
interface Network{//網路連線
    public void browse(String url);
}
class RealNetwork implements Network{
    public void browse(String url) {
        System.out.println("訪問站點"+url);
    }
}
class ProxyNetwork implements Network{
    private Network net;//儲存真正的上網連線
    //public ProxyNetwork(RealNetwork realNetwork) {
    // TODO Auto-generated constructor stub
    //}
    public void browse(Network net) {
        this.net=net;
    }
    public boolean check(String url) {
        if(url.contains("whitehouse")) {
                return false;
        }
        return true;
    }
    public void browse(String url) {
        if(this.check(url)) {
            this.net.browse(url);
        }
    }
    public void record(String url) {
            System.out.println("上網記錄"+url);
    }
}
public class Interfacec {
    public static void main(String[] args) {
            // TODO Auto-generated method stub
            Network nw=new ProxyNetwork(new RealNetwork());
            nw.browse("www.weibo.com");
            nw.browse("www.whitehouse.com");
    }
}

總結：抽象類與介面的區別（面試題）

No 區別 | 抽象類介面

1 關鍵字 | abstract class 類名稱{} interface 介面名稱{}

2 組成 | 普通方法，構造方法，抽象方法，常量，變數全域性常量，抽象方法

3 許可權 | 各類許可權只能是public許可權

4 使用 | 子類使用extends只能夠繼承一個父類子類使用implements可以實現多個介面

5 關係 | 抽象類可以實現多個介面介面不能夠繼承抽象類，但是可以繼承多個介面，實現介面多繼承

6 設計模式 | 模板設計模式工廠設計模式，代理設計模式

7 侷限 | 單繼承侷限無侷限

通過以上分析可以發現，在專案之中是使用抽象類還是使用介面其實都一樣，可是由於介面沒有抽象類的單繼承侷限，那麼在整個開發之中,如果發現抽象類和介面都可以使用時，優先使用介面，避免單繼承侷限

JAVA程式結構就講解完整了，包含單元有：介面，抽象類，類，物件，繼承，

介面

介面（核心）

介面引用--定義規範標準

介面應用（工廠設計模式（Factory，背））

介面定義--代理設計模式

相關文章