Java接口详解

接口详解

是一个解除耦合的工具
接口是特殊的抽象类，（类似于抽象类，但它终归不是类，类的关键字是class）
接口是没有对象的，接口的实现类有对象

• 关键字 interface
• 子类继承接口：implements（实现） 类似于抽象类中子类继承父类
• 接口继承接口：extend

特点：
1，所有的属性都是公开静态常量 public static fianl int i = 1;
2，所有的方法都是公开抽象方法 public abstract void animal( );
3，没有构造方法

注意：（和类的区别）

1，一个类去实现接口，如果这个类不希望也成为抽象类，就必须实现接口中所有的方法
2，接口之间可以继承、多继承，（接口处于次要地位）（突破了java单继承的特点）
3，一个类在继承另外一个类的同时，还可以实现多个接口（但顺序不能颠倒，先继承类，再实现接口）

示例代码：       
    public class TestInterface {
    public static void main(String[] args) {
        IA a = new Impl();
        a.ma1();
        a.ma2();
        }
    }
    abstract class ClassA {
        public static final int M = 10;
        public static final double N = 2.78;
        public abstract void ma1();
        public abstract void ma2();
    }

    // 定义一个接口 IA ，等价于上面代码：ClassA方法
    interface IA {
        //接口中的属性默认为静态常量，修饰符可以省略
        int M = 10;
        double N = 2.78;
        //接口中的方法默认为公开抽象方法
        void ma1();
        void ma2();
    }

    interface IB {
    void mb();
    }
    interface IC {
        void mc();
    }
    //接口之间可以实现多继承
    interface ID extends IB, IC {
        public void md();
    }
    abstract class ClassE{
        public abstract void me();  
    }

    //一个类去实现接口，如果这个类不希望也成为抽象类，就必须实现接口中所有的方法
    //一个类在继承另外一个类的同时，还可以实现多个接口
    class Impl extends ClassE implements IA,ID {
        @Override
        public void ma1() {
            System.out.println("重写IA中的ma1()方法");
        }
        @Override
        public void ma2() {
            System.out.println("重写IA中的ma2()方法");
        @Override
        public void mb() {
        }
        @Override
        public void mc() {
        }
        @Override
        public void md() {  
        }
        @Override
        public void me() {
        }
        }
    }

接口作用

（实现多继承——->片面的理解，c++没有接口，是通过类实现的多继承）
* 解除耦合的工具：*
利用接口实现多继承，不会破坏类之间树状关系的简单性
接口是解除耦合的工具，相当于是一个标准
把标准的使用者和标准的实现者分离
例如：
有一个台灯Lamp，一个黄灯泡YellowLight，一个蓝灯泡BlueLight；
①如果要是交换使用黄灯泡或者蓝灯泡的话，就得需要来回改变lamp的内容，此时台灯Lamp和灯泡之间是强耦合；
②如果我们定义一个接口Light（相当于是一个标准）、将YellowLight或者BlueLight与Light相连接，
就不需要再改变Lamp的内容了，此时台灯Lamp和黄绿灯泡之间就是弱耦合

public class TestInterface1 {
    public static void main(String[] args) {
        //这是强耦合
        Lamp l = new Lamp();//买个台灯
        YellowLight yl = new YellowLight();//买个黄灯泡
        l.setLight(yl);//把灯泡安装在台灯上
        l.powerOn();//打开台灯

        //利用接口实现：接口解耦合作用
        RedLight rl = new RedLight();
        l.setLight(rl);
        }
    }
    class Lamp {
        private Light light = null;
        public void setLight(Light light) {
            this.light = light;
        }
        public void powerOn() {
            light.on();
        }
    }
    interface Light {
        void on();
    }
    class YellowLight implements Light {
        public void on() {
            System.out.println("发出黄光");
        }
    }
    class RedLight implements Light {
    public void on() {
        System.out.println("发出红光");
        }
    }

接口的回调

情景模式：
比如说，类A要调用类B，是先写A还是先写B？———>一般是先写类B（别人写好的东西，你要是用的话就去调用就可以了，比如java的函数库）
但是如果A类先写好了，B还没有写，这时可以应用接口的思想对B类进行调用，（回调）

接口的回调： 在定义接口之后，先有接口的使用者，后有接口的实现者 使用者通过接口调用实现者中的方法。