JavaSE基础知识学习-----多态

多态

Java面向对象编程有三大特性:封装,继承和多态
封装隐藏类的内部具体实现机制,保护数据,对外界隐藏内部细节,只向外部提供它所允许访问的方法
继承是为了复用代码和实现向上转型,当然继承也是为多态做准备。
多态可以说是Java面向对象的精华所在。

什么是多态

多态是指允许不同子类型的对象对同一消息做出不同的响应,简单来讲,就是用同样的对象调用同样的方法但是却做了不同的事情。也可以理解为一个事物的多种表现形态。
多态性分为编译时的多态性和运行时的多态性。例如:
方法重载:实现的是编译时的多态性
方法重写:实现的是运行是的多态性
子类对象的多态性,这个是Java多态性中最常用的事。

实现多态的条件

1.方法重写,也就是说要有继承吧,只有有了继承,子类重写了父类已有的或抽象的方法
2.对象造型,也就是说要有父类的引用指向子类对象
只有这样,同样的引用调用同样的方法就会作出不同的响应,简单来讲如下代码所示:
父类Person有如下方法:

public void walk(){
    System.out.println("人走路");
}

public void eat(){
    System.out.println("人吃饭");
}

如果子类Man类没有重写这两个方法,那么我们做如下的事情:

    Person man = new Man();
    man.walk();

输出结果:

人走路

综上所述:父类引用man指向的是子类对象,这个就是子类对象的多态性(也叫向上转型),man可以调用父类的方法,前提是子类没有重写父类方法。
如果子类Man类重写了父类方法

public void walk(){
    System.out.println("男人应该挺拔的走路");
}

public void eat(){
    System.out.println("男人应该多吃肉");
}

同样的调用:

Person man = new Man();
man.walk();

结果就是:

男人应该挺拔的走路

综上所述:子类对象重写了父类方法,那么man调用父类方法,执行的就是子类的方法。这个也虚拟方法调用,说到这里你应该可以猜到,什么是多态了吧,就是同样的父类对象应用,指向不同的子类对象,就会作出不同的响应,例如子类Woman类也重写了父类的方法:

public void walk(){
    System.out.println("女人应该温柔的走路");
}

public void eat(){
    System.out.println("女人应该少吃肉多吃水果蔬菜");
}

调用方法:

Person man = new Man();
Person woman = new Woman();
man.walk();
woman.walk();

结果为:

男人应该挺拔的走路
女人应该温柔的走路

综上所述:应该是很清晰了什么是子类对象的多态性,就是你相同的父类引用,不同的子类对象,就会响应对应的子类对象的方法。

方法重载和方法重写

方法重载和方法重写两者都是实现多态的方式,区别在于方法重载实现的是编译时的多态,方法重写实现的是运行时的多态,重载发生在同一个类中,同名的方法有不同的参数列表。

注意:方法的重载与返回值无关,简称两同一不同,同一个类,同一个方法,不同的参数列表

方法的重写发生在子类和父类之间,重写要求子类方法返回值,方法名,参数列表与父类爆出一致,权限修饰符大于父类,同时要同为static或同为非static。

注意:构造器不能被继承,所以不能被重写,但是却可以被重载

多态的使用例子

例如在父类Person类中有如下方法:

public void show(Person person){
    System.out.println("这是父类show方法");
}

子类Man类重写了子类方法:

public void show(Person person){
    System.out.println("这是子类show方法");
}

如果实例化Man对象,调用man的show(Person person)方法,就应该传入Person对象,这个时候就可以传入父类对象的引用。

Person man = new Man();
man.show(man);

父类引用指向不同的子类对象,作出不同的响应。

多态经典案例

摘自http://blog.csdn.net/thinkGhoster/archive/2008/04/19/2307001.aspx

    public class A {  
    public String show(D obj) {  
        return ("A and D");  
    }  
  
    public String show(A obj) {  
        return ("A and A");  
    }   
  
}  
  
public class B extends A{  
    public String show(B obj){  
        return ("B and B");  
    }  
      
    public String show(A obj){  
        return ("B and A");  
    }   
}  
  
public class C extends B{  
  
}  
  
public class D extends B{  
  
}  
  
public class Test {  
    public static void main(String[] args) {  
        A a1 = new A();  
        A a2 = new B();  
        B b = new B();  
        C c = new C();  
        D d = new D();  
          
        System.out.println("1--" + a1.show(b));  
        System.out.println("2--" + a1.show(c));  
        System.out.println("3--" + a1.show(d));  
        System.out.println("4--" + a2.show(b));  
        System.out.println("5--" + a2.show(c));  
        System.out.println("6--" + a2.show(d));  
        System.out.println("7--" + b.show(b));  
        System.out.println("8--" + b.show(c));  
        System.out.println("9--" + b.show(d));        
    }  
}  

输出结果为:

1--A and A  
2--A and A  
3--A and D  
4--B and A  
5--B and A  
6--A and D  
7--B and B  
8--B and B  
9--A and D  

结果分析如下:

System.out.println("1--" + a1.show(b)); //a1是A的引用指向是A对象,故调用A中的show方法,传入的是b,b指向的是B对象,因为B继承与A,故传入的也可认为是A,结果为A and A
System.out.println("2--" + a1.show(c)); //c指向C对象,C继承B,B继承A,相当于传入A,结果为A and A
System.out.println("3--" + a1.show(d)); //d指向D对象,在A中有传入D对象的方法,结果为 A and D
System.out.println("4--" + a2.show(b)); //a2是父类引用,指向子类对象,按理说调用show方法会执行子类B的show方法,传入的是b,b指向的是B对象,
                                        //但是B中的show(B)是子类特有的方法,故不能被调用,传入的是B,B继承与A,相当于传入A,B类重写了show(B)方法,结果为B and A
System.out.println("5--" + a2.show(c)); //传入c,执行B中show(C)的方法,没有,C继承B,执行B中show(B),但是这是B中特有方法,不能被调用,
                                        //B继承A,调用B中show(A),结果B and A
System.out.println("6--" + a2.show(d)); //传入D,执行B中show(D)方法,没有,但是A中有就会执行父类show(D)方法,所以结果为:A and D
System.out.println("7--" + b.show(b)); //b指向B,传入B, 结果为B and B
System.out.println("8--" + b.show(c)); //传入c,执行B中show(C),没有,C继承B,执行B中show(B),结果为:B and B
System.out.println("9--" + b.show(d)); //传入d,执行B中show(D)方法,没有,当时B继承A,是存在A中show(D)的方法,结果为 A and D 

案例总结

对于a2.show(c)来讲,a2是A的应用,故先去A中找show(C)方法(this.show(O)),A中没有,按理应该去A的父类中找(super.show(O)),但是A没有父类,故只能在A中找show(c的父类)方法(this.show(super)),c的父类有B和A,A中找到show(A)的方法,但是B重写了该方法,故执行子类的方法,所以结果为B and A。找的顺序是this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)。

你可能感兴趣的:(JavaSE基础知识学习-----多态)