JavaSE 第二十一讲：多态详解 续2

1.抽象类(abstract class)：使用了abstract关键字所修饰的类叫做抽象类。抽象类无法实例化，也就是说，不能new出来一个抽象类的对象(实例)。

抽象类的定义格式：

public abstract class abstractTest
{
}

public class Test
{
	public static void main(String[] args)
	{
		T t = new T();
	}
}

abstract class T
{

}

执行结果：

D:\src>javac Test.java
Test.java:5: 错误: T是抽象的; 无法实例化
                T t = new T();
                      ^
1 个错误

【说明】：以上程序错误的原因是抽象类不能被实例化

2.抽象方法(abstract method)：使用abstract关键字所修饰的方法叫做抽象方法(有声明，无实现)。抽象方法需要定义在抽象类中。相对于抽象方法，之前所定义的方法叫做具体方法(有声明，有实现)。

public class Test
{
	public static void main(String[] args)
	{
	}
}

abstract class T
{
	public abstract void method();
}

上例程序中定义一个抽象方法：public abstract void method();注意直接用分号结束，没有花括号，没有花括号表示没有实现这个方法，注意的是如果有花括号即便是花括号里面没有内容，这也算是有实现的，只不过这个方法体为空，空实现。

3.如果一个类包含了抽象方法，那么这个类一定是抽象类。

4.如果某个类是抽象类，那么该类可以包含具体方法(有声明，有实现)。

public class Test
{
	public static void main(String[] args)
	{
	}
}

abstract class T
{
	public abstract void method();
	public void test()
	{
		System.out.println("test");
	}
}

编译成功！

5.如果一个类中包含了抽象方法，那么这个类一定要声明成abstract class，也就是说，该类一定是抽象类；反之，如果某个类是抽象类，那么该类既可以包含抽象方法，也可以包含具体方法，甚至什么都不包含也是可以的。

6.无论何种情况，只要一个类是抽象类，那么这个类就无法实例化。

7.在子类继承父类（父类是个抽象类）的情况下，那么该子类必须要实现父类中所定义的所有抽象方法；如果子类不实现父类的所有方法，否则，该子类需要声明成一个abstract class。

public class Test
{
	public static void main(String[] args)
	{
		R r = new R();
	}
}

abstract class T
{
	public abstract void method();
	public void test()
	{
		System.out.println("test");
	}
}

class R extends T
{

}

编译结果：

D:\src>javac Test.java
Test.java:18: 错误: R不是抽象的, 并且未覆盖T中的抽象方法method()
class R extends T
^
1 个错误

两种解决办法：

第一种实现父类的抽象方法：

public class Test
{
	public static void main(String[] args)
	{
		R r = new R();
	}
}

abstract class T
{
	public abstract void method();
	public void test()
	{
		System.out.println("test");
	}
}

class R extends T
{
	public void method()
	{
		System.out.println("method");
	}

}

编译通过！

第二种，将子类转为抽象类

public class Test
{
	public static void main(String[] args)
	{
	//	R r = new R();
	}
}

abstract class T
{
	public abstract void method();
	public void test()
	{
		System.out.println("test");
	}
}

abstract class R extends T
{

}

编译通过！

【说明】：此时子类还是不能被实例化，如果想使用这个子类，还必须定义一个R的一个子类，把method的方法实现出来。

继续修改以上例子：

public class Test
{
	public static void main(String[] args)
	{
	//	R r = new R();
	}
}

abstract class T
{
	public abstract void method();
	public void test()
	{
		System.out.println("test");
	}
}

abstract class R extends T
{
	public void method()
	{
		System.out.println("method");
	}
}

编译成功！

【说明】：R继承了T，则R类里面有两个方法，一个方法是实现T的抽象方法，另外一个是从T当中继承下来的具体方法test()；此时把R声明为抽象类正常，应该抽象类本身可以包含具体方法，也可以包含抽象方法。

8.抽象方法，抽象类有什么作用，有声明没实现？
这个实现是推迟到子类当中去实现的，父类实现不了，父类可以声明一个抽象方法，写一个注释，告诉这个类的实现者，告诉它我这个方法有什么用，可以让子类去实现，对于一个父类来说，可以有多个子类，而不同的子类可以实现不同的方法。比如说在父类中定义一个排序的抽象方法，而在这个父类的各个子类当中可以分别实现这个抽象方法，具体子类实现方法有可能是用冒泡排序，有可能是用哈希排序，每种实现规则的不一样，从这一点可以看出，抽象类和抽象方法主要起到一个规范，约束的作用。

举个例子加深理解

public class Test2
{
	public static void main(String[] args)
	{
		Shape shape = new Triangle(10,6);
		int area = shape.computerArea();
		System.out.println("triangle:" + area);
		
		shape = new Rectangle(10,10); //前面area用完，shape指向完已经关闭，下面可以不用定义直接使用。     
		area = shape.computerArea();
	        System.out.println("rectangle" + area);	
	}

}

abstract class Shape
{
	public abstract int computerArea(); //计算形状面积
}

class Triangle extends Shape
{
	int width;
	int height;
	public Triangle(int width, int height)  //用构造方法来完成一些初始化工作
	{
		//注意此处用this是因为生命完构造方法之后，把方法外面的int width;和int height;给屏蔽掉了，所以这个地方要访问到外面的width和height成员变量就用this，this表示对自己的引用。这样就把方法参数传给成员变量。
		this.width = width;     
		this.height = height;
	}

	public int computerArea()
	{
		return width * height / 2;
	}
}

class Rectangle extends Shape
{
	int width;
	int height;
	public Rectangle(int width,int height)
	{
		this.width = width;
		this.height = height;
	}
	public int computerArea()
	{
		return width * height;
	}
}

执行结果：

D:\src>java Test2
triangle:30
rectangle100

【说明】：从这个例子说可以看到抽象方法起到规范，规则子类行为的作用具体怎么实现满足这个规则由子类去实现。约束规则，比如说定义什么类型，传递什么参数等。