JavaSE总结 - interface接口

零基础学Java，肝了bilibili的6百多集JavaSE教程传送门的学习笔记！！！

下面博客分为两部分：

• ① 接口的要点（想快速了解接口的小伙伴选择）
• ② 案例代码，对①中的知识点进行解释（需要再花费5分钟学习的小伙伴选择）

---

一、接口的要点

接口的基础语法

 1、接口是一种 "引用数据类型" 。
 2、接口时完全抽象的。
 3、接口这么定义：[修饰符列表] interface 接口名 {}
 4、接口支持多继承。
 5、接口中只有：常量+抽象方法。
 6、接口中所有的元素都是public修饰的。
 7、接口中的抽象方法定义时：public abstract可以省略。
 8、接口中的变量定义时：public static final可以省略。
 9、接口中的方法不能有方法体。
 10、一个非抽象的类实现接口需要将接口中所以方法加以实现。
 11、一个类可以实现多个接口。
 12、extends和implements可以同时使用。extends在前，implements在后。
 13、使用接口写代码的时候，可以使用多态。(父类型引用指向子类型对象)

---

接口在开发中的作用

类似于多态在开发中的作用 ---> 解耦合。
多态：面向抽象编程，不要面向具体编程。减低程序的耦合度。提高程序的扩展力。
            符合OCP开发原则。
            
接口的进一步理解：类和类的关系
    is a: 继承关系
        Cat is a Animal.

    has a: 关联关系
        I has a pen.

    like a: 实现关系
        Cooker like a FoodMenu.(厨师像一个菜单，功能的"像")


抽象类和接口的区别：
    这里只解释下语法上的区别。

抽象类是半抽象的。
接口是完全抽象的。

抽象类中有构造方法。
接口中没有构造方法。

类和类之间只能单继承。
接口和接口之间支持多继承。

一个类可以同时实现多个接口。
一个抽象类只能继承一个类(单继承)。

接口中只允许出现常量和抽象方法。

---

二、案例代码

1、接口的基础语法

① InterfaceTest.java

public class InterfaceTest {

    public static void main(String[] args) {

        M m = new E();
        // 接口和接口之间在进行强制类型转换的时候，没有继承关系，也可以强制。
        // 编译器没意见，但是运行时可能会出现ClassCastException异常。
        K k = (K) m;	// 此处就会报错
        
        if (m instanceof K) {
            K k = (K) m;
        }
    }
}

interface K {

}

interface M {

}

class E implements M {

}

---

② InterfaceTest01

接口的基础语法：

• 1、接口是一次 “引用数据类型” 。接口编译之后也是一个class字节码文件
• 2、接口是完全抽象的，(抽象类是半抽象)或者说接口是特殊的抽象类。
• 3、接口这么定义呢？

语法：
       [修饰符列表] interface 接口名 {
}

• 4、接口支持多继承，一个接口可以继承多个接口。
• 5、接口中只包含两部分内容，一部分是：常量；一部分是：抽象方法。
  接口中没有其它内容。只有以上两部分
• 6、接口中所有的元素都是public修饰的。
• 7、接口中的抽象方法定义时：public abstract可以省略。
• 8、接口中的变量定义时：public static final可以省略。
        接口中随便写的变量就是常量。
• 9、接口中的方法都是抽象方法，所以接口中的方法不能有方法体。

public class InterfaceTest01 {

    public static void main(String[] args) {
        System.out.println("A.PI: " + A.PI);
        System.out.println("A.ID:" + A.ID);
    }
}

interface A {
    public static final double PI = 3.1415926;
    double ID = 2018217213.0901;

    public abstract int doSome();
    public int doOther();
    int move();
}

interface B extends A {

}

interface C extends A, B {

}

---

③ InterfaceTest02.java

接口的基础语法2：

• 类和类之间叫做继承，类和接口之间叫做实现,也可以把实现看成一种继承
• 继承使用extend关键字完成
• 实现使用implements关键字完成

public class InterfaceTest02 {

    public static void main(String[] args) {
        // 能使用多态吗？可以。

        // 父类型的引用指向子类型的对象。
        MyMath mm = new MyMathImpl();

        // 调用接口里面的方法(面向接口编程)
        int result1 = mm.sum(2,2);
        int result2 = mm.sub(1,2);
        System.out.println("result1: " + result1 + " result2: " + result2);

        // 编译时，编译器看接口里有没有该方法，有就编译通过。
        // 运行时，调用子类里的方法。
    }

}

interface MyMath {
    double PI = 3.1415926;
    int sum(int a, int b);
    int sub(int a, int b);
}

