关于接口的一些学习

java中的接口

接口的概念

同一个类的内部状态数据，各种方法的实现细节完全相同，类是一种具体实现体，而接口定义了一种规范，接口定义了某一批类所需要遵守的规范，接口不关心这些类的内部状态数据，也不关心这些类里方法的实现细节，它只规定这批类里必须提供某些方法，提供这些方法的类就可满足实际需要。

接口的定义

【修饰符】interface 接口名 extends 父接口1，父接口2....
{
	零到多个常量定义
	零到多个抽象方法的定义
	零到多个内部类，接口，枚举的定义
	零到多个私有方法，默认方法或类方法定义
}

需要注意的是
1.修饰符可以是public或者省略，如果省略了public访问控制符，则默认采用包权限控制符，即只有在相同包结构下才可以访问该接口。
2.接口名应与类名采用相同的命名规则，即如果仅从语法角度来看，接口名只要是合法的标识符即可；如果要遵守java可读性规范，则接口名应由多个有意义的单词连缀而成，每个单词首字母大写，单词与单词之间无需任何分隔符，接口名通常能够使用形容词。
3.一个和接口可以有多个直接父接口，但接口只能继承接口，不能继承类。
4.由于接口定义的是一种规范，因此接口里不能包含构造器和初始化块定义。接口里可以包含成员变量（只能是静态变量），方法（只能是抽象实例方法，类方法，默认方法或者私有方法），内部类（包括内部接口，枚举）定义。
下面是一个定义的范例

public interface Output
{
	// 接口里定义的成员变量只能是常量
	int MAX_CACHE_LINE = 50;
	// 接口里定义的普通方法只能是public的抽象方法
	void out();
	void getData(String msg);
	// 在接口中定义默认方法，需要使用default修饰
	default void print(String... msgs)
	{
		for (var msg : msgs)
		{
			System.out.println(msg);
		}
	}
	// 在接口中定义默认方法，需要使用default修饰
	default void test()
	{
		System.out.println("默认的test()方法");
	}
	// 在接口中定义类方法，需要使用static修饰
	static String staticTest()
	{
		return "接口里的类方法";
	}
	// 定义私有方法
	private void foo()
	{
		System.out.println("foo私有方法");
	}
	// 定义私有静态方法
	private static void bar()
	{
		System.out.println("bar私有静态方法");
	}
}

接口里的成员变量默认使用public static final修饰，因此即使另一个类处于不同包下，也可以通过接口来访问接口里的成员变量。如

public class OutputFieldTest
{
	public static void main(String[] args)
	{
		// 访问另一个包中的Output接口的MAX_CACHE_LINE
		System.out.println(lee.Output.MAX_CACHE_LINE);
		// 下面语句将引起"为final变量赋值"的编译异常
		// lee.Output.MAX_CACHE_LINE = 20;
		// 使用接口来调用类方法
		System.out.println(lee.Output.staticTest());
	}
}

接口的继承

接口的继承和类继承不一样，接口能够完全支持多继承，也就是说，一个接口能够有多个直接的父接口，和类继承相似，子接口拓展某个父接口后，将会获得接口里定义的所有抽象方法和常量。

interface InterfaceA
{
	int PROP_A = 5;
	void testA();
}
interface InterfaceB
{
	int PROP_B = 6;
	void testB();
}
interface InterfaceC extends InterfaceA, InterfaceB
{
	int PROP_C = 7;
	void testC();
}
public class InterfaceExtendsTest
{
	public static void main(String[] args)
	{
		System.out.println(InterfaceC.PROP_A);
		System.out.println(InterfaceC.PROP_B);
		System.out.println(InterfaceC.PROP_C);
	}
}

如何使用接口

接口不能用于创建实例，但是接口可以用于声明引用类型的变量。当使用接口来声明引用类型变量时，这个引用类型变量必须引用到其实现类的对象。此外，接口的主要用途就是实现类实现。
而一个类可以实现一个或者多个接口，继承使用extends关键字，实现用Implements关键字。
类实现接口的格式如：

【修饰符】class类名 extends 父类  implements 接口1，接口2.
{
	类体部分
}

实现接口与继承父类相似，一样可以获得所实现接口里定义的常量（成员变量），方法（包括抽象方法和默认方法）。
一个类实现了一个或者多个接口之后，这个类必须完全实现这些接口里定义的全部抽象方法（也就是重写这些抽象方法）；否则，该类将保留从父接口那里继承到的抽象方法，该类也定义成抽象类。
下面是一个关于实现接口的类的例子

// 定义一个Product接口
interface Product
{
	int getProduceTime();
}
// 让Printer类实现Output和Product接口
public class Printer implements Output, Product
{
	private String[] printData
		= new String[MAX_CACHE_LINE];
	// 用以记录当前需打印的作业数
	private int dataNum = 0;
	public void out()
	{
		// 只要还有作业，继续打印
		while (dataNum > 0)
		{
			System.out.println("打印机打印：" + printData[0]);
			// 把作业队列整体前移一位，并将剩下的作业数减1
			System.arraycopy(printData, 1,
				printData, 0, --dataNum);
		}
	}
	public void getData(String msg)
	{
		if (dataNum >= MAX_CACHE_LINE)
		{
			System.out.println("输出队列已满，添加失败");
		}
		else
		{
			// 把打印数据添加到队列里，已保存数据的数量加1。
			printData[dataNum++] = msg;
		}
	}
	public int getProduceTime()
	{
		return 45;
	}
	public static void main(String[] args)
	{
		// 创建一个Printer对象，当成Output使用
		Output o = new Printer();
		o.getData("11111");
		o.getData("22222");
		o.out();
		o.getData("33333");
		o.getData("44444");
		o.out();
		// 调用Output接口中定义的默认方法
		o.print("AAAAA", "BBBBB", "CCCCC");
		o.test();
		// 创建一个Printer对象，当成Product使用
		Product p = new Printer();
		System.out.println(p.getProduceTime());
		// 所有接口类型的引用变量都可直接赋给Object类型的变量
		Object obj = p;
	}
}