2021-07-22

java中的接口详解（IDEA版本）

（1）：接口的定义：它与定义类方式相似，但是使用 interface 关键字。它也会被编译成.class文件，但一定要明确它并不是类，而是另外一种引用数据类型。
（2）：接口的使用：接口不可以实例化，但是可以被实现。实现接口的类，必须重写接口中的所有的抽象方法，但是如果该类是抽象类，其可以不用重写接口的抽象方法.如下：

# 定义一个关于animal的接口
package demo;

public interface animal {

    public abstract void speak();

    public abstract void eat();

    public static void run(){
        System.out.println("animal can run ");
    }
    
	public default void sleep(){
        System.out.println("animal need sleeping");
    }

}

（3）：类的实现，即需要重写接口中的所有的抽象类, 同时继承了接口的默认方法，可以通过实现类的实例化进行直接调用，也可以进行重写

public class dog implements animal {

    @Override
    public void speak() {
        System.out.println("汪汪汪");
    }

    @Override
    public void eat(){
        System.out.println("狗吃肉");
    }

    public static void main(String[] args) {
        dog haha = new dog();
        haha.speak();
        haha.eat();
        haha.sleep();

    }
}

（4）：抽象类的实现

package demo;

public abstract class dog_abstract implements animal {

}

（5）：关于接口的方法
1：默认方法：使用 default 修饰，不可省略，供子类调用或者子类重写
2：静态方法：使用 static 修饰，供接口直接调用,不可以通过类名或者实现类的对象调用

# 定义一个接口
public interface LiveAble {
	public static void run(){
		System.out.println("跑起来~~~");
	}
}

public class Animal implements LiveAble {
// 无法重写静态方法
}

public class InterfaceDemo {
	public static void main(String[] args) {
		// Animal.run(); // 【错误】无法继承方法,也无法调用
		LiveAble.run(); //
	}
}
输出结果：
跑起来~~~

3：私有方法：使用 private 修饰，供接口中的默认方法或者静态方法调用。（在jdk1.8中，不提供该功能）私有方法：只有默认方法可以调用。私有静态方法：默认方法和静态方法可以调用。

（6）：接口的多实现：在继承当中一个子类只可以继承一个父类，但是一个类却可以实现多个接口，这就是接口的多实现。

class 类名 [extends 父类名] implements 接口名1,接口名2,接口名3... {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【不重名时可选】
}

多实现中的重名问题：
1：抽象方法重名：只需要重写一次即可

# 定义多个接口
interface A {
	public abstract void showA();
	public abstract void show();
}
interface B {
	public abstract void showB();
	public abstract void show();
}

# 实现多个接口并对抽象类进行重写
public class C implements A,B{
	@Override
	public void showA() {
		System.out.println("showA");
	}
	@Override
	public void showB() {
		System.out.println("showB");
	}
	@Override
	public void show() {
		System.out.println("show");
	}
}

2：默认方法重名：必须重写一次默认方法

interface A {
	public default void methodA(){}
	public default void method(){}
}
interface B {
	public default void methodB(){}
	public default void method(){}
}

# 有多个默认方法重名必须进行重写一次
public class C implements A,B{
	@Override
	public void method() {
		System.out.println("method");
	}
}

3：静态方法重名：无影响，因为可以通过接口名进行分别调用

（7）：接口的继承：一个接口能继承另一个或者多个接口，这和类之间的继承比较相似。接口的继承使用 extends 关键字，子接口继承父接口的方法。如果父接口中的默认方法有重名的，那么子接口需要重写一次。同时子接口和子类都可以继承多个接口，子接口，重写默认方法时，default关键字可以保留，子类重写默认方法时，default关键字不可以保留。

interface A {
	public default void methodA(){}
	public default void method(){}
}
interface B {
	public default void methodB(){}
	public default void method(){}
}

# 有多个默认方法重名必须进行重写一次（子类继承多个接口）
public class C implements A,B{
	@Override
	public void method() {
		System.out.println("method");
	}
}

# 有多个默认方法重名必须进行重写一次（子接口继承多个接口）
interface D extends A,B{
	@Override
	public default void method() {
		System.out.println("DDDDDDDDDDDDDD");
	}
}

（8）：接口中的其他成员特点
接口中，无法定义成员变量，但是可以定义常量，其值不可以改变，默认使用public static final修饰。
接口中，没有构造方法，不能创建对象。
接口中，没有静态代码块