多态性——对象的多态性

一、在java中主要通过以下两种方式实现多态：

1、方法的重载和覆写（具体的请查看以前的文章）

2、对象的多态性

二、对象的多态性

对象的多态性主要分两种类型，向上转型和向下转型

1、对象的向上转型

（1）格式： 父类  父类对象 = 子类实例；

（2）代码示例如下：

package lkp;

//定义一个类A
class A{
	public void fun1(){
		System.out.println("A");
	}
	public void fun2(){
		this.fun1();
	}
}
//定义一个子类B，继承A
class B extends A{
	public void fun1(){//覆写父类中的fun1方法
		System.out.println("B");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("C");
	}
}

class Test{
	public static  void main(String args []){
		B b =new B();//定义子类实例化对象
		A a = b;  //向上转型  ， 子类——》父类
		a.fun1();//次方法是被子类覆写过
	}
}

（3）注意

使用父类对象调用fun1方法，实际上调用的方法是被子类覆写过的方法

即如果对象发生了向上转型，所调用的方法一定是被子类覆写过的方法

2、对象的向下转型

（1）格式：子类  子类对象 = （子类） 父类实例

（2）代码示例如下：

package lkp;

//定义一个类A
class A{
	public void fun1(){
		System.out.println("A——1");
	}
	public void fun2(){
		this.fun1();
	}
}
//定义一个子类B，继承A
class B extends A{
	public void fun1(){//覆写父类中的fun1方法
		System.out.println("B——1");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B——3");
	}
}

class Test{
	public static  void main(String args []){
		A a = new B();//向上转型
		B b = (B)a;//向下转型
		b.fun1();//调用被覆写的方法
		b.fun2();//调用父类的方法
		b.fun3();//调用子类自己定义的方法
	}
}

（3）注意

向上转型，实现的是子类中的方法。

在进行对象的向下转型前，必须首先发生对象的向上转型，否则将出现对象转换异常。

3、对象多态性的应用

package lkp;

//定义一个类A
class A{
	public void fun1(){
		System.out.println("A——1");
	}
	public void fun2(){
		this.fun1();
	}
}
//定义一个子类B，继承A
class B extends A{
	public void fun1(){//覆写父类中的fun1方法
		System.out.println("B——1");
	}
	public void fun3(){//子类自己定义的方法
		System.out.println("B——3");
	}
}

//定义一个子类C，继承A
class C extends A{
	public void fun1(){//覆写父类的fun1方法
		System.out.println("C——1");
	}
	public void fun4(){//子类自己定义的方法
		System.out.println("C——4");
	}
}
class Test{
	public static  void main(String args []){
		fun(new B());//传递B类的实参，产生向上转型
		fun(new C());//传递C类的实参，产生向上转型
	}
	//未使用多态性
//		public static void fun(B b){
//			b.fun1();
//		}
//		public static void fun(C c){
//			c.fun1();
//		}
	public static void fun(A a){//接收父类的对象
		a.fun1();
	}
	
}

未使用多态性的程序，当产生一个A类的子类时，fun（）方法就要重载一次。则每次扩充子类都必修修改类本身

使用多态性的程序，此时由于在fun（）方法中使用了对象的多态性，所以可以接受任何的子类对象，这样无论

子类如何增加，fun（）方法都不需要做任何修改。因为一旦发生对象的向上转型关系后，调用的方法一定是被子类

覆写过的方法。