Java和C++中“隐藏/覆盖/重写/重载” 的区别

最新推荐文章于 2024-08-03 11:32:43 发布

转载最新推荐文章于 2024-08-03 11:32:43 发布 · 589 阅读

文章标签：

#Java中重写覆盖隐藏重载

C++和Java 专栏收录该内容

0 篇文章

订阅专栏

本文详细解释了在面向对象编程中重写与隐藏的概念及它们之间的区别，通过Java实例展示了如何实现方法的重写和变量及方法的隐藏，并强调了重写与隐藏的不同绑定特性。

重载：重载是一个类的各个函数之间的，就是函数或者方法有相同的名称，但是参数列表不相同的情形，这样的同名不同参数的函数或者方法之间，互相称之为重载函数或者方法。

重写：重写是父类子类之间的。

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

首先，重写和隐藏是互斥的，相对的。父子中都存在的函数，不是重写就是隐藏。

重写和隐藏的本质区别是：重写是动态绑定，根据运行时引用所指向的对象的实际类型来决定调用相关类的成员，而隐藏是静态绑定的，根据编译时引用的静态类型来决定调用的相关成员。

（就是父类的引用调用的是子类的方法，就是子类的这个方法重写了；如果父类的引用仍然调用的是父类的方法，子类的引用调用的是子类的方法，那么如果这连个方法重名，那就是子类隐藏了父类的方法。）

C++中重写，一般叫做覆盖。

C++ 中隐藏和重写(覆盖) 只与virtual有关，如果方法有修饰符virtual,表示的是虚函数，是需要子类重写父类的方法。

Java里面的隐藏，值针对参数一样的static函数，参数不一样的static函数，照样不会隐藏。

实例

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 static void method1(int a) {
        System.out.println("SuperClass Method1 with int " + a);
    }

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

    public void method2(int a) {
        System.out.println("SuperClass Method2 with int " + a);
    }

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

}

class SubClass extends SuperClass {

    public  int i = 2;//无论是不是static，都能隐藏父类的变量i
    public static int j = 1;
    public  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.method1(3);
        sc.method2();
        sc.method2(3);
        sc.method3();



        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.method1(3);
        subc.method2();
        subc.method2(3);
        subc.method3();

        // 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
SuperClass Method1 with int 3
SubClass Method2
SuperClass Method2 with int 3
SuperClass Method3
i = 2
j = 1
k = 4
SubClass Method1
SuperClass Method1 with int 3
SubClass Method2
SuperClass Method2 with int 3
SuperClass Method3