Java学习笔记 --- 接口

一、基本介绍

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

语法：

interface 接口名 {

        属性

        方法：抽象方法，默认实现方法，静态方法

}

class 类名 implements 接口 {

        自己属性；

        自己方法；

        必须实现接口的抽象方法；

}

小结：

1、在JDK7.0之前，接口里面的所有方法都没有方法体，即都是抽象方法

2、JDK8.0后接口可以有静态方法，默认方法，也就是说接口中可以有方法的具体实现

package com.javase.interface_;

public interface Ainterface {
    //属性
    public int n1 = 10;
    //方法
    //在接口中，抽象方法可以省略abstract关键字
    public void hi();
    //在JDK8以后，可以有默认实现方法，需要default关键字修饰
    default public void n2() {
        System.out.println("默认方法...");
    }
    //在JDK8以后，可以有静态方法
    public static void n3() {
        System.out.println("静态方法....");
    }
}

二、注意事项和使用细节

1、接口不能被实例化（即不能创建对象）

2、接口中所有的方法是 public 方法，接口中抽象方法，可以不用 abstract 修饰

public interface Ainterface {
    //在接口中，抽象方法可以省略abstract关键字
    void hi();

}

3、一个普通类实现接口，就将该接口的所有方法都实现

interface IA {
    void say();
    void hi();
}

class Cat implements IA {
    @Override
    public void hi() {

    }

    @Override
    public void say() {

    }
}

4、抽象类实现接口，可以不用实现接口的方法

interface IA {
    void say();
    void hi();
}
//抽象类实现接口，可以不用实现接口的方法
abstract class TB implements IA {
    
}

5、一个类可以同时实现多个接口

interface IB {
    void say();
}
interface IC {
    void ok();
}
//一个类可以同时实现多个接口
class Pig implements IB,IC {

    @Override
    public void say() {
        
    }

    @Override
    public void ok() {

    }
}

6、接口中的属性，只能是final的，而且是 public、static、final 修饰符

public class InterfaceDetail02 {
    public static void main(String[] args) {
        System.out.println(IB.n1);//说明n1 是static
        //IB.n1 = 20; 说明n1 是 final 
    }
}

interface IB {
    int n1 = 10;//等于 public static final int n1 = 10;
}

7、接口中属性的访问形式：接口名.属性名

8、接口不能继承其他的类，但是可以继承多个别的接口

interface IB {
    void say();
}
interface IC {
    void ok();
}
//接口不能继承其他的类，但是可以继承多个别的接口
interface ID extends IB,IC {
    
}

9、接口的修饰符只能是 public 和默认，这点和类的修饰符是一样的

三、接口 VS 继承

1、接口和继承解决的问题不同：

      继承的主要价值在于：解决代码的复用性和可维护性

      接口的价值主要在于：设计，设计好各种规范（方法），让其它类去实现这些方法

2、接口比继承更加灵活：

      继承是满足 is - a 的关系，而接口只需满足 like - a 的关系

3、接口在一定程度上实现代码解耦（即：接口规范性 + 动态绑定）

小结：当子类继承了父类，会自动拥有父类的能力与属性。当子类需要扩展功能时，可以通过实现接口的方式扩展。实现接口是对Java单继承机制的一种补充

package com.javase.interface_;

public class ExtendsVsInterface {
    public static void main(String[] args) {
        LittleMonkey wukong = new LittleMonkey("悟空");
        wukong.climbing();
        wukong.swimming();
        wukong.flying();
    }
}

//继承
class Monkey {
    private String name;

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

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void climbing() {
        System.out.println("猴子会爬树...");
    }
}

//接口
interface Fishable {
    void swimming();
}
interface Birdable {
    void flying();
}

//子类
class LittleMonkey extends Monkey implements Fishable,Birdable {
    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "学会了像鱼儿一样游泳...");
    }

    @Override
    public void flying() {
        System.out.println(getName() + "学会了像鸟儿一样飞行...");
    }
}

四、接口多态特性

1、多态参数

package com.javase.interface_;

public class InterfacePolyParameter {
    public static void main(String[] args) {
        //接口的多态体现
        //接口类型的变量 n1 可以指向 实现了IF接口的对象实例

        IF n1 = new Monster();
        n1 = new Dog();
    }
}

interface IF { }
class Monster implements IF {}
class Dog implements IF {}

2、多态数组

package com.javase.interface_;

import javax.swing.*;

public class InterfacePolyArr {
    public static void main(String[] args) {
        //多态数组 ->接口类型数组
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone();
        usbs[1] = new Camer();

        //遍历数组输出
        for (int i = 0; i < usbs.length; i++) {
            usbs[i].work();//动态绑定机制
            //进行类型判断
            if (usbs[i] instanceof Phone) {
                ((Phone) usbs[i]).call();//向下转型
            }
        }
    }
}

interface Usb {
    void work();
}

class Phone implements Usb {
    public void call() {
        System.out.println("打电话...");
    }

    @Override
    public void work() {
        System.out.println("手机开始工作...");
    }
}

class Camer implements Usb {

    @Override
    public void work() {
        System.out.println("相机开始工作...");
    }
}

3、多态传递

package com.javase.interface_;

public class InterfacePolyPass {
    public static void main(String[] args) {
        //接口类型的变量可以指向实现了该接口的类的对象实例
        IG ig = new Teacher();
        //如果 IG 继承了 IH 接口，而 Teacher 类实现了 IG 接口
        //那么就相当于 Teacher 类也实现了 IH 接口
        IH ih = new Teacher();
    }
}

interface IH {
    void say();
}
interface IG extends IH{}

class Teacher implements IG {
    @Override
    public void say() {
        
    }
}

五、入门练习

package com.javase.interface_;

import com.sun.xml.internal.ws.api.model.wsdl.WSDLOutput;

public class InterfaceExercis01 {
    public static void main(String[] args) {
        new CC().say();
    }
}

interface AA {
    int x = 0;
}

class BB {
    int x = 1;
}

class CC extends BB implements AA {
    public void say() {
        //System.out.println(x);错误，原因不明确指向哪个X
        //明确的指定X 访问接口的就使用 接口名.X
        //访问父类的就使用super.x
        System.out.println(AA.x + " " + super.x);
    }
}

 六、类定义的进一步完善