java笔记--接口interface与实现implements

格式：

interface{}

接口中的成员修饰符是固定的：

1 成员变量：publica static final
2 成员函数：publica abstract
3 发现接口中的成员都是public的

当一个抽象类的方法都是抽象的时候，这时可以将
该抽象类用另一种形式定义和表示，就是 接口 。

定义接口使用的关键字不是class，是interface。

对于接口当中常见的成员：而且这些成员都有固定的修饰符
1 全局常量：public static final
2 抽象方法，public abstract

interface Demo{
    public static final int NUM=4;
    
    public abstract void show1();
    public abstract void show2();
} 

由此得出结论，接口中的成员都是公共的权限。

类与类之间是继承关系，类与接口之间是实现关系implements。

接口不可以实例化，只能由实现了接口的子类并覆盖了接口中所有的抽象方法后，该子类才可以实例化，否则，这个子类就是一个抽象化。

实现例子：

//定义接口
interface Demo{
    public static final int NUM=4;
    
    public abstract void show1();
    public abstract void show2();
} 
//实现接口的子类并覆盖接口中所有的抽象方法
class DemoImpl implements Demo{
    public void show1()
    {}
    public void show2()
    {}
}

//将子类实例化，并调用NUM
public class InterfaceDemo {

    public static void main(String[] args) {
        DemoImpl d=new DemoImpl();
        System.out.println(d.NUM);
        System.out.println(DemoImpl.NUM);
        System.out.println(Demo.NUM);
    }

}

运行： image.png

接口的出现将“多继承”通过另外一种形式体现出来，即“多实现”。

在java中不直接支持多继承，因为会出现调用的不确定性。所以java将多继承机制进行改良，在java中变成了多实现。

一个类可以实现多个接口。

多实现例子：

interface A{
    public void show();
}

interface Z{
    public void show();
}
interface M{
    public int add(int a,int b);
}
public class MoreIamplements implements A,Z,M//多实现
{
    public void show(){
        System.out.print(add(1,2));
    }
    public int add(int a,int b){
        return a+b;
    }
}

public class InterfaceDemo {

    public static void main(String[] args) {
        MoreIamplements m=new MoreIamplements();
        m.show();
}

运行： image.png

一个类在继承另一个类的同时，还可以实现多个接口。

一个类在继承另一个类的同时，还可以实现多个接口，接口的出现避免了单继承的局限性：

//接口A,M的代码同上
class Q{
    public void method(){
        System.out.println("继承");
    }
}
public class MoreIamplements extends Q implements A,M//继承先增加功能，多实现再扩展其他功能
{
    public void show(){
        super.method();
        System.out.println("实现");
    }
    public int add(int a,int b){
        return a+b;
    }

public class InterfaceDemo {

    public static void main(String[] args) {
        MoreIamplements m=new MoreIamplements();
        m.show();
          }
}

运行： image.png

接口与接口之间可以继承，是继承关系，而且接口可以多继承。原理就是方法体是否有存在。

interface CC{
    void show();
}
interface MM{
    void show();
}
interface QQ extends CC,MM{
    void function();
}
class WW implements QQ{
    //因为接口都是抽象的，所以实现要覆盖三个方法。
    public void show(){}
    public void method(){}
    public void function(){}
}

总结：

接口的特点：

1 接口是对外暴露的规则
2 接口是程序的功能扩展
3 接口的出现降低耦合性（联系性）
4 接口可以用来多实现
5 类与接口之间是实现关系，而且类可以继承一个类的同时实现多个接口。
6 接口与接口之间可以有继承关系

接口与抽象类的异同点：

相同点：
都是不断向上抽取而来的。

不同点：
1 抽象类需要被继承，而且只能单继承。接口需要被实现，而且可以多实现
2 抽象类中可以定义抽象方法和非抽象方法，子类继承后，可以直接使用非抽象方法。
3 抽象类的继承，是 is a关系，在定义该体系的基本共性内容。接口的实现是 like a关系，在定义额外功能。

abstract class 犬{//基本功能
        abstract void 吼叫();
}
//abstract class 导盲//会导盲的不止有导盲犬
interface 导盲{//额外功能
        abstract void 导盲();
  }
class  导盲犬  extends   犬 implements  导盲{
        public void 吼叫(){}
        public void 导盲(){}
}

接口的应用：

以笔记本为例，为了扩展笔记本的功能，但日后出现什么功能设备不知道。
定义一个规则，只要日后出现的设备符合这个规则就可以了。
规则在java中就是接口。

interface USB{//暴露的规则
    public void open();
    public void close();
}

public class BookPC {

    public static void main(String[] args) {
        useUSB(new UPan());//功能扩展
    }
    //使用规则
    public static void useUSB(USB u){//接口类型的引用，用于接收（或者说指向）接口的子类对象       //这里是多态（后面讲）的使用即USB u=new UPan();
        u.open();
        u.close();
    }
}
//一年后买了个U盘   必须得符合规则
//实现规则
//这些设备和电脑的耦合性降低了
class UPan implements USB{//符合规则
    public void open(){
        System.out.println("upan open");
    }
    public void close(){
        System.out.print("upan close");
    }
}

运行： image.png