JavaSE第十九讲：多态详解

写一个程序，输出16在内的随机数，此程序与本讲内容不相关，仅作为随机抽查来用

import java.util.Random;

public class RandomTest
{
	public static void main(String[] args)
	{
		Random random = new Random();
		int result = random.nextInt(16) + 1;
		System.out.println(result);
	}
}

输出结果：

D:\src>java RandomTest
1

【说明】：此处输出结果是1到16在内的随机数。

1. 多态：父类型的引用可以指向子对象。

public class PolyTest
{
	public static void main(String[] args)
	{
		Parent parent = new Parent();
		parent.sing();
	}
}

class Parent
{
	
	public void sing()
	{
		System.out.println("parent is singing");
	}
	
}

class Child extends Parent
{
	public void sing()
	{
		System.out.println("child is singing");
	}
}

执行结果：

D:\src>java PolyTest
parent is singing

修改以上程序第三行那段代码：

	public static void main(String[] args)
	{
	//	Parent parent = new Parent();
	//	parent.sing();
		Child child = new Child();
		child.sing();
	}

执行结果：

D:\src>java PolyTest
child is singing

继续修改以上程序第三行那段代码：

	public static void main(String[] args)
	{
	//	Parent parent = new Parent();
	//	parent.sing();
	//	Child child = new Child();
	//	child.sing();
		
		Parent p = new Child();
		p.sing();
	}

执行结果：

D:\src>java PolyTest
child is singing

【说明】：Parent p = new Child(); p类型是父类型，看类型是要左边的那个Parent。指向了子类生成的属性，接下来调用sing();方法，指向child(),就调用子类的方法，所以输出子类的方法，指向谁就调用谁的方法。

继续修改以上程序

public class PolyTest
{
	public static void main(String[] args)
	{
	//	Parent parent = new Parent();
	//	parent.sing();
	//	Child child = new Child();
	//	child.sing();
		
		Parent p = new Child();
		p.sing();
	}
}

class Parent
{
	
	public void sing()
	{
		System.out.println("parent is singing");
	}
	
}

class Child extends Parent
{
	/*
	public void sing()
	{
		System.out.println("child is singing");
	}
	*/
}

执行结果：

D:\src>java PolyTest
parent is singing

【说明】：此时子类继承了父类的sing()方法。

【重要】继续修改以上程序：

public class PolyTest
{
	public static void main(String[] args)
	{
	//	Parent parent = new Parent();
	//	parent.sing();
	//	Child child = new Child();
	//	child.sing();
		
		Parent p = new Child();
		p.sing();
	}
}

class Parent
{
/*	
	public void sing()
	{
		System.out.println("parent is singing");
	}
	*/
}

class Child extends Parent
{
	
	public void sing()
	{
		System.out.println("child is singing");
	}
	
}

执行结果：

D:\src>javac PolyTest.java
PolyTest.java:11: 错误: 找不到符号
                p.sing();
                 ^
  符号:   方法 sing()
  位置: 类型为Parent的变量 p
1 个错误

【说明】：p是指向子类对象的引用，但是p还是Parent类型的，而Parent中没有这个方法,对于多态可以这样理解，即便p是指向子类，但是必须在p所在类型Parent中必须存在这个方法，才可以调用。p在调用子类的方法的时候，会去检查p所在类型是否有这个方法，如果有的话，就调用子类的方法，否则报错。

2.Parent p = new Child();当使用多态方式调法时，首先检查父类中是否有sing()方法,如果没有则编译出错；如果有再去调用子类的sing()方法。

继续修改以上程序

public class PolyTest2
{
	public static  void main(String[] args)
	{
		Animal a = new Dog();
		Dog dog = (Dog)a;
		dog.sing();
	}
}

class Animal
{
	public void sing()
	{
		System.out.println("animal is singing");
	}
}

class Dog extends Animal
{
	public void sing()
	{
		System.out.println("dog is singing");
	}
}

class Cat extends Animal
{
	public void sing()
	{
		System.out.println("cat is singing");
	}
}

执行结果：

D:\src>java PolyTest
dog is singing

【说明】：Animal a = new Dog(); Dog dog = (Dog)a;这两条语句是一个强制类型转换，将一个父类型的引用强制给子类型的引用,这在多态中叫做向下类型转换，注意的是它实际指向的是谁，才能转换成谁。比如a实际指向的是Dog对象，所以才能强制类型转换为Dog类型的引用。

修改以上代码段第三行开始

		Animal a = new Dog();
		Dog dog = (Dog)a;
		dog.sing();
		Animal b = new Cat();
		Cat cat = (Cat)b;
		cat.sing();

执行结果：

D:\src>java PolyTest2
dog is singing
cat is singing

继续修改此段代码：

		Animal a = new Dog();
		Dog dog = (Dog)a;
		dog.sing();
		Animal b = new Cat();
		Dog d = (Dog)b;
		d.sing();

执行结果：

D:\src>javac PolyTest2.java
D:\src>java PolyTest2
dog is singing
Exception in thread "main" java.lang.ClassCastException: Cat cannot be cast to Dog
        at PolyTest2.main(PolyTest2.java:9)

【说明】:这个程序在编译的时候提示错误，在执行字节码文件时候出现错误，提示类转换异常：猫不能转换成狗。因为b指向的是Cat类型的对象，而在转换后变成b指向了Dog类型的引用，所以出错。向下类型转换的引用指向那个对象，才能强制类型转换为这个类型的引用。