多态 Java

1、定义：

多态性是指允许不同类的对象对同一消息作出响应。可以设计一个方法，参数类型为类或接口（是一个父类类型的变量），传入的参数是一个子类类型的对象，根据引用子类对象特征的不同，得到不同的运行结果。如下面代码：

// 定义接口Anmal
interface Animal {    
	void shout();     // 定义抽象shout()方法
}
// 定义Cat类实现Animal接口
class Cat implements Animal {
// 实现shout()方法
	public void shout() {
		System.out.println("喵喵喵");
	}
}
// 定义Dog类实现Animal接口
class Dog implements Animal {
     // 实现shout()方法
	public void shout() {
		System.out.println("Dog叫");
	}
}

public class Example {
	public static void main(String[] args) {
		Animal an1 = new Cat(); // 创建Cat对象,使用Animal类型的变量an1引用
		Animal an2 = new Dog(); // 创建Dog对象,使用Animal类型的变量an2引用
		animalShout(an1);        // 调用animalShout()方法，将an1作为参数传入，（这里相当于上转型）
		animalShout(an2);        // 调用animalShout()方法，将an2作为参数传入
	}
     // 定义静态的animalShout()方法，接收一个Animal类型的参数
	public static void animalShout(Animal an) {
		an.shout();               // 调用实际参数的shout()方法
	}
}

结果：

喵喵喵

Dog叫

2、对象的类型转换

上转型：

子类转型成父类是向上转型，即将子类对象当作父类类型使用，例如下面的代码

Animal an1=new Cat();

子类对象当作父类类型使用不需要任何显示的声明，但此时子类对象失去了子类对象中新添加的特征。如下面代码将会报错。

// 定义Animal接口
interface Animal {    
	void shout(); // 定义抽象方法shout()
}
// 定义Cat类实现Animal接口
class Cat implements Animal {   
     // 实现抽象方法shout()
	public void shout() {			  
		System.out.println("喵喵……");
	}
     // 定义sleep()方法
	void sleep() {
		System.out.println("猫睡觉……");
	}
}
// 定义测试类 
public class Example {
	public static void main(String[] args) {
         Cat cat = new Cat(); // 创建Cat类的实例对象
		animalShout(cat);    // 调用animalShout()方法，将cat作为参数传入
	}
     // 定义静态方法animalShout()，接收一个Animal类型的参数
	public static void animalShout(Animal animal) {
		animal.shout();  // 调用传入参数animal的shout()方法
		animal.sleep();  // 调用传入参数animal的sleep()方法
	}
}

因为上面代码中，Animal类中没有定义sleep()方法，Catl类型 对象当作父类Animal类型使用时，Catl类对象失去了子sleep()方法；

但这个问题可以结果，可以将Animal类型的变量强制转为Cat类型。也就是下转型，如下面描述

下转型：

子类转型成父类是向上转型，反过来说，父类转型成子类就是向下转型。如下面代码

public static void animalShout(Animal animal) {
		Cat cat=(Cat)animal;   // 将Animal对象强制转换成Cat类型       
		cat.sleep();            // 调用cat的sleep()方法
		cat.shout();            // 调用cat的shout()方法
}

但之所可以这样强制类型转换，是因为调用animalShout()方法时传入的是Cat类型的对象，将 Cat类型的对象上转型了，之后可以下转型。若此时传入的是一个Dog类型的对象，这时进行强制类型转换就会出错。如下面的代码。

// 定义Animal类接口
interface Animal {    
	void shout(); // 定义抽象方法shout()
}
// 定义Cat类实现Animal接口
class Cat implements Animal {    
     // 实现shout()方法
	public void shout() {			  
		System.out.println("喵喵……");
	}
     // 定义sleep()方法
	void sleep() {
		System.out.println("猫睡觉……");
	}
}
// 定义Dog类实现Animal接口
class Dog implements Animal {
     // 实现shout()方法
	public void shout() {			   
		System.out.println("汪汪……");
	}
}
// 创建测试类
public class Example15 {
	public static void main(String[] args) {
          Dog dog =new Dog(); // 创建Dog类型的实例对象
		animalShout(dog);    // 调用animalShout()方法，将dog作为参数传入
	}
     // 定义静态方法animalShout(),接收一个Animal类型的参数
	public static void animalShout(Animal animal) {
			Cat cat=(Cat)animal;   // 将Animal对象强制转换成Cat类型 ，这里出错。      
			cat.sleep();            // 调用cat的sleep()方法
			cat.shout();            // 调用cat的shout()方法
	}
}

3、关键字instanceof

针对上述强制类型转换出错的情况，Java提供关键字instanceof，它可以判断一个对象是否为某个类或接口的实例或者子类实例。

格式：对象（或者对象引用变量）instanceof 类（或接口） 具体代码如下

	public static void animalShout(Animal animal) {
		if(animal instanceof Cat){
			Cat cat=(Cat)animal;   // 将Animal对象强制转换成Cat类型       
			cat.sleep();            // 调用cat的sleep()方法
			cat.shout();            // 调用cat的shout()方法			
		}
		else{
			System.out.println("可以进行强制类型转换");
		}
	}