【Java接口 12】

一、 接口（interface）

1、接口等同看作类，接口也是引用数据类型

2、接口是一个特殊的抽象类，特殊在接口是完全抽象的

3、接口不能被实例化，并且也没有构造方法

4、接口只能出现“常量”+“抽象方法”

5、接口和接口之间可以多继承，类和类之间只能单继承

6、一个类可以实现多个接口，（实现implements类似于继承extends）

7、一个非抽象的类实现接口，必须将接口中所有的抽象方法完全覆盖，实现。

8、接口中所有的数据都是public的，只有接口被实现的时候才能体现是public的

package com.JavaStudy.study0515;

/**
 * @Author wufq
 * @Date 2020/5/15 14:33
 */
public interface A
{
    //常量
    public static final double PI = 3.14;

    //程序中没有写final关键字时，系统会默认添加
    int BYTE_MAX_VALUE = 127;

    //抽象方法   --->接口中只能出现常量和抽象方法
    public abstract void m1();

    //同样抽象方法，不写abstract系统会默认添加
    void m2();

    //-->接口方法中不能有构造方法
    //void m3(){};

    //接口不能实例化,不能有构造方法
    //public A(){};

}

interface X{
    void m1();
}

interface Y{
    void m2();
}

interface Z{
    void m3();
}

//一个类可以实现多个接口，并且需要把接口里面的方法都实现
class k implements X,Y,Z{
    public void m1(){}; //抽象方法的实现，只需要加上实现体
    public void m2(){};
    public void m3(){};
}

//接口之间可以实现多继承
interface W extends X,Y,Z{
    void m4();
}

//e类实现W接口，而W接口又继承了X,Y,Z接口，所以需要实现X,Y,Z，W的所有方法
class e implements W{
    public void m1(){}; //抽象方法的实现，只需要加上实现体
    public void m2(){};
    public void m3(){};
    public void m4(){};
}

二、实例：

1、类继承接口实现接口的方法

2、运用多态调用接口内的方法

package com.JavaStudy.study0515;

public interface CustomeServices {
    //定义一个退出的方法
    void logOut();
}

package com.JavaStudy.study0515;

 public class CustomeServicesImpL implements CustomeServices {
    public void logOut(){
        System.out.println("退出成功！");
    }
}

package com.JavaStudy.study0515;

public class Test {

    public static void main(String[] args){
        CustomeServices c = new CustomeServicesImpL(); //父类的引用指向子类的对象，多态
        c.logOut();
    }
}

=====执行结果=====
退出成功！

三、接口应用

接口的作用：

1、有了接口以后，项目有了分层，项目可以分小组同时开发，项目的开发效率高

2、所有的程序都是面向接口编程的，没有面向具体，所以代码自然是解耦合的

项目的拓展能力增强，这种特性叫做“可插拔”特性

注意：分析接口的时候，必须分析清楚：实现方和调用方

菜单接口Menu (规范、标准、协议、合同)

接口实现方：Cooker

接口调用方：Customer

package com.JavaStudy.studyInterface0515;

/**
 * @Author wufq
 * @Date 2020/5/15 16:22
 */
public interface Menu {
    void hongshaorou();
    void oupian();
}

package com.JavaStudy.studyInterface0515;

/**
 * @Author wufq
 * 方法的实现方
 */
public class Cooker  implements Menu{
    public void hongshaorou(){
        System.out.println("张三喜欢红烧肉！");
    };
    public void oupian(){
        System.out.println("张三喜欢藕片！");
    };
}

package com.JavaStudy.studyInterface0515;

/**
 * @Author wufq
 * @Date 2020/5/15 16:31
 * 需求变更：接口需要另外类加以实现
 */
public class Cooker2 implements Menu{
    public void hongshaorou(){
        System.out.println("李四的红烧肉好了！");
    };
    public void oupian(){
        System.out.println("李四的藕片好了！");
    };
}

package com.JavaStudy.studyInterface0515;

/**
 * @Author wufq
 * @Date 2020/5/15 16:23
 * 方法的调用方
 */
public class Customer {
    //面向接口编程，避免面向具体编程（解耦合，增强扩展力）
    Menu m;

    Customer(Menu m){
        this.m = m;
    }

    public void diancan(){
        m.hongshaorou();
        m.oupian();
    }
}

package com.JavaStudy.studyInterface0515;

/**
 * @Author wufq
 * @Date 2020/5/15 16:23
 * 测试方法
 */
public class Test {
    public static void main(String[] args){
        //创建厨师
        Cooker cooker = new Cooker();
        //创建顾客
        Customer customer = new Customer(cooker);
        customer.diancan();

        Cooker2 cooker1 = new Cooker2();
        Customer customer1 = new Customer(cooker1);
        customer1.diancan();


    }
}

四、适配者模式

当想实现一个接口但又不想实现所有接口方法，只想去实现一部分方法时，

在接口和具体实现类中添加一个抽象类，而用抽象类去空实现目标接口的所有方法

具体的实现类只需要覆盖其需要完成的方法即可

package com.JavaStudy.studyInterface0515;

/**
 * @Author wufq
 * @Date 2020/5/15 17:30
 */
public interface Job {
    void speakChinese();
    void speakEnglish();
    void speakJapanese();
}

abstract class Tom implements Job{
    public void speakChinese(){};
    public void speakEnglish(){};
    public void speakJapanese(){};
}

//只想实现接口内的其中一个方法，需要用抽象类空实现接口的抽象方法
class Jack extends Tom{
    public void speakChinese(){
        System.out.println("只想说汉语");
    }
}