多态

在java中多态性主要有2种体现方式

1,。方法的重载和覆写

2.对象的多态性。

对象的多态性主要分为以下两种类型

1.向上转型：子类对象------》父类对象 子类变为父类，未抽象类实例化

对于向上转型，程序会自动完成：父类 父类对象 =子类实例

2.向下转型：父类对象------》子类对象 将类变为子类，为接口实例化

对于向下转型时，必须明确指明要转型的子类类型

子类 子类对象 =（子类）父类实例

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.println("B --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B --> public void fun3(){}") ;
}
};
public class PolDemo01{
public static void main(String asrgs[]){
B b = new B() ; // 实例化子类对象
A a = b ; // 向上转型关系
a.fun1() ; // 此方法被子类覆写过
a.fun3() ;
}
};

如果调用的方法被子类覆写了 则肯定调用的是被覆写的方法

  转型后应为操作的是父类对象 所以是无法调用子类的新方法的

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.println("B --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B --> public void fun3(){}") ;
}
};
public class PolDemo02{
public static void main(String asrgs[]){
A a = new B() ; // 向上转型关系
B b = (B)a ; // 发生了向下转型关系
b.fun1() ;
b.fun2() ;
b.fun3() ;
}
};

如果要发生向下转型则必须先发生一个向上转型的关系

对象多态性的应用：

设计一个类可以接受A类的任意对象并调用其方法

1.使用方法重载

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.println("B --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B --> public void fun3(){}") ;
}
};
class C extends A{
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 asrgs[]){
fun(new B()) ; // 传递B的实例
fun(new C()) ; // 传递B的实例
}
public static void fun(B b){
b.fun1() ; // 调用覆写父类中的fun1()方法
}
public static void fun(C c){
c.fun1() ; // 调用覆写父类中的fun1()方法
}
};

从上面程序可以看出需要覆写很多次方法，写起来很不

方便 ，如果使用对象的多态性，应为向上转型时自动产生的，所以程序可以这样写

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.println("B --> public void fun1(){}") ;
}
public void fun3(){
System.out.println("B --> public void fun3(){}") ;
}
};
class C extends A{
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 asrgs[]){
fun(new B()) ; // 传递B的实例
fun(new C()) ; // 传递B的实例
}
public static void fun(A a){
a.fun1() ; // 调用覆写父类中的fun1()方法
}

};