Java中的抽象类和接口

1、抽象类

“抽象方法”。它属于一种不完整的方法，只含有一个声明，没有方法主体。下面是抽象方法声明时采用的语法：

abstract void X();

包含了抽象方法的一个类叫作“抽象类”。如果一个类里包含了一个或多个抽象方法，类就必须指定成abstract（抽象）。否则，编译器会向我们报告一条出错消息。

如果从一个抽象类继承，而且想生成新类型的一个对象，就必须为基础类中的所有抽象方法提供方法定义。如果不这样做（完全可以选择不做），则衍生类也会是抽象的，而且编译器会强迫我们用abstract 关键字标志那个类的“抽象”本质。

即使不包括任何abstract 方法，亦可将一个类声明成“抽象类”。如果一个类没必要拥有任何抽象方法，而且我们想禁止那个类的所有实例，这种能力就会显得非常有用。

Instrument 类可很轻松地转换成一个抽象类。只有其中一部分方法会变成抽象方法，因为使一个类抽象以后，并不会强迫我们将它的所有方法都同时变成抽象。下面是它看起来的样子：

下面是我们修改过的“管弦”乐器例子，其中采用了抽象类以及方法：

//Abstract classes and methods
import java.util.*;

abstract class Instrument4 {
	int i; // storage allocated for each

	public abstract void play();

	public String what() {
		return "Instrument4";
	}

	public abstract void adjust();
}

class Wind4 extends Instrument4 {
	public void play() {
		System.out.println("Wind4.play()");
	}

	public String what() {
		return "Wind4";
	}

	public void adjust() {
	}
}

class Percussion4 extends Instrument4 {
	public void play() {
		System.out.println("Percussion4.play()");
	}

	public String what() {
		return "Percussion4";
	}

	public void adjust() {
	}
}

class Stringed4 extends Instrument4 {
	public void play() {
		System.out.println("Stringed4.play()");
	}

	public String what() {
		return "Stringed4";
	}

	public void adjust() {
	}
}

class Brass4 extends Wind4 {
	public void play() {
		System.out.println("Brass4.play()");
	}

	public void adjust() {
		System.out.println("Brass4.adjust()");
	}
}

class Woodwind4 extends Wind4 {
	public void play() {
		System.out.println("Woodwind4.play()");
	}

	public String what() {
		return "Woodwind4";
	}
}

public class Music4 {
	// Doesn't care about type, so new types
	// added to the system still work right:
	static void tune(Instrument4 i) {
		// ...
		i.play();
	}

	static void tuneAll(Instrument4[] e) {
		for (int i = 0; i < e.length; i++)
			tune(e[i]);
	}

	public static void main(String[] args) {
		Instrument4[] orchestra = new Instrument4[5];
		int i = 0;
		// Upcasting during addition to the array:
		orchestra[i++] = new Wind4();
		orchestra[i++] = new Percussion4();
		orchestra[i++] = new Stringed4();
		orchestra[i++] = new Brass4();
		orchestra[i++] = new Woodwind4();
		tuneAll(orchestra);
	}
}

可以看出，除基础类以外，实际并没有进行什么改变。

2、接口

“interface”（接口）关键字使抽象的概念更深入了一层。我们可将其想象为一个“纯”抽象类。

它允许创建者规定一个类的基本形式：方法名、自变量列表以及返回类型，但不规定方法主体。

接口也包含了基本数据类型的数据成员，但它们都默认为static 和final。接口只提供一种形式，并不提供实施的细节。

为创建一个接口，请使用interface 关键字，而不要用class。为了生成与一个特定的接口（或一组接口）相符的类，要使用implements（实现）关键字。

下面是乐器例子的示意图：

具体实现了一个接口以后，就获得了一个普通的类，可用标准方式对其进行扩展。可决定将一个接口中的方法声明明确定义为“public”。但即便不明确定义，它们也会默认为public。

如下所示：

//Interfaces
import java.util.*;

interface Instrument5 {
	// Compile-time constant:
	int i = 5; // static & final
	// Cannot have method definitions:

	void play(); // Automatically public

	String what();

	void adjust();
}

class Wind5 implements Instrument5 {
	public void play() {
		System.out.println("Wind5.play()");
	}

	public String what() {
		return "Wind5";
	}

	public void adjust() {
	}
}

class Percussion5 implements Instrument5 {
	public void play() {
		System.out.println("Percussion5.play()");
	}

	public String what() {
		return "Percussion5";
	}

	public void adjust() {
	}
}

class Stringed5 implements Instrument5 {
	public void play() {
		System.out.println("Stringed5.play()");
	}

	public String what() {
		return "Stringed5";
	}

	public void adjust() {
	}
}

class Brass5 extends Wind5 {
	public void play() {
		System.out.println("Brass5.play()");
	}

	public void adjust() {
		System.out.println("Brass5.adjust()");
	}
}

class Woodwind5 extends Wind5 {
	public void play() {
		System.out.println("Woodwind5.play()");
	}

	public String what() {
		return "Woodwind5";
	}
}

public class Music5 {
	// Doesn't care about type, so new types
	// added to the system still work right:
	static void tune(Instrument5 i) {
		// ...
		i.play();
	}

	static void tuneAll(Instrument5[] e) {
		for (int i = 0; i < e.length; i++)
			tune(e[i]);
	}

	public static void main(String[] args) {
		Instrument5[] orchestra = new Instrument5[5];
		int i = 0;
		// Upcasting during addition to the array:
		orchestra[i++] = new Wind5();
		orchestra[i++] = new Percussion5();
		orchestra[i++] = new Stringed5();
		orchestra[i++] = new Brass5();
		orchestra[i++] = new Woodwind5();
		tuneAll(orchestra);
	}
}