第九章 接口和抽象类 接口详解

1.完全解耦

• 一个方法 void next(Processor p),如果p仅仅是一个父类 或抽象类的话，那传入这个方法的p只能是继承晕Processor的子类或Processor类，
  其他的类则不能传入，而如果是Processor是一个接口的话，那传入其中的类只要实现这个接口就可以啦，这个类就可以留出空间去继承其他
  的类了，也可以去实现其他接口，这个方法的耦合性就低了很多。
• 让方法接受接口类型，是一种让任何类对该方法进行适配的方式，只要这个类implement这个接口。
  

2.java中的多重继承

• java是单继承语言，但可以通过借口的方式实现多重继承。
  因为接口根本没有任何具体实现，也就是说没有任何与接口相关的存储，
• 实现接口和继承的不同之处，
  继承 子类需要在构造方法中先调用父类构造方法完成父类的初始化，因为子类中可能有依赖父类的方法。
  接口不用，因为子类一点点都没有依赖所实现的接口，这也是接口为什么能实现多重继承的一个原因。

• interface CanFight{
  	void fight();
  }
  interface CanSwim{
  	void swim();
  }
  interface CanFly{
  	void fly();
  }
  class ActionCharacter{
  	public void fight(){}
  }
  
  class Hero extends ActionCharacter
  	implements CanFight,CanFly,CanSwim{
  	public void swim() {}
  	public void fly() {}
  	/**
  	 * 下面这句代码注释掉也没关系，虽然我们implement了CanFight,但因为父类中有这个方法，所以不需要实现。
  	 * 即使没有显示的定义fight()方法，其定义也会随着父类而来
  	 */
  //	public void fight(){}
  }
  
  public class Adventure {
  }
  

• 当使用Hero时，他会被以此向上转型为相应的接口类型。

3.通过继承来扩展接口（接口继承接口）

• 接口继承接口，可以实现接口的扩展。
• 当一个类实现了一个继承接口的接口的时候，那这个类必须实现所有接口的方法
  另外接口继承接口也用extends关键字，但extends后面可以跟多个接口，用逗号隔开。
  

  interface CanDos extends CanFly,CanSwim{
  	void dos();
  }
  class ActionCharacter implements CanDos{
  	public void fight(){}
  	public void fly() {}
  	public void swim() {}
  	public void dos() {}
  }
  

4.组合接口时的方法名字的冲突

• 当打算组合的接口中使用相同的名字会造成代码的可读性的混乱，虽然运行不会出什么问题，尽量避免这种情况。
  

  interface I1{
      void f();
  }
  interface I2{
      void f();
  }
  interface I3 extends I2{
      void f();
  }
  
  class C1 implements I3,I2{
      public void f() {}
  }
  
  public class Test extends C1{
  
      public void f() {System.out.println("呵呵");}
      public static void main(String[] args) {
          C1 i = new Test();
          i.f();
      }
  }
  
  
  

  
  
  

5.接口相当于枚举

• 因为在接口中的域都是final、static和public的（public final static int i = 0;）,所以在java没有枚举之前接口可以当作其来达到相同的作用。
  因为接口中的域都是final的所以必须对它们初始化。
  

  interface RandVal{
  	Random RAND = new Random(47);
  	int RANDOM_INT = RAND.nextInt(10);
  	long RANDOM_LONG = RAND.nextInt()*10;
  }
  public class TestRandVals {
  	public static void main(String[] args) {
  		System.out.println(RandVal.RANDOM_INT);
  		System.out.println(RandVal.RANDOM_LONG);
  	}
  }

• 这些域不是接口的一部分，他们的值存储在该接口的静态存储区域内。
  
  

6.嵌套接口

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

• class A{
  	interface B{
  		void f();
  	}
  	public class BImp implements B{
  		public void f() {}
  	}
  	private class BImp2 implements B{
  		public void f() {}
  	}
  	//private类型的
  	private interface D{
  		void f();
  	}
  	private class DImp implements D{
  		public void f() {}
  	}
  	public class DImp2 implements D{
  		public void f() {}
  	}
  }
  
  interface E{
  	interface G{
  		void f();
  	}
  	public interface H{
  		void f();
  	}
  	void g();
  }
  
  public class NestingInterfaces {
  }

  上面的代码有一处特出的情况，就是接口在类内部被声明为private修饰的时候。
  这只是一种方法，因为是private的，它会强制不允许向上转型。
• 当实现某个接口时，并不需要实现嵌套在其内部的任何接口，继承类也一样。
  
  

7.接口和工厂

• 可以通过接口实现工厂模式，使用工厂对戏那个生成接口的某个实现对象。使用设计模式应该考虑到自身的情况，选择适合的设计模式。
  但也有情况是不能使用模式的。

总结：

• 继承和接口不能滥用，考虑情况而定，可以直接实现类的时候优先实现类。