Java接口的理解和实现

1 接口概述

1. 接口是方法的集合，接口的内部主要就是封装了方法，包含抽象方法、默认方法、静态方法和私有方法
2. 接口是Java中的一种引用类型，使用interface关键字
3. Java中的引用类型：数组、类、接口
4. 接口不能被实例化，它用来被实现（implements）,一个实现接口的类，如果是非抽象类，必须重写接口中所有的抽象方法，否则是抽象类

2 接口定义格式

public interface 接口名称 {
	// 抽象方法
	// 默认方法
	// 静态方法
	// 私有方法
}

2.1 含有抽象方法

抽象方法：使用abstract关键字修饰，可以省略，没有方法体。该方法供子类重写使用。

public interface InterFaceName {
	public abstract void method();
}

2.2 含有默认方法和静态方法

默认方法：使用default修饰，不可省略，供子类调用或重写使用

静态方法：使用static修饰，供接口直接调用

public interface InterFaceName {
	public default void method1() {
		// 执行语句
	}
	public static void method2() {
		// 执行语句
	}
}

2.3 含有私有方法和私有静态方法

私有方法：使用private修饰，供接口中的默认方法调用

私有静态方法：使用private static修饰，供接口中的默认方法和静态方法调用

public interface InterFaceName {
	private void method() {
		//执行语句
	}
}

3 接口实现

3.1 实现概述

类与接口的关系为实现关系，即类实现接口，该类称为接口的实现类，实现使用implements关键字。

非抽象类实现接口：

1. 必须重写接口中所有抽象方法；
2. 继承了接口的默认方法，既可以直接调用，也可以重写。

实现格式：

class 类名 implements 接口名 {
	// 重写接口中抽象方法【必须】
	// 重写接口中默认方法【可选】
}

示例：

# 定义接口
public interface LiveAble {
	// 定义抽象方法
	public abstract void eat();
	public abstract void sleep();
}

# 定义实现类
public class Animal implements LiveAble {
	@Override
	public abstract void eat() {
		System.out.println("吃东西");
	}
	@Override
	public abstract void sleep() {
		System.out.println("晚上睡");
	}
}

# 定义测试类
public class InterfaceDemo {
	public static void main(String[] args) {
		//创建子类对象
		Animal a = new Animal();
		//调用实现后的方法
		a.eat();
		a.sleep();
	}
}

---

吃东西
晚上睡

3.2 默认方法的使用

可以直接调用，也可以重写后调用，但只能通过实现类的对象来调用。

1 直接调用

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}
public class Animal implements LiveAble {
	// 什么都不用写，直接调用
}
public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}

---

天上飞

2 重写后调用

public interface LiveAble {
    public default void fly(){
        System.out.println("天上飞");
    }
}
public class Animal implements LiveAble {
	@Override
	public void fly() {
		System.out.println("自由自在的飞");
	}
}
public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象
        Animal a = new Animal();
        // 调用默认方法
        a.fly();
    }
}

---

自由自在的飞

3.3 静态方法的使用

接口中的静态方法只能使用接口名调用，不可以通过实现类的类名或者实现类的对象调用。

public interface LiveAble {
    public static void fly(){
        System.out.println("天上飞");
    }
}
public class Animal implements LiveAble {
    // 无法重写静态方法
}
public class InterfaceDemo {
    public static void main(String[] args) {
        // 创建子类对象
        // Animal.fly();//错误，实现类不能调用
        Animal a = new Animal();
        // a.fly();//错误，实现类的对象也不能调用
        LiveAble.fly();
    }
}

---

天上飞

3.4 私有方法的使用

私有方法：只有默认方法可以调用

私有静态方法：默认方法和静态方法可以调用

public interface LiveAble {
    default void func() {
        func1();
        func2();
    }
    
    private void func1() {
        System.out.println("吃饭");
    }
    
    private void func2() {
        System.out.println("睡觉");
    }
}

4 接口的多实现

一个类只能继承一个父类，但一个类可以实现多个接口。并且，一个类能继承一个父类，同时实现多个接口。

实现格式：

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

重名问题：

1. 在多实现中，如果默认方法有重名的，必须重写一次；
2. 在多实现中，存在同名的静态方法并不会冲突，原因是只能通过各自接口名访问静态方法；
3. 如果一个类既继承一个父类，又实现若干个接口，父类中的成员方法与接口中的默认方法重名，子类就近选择执行父类的成员方法

5 接口的多继承

1. 一个接口可以继承多个接口，这与类的单继承不同
2. 如果父接口中的默认方法有重名的，子接口必须重写一次
3. 子类重写默认方法时，default关键字不可以保留
4. 子接口重写默认方法时，default关键字可以保留

6 其他注意事项

1. 接口中，成员变量必须被public static final修饰，必须赋初值，不能被修改；
2. 接口中没有构造方法，不能创建对象；
3. 接口中没有静态代码块；