java学习——多态

final关键字

最终的意思,可以修饰类,方法,变量

1. 修饰变量:
   该变量只能被赋值一次,即用final修饰的变量为常量
2. 修饰方法
   该方法不能被重写
3. 修饰类
   该类不能被继承

多态

定义

• 多态就是指程序中定义的引用变量所指向的具体类型和通过该引用变量发出的方法调用在编程时并不确定，而是在程序运行期间才确定，即一个引用变量倒底会指向哪个类的实例对象，该引用变量发出的方法调用到底是哪个类中实现的方法,必须在由程序运行期间才能决定。为在程序运行时才确定具体的类，这样，不用修改源程序代码,就可以让引用变量绑定到各种不同的类实现上，从而导致该引用调用的具体方法随之改变，即不修改程序代码就可以改变程序运行时所绑定的具体代码,让程序可以选择多个运行状态，这就是多态性

一个经典例题:

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));  
        /*
        4--B and A.
        首先a2是A引用，B实例，调用show（B b）方法
        此方法在父类A中没有定义，所以B中方法show(B b)不会调用(多态必须父类中已定义该方法)
        再按优先级为：this.show(O)、super.show(O)、this.show((super)O)、super.show((super)O)
        即先查this对象的父类，没有重头再查参数的父类
        查找super.show((super)O)时，B中没有，再向上，找到A中show(A a),因此执行
        */
        System.out.println("5--" + a2.show(c));  //同上  
        System.out.println("6--" + a2.show(d));  //A and D .查找B中没有show(D d)方法，再查A中，有，执行。  
        System.out.println("7--" + b.show(b));    
        System.out.println("8--" + b.show(c));  //B and B .  
        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
*/

方法调用的优先级
this.show(O) > super.show(O) > this.show((super)O) > super.show((super)O)

前提

1. 要有继承关系
2. 要有方法重写
3. 要有父类引用指向子类对象(向上转型)
   父类 f = new 子类();
   代码体现:

public class Animal {
    public Animal(){}
    public void show() {
        System.out.println("Animal show");
    }
}
public class Dog extends Animal {
    public Dog(){}
    public void show(){
        System.out.println("Dog show");
    }
}
public class Test {
    public static void main(String[] args) {
        Animal a = new Dog();
        a.show();
    }
}

方法重写与方法重载

• 方法重载
  同一个类中,方法名相同,参数列表不同的两个方法,与返回值类型无关,在方法调用时根据类型判断调用哪个方法,这叫做方法重载
• 方法重写
  在父类中已经定义过的方法,在子类中重新进行定义,方法名,返回值类型,参数列表完全相同,这叫做方法重写

• 成员访问特点

  1. 成员变量:
     编译看引用对象的类型(左边)，运行看引用对象的类型(左边)
     因为变量的类型在左边显示，所以编译看左边，运行看左边，即多态使用的变量是变量类型的变量
  2. 成员方法:
     编译看左边，运行看右边
     编译时看父类引用的类型，运行的是父类引用所指向的对象的被重写后的方法
     即多态只能调用被子类对象重写后的方法
     若调用的方法在子类对象中没有被重写，则调用自己的方法，若被重写，则调用被重写后的方法
  3. 构造方法:
     创建(new)一个子类对象的时候，访问父类的构造方法，对父类数据进行初始化
     

  原因:成员方法存在方法重写

优势

1.提高了代码维护性(由继承保证)
    一个父类可以有多个子类,当想要修改子类相同的部分时只需要修改父类中的代码
2.提高了代码扩展性()

弊端

父类不能使用子类特有的功能

转型

• 向上转型:
  父类 f = new 子类();
• 向下转型:
  子类 z = (子类) f;
  

理解:从右往左看,若是子类到父类则为向上转型,反之,若是父类强制转化为子类则为向下转型