java中的接口

2021.02.09
第五次记录
课堂笔记：
/*接口的基础语法：

• 1.类和类之间叫做继承，类和接口之间叫做实现。（可以将实现看作是继承）
• 继承使用extends关键字
• 实现使用implements关键字完成
• 2.当一个非抽象的类实现接口的话，必须将接口中所有的抽象方法全部实现（覆盖、重写）。
• 如：int sum(int a, int b);----> public int sum(int a, int b){
  return a + b;
  }
  加public ，把();变为{}，加返回值类型
  3.接口在开发中的作用：
  面向接口编程，可以降低程序的耦合度，提高程序的扩展力，符合OCP开发原则。
  接口的使用离不开多态机制。（接口+多态才可以达到降低耦合度）
  任何一个接口都有调用者和实现者。
  接口可以将调用者和实现者解耦合。
  调用者面对接口调用；
  实现者面向接口编写实现。
  以后进行项目开发，一般都是将项目分离成多个模块，模块之间采用接口连接，降低耦合度。
  4.类型和类型之间的关系：
  is a(继承)、has a(关联)、like a(实现)
  is a：
  Cat is a Animal（猫是一个动物）
  凡是能满足is a的表示“继承关系”
  A extends B
  has a：
  I has a Pen（我有一支钢笔）
  凡是能满足has a的表示“关联关系”
  “关联关系”通常以属性的形式存在
  A{
  B b
  }
  like a：
  Cooker like a FoodMenu（厨师像一个菜单一样）
  凡是能满足like a的表示“实现关系”。
  “实现关系”通常是：类实现接口
  A implements B
  5.抽象类和接口之间的区别：
  抽象类是半抽象的，接口是完全抽象的
  抽象类中有构造方法，接口中没有构造方法
  类和类之间只能单继承，接口和接口之间支持多继承
  一个类可以同时实现多个接口，一个抽象类只能继承一个类（单继承）
  接口中只允许出现常量和抽象方法
  /
  /
  1.接口和接口之间支持多继承，那么一个类可以同时实现多个接口吗?
  一个类可以实现多接口，但是在子类中一定要将所有继承的接口中的方法都进行覆盖/重写/实现
  2.如果接口A和接口B之间没有实现（继承）关系，也可以强转，编译器在编译时不会报错，但是
  在运行时可能会出现ClassCastException。所以，在进行强转时需要加上if + instanceof判断。
  /
  /
  继承和实现都存在的话，则extends在前，implements在后
  */
  代码演示1：

public class interfaceDemo02 {
    public static void main(String[] args) {
        MyMath m = new A();
        System.out.println(m.sub(15,1));
        System.out.println(m.sum(10,1));
        System.out.println(m.PI);
    }
}
interface MyMath {
    double PI = 3.14;
    int sum(int a, int b);
    int sub(int a, int b);
}
class A implements MyMath {
    public int sum(int a, int b){
        return a + b;
    }
    public int sub(int a, int b){
        return a - b;
    }
}  

输出结果：
14
11
3.14
代码演示2：

public class interfaceDemo03 {
    public static void main(String[] args) {
        I i = new M();
        J j = new M();
        K k = new M();
        i.m1();
        j.m2();
        k.m3();
        //向下转型
        if (i instanceof J){
            J j2 = (J)i;
            j2.m2();
        } else if (i instanceof K) {
            K k3 = (K)i;
            k3.m3();
        }
    }
}
interface I {
    void m1();
}
interface J {
    void m2();
}
interface K {
    void m3();
}
class M implements I,J,K{
    public void m1() {
        System.out.println("m1...");
    }
    public void m2() {
        System.out.println("m2...");
    }
    public void m3() {
        System.out.println("m3...");
    }
}

输出结果：
m1…
m2…
m3…
m2…
代码演示3：

public class interfaceDemo04 {
    public static void main(String[] args) {
        Animal ani = new Cat();
        ani.show();
        Flyable f = new Cat();
        f.fly();
    }
}
abstract class Animal {
    public abstract void show();
}
//接口提取的通常是行为、动作
interface Flyable {
    void fly();
}
class Cat extends Animal implements Flyable {
    public void show(){
        System.out.print("插入翅膀的猫是");
    }
    public void fly(){
        System.out.println("猫头鹰");
    }
}

输出结果：
插入翅膀的猫是猫头鹰