JAVA接口與抽象類怎么使用

本篇內容介紹了“JAVA接口與抽象類怎么使用”的有關知識，在實際案例的操作過程中，不少人都會遇到這樣的困境，接下來就讓小編帶領大家學習一下如何處理這些情況吧！希望大家仔細閱讀，能夠學有所成！

接口

概述

1. 當需要從幾個類中派生出一個類，繼承他們所有的屬性和方法，JAVA沒有多重繼承需要用接口實現

2. 從幾個類中抽取出一些共同的行為特征，而他們之間又沒有is-a的關系，也需要借助接口實現

3. 接口本質是契約，規范

使用

1. 接口中使用interface來定義

2. 接口和類是兩個不同的結構

3. 接口中不能定義構造器（也就不能實例化）

4. 接口通過類來實現implements

5. JAVA類可以實現多個接口格式：class AA extends BB interface CC,DD

6. 接口與接口之間可以繼承，并且可以多繼承

7. 接口體現了多態性

public class UsbTest {
    public static void main(String[] args) {
        Computer com =new Computer();
        Flash flash=new Flash();
        com.transferData(flash); // USB usb =new Flash()
        com.transferData(new Printer());
        /*
		* U盤開始工作
		* 傳輸數據
		* U盤結束工作
		* 打印機開始工作
		* 傳輸數據
		* 打印機結束工作
		* 
		* */
    }}class Computer{
    public void transferData(USB usb){
        usb.start();
        System.out.println("傳輸數據");
        usb.stop();
    }}interface USB{
    void start();
    void stop();}class Flash implements USB{

    @Override
    public void start() {
        System.out.println("U盤開始工作");
    }

    @Override
    public void stop() {
        System.out.println("U盤結束工作");

    }}class Printer implements USB{

    @Override
    public void start() {
        System.out.println("打印機開始工作");

    }

    @Override
    public void stop() {
        System.out.println("打印機結束工作");

    }}

8. JDK8的寫法

• 接口中定義的靜態方法，只能通過接口調用

• 通過實現類的對象，可以實現接口中的默認方法

• 如果子類（或者實現類）繼承的父類和實現的接口中聲明了同名同參數方法，如果子類沒有重寫該方法，調用的是父類中同名同參數方法

public class JDK8Test {
    public static void main(String[] args) {
        SubClass sub =new SubClass();
        CompareA.methods1();
        sub.methods2();
        /*
        * Compare 北京
		* Compare 上海
        */
    }}class SubClass implements CompareA{}interface CompareA{
    public static void methods1() {
        System.out.println("Compare 北京");
    }
    public default void methods2() {
        System.out.println("Compare 上海");
    }}

代理模式

1. 代理模式就是為其他對象提供一種代理以控制對這個對象的訪問

2. 實例

public class NetWorkTest {
    public static void main(String[] args) {
        Server server=new Server();
        ProxyServer proxyServer=new ProxyServer(server); // 放的是被代理對象進去
        proxyServer.browse(); // 調用的是代理對象，但結果是真實對象的方法被調用
        /*
        * 檢查工作
		* 真實服務器訪問網絡
        */
    }}interface NetWork{
    void browse();}// 被代理類class Server implements NetWork{

    @Override
    public void browse() {
        System.out.println("真實服務器訪問網絡");
    }}// 代理類class ProxyServer implements NetWork{
    private NetWork work;
    public ProxyServer(NetWork work){
        this.work=work;
    }
    public void check(){
        System.out.println("檢查工作");
    }

    @Override
    public void browse() {
        check();
        work.browse();
    }}

內部類

1. JAVA允許將一個類A聲明在另一個類B中，則類A是內部類，類B是外部類

2. 內部類分類

• 成員內部類

• 靜態 static

• 非靜態

• 局部內部類

• 方法內

• 代碼塊內

• 構造器內

3. 實例化內部類對象

public class InnerClassTest {
    public static void main(String[] args) {
        // 實例化Dog，靜態類
        Pseson.Dog dog=new Pseson.Dog();
        dog.eat();
        // 吃骨頭
        // 實例化Cat，非靜態類
        Pseson p1 =new Pseson();
        Pseson.Cat cat=p1.new Cat();
        cat.eat();
        // 貓吃魚
    }}class Pseson{
    String name;
    int age;
    public void eat(){
        System.out.println("吃飯");
    }
    static class Dog{
        String name;
        int age;
        public void eat(){
            System.out.println("吃骨頭");
        }
    }
    class Cat{
        public void eat(){
            System.out.println("貓吃魚");
        }
    }}

4. 調用外部類結構

public class InnerClassTest {
    public static void main(String[] args) {
        // 實例化Cat，非靜態類
        Pseson p1 =new Pseson();
        Pseson.Cat cat=p1.new Cat();
        cat.eat();
        cat.display("小花");
        /*
        * 小花
        * 波斯貓
        * 人
        */ 
    }}class Pseson{
    String name="人";
    int age;
    public void eat(){
        System.out.println("吃飯");
    }
    static class Dog{
        String name;
        int age;
        public void eat(){
            System.out.println("吃骨頭");
        }
    }
    class Cat{
        String name="波斯貓";
        public void eat(){
            System.out.println("貓吃魚");
        }
        public void display(String name){
            System.out.println(name); // 方法中name
            System.out.println(this.name); // 內部類中name
            System.out.println(Pseson.this.name); // 外部類中name

        }
    }}

5. 接口與抽象類

• 相同點：不能實例化；都包含抽象方法；能被繼承

• 不同點：抽象類有構造器，接口沒有構造器；抽象類只有單繼承，而接口可以多繼承；抽象類extands繼承，接口implements實現

“JAVA接口與抽象類怎么使用”的內容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業相關的知識可以關注億速云網站，小編將為大家輸出更多高質量的實用文章！