面向对象特征之多态

太过爱你忘了你带给我的痛 2023-10-04 08:24 4阅读 0赞

# 思维导图 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70][]

# 代码练习 #

public class PolymorTest {
        public static void main(String[] args) {
            // 多态概念：一个引用变量的编译时类型和运行时类型不一致
            // 多态实现：1.父类引用指向子类对象 2.子类重写父类方法 3.父类引用调用被重写的方法
            Father father = new Son();
    
            // 多态体现：
            // 在成员变量上不呈现多态性
            System.out.println(father.name);//Father
            // 只在被子类重写的方法上呈现多态性，
            father.test();//Son test
    
            // 向上转型：即子类对象可以赋值给父类引用，系统自动完成对子类对象的类型提升
            Son son = new Son();
            Father father1 = son;
    
            // 引用类型变量强转
            // 条件1：引用类型变量强转只能发生在具有父子类关系的类型间
            // 条件2：发生强转的引用类型变量指向的是其子类对象
            Son son1 = (Son) father1;
    
            // 建议在强转之前使用instanceof运算符判断下引用变量是否可以强转,这样可以保证代码健壮性，不会抛ClassCastException
            if (father instanceof Son) {
                Son son2 = (Son) father;
            }
        }
    }
    
    class Father{
        public String name = "Father";
    
        public void test(){
            System.out.println("Father test");
        }
    }
    
    class Son extends Father{
        public String name = "Son";
    
        public void test(){
            System.out.println("Son test");
        }
    }

# 思考题 #

## 1.如何证明子类对象是一种特殊的父类? ##

Father father = new Son();
    
    首先java是允许上面的代码形式的。即父类引用指向子类对象。
    
    我们一般理解 Father father = new Father();
    
    这样才算是正常的。
    
    其实换一种思维考虑：我们是不是可以简单认为：new Son()也是一种特殊的new Father()
    
    其实父类引用指向子类对象，还有一个专业名称叫：
    
    向上转型

## 2.请看下面代码，结果如何 ##

public class PolymorTest {
        public static void main(String[] args) {
            Father father = new Son();
            father.info();
        }
    }
    
    class Father{
        public void test(){
            System.out.println("Father test");
        }
    
        public void info(){
            System.out.println("Father info");
        }
    }
    
    class Son extends Father{
        public void test(){
            System.out.println("Son test");
        }
    
    }

引用变量在编译期只能调用其编译时类型所具有的方法。father的编译时类型是Father,Father类有info方法,所以编译期没有问题。
    
    引用变量在运行期会调用其运行时类型所具有的方法。而father的运行时类型时Son，而Son继承了Father,也就继承info方法，所以运行期也没有问题。
    
    最终输出 Father info

## 3.请看下面代码，结果如何 ##

public class PolymorTest {
        public static void main(String[] args) {
            Father father = new Son();
            father.info();
        }
    }
    
    class Father{
        public void test(){
            System.out.println("Father test");
        }
    }
    
    class Son extends Father{
        public void test(){
            System.out.println("Son test");
        }
        
        public void info(){
            System.out.println("Father info");
        }
    }

引用变量在编译期只能调用编译时类型所具有的方法，而此题中father引用变量编译期是Father类型，而Father类没有info方法，所以此程序在father.info()行编译报错info方法不存在。

## 4.请看下面代码，结果如何 ##

public class PolymorTest {
        public static void main(String[] args) {
            Father father = new Son();
            father.name;
        }
    }
    
    class Father{
        public String name = "Father";
    }
    
    class Son extends Father{
        public String name = "Son";
    }

多态性只体现在被子类重写的方法上。而父子类间的实例变量不具备多态性。即：
    
    通过引用变量来访问其包含的实例变量时，系统总是去访问其编译时类型所定义的实例变量。

## 5.父子类间相同的静态方法是否可以体现多态性? ##

public class StaticPolyTest {
        public static void main(String[] args) {
            Super s = new Base();
            s.test();//Super static test
        }
    }
    
    class Super{
        public static void test(){
            System.out.println("Super static test");
        }
    }
    
    class Base extends Super{
        public static void test(){
            System.out.println("Base static test");
        }
    }

首先这个问题没有敢说父子类间的相同的静态方法是重写。
    
    其实父子类间的静态方法不能重写。
    
    然后本题结论是：父子类间相同的静态方法不具备多态性。

## 6.请思考下面程序的运行结果 ##

class A {
        public A() {
            init();
        }
    
        public void init() {
        }
    }
    
    public class B extends A {
        int i;
        int s = 0;
    
        public void init() {
            i = 100;
            s = 100;
        }
    
        public void println() {
            System.out.println(i);
            System.out.println(s);
        }
    
        public static void main(String[] arg) {
            new B().println();
        }
    }

输出结果是
    100
    0
    
    我们需要了解new B()时发生的动作
    
    1.JVM寻找main入口，则需要现在加载main入口所在类B
    2.但是B继承了A，所以要先加载类A
    3.加载类A时，系统会自动初始化类A的静态成员（A没有静态成员）
    4.类A加载完成后，加载类B，系统为类B的静态成员初始化，（B没有静态成员需要初始化）
    5.类B加载完成后，执行new B()，
    
    
    6.创建B对象第一步，先要为B对象的实例变量（包括继承自父类的实例变量）开辟内存，并执行默认初始化
    7.此时 i,s的值都为0
    8.默认初始化完成后，由于子类构造器总会先调用父类构造器，所以执行父类构造器A（）
    9.A构造器中调用了init()方法，我们发现该方法已经被子类重写了，所以根据多态性，调用了子类B的init方法
    10.init调用完后，i,s的值都变为100
    11.然后A构造器执行完毕
    12.执行子类B构造器，在执行B构造器前，需要先进行实例变量声明时初始化
    13.所以s的值变为0
    
    所以最终输出100 0
    
    总结以上规律：
    创建对象 new时
    首先为子类对象开辟空间，并分别为子类自定义实例变量和继承自父类的实例变量分配内存，并执行默认初始化
    
    然后执行继承自父类的实例变量的声明时初始化，再执行父类构造器初始化
    
    最后执行子类自定义实例变量初始化，再执行子类构造器初始化。
    
    总之：对象先创建，变量分内存，默认初始化，再看构造器，构造器不急，声明处先来。若有父子类，优先父亲上。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210315195420430.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FmY18xMjgyMjA=,size_16,color_FFFFFF,t_70