【Java面向对象】java学习之旅17-接口_设计一个接口,然后设计接口的实现类,使用关键字 implements 实现接口中的方法-优快云博客

本文链接：https://blog.youkuaiyun.com/Jeffhan_java/article/details/123329641

定义：

表示一种能力或者规范

使用：

使用interface关键字声明接口
接口中可以声明常量、抽象方法、静态方法、默认实现的方法
用implements关键字实现接口
实现类中需要重写实现所有的抽象方法，也可以重写接口中默认实现的方法

一个简单的接口实例：

//接口的声明用interface,可以继承多个接口
public interface MyInterface extends MyFaterInterface, MyFaterInterface2 {

    //接口中可以定义的有：
	// 常量
	public static final String NAME = "阿文";
	
	// 默认使用public static final修饰
	int AGE = 18;
	
	// 静态方法 jdk1.8+
	public static void fun1() {
		System.out.println("fun1");
	}
	
	// 默认实现的方法 jdk1.8+
	public default void fun2() {
		System.out.println("fun2");
	}
	
	// 抽象方法
	public abstract void fun3();
	
	// 默认使用public abstract修饰
	void fun4();
}

接口中的抽象方法需要子类去实现：

/**
 * 接口实现类
 */
 //类可以实现多个接口
public class MySubClass implements MyInterface, MyInterface2 {

	@Override
	// 接口默认实现的方法，也可以重写
	public void fun2() {
		System.out.println("sub-fun2");
	}

	@Override
	public void fun3() {
		System.out.println("sub-fun3");
	}

	@Override
	public void fun4() {
		System.out.println("sub-fun4");
	}

}

注意事项：

实现类及其对象都无法调用接口的静态方法，只能通过接口名调用
实现类可以获得接口中所有静态常量
jdk1.8+接口中的方法不只是抽象方法，还有静态方法和默认实现的方法
一个类可以实现多个接口，用逗号分隔
接口只能继承接口，多继承，使用逗号分隔
实现类需要实现接口中的所有抽象方法，否则该类是一个抽象类

我们在主类中测试一下：

    @Test
	public void test2() {
	    //通过实现类的子类调用自身重写后的方法
		MySubClass msc = new MySubClass();
		msc.fun3();
		msc.fun4();
		msc.fun2();
		
		//接口中的静态方法只能通过自身的接口名去调用
		MyInterface.fun1();
		//msc.fun1(); 实现类的对象无法调用接口的静态方法
		//MySubClass.fun1();
		
		//接口可以自己点出自身的静态常量
		System.out.println(MyInterface.NAME);
		System.out.println(MyInterface.AGE);
		
		//实现类可以获得接口中所有静态常量
		System.out.println(msc.NAME);
		System.out.println(msc.AGE);
		System.out.println(MySubClass.NAME);
		
	}

分类：

普通接口：可以有静态常量、抽象方法、静态方法、默认实现的方法
标识接口：接口内没有任何成员，标识一种能力（如Serializable标识该类可序列化）
函数式接口：接口中只能有一个抽象方法，便于函数式编程使用

上述所示的是一般普通的接口

标识接口

 /**
 * @author  unascribed
 * @see java.io.ObjectOutputStream
 * @see java.io.ObjectInputStream
 * @see java.io.ObjectOutput
 * @see java.io.ObjectInput
 * @see java.io.Externalizable
 * @since   JDK1.1
 */
 //这种所示的是标识性的接口，该接口类强调的是一种能力，具体的实现会在java虚拟机中进行
 public interface Serializable {
 }

函数式接口：

/**
 * 自定义函数式接口
 */
 //函数式接口的注解，规定函数式接口内只定义有一个抽象方法，可以有多个其他
 //的静态方法。
@FunctionalInterface
public interface MyFunInterface {
	
	double apply(double d);
	
}

/**
 * 自定义函数式接口的实现（传统的实现方式）
 */
public class MyFunInterfaceImpl implements MyFunInterface {

	@Override
	public double apply(double d) {
		return Math.round(d * 100) * 0.01;
	}
	
}

传统用法 vs 接口的内部实现 vs 函数式编程

    @Test
	public void test3() {
		//传统用法
		MyFunInterfaceImpl mfii = new MyFunInterfaceImpl();
		double result = mfii.apply(3.1415);
		System.out.println(result);
		
		//使用接口的内部实现优化（这里默认的是创建了一个接口的隐式对象，需要我们实现里面的方法才能创建该对象。）
		MyFunInterface mfi = new MyFunInterface() {
			@Override
			public double apply(double d) {
				return Math.round(d * 1000) * 0.001;
			}
		};
		System.out.println(mfi.apply(3.1415));
		
		//使用函数式编程优化
		MyFunInterface mfi1 = d -> {return Math.round(d * 1000) * 0.001;};
		System.out.println(mfi1.apply(3.1415));
	}

接口和抽象类的异同：

相同点：

1. 都不能实例化，但是可以内部实现（匿名内部类）。
2. 都可以包含抽象方法。
3. 子类或者实现类在继承或者实现抽象类或者方法的时候，必须重写实现所有的抽象方法，否则这个类还是抽象类。
4. 抽象类和接口都是引用数据类型，都可以作为父类引用指向子类对象，实现了多态。

不同点：

1. 子类只能继承一个抽象类，可以实现多个接口。
2. 抽象类只能继承一个抽象类，接口可以继承多个接口。
3. 抽象类可以声明变量、常量，接口中只能声明常量。
4. 抽象类的成员可以使用所有权限修饰符，接口中只能使用public。
5. 抽象类有构造方法，接口没有构造方法。
6. 抽象类可以有抽象方法和普通方法，接口只有抽象方法、静态方法、默认实现的方法。
7. 抽象类可以实现接口，接口无法继承抽象类。