01.接口

1、作用

• 我们知道 Java 仅支持单继承，也就是说一个类只允许有一个直接父类，这样保证了数据的安全
• 接口就是为了解决 Java 单继承这个弊端而产生的
• 继承和接口的双重设计既保持了类的数据安全也变相实现了多继承

// interface
interface Animal {
  public void eat(); // 接口方法(没有实现)
  public void run(); // 接口方法(没有实现)
}

2、基本使用

• 要访问接口方法，必须实现接口 （有点像继承的），由另一个类使用implements关键字（而不是extends）
• 接口方法的实现由用implements关键字的类提供
• 注意：
  • 与抽象类一样，接口不能用于创建对象
  • 接口方法没有实现，实现由使用implements关键字类提供
  • 在实现接口时，必须重写其所有方法
  • 接口中的方法在默认情况下public abstract
  • 接口属性默认情况下public static final
  • 接口不能包含构造函数（因为它不能用于创建对象）

public class Test{
    public static void main(String args[]){
        Cat myCat = new Cat();  // 创建Cat对象
        myCat.eat();
        myCat.sleep();
    }
}

// Interface
interface Animal {
    public void eat();   // 接口方法(没有实现)
    public void sleep(); // 接口方法(没有实现)
}

// Cat 实现 Animal 接口
class Cat implements Animal {
    public void eat() {
        // 这里提供了eat()的实现
        System.out.println("吃鱼");
    }
    public void sleep() {
        // 这里提供了sleep()的实现
        System.out.println("Zzz");
    }
}

3、多接口

• 要实现多个接口，需要用逗号分隔它们

package com.case_01;

public class Test{
    public static void main(String args[]){
        DemoClass myObj = new DemoClass();
        myObj.myMethod();
        myObj.myOtherMethod();
    }
}

interface FirstInterface {
    public void myMethod(); // 接口方法
}

interface SecondInterface {
    public void myOtherMethod(); // 接口方法
}

class DemoClass implements FirstInterface, SecondInterface {
    public void myMethod() {
        System.out.println("myMethod");
    }
    public void myOtherMethod() {
        System.out.println("myOtherMethod");
    }
}

4、接口和抽象类

• 1）接口的方法默认是 public

  • 所有方法在接口中不能有实现（Java 8 开始接口方法可以有默认实现），而抽象类可以有非抽象的方法

• 2）接口中除了 static 、final 变量，不能有其他变量，而抽象类可以

• 3）一个类可以实现多个接口，但只能实现一个抽象类

  • 接口自己本身可以通过 extends 关键字扩展多个接口

• 4）接口方法默认修饰符是 public ，抽象方法可以有 public 、protected 和 default 这些修饰符

  • 抽象方法就是为了被重写所以不能使用 private 关键字修饰

• 5）从设计层面来说，抽象是对类的抽象，是一种模板设计，而接口是对行为的抽象，是一种行为的规范

02.接口其他使用

1、默认方法

• 我们可以使用 default 关键字，在接口主题中实现带方法体的方法
• 在实现类中，可以不实现默认方法

public class Test{
    public static void main(String[] args){
        Student stu = new Student();
        stu.run();  // 学生可以跑步
        stu.eat();  // 我是默认的吃方法
    }
}

// 我们可以使用 default 关键字，在接口主题中实现带方法体的方法
interface Person {
    void run();

    default void eat() {
        System.out.println("我是默认的吃方法");
    }
}

//  调用和重写：在实现类中，可以不实现默认方法
class Student implements Person {
    @Override
    public void run() {
        System.out.println("学生可以跑步");
    }
}

2、静态方法

• 使用 static 关键字在接口中声明静态方法
• 类中的静态方法只能被子类继承而不能被重写
• 如果想要调用接口中的静态方法，只需使用接口名

public class Test{
    public static void main(String[] args){
        // 如果想要调用接口中的静态方法，只需使用`接口名`
        Person.sayHello();
        
        Student myObj = new Student();
        myObj.walk();
    }
}

interface Person {
    void walk();
    // 声明静态方法
    static void sayHello() {
        System.out.println("Hello Tom!");
    }
}

class Student implements Person {
    @Override
    public void walk() {
        // 调用接口中的类方法
        System.out.println("学生会走路");
    }
}
/*
Hello Tom!
学生会走路
 */

3、多接口重名默认方法

public interface MyInterface1 {
    default void defaultMethod() {
        System.out.println("我是MyInterface1接口中的默认方法");
    }
}

public interface MyInterface2 {
    default void defaultMethod() {
        System.out.println("我是MyInterface2接口中的默认方法");
    }
}

• 解决办法是在实现类中重写这个默认方法

public class MyClass implements MyInterface1, MyInterface2 {
	public void defaultMethod() {
      	System.out.println("我是重写的默认方法");
    }
}

4、多接口重名常量

• 例如有两个接口，存在重名的常量

public interface MyInterface1 {
    final int NUM = 100;
}

public interface MyInterface2 {
	final int NUM = 200;
}

• 此时在实现类中，我们可以使用**接口名.常量名**的方式分别调用

public MyClass implements MyInterface1, MyInterface2 {
	  System.out.println(MyInterface1.NUM);  	
	  System.out.println(MyInterface2.NUM);  	
}