Java --- 接口_接口解决了继承什么问题-CSDN博客

interface A{
    //属性
    public int a = 1;
    //抽象方法，在接口中可以不用写abstract关键字
    public void  a1();
    //默认方法
    default void a2(){
        System.out.println("我是接口1");
    }
    //静态方法
    public static void a3(){
        System.out.println("我是接口2");
    }
}

二、注意事项

1、接口不能被实例化。

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

interface A1{
    public abstract void ok1();
    //默认可以不写abstract
    void ok2();
}

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

interface A1{
    public abstract void ok1();
    //默认可以不写abstract
    void ok2();
}
class Cat implements A1{

    @Override
    public void ok1() {
        
    }

    @Override
    public void ok2() {

    }
}

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

interface A1{
    public abstract void ok1();
    //默认可以不写abstract
    void ok2();
}
abstract class Cat implements A1{
    
}

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

interface A1{
     void ok1();
}
interface A2{
    void ok2();
}
 class Cat implements A1,A2{
     @Override
     public void ok1() {
     }
     @Override
     public void ok2() {
     }
 }

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

public class Test01 {
    public static void main(String[] args) {
        System.out.println(A1.a);
    }
}
interface A1{
     int a = 10;//默认使用public static final修饰
}

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

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

interface A1{
     
}
interface A2{
    void ok2();
}
interface A3 extends A1,A2{}

9、接口的修饰符，只能是public和默认。

三、接口 VS 继承

1、接口和继承解决的问题不同：①、继承主要解决代码的复用性和可维护性。②、接口主要用于设计好各种规范(方法)，让其它类去实现这些方法。

2、接口比继承更加灵活：继承是满足is - a的关系，而接口只需要满足like - a的关系。

3、接口在一定程度上实现代码解耦。

public class Test01 {
    public static void main(String[] args) {
        LittleMonkey monkey = new LittleMonkey("吉吉");
        monkey.climbing();
        monkey.swimming();
    }
}
//父类
class Monkey{
    private String name;

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

    public String getName() {
        return name;
    }

    public void climbing(){
        System.out.println(name + "会爬山");
    }
}
class LittleMonkey extends Monkey implements Fishable{

    public LittleMonkey(String name) {
        super(name);
    }

    @Override
    public void swimming() {
        System.out.println(getName() + "学会了游泳");
    }
}
interface Fishable{
    public void swimming();
}

运行结果：

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

四、接口多态

1、多态参数

public class Test02 {
    public static void main(String[] args) {
        //接口类型的变量dog可以指向实现了A接口的类的对象实例。
        A dog = new Dog();
        dog = new Cat();
    }
}
interface A{}
class Dog implements A{}
class Cat implements A{ }

2、多态数组

public class Test03 {
    public static void main(String[] args) {
        Usb[] usbs = new Usb[2];
        usbs[0] = new Phone();
        usbs[1] = new Camera();
        for (int i = 0; i <usbs.length ; i++) {
            usbs[i].work();//动态绑定
           if (usbs[i] instanceof Phone){//判断运行类型
               ((Phone)usbs[i]).call();//向下转型
           }
        }

    }
}
interface Usb{
    public void work();
}
class Phone implements Usb{
    @Override
    public void work() {
        System.out.println("手机在工作");
    }
    public void call(){
        System.out.println("手机在打电话");
    }
}
class Camera implements Usb{
    @Override
    public void work() {
        System.out.println("相机在工作");
    }
}

运行结果：

3、多态传递

public class Test04 {
    public static void main(String[] args) {
        //接口类型的变量可以指向，实现了该接口的类的对象实例
        B2 b3 = new B3();
        //因为B2继承了B1接口，而B3类实现了B2接口
        //所以也相对于实现了B1接口
        B1 b1 = new B3();
    }
}
interface B1{}
interface B2 extends B1 {}
class B3 implements B2{}

五、JDK8与JDK9接口新特性

public interface A {
    //jdk8:静态方法
    public static void method(){
        System.out.println("这是一个静态方法");
    }
    //jdk8:默认方法
    default void method1(){
        System.out.println("这是一个默认方法");
    }
    //jdk9:私有方法
    private void method2(){
        System.out.println("这是一个私有方法");
    }
}

public class B implements A{
}

public class BTest {
    public static void main(String[] args) {
        //接口中的静态方法只能被接口自己调用，其实现类无法调用
       A.method();
       //接口中的默认方法可以被实现类继承，实现类没有重写该方法默认调用接口默认方法，
        // 否则调用实现类重写的方法
       new B().method1();
    }
}