JavaSE - 深度探讨继承与多态，私有成员是否被继承问题

最新推荐文章于 2023-04-14 16:34:38 发布

__zz11

最新推荐文章于 2023-04-14 16:34:38 发布

阅读量606

点赞数 1

分类专栏： Java 文章标签： java 开发语言

本文链接：https://blog.csdn.net/i777777777777777/article/details/125622610

版权

Java 专栏收录该内容

7 篇文章 1 订阅

订阅专栏

有关Java中私有成员到底是否会被继承的问题，

一、继承

举例

Java - 图书馆管理系统_配的上了吗的博客-CSDN博客

中的User和Administrator User和GeneralUser就是一种继承关系。

概念

继承：是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加新功能，这样产生新的类，称派生类。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。继承主要解决的问题是：共性的抽取，实现代码复用。

简单来说，继承是is--a的关系：管理员用户是一种用户，猫是一种动物，某种特定的销售方式是一种销售方式。

语法规则，访问问题。

Java的类只有两种访问修饰限定符：public和什么都不加的默认权限访问。一个Java文件中只能只能有一个public类。

============================================

实例：

public class Base {
    private int pri_num = 0;
    public int Same_num;
    public int num1 = 0;

    public Base(int n) { // 有了自定义的构造函数，编译器就不会自动生成默认构造函数
        Same_num = n;
    }
    // 基类的静态函数，不能被重写，属于类
    public static void static_func() {
        System.out.println("Base::static_func");
    }
    // 基类的普通函数
    public void func() {
        System.out.println("Base::func");
        System.out.println(Same_num); // 这里打印的是哪里的Same_num呢？
    }

    private void private_func() {
        System.out.println("Base::private_func");
    }

    public static void main(String[] args) {
        // 这里算是比较有趣的了。
        Base base = new Derived();
        base.private_func();
    }
}

class Derived extends Base {
    public int Same_num;   // 与基类数据成员同名的数据成员，不会覆盖。
    public Derived() { // 需要帮助基类部分初始化，只能一次且必须在第一行。
        super(10);
        this.Same_num = 22;
        super.Same_num = 11;
    }
    // @Override  静态方法不可以重写，也就是子类和父类中各有一个静态方法
    public static void static_func() {
        System.out.println("Derived::static_func");
    }
    @Override  // 这个@override可省略，书写目的是让编译器检测类型，返回值部分是否覆盖成功，否则会创建新的函数，构成重载。
    public void func() {
        System.out.println("Derived::func");
    }
//    @Override  未覆盖，可能因为程序员大意，所以要写@Override
    public void func(int n) {
        System.out.println("Derived::unOverrideFunction");
    }
    // 为了证实基类引用不可以调用派生类独有的函数
    public void Derived_func() {
        System.out.println("Derived specific func");
    }
    public void testNum() {
        // 测试访问同名的非静态数据成员
        System.out.println(Same_num);
        System.out.println(super.Same_num);
        System.out.println(this.Same_num);
    }
    public void testStaticFunc() {
        // 测试访问静态成员方法，这是不能重写的。
        static_func();         //
        super.static_func();
        Base.static_func();
        this.static_func();
        Derived.static_func();
    }
}

class Main {
    public static void main(String[] args) {
        Derived derived = new Derived();
        System.out.println(derived.Same_num); // 22
        derived.testNum();         // 22 11 22
        derived.testStaticFunc();  // d b b d d
        derived.Derived_func();    //


        Base base = new Derived();
        base.func();            // d
        base.static_func();  // 无法发生动态绑定
    }
}

运行结果：是与main函数中的注释相同的。

对于这样的语句：Derived derived = new Derived();

搞清楚内存布局是很关键的。

实在不想写太多的总结性话语了，其实Java的继承和C++的如出一辙，并无太大变化。上面代码中已经测试了大多数情况了。详细阅读代码即可，且成员命名也比较明确。

总结：

1. 子类的实例中, 也包含着父类的实例. 可以使用 super 关键字得到父类实例的引用.

2. Java 中一个子类只能继承一个父类 (而C++/Python等语言支持多继承).

3. 对于父类的 private 的字段和方法, 子类的成员函数中是无法访问的.

4. 关于继承中的构造函数：子类需要先帮助父类进行构造，再构造自己的成员。且子类的构造函数中默认会调用父类的默认构造函数，即默认有一个super(); 我印象中这是和C++一样的。但是如果子类没有默认构造函数，则需要程序员手动调用合适的基类构造函数，同样是super(....) 的方式。补：super: 父类对象的引用 [不能出现在静态方法当中] super(xxx); //调用父类的构造方法
super.funcO;
super.data;

5. 子类的重写函数的访问权限不能低于父类的被重写的函数的访问权限。当然private基类函数也不能被重写，因为父类中不可见。

有关Java中私有成员到底是否会被继承的问题，

可以看Base函数的main函数，调用结果为

这里其实发生了动态绑定，并且运行成功了，也成功调用了private_func();函数。这算是比较深的探究了对于Java中的继承。

java继承关系中，父类private修饰的内容真的不能被继承吗？NO！！_阿亮_1024的博客-CSDN博客_父类的private能不能被继承

这是一篇针对此问题较为深刻探讨的博客。

1. 这下果然不报错了，编译可以通过。但是程序的运行结果，却让我大吃一惊。程序运行不但没出错，还输出了：父类private的方法。什么？？这是什么情况，为什么可以成功执行，子类中明明没有这个method方法的，为什么可以成功运行？？？（为了便于后面理解，我将这个问题命名为问题1）

2. 但是：运行的时候，是在父类中运行子类的private修饰的方法，那也应该不能成功运行才对，但实际上却成功运行了，这又是为什么？（为了便于后面理解，我将这个问题命名为问题2）

3. 证明了：“在继承关系中，子类从父类中继承下来的方法，它的权限修饰符是针对父类而言的！”，我们就能解释问题2了。被子类继承的private方法，也是只对本类（父类）可见的，所以当然就可以在父类的main方法中运行被子类继承下去的private方法了。
问题2解决了，那问题1也就解决了，因为子类继承了父类中被private修饰的方法。所以，方法当然可以被正常调用。

以上三点摘自上方链接处的文章。其实说的就是上方代码中Base类的main函数问题。