第九章 接口和抽象类 基本使用

导语：

• 接口和内部类为我们提供了一种将接口和实现分离的更加结构化的方法。
• Java关键字这个事实表明人们认为这些思想很重要，以至于要提供对它们的直接支持。

1.抽象类

• 第八章中的Instrument乐器类中直接调用其方法会出错。因为Instrument的目的是为实现它的子类提供一个通用的接口。
  目的是不同的子类以不同的方式实现此接口。
• 通用接口建立起一种基本形式，表示所有子类的共同部分。另一种说法是将Instrument类称作抽象基类，简称抽象类。
• 抽象类的作用:通过抽象类创建的对象几乎没有意义，只是希望通过抽象类这个抽象接口引用操纵一系列类（多态）。
• 注意：1.调用所有抽象类中的方法编译器都会报错。
  2.如果一个类包含抽象方法，那么它必须被声明为抽象类 关键字abstract。
  3.如果创建抽象类的对象时，编译器会报错，编译器会确保抽象类的纯粹性。
  
• 创建使用抽象类：继承一个抽象类，必须实现其中所有的抽象方法。如果不这样做，那么导出类也是抽象类，并且编译器将会强制用abstract关键字来限定这个类。
• 抽象类的优点：抽象类可以使类的抽象性明确起来，并告诉用户和编译器打算怎样来使用它们，抽象类是很有用的重构工具，使我们可以很容易的将公共方法沿继承层次结构向上移动。
  
• 代码提供:

  abstract class Instrument {
  	abstract void play(String n);
  	// 非抽象方法
  	private String what() {return "Instrument";}
  	abstract void adjust();
  }
  
  class Wind extends Instrument {
  	void play(String n) {System.out.println("Wind" + n);}
  	void adjust() {}
  }
  
  // 没实现完抽象父类中的方法
  abstract class Percussion extends Instrument {
  	// 实现其中的一个
  	void play(String n) {
  		System.out.println("Percussion" + n);
  	}
  	// 没实现这个方法,虽然这个adjust和父类Instrument中的一样，但这个方法是Percussion的抽象方法
  	abstract void adjust();
  	// 这个抽象类还可以定义其他抽象的方法
  	abstract void next();
  }
  
  class Brass extends Wind {
  }
  
  public class Music {
  	public static void main(String[] args) {
  		// 声明一个Instrument,这样会报错
  		// Instrument instrument = new Instrument();
  		// 不过可以这样
  		Instrument inside = new Instrument() {
  			void play(String n) {
  				System.out.println("内部定义:" + n);
  			}
  
  			void adjust() {
  			}
  		};
  		// 调用
  		Instrument[] orchestra = { inside, new Wind(), new Brass() // 因为这个是个空类，没有重写父类方法，他就只能执行父类中的方法了。
  		};
  		for (Instrument i : orchestra) {
  			i.play("呵呵：");
  		}
  	}
  }
  

  
  
  

   

2.接口

• 接口关键字使抽象的概念更向前迈了一步
• interface关键字产生了一个完全抽象的类，其中的方法声明没有任何具体的实现，仅仅是声明而已，抽象类可以有部分方法实现。
• 一个接口表示：“所有实现了该特定接口的类看起来都像这样”。
• java是单一继承的，而接口的产生就可以实现多重继承了，可以向上转型（子类有父类的引用）为多种父类的类型。
• 接口中的域（字段等）都隐式的声明为static和final的，并且是public的。接口中的方法也都必须是public的，否则编译器会报错。
• 实现接口，需要使用implements关键字，表示“interface”只是它的表象。
• 代码：
  

  interface Instrument{
  	int i = 0;//接口中的域 static&final
  	void play (String n);
  	public void adjust();
  }
  //接口也可以继承接口而不必实现其中的方法,但不能使用implements关键字
  interface Insturment2 extends Instrument{
  	//但父接口（Instrument）的方法并没有被重写，虽然是一样的，这个play仅属于Insturment2
  	public void play(String n);
  }
  class Wind implements Instrument{
  	public void play(String n) {System.out.println("Wind" + n);}
  	public void adjust() {}
  }
  class Percussion implements Instrument{
  	public void play(String n) {System.out.println("Percussion" + n);}
  	public void adjust() {}
  }
  public class Music {
  	public static void main(String[] args) {
  		Instrument instrument = new Instrument() {
  			public void play(String n) {System.out.println("内部实现：" + n);}
  			public void adjust() {}
  		};
  		Instrument[] orchestra = {
  			new Wind(),new Percussion(),instrument
  		};
  //		Instrument.i ++;//因为是final的这样是错误的调用，因为是静态、public，可以Instrument.i
  	}
  }