javaSE学习：第十七章、接口

1、接口：

接口就是给出一些没有实现的方法，封装到一起，到某个类要使用的时候，再根据具体情况把这些方法写出来。

1、 接口是用来建立类与类之间的协议，它所提供的只是一种形式，而没有具体的实现。
2、实现该接口的实现类必须要实现该接口的所有方法，通过使用implements关键字。
3、 接口是抽象类的延伸，java为了保证数据安全是不能多重继承的，也就是说继承只能存在一个父类，但是接口不同，一个类可以同时实现多个接口，不管这些接口之间有没有关系，所以接口弥补了抽象类不能多重继承的缺陷，

语法方面：
1.由interface关键词修饰的称之为接口；
2.接口中可以定义成员变量，但是这些成员变量默认都是public static final的常量。
3.接口中没有已经实现的方法，全部是抽象方法。
4.一个类实现某一接口，必须实现接口中定义的所有方法。
5.一个类可以实现多个接口。

1.Java接口定义的语法:

public interface AInterface {
    // 1、接口中的方法默认是public abstract的，可以省略。
    // public abstract void say();
    void say1();
    
    // 2、接口中字段默认使用public static final，可以省略。
    // public static final int n1 = 10;
    int n2 = 12;
    
    // 3、接口中可以定义static方法，默认是public类型的。
//    public static void hi() {
//        System.out.println("hello word");
//    }
    static void hi() {
        System.out.println("helloWord");
    }
    
    // 4、可以定义普通方法，但是要使用default修饰。。
    public default void run() {
        System.out.println("running");
    }
}

public interface A {
		/*
		*接口中的方法默认使用public abstract修饰
		接口中的字段默认使用 public static final修饰
		接口中可以定义public static 静态方法
		定义public  default方法
		*/
}

2、细节：

1、接口不能被实例化。
2、接口中所有的方法都是public方法，接口中的抽象方法，可以不用abstract修饰。
3、一个普通类实现接口，就必须将该接口的所有方法实现。
4、抽象类实现接口，可以不用实现接口的方法。
5、一个类同时可以实现多个接口。
6、接口中的属性，是public static final的，使用接口名.属性名来访问（因为是static的）。
7、接口不能继承其它类，但是可以继承多个别的接口。
8、接口的修饰符只能是public 和 默认。

// A 和 B 要在同一个文件中
interface A {
	int a = 20;
}

class B implements A { }

main:
B b = new B();
System.out.println(b.a);// 23
System.out.println(A.a);// 23
System.out.println(B.a);// 23

3、接口和继承：

区别：

1、继承：主要是解决代码的复用性和可维护性。继承之间要满足is-a的关系。
2、接口：设计好各种规范（方法），让其他类去实现这些方法。接口只需满足like-a的关系。

当子类继承了父类，就自动拥有了父类的功能。
如果子类需要扩展功能，可以通过实现接口的方式扩展子类的功能。

package com.hsf.extends_.interface_;

public class Monkey {
    public static void main(String[] args) {
        SonMonkey WuKong = new SonMonkey("悟空");
        WuKong.climb();
        WuKong.swimming();
        WuKong.fly();
    }
}

class FatherMonkey {
    private String name;

    public FatherMonkey(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

interface Fish {
    void swimming();
}

interface Bird {
    void fly();
}

class SonMonkey extends FatherMonkey implements Fish,Bird{
    public SonMonkey(String name) {
        super(name);
    }

    public void climb() {
        System.out.println(getName() + "会爬树");
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "通过学习，学会了游泳");
    }

    @Override
    public void fly() {
        System.out.println(getName() + "通过学习，学会了飞翔");
    }
}

4、接口多态性的体现：

1、接口作为参数传入方法中，那么实现了该接口的

public class Computer {
    public void work(Usb usb) {
        usb.start();
        usb.stop();
    }
}

接口可以指向实现了接口的类的对象

// 接口可以指向实现了接口的类的对象
public class Test2 {
    public static void main(String[] args) {
        IA ia = new Camera_();
        ia = new Phone_();
    }
}

interface IA { }
class Camera_ implements IA{}
class Phone_ implements IA{}

2、多态数组：

package com.hsf.extends_.interface_;

public class Test3 {
    public static void main(String[] args) {
        Usb2[] usb2s = new Usb2[2];
        usb2s[0] = new Phone2();
        usb2s[1] = new Camera2();
        for (int i = 0; i < usb2s.length; i++) {
            if (usb2s[i] instanceof Phone2) {
                ((Phone2) usb2s[i]).call();
            }
            usb2s[i].work();
        }
    }
}

interface Usb2 {
    void work();
}

class Phone2 implements Usb2 {
    @Override
    public void work() {
        System.out.println("手机在工作");
    }
    public void call() {
        System.out.println("手机在打电话");
    }
}

class Camera2 implements Usb2 {
    @Override
    public void work() {
        System.out.println("相机在工作");
    }
}

3、接口多态：多态传递现象：

package com.hsf.extends_.interface_;

public class Test4 {
    public static void main(String[] args) {
        // 接口类型的变量可以指向，实现了该接口的类的对象。
        IBB ibb = new CC();
        /*
        接口多态多态传递现象：
        * 如果IBB 继承了 IAA，而CC类实现了IBB接口，
        * 那么就相当于 CC类也实现了IAA接口。
        * */
        IAA iaa = new CC();
    }
}

interface IAA {
    void say();
}
interface IBB extends IAA {}

class CC implements IBB {
    @Override
    public void say() {

    }
}

一个作业：如何访问父类及接口的同名属性：

package com.hsf.extends_.interface_;

public class HomeWork {
    public static void main(String[] args) {
        Son son = new Son();
        son.print1();
    }
}

interface IF {
    int x = 1;
}

class Father {
    int x = 2;
}

class Son extends Father implements IF {
    public void print1() {
//        System.out.println(x); // 报错：不知道访问的是父类还是接口的x
        System.out.println(IF.x + " " + super.x);
    }
}