06 Java语言核心知识 -10

抽象类与接口

Java可以创建一种类专门用来当作父类，这种类称为 “ 抽象类 ” 。抽象类的作用有点类似于模板，其目的是要设计者依据它的格式来修改并创建新的类。

1 抽象类的基本概念

在Java中可以创建一种类专门用来当作父类，这种类称为 “ 抽象类 ” 。抽象类实际上也是一个类，只是与之前的普通类相比，其中多了抽象方法。

抽象方法是只声明而未实现的方法，所有的抽象方法必须使用abstract关键字声明，包含抽象方法的类也必须使用abstract class声明。

抽象类定义规则如下：
（1）抽象类和抽象方法都必须用abstract关键字来修饰；
（2）抽象类不能被直接实例化，也就是不能直接用new关键字去产生对象；
（3）抽象方法只需声明，而不需实现；
（4）含有抽象方法的类必须被声明为抽象类，抽象类的子类必须覆写所有的抽象方法后才能被实例化，否则这个子类还是个抽象类。

abstract class 类名称{			//定义抽象类
	声明数据成员;
	
	访问权限 返回值的数据类型 方法名称(参数···){
		···定义一般方法
	}

	abstract 返回值的数据类型 方法名称(参数···);
	//定义抽象方法，在抽象方法里没有定义方法体
}

注意：
在抽象类定义的语法中，方法的定义可分为两种：
（1）一种是一般的方法，它和先前介绍过的方法没有什么两样；
（2）另一种是 “ 抽象方法 ” ，它是以abstract关键字为开头的方法，此方法只声明了返回值的数据类型、方法名称与所需要的参数，但没有定义方法体。

2 抽象类实例

限制子类的访问

abstract class Person{
	String name;
	int age;
	String occupation;
	//声明一抽象方法talk()
	public abstract String talk();
}

//Student类继承Person类
class Student extends Person{
	public Student(String name,int age,String occupation){
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}
	//覆写talk()方法
	public String talk(){
		return "学生--→姓名:"+this.name+",年龄:"+this.age+",职业:"+this.occupation+"!";
	}
}

//Worker类继承自Person类
class Worker extends Person{
	public Worker(String name,int age,String occupation){
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}

	//覆写talk()方法
	public String talk(){
		return "工人-→姓名:"+this.name+",年龄："+this.age+",职业:"+this.occupation+"!";
	}
}

class TestAbstractDemo1{
	public static void main(String[] args){
		Student s = new Student("张三",20,"学生");
		Worker w = new Worker("李四",30,"工人");
		System.out.println(s.talk());
		System.out.println(w.talk());
	}
}

可以看到两个子类Student、Worker都分别按各自的要求覆写talk()方法。上面的程序可由下图表示。

可以看到两个子类Student、Worker都分别按各自的要求覆写了talk()方法。上面的程序可由下图表示。

提示：
与一般类相同，在抽象类中也可以定义拥有构造方法，但是这些构造方法必须在子类中被调用。

抽象类的使用

abstract class Person{
	String name;
	int age;
	String occupation;
	public Person(String name,int age,String occupation){
		this.name = name;
		this.age = age;
		this.occupation = occupation;
	}
	public abstract String talk();
}

class Student extends Person{
	public Student(String name,int age,String occupation){
		//在这里必须明确调用抽象类中的构造方法
		super(name,age,occupation);
	}
	public String talk(){
		return "学生-→姓名:"+this.name+",年龄:"+this.age+",职业"+this.occupation+"!";
	}
}

class TestAbstractDemo2{
	public static void main(String[] args){
		Student s = new Student("张三",20,"学生");
		System.out.println(s.talk());
	}
}

抽象类也可以像普通类一样，有构造方法、一般方法和属性，更重要的是还可以有一些抽象方法，留给子类去实现，而且在抽象类中声明构造方法声明构造方法后，在子类中必须明确调用。

3 接口的基本概念

接口（Interface）是Java所提供的另一种重要技术，它的结构和抽象类非常相似，也具有数据成员与抽象方法，但它与抽象类又有以下两点不同。
（1）接口里的数据成员必须初始化，且数据成员均为常量。
（2）接口里的方法必须全部声明为abstract，也就是说，接口不能像抽象类一样保有一般的方法，必须全部是 “ 抽象方法 ” 。
接口定义的语法如下：

