《 Thinking in Java 》第九章 接口

接口和内部类为我们提供了一种将接口与实现分离的更加结构化的方式

抽象类和抽象方法

抽象方法:仅有声明而没有方法体。
下面是抽象方法语法：

abstract void f();

包含抽象方法的类叫做抽象类。如果一个类包含一个或多个抽象方法，该类必须被限定为抽象的。

如果想从一个抽象类继承，并想创建该心累的对象，就必须为基类中的所有抽象方法提供方法定义。如果不这样做，那么导出类也是抽象类，编译器会强制要求用 abstract 关键字来限定这个类。

接口

abstract 允许在类中创建一个或多个没有定义的方法——提供了接口部分，但是没有提供任何相应的具体实现。
interface 产生一个完全抽象的类，它根本就没有提供任何具体的实现。
如果不添加 public 关键字，它只具有包访问权限，接口也可以包含域，但是这些域隐式地是 static 和 final 。
在接口中被定义的方法必须被定义是 public 的，在没有声明时，自动就是 public 。

Java 中的多重继承

继承多个接口，并可以向上转型为每个接口，因为每一个接口都是一个独立类型。

通过继承来扩展接口

一个接口可以扩展另一个或多个接口，从而轻易地做到为接口添加新的声明方法。

组合接口时的名字冲突

interface I1 { void f(); }
interface I2 { int f(int f); }
interface I3 { int f(); }
class C {
	public int f() {
		return 1;
	}
}

class C2 implements I1, I2 {
	@Override
	public void f() {
		
	}
	@Override
	public int f(int i) {
		return 1;
	}
	
}

class C3 extends C implements I2 {
	@Override
	public int f(int i) {
		return 1;
	}
}
class C4 extends C implements I3 {
	public int f() {
		return 1;
	}
}

//class C5 extends C implements I1 {}
//interface I4 extends C implements I1 {}

最后两行为错误的，因为重载、重写和实现混杂在一起，具体参照之前章节重载的规则问题，即可发现错误所在。

接口中的域

放入接口中的任何域都自动是 static 和 final 的。

初始化接口中的域

在接口中的域不能是 “空白 final ”，但是可以被非常量表达式初始化。
因为域是 static 的，他们在第一次被加载时初始化，发生在任何域首次被访问时。
当然这些域不是接口的一部分，他们的值被存储在该接口的静态存储区域内。

嵌套接口

接口可以嵌套在类或其他接口中。

class A {
	interface B {
		void f();
	}
	public class BImpl implements B {
		public void f() {
		}
	}
	private class BImpl2 implements B {
		public void f() {
		}
	}
	
	
	//********************
	
	public interface C {
		void f();
	}
	class CImpl implements C {
		public void f() {
		}
		
	}
	private class CImpl2 implements C {
		public void f() {
		}
		
	}
	
	//**************************
	private interface D {
		void f();
	}
	private class DImpl implements D {
		public void f() {
		};
	}
	public class DImpl2 implements D {
		public void f() {
			
		}
	}
	
	public D getD() {
		return new DImpl2();
	}
	private D dRef;
	public void receiveD(D d) {
		dRef =  d;
		dRef.f();
		
	}
	
	
	interface E {
		interface G{
			void f();
		}
		public interface H {
			void f();
		}
		void g();
	}
	
}

public class NestingInterfaces {
	public class BImp implements A.B {
		public void f() {
		}
	}
	class CImp implements A.C {
		public void f() {
		}
	}
	class EImp implements E {
		public void g() {
		}
	}
	class EGImp implements E.G {
		public void f() {
		}
	}
	class EImp2 implements E {
		public void g() {
		}
		class EG implements E.G{
			public void f() {
			}
		}
	}
	
	public static void main(String[] args) {
		A a = new A();
		// Can't access A.D:
		//! A.D ad = a.getD();
		//Doesn't return anything but A.D:
		//! A.DImp2 di2 = a.getD();
		//Only anoter A can do anythig with getD();
		A a2  = new A();
		a2.receiveD(a.getD());
	}
}

在类中嵌套接口的语法是显而易见的，可以有 public 和“包访问”两种可视性。
作为一种新添加的方式，接口也可以被实现为 private 的，就像在 A.D 中所看到的（相同的语法既适用于嵌套接口，也适用于嵌套类）。
private 接口能够被实现为 DImp 中的一个 private 内部类，也可以实现为 public 类，如 A.DImp2 。但是 A.DImp2 只能被其自身使用。

实现一个 private 接口只是一种方式，它可以强制该接口中的方法定义不要添加任何类型信息（也就是说，不允许向上转型）。

getD() 方法可以看到用 public 方法返回了 private 的接口。显然，在除 A 对象的其他地方，是看不到 这个 D private 接口的，所以只能使用 A 这个本身有权限的对象的某个类似于 receiveD() 方法来使用。


接口 E 说明接口之间也可以嵌套，因此，嵌套在另一个接口中的接口自动就是 public 的，而不能声明为 private 的。