Java多态之向上转型、同名变量以及方法覆盖

首先，我们先要简单理解两个概念：

1、向上转型：父类类型的引用指向子类类型的对象。例如：

class Parent {
 
}
 
class Child extends Parent {
 
}
 
public class MainClass {
 
    public static void main(String[] args) {
        Parent parent = new Child();//向上转型
 
    }
 
}
2、向上转型中的多态体现，先看例子：
class Parent {
void myType() {
    System.out.println("I`m Parent.");
}
}
 
class Son extends Parent {
    void myType() {
        System.out.println("I`m Son.");
    }
}
 
class Daughter extends Parent {
    void myType() {
        System.out.println("I`m Daughter.");
    }
}
 
public class MainClass {
 
    public static void main(String[] args) {
        Parent parent_Parent = new Parent();
        Parent parent_Son = new Son();
        Parent parent_Daughter = new Daughter();
        System.out.print("parent_Parent:");
        parent_Parent.myType();
        System.out.print("parent_Son:");
        parent_Son.myType();
        System.out.print("parent_Daughter:");
        parent_Daughter.myType();
 
    }
 
}
输出结果：
parent_Parent:I`m Parent.
parent_Son:I`m Son.
parent_Daughter:I`m Daughter.

可以看到，Parent类型引用了不同的对象，调用了相同的方法，输出了不一样的结果。向上转型中的多态体现可以用在函数传递方面，如果函数参数的类型为Parent,我们可以传递给它Parent,Son,Dauther类型的对象。

在学习下面关于Java向上转型的同名变量以及方法覆盖前，希望您能了解Java程序初始化顺序，您先看看这篇博文：点击打开链接 的例子，将非常有助于您对一下例子的理解。

我们先记住这几个知识点：

一、如果使用父类类型的引用指向子类的对象，该引用只能调用父类中定义的方法和变量；

二、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；

三、变量不能被重写（覆盖），”重写“的概念只针对方法。



接下来，我们逐点分析：

一、如果使用父类类型的引用指向子类的对象，该引用只能调用父类中定义的方法和变量；

对于第一点，可以在编写程序的时候发现，对于一个父类类型引用了一个子类的对象，在编译器，比如eclipse，不会提示父类没有而子类有的方法，读者可以去试一试。



二、如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；

先看一个简单的例子：

class Parent {
    public String ap = getStr();//调用的是Child中的getStr()方法,1
 
    public Parent() {
        System.out.println("parent_construct");
        System.out.println("ap:"+ap);//2
    }
 
    public String getStr() {//这个方法不会被调用
        System.out.println("parent_method");
        return "Parent";
    }
 
}
 
class Child extends Parent {
 
    String ac = getStr();//调用的是自己getStr()的方法
 
    public Child() {
        System.out.println("Child_construct");
        System.out.println("ac:"+ac);
    }
 
    public String getStr() {//这个方法被调用两次
        System.out.println("child_method");
        return "Child";
    }
}
 
public class MainClass {
    
    public static void main(String[] args) {
        Parent parent = new Child();
 
    }
 
}
输出结果：
child_method
parent_construct
ap:Child
child_method
Child_construct
ac:Child

这里要注意的是第一个输出，对应程序中注释为1的地方。同时，由于调用的是子类的getStr()方法，所以ap的值为CHild,因此，第三行输出的是Child，对于程序中注释为2的地方。所以，如果子类中重写了父类中的一个方法，那么在调用这个方法的时候，将会调用子类中的这个方法；



三、如果父类和子类中存在同名变量会是个什么情况？

我们先看一个例子，

class Parent {
    public String a = getAParent();
 
    public Parent() {
        System.out.println("parent_construct:"+a);
        getStr();//调用的是子类的getStr()方法，1
    }
 
    public void getStr() {
        System.out.println("parent_method");
        System.out.println("ap:"+a);
    }
    public String getAParent() {
        System.out.println("getAParent");
        return "pA";
    }
 
}
 
class Child extends Parent {
 
    public String a = getAChild();
 
    public Child() {
        System.out.println("Child_construct:"+a);
        getStr();
    }
 
    public void getStr() {//被调用两次,这里的变量a是子类的变量a,2
        System.out.println("child_method");
        System.out.println("ac:"+a);
    }
    public String getAChild() {
        System.out.println("getAChild");
        return "cA";
    }
}
 
public class MainClass {
    int a;
    public static void main(String[] args) {
        Parent parent = new Child();
 
    }
 
}
输出结果：
getAParent
parent_construct:pA
child_method
ac:null
getAChild
Child_construct:cA
child_method
ac:cA
输出的第四行竟然是null,好像很奇怪，实则不奇怪。在代码中注释为1的地方，调用的是子类的getStr()方法，而getStr()函数中的变量a是子类的变量a,而不是父类中已经被赋值为字符串“pA”的变量a,由于Java初始化顺序，在子类中的getStr()方法这次被调用的时候，子类中的变量a还没有被赋值为“cA”.

我们再看看子类中没有同名变量a 的情况，我们直接把对应的那一行代码注释掉。

class Parent {
    public String a = getAParent();
 
    public Parent() {
        System.out.println("parent_construct:"+a);
        getStr();//调用的是子类的getStr()方法，1
    }
 
    public void getStr() {
        System.out.println("parent_method");
        System.out.println("ap:"+a);
    }
    public String getAParent() {
        System.out.println("getAParent");
        return "pA";
    }
 
}
 
class Child extends Parent {
 
    //public String a = getAChild();//子类中没有同名变量a
 
    public Child() {
        System.out.println("Child_construct:"+a);
        getStr();
    }
 
    public void getStr() {//被调用两次,这里的变量a是子类的变量a,2
        System.out.println("child_method");
        System.out.println("ac:"+a);
    }
    public String getAChild() {
        System.out.println("getAChild");
        return "cA";
    }
}
 
public class MainClass {
    int a;
    public static void main(String[] args) {
        Parent parent = new Child();
 
    }
 
}
输出结果：
getAParent
parent_construct:pA
child_method
ac:pA
Child_construct:pA
child_method
ac:pA

输出的第四行变成了“pA”,说明在调用子类的getStr()方法时，里面的变量是父类中的变量a,这不是废话吗：）

我们最后来看一下如果父类和子类中存在同名变量，内存是不是给两个变量都分配了空间。

class Parent {
    public String a = getAParent();
 
    public Parent() {
        System.out.println("parent_construct:"+a);
        getStr();
    }
 
    public void getStr() {
        System.out.println("parent_method");
        System.out.println("ap:"+a);
    }
    public String getAParent() {
        System.out.println("getAParent");
        return "pA";
    }
    
    public void getParentA() {//
        System.out.println("ParentA always is :"+a);
    }
 
}
 
class Child extends Parent {
 
    public String a = getAChild();
 
    public Child() {
        System.out.println("Child_construct:"+a);
        getStr();
    }
 
    public void getStr() {
        System.out.println("child_method");
        System.out.println("ac:"+a);
    }
    public String getAChild() {
        System.out.println("getAChild");
        return "cA";
    }
    public void getParentB() {//
        System.out.println("ParentA always is :"+a);
    }
}
 
public class MainClass {
    int a;
    public static void main(String[] args) {
        Parent parent = new Child();
        parent.getParentA();
        Child child = (Child)parent;//1
        child.getParentB();
        System.out.println("Parent类型 a:"+parent.a);
        System.out.println("Child类型 a: "+child.a);
    }
}
输出结果：
getAParent
parent_construct:pA
child_method
ac:null
getAChild
Child_construct:cA
child_method
ac:cA
ParentA always is :pA
ParentA always is :cA
Parent类型 a:pA
Child类型 a: cA

说明了内存给两个变量都分配了空间。根据最后两行的输出结果，说明如果直接调用变量a,a所属的类与类型有关，而与具体的引用对象无关。