Interface 接口名称{				//定义抽象类
	final 数据类型 成员名称 = 常量;		//数据成员必须赋初值
	abstract 返回值的数据类型 方法名称(参数···);
	//抽象方法，注意在抽象方法里没有定义方法的主体
}

接口与一般类一样，本身也具有数据成员与方法，但数据成员一定要赋初值，且此值不能再更改，方法也必须是 “ 抽象方法 ” 。也正因为方法是抽象方法，而没有一般的方法，所以如上格式中，抽象方法声明的关键字abstract是可以省略的。

相同的情况也发生在数据成员身上，因数据成员必须赋初值，且此值不能再被更改，所以声明数据成员的关键字final可以省略。事实上，只要记住以下两点即可。
（1）接口里的 “ 抽象方法 ” 只要做声明即可，而不用定义其处理的方式。
（2）数据成员必须赋初值。

在Java中接口是用于实现多继承的一种机制，也是Java设计中最重要的一个环节，每一个由接口实现的类必须在类的内部覆写接口中的抽象方法，且可自由地使用接口中的常量。

既然接口里只有抽象方法，它只要声明而不用定义处理方式，于是自然可以联想到接口有没有办法像一般类一样，再用来创建对象。利用接口打造新的类的过程，称之为接口的实现（implementation）。

以下为接口实现的语法。

class 类名称 implements 接口A,接口B		//接口的实现
{
	···
}

4 接口实例

接口的使用

interface Person{
//声明了一个Person接口，并在里面声明了3个变量：name，age，occupation，并分别赋值。
	String name = "张三";
	int age = 25;
	String occupation = "学生";
	//声明一抽象方法talk();
	public abstract String talk();
}

//Student类实现自Person类
class Student implements Person{
//声明了一个Student类，此类实现了Person接口，并覆写Person中的talk()方法。
	//覆写talk()方法
	public String talk(){
		return "学生--→姓名:"+this.name+",年龄:"+this.age+",职业:"+this.occupation+"!";
	}
}

class TestInterfaceDemo1{
	public static void main(String[] args){
		Student s = new Student();		//实例化了一个Student的对象s
		System.out.println(s.talk());
	}
}

# 运行结果
学生--→姓名:张三,年龄:25,职业:学生!

在这里需要再次提醒读者的是：接口是Java实现多继承的一种机制，一个类只能继承一个父类，但如果需要一个类继承多个抽象方法的话，就明显无法实现，所以就出现了接口的概念。一个类只可以继承一个父类，但却可以实现多个接口。

接口与一般类一样，均可通过扩展的技术来派生出新的接口。原来的接口称为基本接口或父接口，派生出的接口称为派生接口或子接口。通过这种机制，派生接口不仅可以保留父接口的成员，同时也可加入新的成员以满足实际的需要。

同样，接口的扩展（或继承）也是通过关键字extends来实现的。有趣的是，一个接口可以继承多个接口，这点与类的继承有所不同。下面是接口扩展的语法。

interface 子接口名称 extends 父接口1,父接口2,···{
	··· ···
}

接口的继承使用

interface A{
	int i = 10;				//接口定义中，数据要赋常量值
	public void sayl();		//接口里的“抽象方法”只要做声明即可，而不用定义其处理的方式
}

interface E{
	int x = 40;				//接口定义中，数据要赋常量值
	public void sayE();		//接口里的“抽象方法”只要做声明即可，而不用定义其处理的方式
}

//B同时继承了A、E两个接口
interface B extends A,E{
	int j = 20;				//接口定义中，数据要赋常量值
	public void sayJ();		//接口里的“抽象方法”只要做声明即可，而不用定义其处理的方式
}

//C继承实现B接口，也就意味着要实现A、B、E等3个接口的抽象方法
class C implements B{
	public void sayl(){
		System.out.println("i="+i);
	}

	public void sayJ(){
		System.out.println("j="+j);
	}

	public void sayE(){
		System.out.println("e="+x);
	}
}

class TestInterfaceDemo2{
	public static void main(String[] args){
		C c = new C();
		c.sayl();
		c.sayJ();
	}
}

# 运行结果
i = 10
j = 20