java学习总结--------接口

接口（interface）

接口基本概念

定义：Java中接口是全局常量，和公共抽象方法的集合（jdk8以前）。接口是一个纯粹的抽象类。

接口的简单使用

接口用interface关键字来定义。

interface  A { //定义一个接口
    public static final Integer I = 10;  //全局常量
    public abstract void fun();    //抽象方法
}

因为接口中只有全局常量和公共的抽象方法，因此对于那些修饰符全部可以去掉。即

interface  A { //定义一个接口
     Integer I = 10;  //全局常量
     void fun();    //抽象方法
}

普通类实现接口

在Java中类不允许多重继承。但一个类可以通过（implements关键字）实现多个接口，该类若不是抽象类则必须覆写接口中的所有抽象方法。

interface  A {
    Integer I = 10;
    void printA();

}
interface B {
    Integer J = 20;
    void printB();
}
class C implements A,B {

    @Override
    //该处必须使用public修饰，因为接口中的方法权限默认是public修饰的
    public void printA() {
        System.out.println("覆写A的抽象方法");
    }

    @Override
    //该处必须使用public修饰，因为接口中的方法权限默认是public修饰的
    public void printB() {
        System.out.println("覆写B的抽象方法");

    }
}

public class TestInterface {
    public static void main(String[] args) {
        A a = new C();     //子类向上转型，实例化接口对象
        B b = new C();
        a.printA();
        b.printB();
        a = (A) b;      //两个接口之间的转换
        b = (B) a;
        
    }
}

即通过一个公共的子类，可以实现两个毫无关系的父接口之间的转换。

同理也可以实现在一个父接口下，两个子类的相互转换。

抽象类实现接口

抽象类是普通类的超集，因此也可以实现若干个接口，且不强求覆写其中的抽象方法。

interface  A {
    Integer I = 10;
    void printA();

}
interface  B {
    String MSG = "hehe";
    void printB();
}

abstract class C implements A,B {
    @Override
    public void printB() {
        System.out.println("覆写B接口的抽象方法");
    }
    //没有覆写A接口的抽象方法
}

class D extends C {

    @Override
    public void printA() {
        System.out.println("覆写A接口的抽象方法");
    }
}

public class TestInterface {
    public static void main(String[] args) {
        //向上转型实例化父类，父父接口对象
        C c = new D();
        A a = new D();
        B b = new D();
        //三层继承
    }
}

接口继承接口

Java中，一个接口可以通过extends关键字继承若干个接口。

interface  A {
    Integer I = 10;
    void printA();

}
interface  B {
    String MSG = "hehe";
    void printB();
}

interface C extends A, B {  //接口继承多个接口
    void printC();
}

class D implements C {
//    覆写其中的所有抽象方法

    @Override
    public void printC() {
        System.out.println("覆写C的抽象方法");        
    }

    @Override
    public void printA() {
         System.out.println("覆写A的抽象方法");        

        
    }

    @Override
    public void printB() {
          System.out.println("覆写的抽象方法");           
    }
}


public class TestInterface {
    public static void main(String[] args) {
        //向上转型实例化父类，父父接口对象
        C c = new D();
        A a = new D();
        B b = new D();
    }
}

抽象类与接口的区别

• 元素组成，抽象类是普通类的超集，可以有普通类的所以东西，且还可以有抽象方法。接口只含有全局常量，和公共的抽象方法。
• 权限： 抽象类中可以有各种权限，但接口中只有public权限。
• 子类使用：子类通过extends来继承抽象类，且一次只能继承一个抽象类。子类通过implempents来实现接口，一次可以实现若干个接口。而且接口与接口之间，子接口也可以使用extends关键字来继承多个接口。
• 关系：抽象类可以实现接口，但接口不能继承或者实现抽象类。
• 使用原则：子类对抽象类的继承必须满足is–a原则，不能仅仅为了代码复用而继承，否则会使得程序很混乱。接口强调特定功能的实现，设计原则为“has — a”关系。