// 非抽象类
class MyMathImpl implements MyMath {

    // 方法前面的public不能省略。
    // 编译报错：正在尝试分配更低的访问权限；以前是public(接口)。
    // 继承的子类里，元素的访问权限只能更高、不能更低。

    @Override
    public int sum(int a, int b) {
        return a + b;
    }

    @Override
    public int sub(int a, int b) {
        return a - b;
    }
}

abstract class MyMath2 implements MyMath {
    // 不需要实现接口中的抽象方法。
}

---

④ InterfaceTest03.java

接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗？

可以，一个类可以同时实现多个接口。

这种机制弥补了Java中的那些缺陷？

Java中类和类只支持单继承。
实际上单继承是为了简单而出现的，现实世界中存在多继承，
Java中的接口弥补了单继承带来的缺陷。

之前的学习中有一个结论：

无论向上转型还是向下转型，两种类型之间必须要有继承关系，没有继承关系编译器会报错。(但这句话不适应在接口方面)
最终实际上和之前一样，需要加：instanceof运算符进行判断。
 
建议：
养成向下转型好习惯。转型之前先if+instanceof进行判断。

public class InterfaceTest03 {

    public static void main(String[] args) {
        // 多态该怎么用呢？
        // 都是父类型引用指向子类型对象。
        Test1 test1 = new Test4();
        Test2 test2 = new Test4();
        Test3 test3 = new Test4();

//        test1.m2();   // 编译报错，Test1接口里没有m2()方法
        Test2 t2 = (Test2) test1;   // 要想调用其它接口中的方法，需要转型(接口转型。)
        t2.m2();

    }

}

interface Test1 {
    void m1();
}

interface Test2 {
    void m2();
}

interface Test3 {
    void m3();
}

class Test4 implements Test1, Test2, Test3 {

    @Override
    public void m1() {
        System.out.println("m1()");
    }

    @Override
    public void m2() {
        System.out.println("m2()");
    }

    @Override
    public void m3() {
        System.out.println("m3()");
    }
}

---

⑤ InterfaceTest04.java

继承和实现都存在时：

extends 关键字在前，mplements 关键字在后（代码规范）

public class InterfaceTest04 {

    public static void main(String[] args) {
        // 创建对象 (表面看Animal类没起作用！)
        Flyable cat = new Cat();
        cat.fly();

        Flyable pig = new Pig();
        pig.fly();
    }

}

class Animal {

}

// 接口通常提取的是行为动作。
interface Flyable {
    void fly();
}

// 会飞的猫类
class Cat extends Animal implements Flyable {

    @Override
    public void fly() {
        System.out.println("会飞的猫!");
    }
}

// 飞猪
class Pig extends Animal implements Flyable {

    @Override
    public void fly() {
        System.out.println("这是一只飞猪!");
    }
}

---

2、接口在开发中的作用

写代码的建议

Cat is a Animal, 满足 "is a" 的表示都可以设置为继承。
Customer has a FoodMenu, 但凡是满足 "has a" 的表示都以属性的形式存在。

写这些代码就是要表示，使用接口抽象编程，降低程序耦合度，提高程序扩展力。
接口的使用离不开多态(接口+多态-->降低程序耦合度)

接口可以解耦合(调用者和实现者)，所以在设计的时候要考虑要两者之间的关系。
调用者是面向接口调用。
实现者面向接口编写实现。

① FoodMenu

public interface FoodMenu {
    void XiHongShichaoJiDan();
    void YuXiangRouSi();
}

② ChinaCooker、AmericanCooker

public class ChinaCooker implements FoodMenu {
    @Override
    public void XiHongShichaoJiDan() {
        System.out.println("中国厨师做的西红柿炒鸡蛋。");
    }

    @Override
    public void YuXiangRouSi() {
        System.out.println("中国厨师做的鱼香肉丝。");
    }
}

public class AmericanCooker implements FoodMenu {
    @Override
    public void XiHongShichaoJiDan() {
        System.out.println("西方厨师做的西红柿炒鸡蛋。");
    }

    @Override
    public void YuXiangRouSi() {
        System.out.println("西方厨师做的鱼香肉丝。");
    }
}

③ Customer

public class Customer {

    private FoodMenu foodMenu;

    public Customer() {
    }
    public Customer(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }

    public FoodMenu getFoodMenu() {
        return foodMenu;
    }

    public void setFoodMenu(FoodMenu foodMenu) {
        this.foodMenu = foodMenu;
    }


    public void order1() {
        foodMenu.XiHongShichaoJiDan();
    }
    public void order2() {
        foodMenu.YuXiangRouSi();
    }

}