对象的多态性

本章目标
掌握对象的向上转型及向下转型的使用
掌握对象转型的限制

多态性
多态性在面向对象中中是一个最重要的概念，在java中面向对象主要有以下两种主要体现：
方法的重载与覆写
对象的多态性

 

对象的多态性
对象的多态性主要分为以下两种类型：
向上转型：子类对象 —> 父类对象
——对于向上转型，程序会自动完成，格式：
————对象向上转型：父类 父类对象 = 子类实例 ;
向下转型：父类对象 —> 子类对象
——对于向下转型时，必须明确的指明要转型的子类类型，格式：
————对象向下转型：子类 子类对象 = (子类)父类实例 ;

 

对象的向上转型

class A{//定义类 A
	public void fun1(){//定义 fun1() 方法
		System.out.println("A --> public void fun1(){}");
	}
	public void fun2(){//定义 fun2() 方法
		this.fun1();
	}
}
class B extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("B --> public void fun1(){}");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B --> public void fun3(){}");
	}
}
public class PolDemo01 {
	public static void main(String[] args) {
		B b = new B();//定义子类实例化对象
		A a = b;//发生了向上转型的关系，子类 --> 父类
		a.fun1();//此方法被子类覆写过
	}
/*结果：
 * B --> public void fun1(){}
 * */
}

 

对象的向下转型

class A{//定义类 A
	public void fun1(){//定义 fun1() 方法
		System.out.println("A --> public void fun1(){}");
	}
	public void fun2(){//定义 fun2() 方法
		this.fun1();
	}
}
class B extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("B --> public void fun1(){}");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B --> public void fun3(){}");
	}
}
public class PolDemo02 {
	public static void main(String[] args) {
		A a = new B();//发生了向上转型的关系，子类 --> 父类
		B b = (B)a;//此时发生了向下转型关系
		b.fun1();//调用方法被覆写的方法
		b.fun2();//调用父类的方法
		b.fun3();//调用子类自己定义的方法
	}
/*结果：
 * B --> public void fun1(){}
 * B --> public void fun1(){}
 * B --> public void fun3(){}
 * */
}

 

注意：对象向下转型的要求
在以上的程序中读者已经了解了对象的向上和向下转型的基本概念，但是必须提醒读者的是，在进行对象的向下转型之前，必须首先发生对象向上转型才可以，否则将出现对象转换异常

 

错误的转型

class A{//定义类 A
	public void fun1(){//定义 fun1() 方法
		System.out.println("A --> public void fun1(){}");
	}
	public void fun2(){//定义 fun2() 方法
		this.fun1();
	}
}
class B extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("B --> public void fun1(){}");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B --> public void fun3(){}");
	}
}
public class PolDemo03 {
	public static void main(String[] args) {
		A a = new A();//此时声明的是父类对象
		B b = (B)a;//此时发生了向下转型关系
		b.fun1();//调用方法被覆写的方法
		b.fun2();//调用父类的方法
		b.fun3();//调用子类自己定义的方法
	}
/*结果：
 * Exception in thread "main" java.lang.ClassCastException: J020607.PolDemo03.A cannot be cast to J020607.PolDemo03.B
 * 	at J020607.PolDemo03.PolDemo03.main(PolDemo03.java:23)
 * */
}

 

对象多态性的作用
现在有以下要求：
——设计一个方法，要求此方法可以接收A类的任意子类对象，并调用方法

class A{//定义类 A
	public void fun1(){//定义 fun1() 方法
		System.out.println("A --> public void fun1(){}");
	}
	public void fun2(){//定义 fun2() 方法
		this.fun1();
	}
}
class B extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("B --> public void fun1(){}");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B --> public void fun3(){}");
	}
}
class C extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("C --> public void fun1(){}");
	}
	public void fun5(){//子类自己定义的方法
		System.out.println("C --> public void fun5(){}");
	}
}
public class PolDemo04 {
	public static void main(String[] args) {
		fun(new B());//传递 B 类实例
		fun(new C());//传递 C 类实例
	}
	public static void fun(B b){//接收子类 B 的实例
		b.fun1();//统一调用覆写父类的 fun1() 方法
	}
	public static void fun(C c){//接收子类 C 的实例
		c.fun1();
	}
/*结果：
 * B --> public void fun1(){}
 * C --> public void fun1(){}
 * */
}

 

class A{//定义类 A
	public void fun1(){//定义 fun1() 方法
		System.out.println("A --> public void fun1(){}");
	}
	public void fun2(){//定义 fun2() 方法
		this.fun1();
	}
}
class B extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("B --> public void fun1(){}");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B --> public void fun3(){}");
	}
}
class C extends A{//子类通过 extends 继承父类
	public void fun1(){//覆写父类中的 fun1() 方法
		System.out.println("C --> public void fun1(){}");
	}
	public void fun5(){//子类自己定义的方法
		System.out.println("C --> public void fun5(){}");
	}
}
public class PolDemo05 {
	public static void main(String[] args) {
		fun(new B());//传递 B 类实例，产生向上转型
		fun(new C());//传递 C 类实例，产生向上转型
	}
	public static void fun(A a){//接收父类对象
		a.fun1();
	}
/*结果：
 * B --> public void fun1(){}
 * C --> public void fun1(){}
 * */
}