java面向对象——多态性

面型对象 多态性

面向对象中多态性的思想是很重要的，什么是多态性呢？其实就是向上转型和向下转型，要注意的是向上转型其实是可以自动向上转型，但向下转型必须在向上转型确定关系之后才能向下转型。
多态性主要的两种体现方式：

• 方法的重载与覆写
• 对象的多态性

对象向上转型关系：
子类进行父类实例化操作，如果调用的方法被子类覆写过则调用的是子类的方法，没有覆写则调用父类本身的方法，转型之后，操作的是父类对象，所以是找不到子类新定义的方法的

package poldemo;

class A{								//定义一个类A
	public void fun1() {				//定义一个方法fun1()
		System.out.println("A————》public void fun1(){}");
	}
	public void fun2() {
		this.fun1();					//调用方法fun1()
	}
}
class B extends A{
	public void fun1() {				//在子类覆写父类的方法
		System.out.print("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();		//实例化子类对象
		//b.fun1();			
		A a = b;			//向上转型关系
		a.fun1();			//此方法被覆写过，所以调用的还是子类的方法fun1(),如果没有被覆写，则是本类的方法。
		a.fun2();
	}
}

将父类对象变为子类对象称之为——向下转型：
向下转型需要强制性

package poldemo;

class AA {								//定义一个类A
	public void fun1() {				//定义一个方法fun1()
		System.out.println("A————》public void fun1(){}");
	}
	public void fun2() {
		this.fun1();					//调用方法fun1()
	}
}
class BB extends AA {
	public void 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[]) {
		AA a = new BB();	//向上转型关系
		BB b = (BB) a ;	//向下转型关系 （BB）表示强制转换
		b.fun1() ;
		b.fun2();
		b.fun3();
	}
}

此时在BB类中存在三个方法，，所以全部都能调用。注意：要想产生向下的转型，必须先产生向上的转型来确定关系才能成功。
多态性的作用：
设计一个方法，接收A3类任意子类的对象，并调用方法。

• 方法一：使用重载

class A3{								//定义一个类A
	public void fun1() {				//定义一个方法fun1()
		System.out.println("A————》public void fun1(){}");
	}
	public void fun2() {
		this.fun1();					//调用方法fun1()
	}
}
class B3 extends A3{
	public void fun1() {				//在子类覆写父类的方法
		System.out.println("B————》public void fun1(){}");
	}
	public void fun3() {
		System.out.println("B————》public void fun3(){}");
	}
}
class C3 extends A3{
	public void fun1() {				//在子类覆写父类的方法
		System.out.println("C————》public void fun1(){}");
	}
	public void fun5() {
		System.out.println("C————》public void fun5(){}");
	}
}
public class polDemo03 {
	public static void main(String args[]) {
		fun(new B3());			//传递B的实例
		fun(new C3());
	}
	public static void fun(B3 b3) {
		b3.fun1();				//调用覆写父类中的fun1方法	
	}
	public static void fun(C3 c3) {
		c3.fun1();				//调用覆写父类中的fun1方法	
	}
}

该方法在每增加一个子类，都要重载fun（）方法
    使用多态性：

package poldemo;

class A4{								//定义一个类A
	public void fun1() {				//定义一个方法fun1()
		System.out.println("A————》public void fun1(){}");
	}
	public void fun2() {
		this.fun1();					//调用方法fun1()
	}
}
class B4 extends A4{
	public void fun1() {				//在子类覆写父类的方法
		System.out.println("B————》public void fun1(){}");
	}
	public void fun3() {
		System.out.println("B————》public void fun3(){}");
	}
}
class C4 extends A4{
	public void 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 B3());			//传递B的实例
		fun(new C3());
	}
	public static void fun(A3 a3) {
		a3.fun1();				//调用覆写父类中的fun1方法	
	}
}

对象多态性的概念：

• 向上转型： 自动完成
• 向下转型：强制
  对象多态性可以解决方法接收参数的问题哦