首页 > 代码库 > Java和C++里面的重写/隐藏

Java和C++里面的重写/隐藏

首先,无关重载

注:重载是同一个类的各个函数之间的。重写是父类子类之间的。Overload和Overwrite的区别。

 

这里主要谈的是函数重写与隐藏

首先,我的理解:重写和隐藏是互斥的、相对的。父子中都存在的函数,不是重写就是隐藏

重写和隐藏的本质区别是:重写是动态绑定的,根据运行时引用所指向对象的实际类型来决定调用相关类的成员。而隐藏是静态绑定的,根据编译时引用的静态类型来决定调用的相关成员。换句话说,如果子类重写了父类的方法,当父类的引用指向子类对象时,通过父类的引用调用的是子类方法。如果子类隐藏了父类的方法(成员变量),通过父类的引用调用的仍是父类的方法(成员变量)。

:这一句话非常绕,说的是子类隐藏了父类的方法,但调用的还是父类的方法,还不如说是父类隐藏了子类的方法。其实原义是,是针对子类引用说的隐藏,指的是子类引用调用子类,不调用父类;而父类引用仍然调用父类)

 

Java的隐藏和C++的隐藏是有区别的。也不能说完全不同,但是覆盖面和默认采用方式不同。

先说Java的隐藏(参考 Link)


覆盖则指的是父类引用指向了子类对象,调用的时候会调用子类的具体方法;
隐藏指的是“子类把父类的属性或者方法隐藏了”,即将子类强制转换成父类后,调用的还是父类的属性和方法。(引号内的容易引起歧义,可以忽略)

(1) 变量只能被隐藏(包括静态和非静态),不能被覆盖

(2) 可以用子类的静态变量隐藏父类的静态变量,也可以用子类的非静态变量隐藏父类的静态变量,也可以用非最终变量(final)隐藏父类中的最终变量;

(3) 静态方法(static)只能被隐藏,不能被覆盖;

(4) 非静态方法可以被覆盖;

(5) 不能用子类的静态方法隐藏父类中的非静态方法,否则编译会报错;

(6) 不能用子类的非静态方法覆盖父类的静态方法,否则编译会报错;

(7) 不能重写父类中的最终方法(final);

(8) 抽象方法必须在具体类中被覆盖;

简单讲,父类和子类的方法的静态性必须一样。要么都有static,要么都没有,否则会报错,已实验。

实例,我在Intellij上面实验了,如下:

package com.company;


class Solution {

}

class SuperClass {
    public static int i = 1;
    public int j = 2;
    public final int k = 3;

    public static void method1() {
        System.out.println("SuperClass Method1");
    }

    public void method2() {
        System.out.println("SuperClass Method2");
    }

    public final void method3() {
        System.out.println("SuperClass Method3");
    }

}

class SubClass extends SuperClass {

    public static int i = 2;//无论是不是static,都能隐藏父类的变量i
    public static int j = 1;
    public final int k = 4;//无论是不是final,都能隐藏父类的变量k

    public static void method1() {
        System.out.println("SubClass Method1");
    }

    public void method2() {
        System.out.println("SubClass Method2");
    }

    /*public final void method3() {
        System.out.println("SuperClass Method3");
    }*/
}

public class Main {

    public static void main(String[] args) throws InterruptedException {

        SuperClass sc = new SubClass();
        System.out.println("i = " + sc.i); // 所有的成员变量,只能被隐藏
        System.out.println("j = " + sc.j);
        System.out.println("k = " + sc.k);
        sc.method1();//静态方法只能被隐藏
        sc.method2();



        SubClass subc = new SubClass();
        System.out.println("i = " + subc.i);
        System.out.println("j = " + subc.j);
        System.out.println("k = " + subc.k);

        subc.method1();
        subc.method2();

        // Your Codec object will be instantiated and called as such:
        //System.out.printf("ret:%d\n", ret);

        System.out.println();

    }

}

打印结果:

i = 1
j = 2
k = 3
SuperClass Method1
SubClass Method2
i = 2
j = 1
k = 4
SubClass Method1
SubClass Method2

 

把上面子类里面变量的static和final去掉:

    public int i = 2;//无论是不是static,都能隐藏父类的变量i
    public static int j = 1;
    public int k = 4;//无论是不是final,都能隐藏父类的变量k

打印的结果和原来的一致:

i = 1
j = 2
k = 3
SuperClass Method1
SubClass Method2
i = 2
j = 1
k = 4
SubClass Method1
SubClass Method2

 

而C++里面的隐藏,和Java里面的隐藏的语义,不太一样,参考 Link:

 如果派生类的函数与基类的函数同名, 但是参数不同. 此时, 不论有无 virtual 关键字, 基类的函数将被隐藏(注意别与重载混淆).
如果派生类的函数与基类的函数同名, 并且参数也相同, 但是基类函数没有 virtual 关键字. 此时, 基类的函数被隐藏(注意别与覆盖混淆).

 

也就是说,C++的重写,只跟virtual关键字有关。如果没有这个关键字,那么父类中的方法和子类是没有关系的。即使用了virtual,如果方法参数不一样,也不重载,而是采用隐藏。

Java默认是重载只有static方法和变量,是不重载,而采用隐藏的。

 

注:我认为的,对于“隐藏”,好的记忆方法是指向子类实例的父类指针(引用),看到的仍然是父类的方法,而把子类的方法给“隐藏”了。

 

Java和C++里面的重写/隐藏