java 父类private_子类调用父类private方法「建议收藏」

java 父类private_子类调用父类private方法「建议收藏」前情引入关于java的继承,初学的时候,一直认为父类中private修饰的东西时无法被子类继承

前情引入

关于java的继承,初学的时候,一直认为父类中private修饰的东西时无法被子类继承。后来随着学习的深入,见得多了一些,看到一些文章博客的另一种观点:其实父类中的东西,除了构造方法之外,其它的全都是可以被继承的,包括私有的。但是由于private修饰的东西,只能在本类中可见。所以即便子类继承了,也是不可见的。

我一开始听着很玄乎,什么?我继承了我父亲的遗产,但是我自己却无法使用?这是什么逻辑。反正继承了private修饰的内容,也是不可见的,那和没继承也没啥区别,而且也没法验证子类是不是真的继承了private的内容,所以也没多想。

问题来了

今天我再重新温习多态的时候,遇到了问题。可能大家都已经知道了,在多态形式下,如果是访问实例方法,是遵循一条口诀的:编译看左右,运行看右边。(如果忘了多态具体的细节,可以先看看我的另一篇博客:多态细节)

就是说,编译的时候,必须父类(或接口)中有对应的方法,编译才能通过,但是运行的时候,就跑去运行子类中的具体方法了,如果重写了,那么运行的是子类中重写过的方法。如果没有重写看起来好像运行的是父类中的方法,但实际上运行的是子类中被继承下去的方法,因为没有重写,所以效果是和父类中方法效果是一样的。

如此一来,在多态形式下,就不能调用子类中特有的方法,如果要调用,就必须向下转型。但是我今天突发奇想:如果是父类中特有,而子类中没有的方法呢?(实际上这种情况是无法做到的,因为子类中将父类中所有的东西都继承下去,包括private) 我在此之前的理解,只要我把父类中的方法用private修饰,那子类就不会继承了。我猜测,在这样的情况下,应该是编译可以通过,运行的时候会报错。

然后我就开始代码测试:

  1. 父类,有一个private修饰的方法
package demo07.test;
//父类,有一个private修饰的方法
public class Father
{ 
   
    private void method()
    { 
   
        System.out.println("父类private的方法");
    }
}
  1. 子类,什么都没写
package demo07.test;
//子类,什么都没写
public class Son extends Father
{ 
   

}
  1. 测试类
package demo07.test;
//测试类
public class Test01
{ 
   
    public static void main(String[] args)
    { 
   
        Father father = new Son();
        father.method();//报错:'method()' has private access in 'demo07.test.Father'
    }
}

但是有问题,因为父类中方法是private的,无法在其它的类中使用,所以在测试类中是无法访问到的。编译就报错

只对本类可见,那好,我就把main方法放在父类中,在父类中进行测试。子类不变,父类改成如下:

package demo07.test;

public class Father
{ 
   
    private void method()
    { 
   
        System.out.println("父类private的方法");
    }

    public static void main(String[] args)
    { 
   
        Father father = new Son();
        father.method();
    }
}

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

我自己想不通,也不知道怎么去搜索这个问题的关键词。然后我去请教了老师,老师好像也不是很清楚,或者说不知道怎么给我解释。但是他说:可能和权限修饰符的可见性有关

真相大白之前

在听了老师的建议之后,我就往这方面思考,如果真是权限修饰符可见性造成的。也就是说,父类这个private修饰的method方法,其实是被子类继承下去了的,只是对子类不可见。但是还是有个问题:我在父类的main方法中调用了父类的method方法的,private可以对本类可见,所以没有问题。但是:运行的时候,是在父类中运行子类的private修饰的方法,那也应该不能成功运行才对,但实际上却成功运行了,这又是为什么?(为了便于后面理解,我将这个问题命名为问题2

由此,我又想到了一个问题:父类中一个方法被子类继承下去,那么这个方法的权限修饰符是针对哪一个类而言的呢?

大伙可能都见过和这张差不多的图:
权限修饰符
我上面那个问题的意思就是:如果父类中有一个protected修饰的方法被子类继承下去了,那么这些本类、同包、子类 是针对父类而言还是针对子类而言呢?
比如说,我的父类和子类不在同一个包,被继承的方法权限修饰符是protected。如果是针对父类而言,那么我在子类所在的包下建一个测试类,创建子类对象,调用这个方法,应该是不能调用这个方法的,因为和父类不在同一个包下。而在父类所在的包下新建一个测试类,创建子类对象,调用这个方法,应该就可以访问,因为和父类在同一个包中。
而如果是针对子类而言的,情况就和上面是相反的。在父类所在的包下建测试类,就不能调用。而在子类所在的包下建测试类,就可以调用。

上面这段有点饶,但是其实想表达的意思很简单。多读几遍,就能理解了

但其实答案可以简单推测出:如果是针对子类而言的,那么被继承下来的private修饰的内容,在子类中应该是可以被访问的,但是实际上并不能被访问,所以应该是针对父类而言的。
但是不能这样推测:因为我们现在就是在验证private修饰的内容是否可以被继承,像上面那样推测,就代表了我们已经认定了private修饰的内容是可以被继承的。所以还是得用代码先证明权限修饰符是针对父类而言。

验证权限修饰符是针对父类还是子类

用代码验证,思路就是上面叙述那样:父类和子类分别在不同的包中,父类中有一个protected修饰的方法。然后分别在父类所在的包下创建测试类,在测试类中创建子类对象,看子类对象是否能调用从父类中继承下来的那个protected修饰的方法
代码如下:注意所在包

  1. test包下的父类:
package test;
//test包下的父类
public class Father
{ 
   
    protected void method()
    { 
   
        System.out.println("父类protected修饰的方法");
    }
}
  1. test.test包下的子类,什么都没写,但是继承了test包下的父类
package test.test;
import test.Father;
//test.test包下的子类,什么都没写,但是继承了test包下的父类
public class Son extends Father
{ 
   
}

  1. test.test包下的测试类Test01(和子类同包)
package test.test;
//test.test包下的测试类(和子类同包)
public class Test01
{ 
   
    public static void main(String[] args)
    { 
   
        Son son = new Son();
        son.method();//报错:'method()' has protected access in 'test.Father'
    }
}

  1. test包下的测试类Test02(和父类同包)
package test;
import test.test.Son;
//test包下的测试类(和父类同包)
public class Test02
{ 
   
    public static void main(String[] args)
    { 
   
        Son son = new Son();
        son.method();
    }
}

果然,在和子类同包的测试类Test01中,无法调用这个方法,并且告诉我:method这个方法在父类中是被protected修饰的。而在和父类同包的测试类Test02中,就能正常调用method方法。

至此,我们独立的通过代码验证了,在继承关系中,子类从父类中继承下来的方法,它的权限修饰符是针对父类而言的!
注意:如果是重写了,那么这个方法的权限修饰符就是针对子类而言的

水落石出

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

至此,就证明了,在继承关系中,父类中的private方法也是可以被子类继承的,只是这个被继承下来的方法,只针对父类可见。
当然,这个结论正确的前提是:在多态形式下,调用实例方法的时候,最终运行的是子类中的方法。 这个结论是正确的。

再次佐证

当初写了博客之后,很久一段时间也没有再想过这个问题,今天再次复习的时候,同学说到了反射,恍然大悟,反射可以无视封装的嘛,

开始尝试

那么可以尝试用反射,获取子类中的所有方法,查看是否能获取到从父类中继承的私有方法。然后,我对反射有多了一层认识:反射要么获取所有public的方法(getMethods),包括继承下来的方法,要么就只能获取子类声明的方法(getDeclaredMethods),根本无法获取从父类中继承下来的非public方法,所以从父类继承的private方法自然也无法获取到。

转机

但是我想到一个问题:虽然无法从子类获取到这个方法,那我为什么非要从子类里面获取呢?我只要获取到这个方法,然后用子类实例去调用就行了。
那我就用父类的字节码对象,去获取到父类的这个私有的方法,然后用方法对象调用invoke方法,传入一个子类实例,如果能够成功调用,一样也可以说明子类是继承了父类中private方法的嘛。

着手尝试
  1. 父类,只声明了一个private的方法
public class Parent
{ 
   
    private void mehotd1()
    { 
   
        System.out.println("父类中的私有方法");
    }
}
  1. 子类,继承了父类,什么方法都没有声明
public class Child extends Parent
{ 
      
}
  1. 测试类,尝试用反射调用方法
import java.lang.reflect.Method;

/** * @author ql * @date 2020/10/30 * @time 17:32 **/
public class Test01
{ 
   	
	// 采用了两种不同的方式获取了这个方法对象,不过原理都差不多
    public static void main(String[] args) throws Exception
    { 
   
        test01();
        test02();
    }

    public static void test01() throws Exception
    { 
   
        Class parentClass = Parent.class;
        Method mehotd1 = parentClass.getDeclaredMethod("mehotd1");
        //System.out.println(mehotd1);
        mehotd1.setAccessible(true);

        Child child = new Child();
        mehotd1.invoke(child);
    }


    public static void test02() throws Exception
    { 
   
        Child child = new Child();
        Class superclass = child.getClass().getSuperclass();
        Method mehotd1 = superclass.getDeclaredMethod("mehotd1");
        //System.out.println(method01);
        mehotd1.setAccessible(true);
        mehotd1.invoke(child);
    }
}
结果

程序完全没问题,成功调用,控制台打印了两句“父类中的私有方法”,所以这也再次佐证了java中私有的内容也是可以被继承的

分割线———————————————————————————————
2023.01.03更新:

人是不断成长的,对事物的看待、认识也是如此。今日在学习jvm相关内容时,又联想到了这个问题,所以又来更新了。想想自己原本的问题:父类private修饰的内容能否被继承?其实是有纰漏的,既然在说能不能被继承,那么“继承父类中的内容”中“继承”的定义又是什么呢?如果按照通常的认为:能够直接访问即为继承,那确实是不能直接访问,但却能通过反射访问又该如何解释?到底是能被继承呢还是不能被继承呢?

小时候,我们在看电视或者日常生活中,总会把自己或者电视剧中的主角当作正义的一方,而反派或者跟自己有过节的人就是那种坏的透透的人。但其实这种看法很片面,每个人,有自己的立场、想法,并不不是大多数人所认为的就一定是对的,应该站在不同的角度去分析,去思考,看透本质,而不是浮于表面。

回到这个问题上来也是如此,我们不应该执着与“是否能被继承”,而应该去理解,代码纠结是怎样运行的,以此来解释这个问题。在尚硅谷宋红康老师jvm课程中有这么一个观点:
java重写本质

这个逻辑与我对java的认知不冲突,反而还能解释很多问题,应该是没错的。关于编译看左、运行看右这句顺口溜,其实也没错,但是他只是初学者用于加深记忆的,并经不起深入的引申。我自己在分析过程中,将这句助记的顺口溜引申为:多态最终运行的方法一定是子类中,这样的引申并不正确。

所以我们在面对这个问题的时候,不应该简单的描述为:能不能继承,而是应该描述为:父类private修饰的内容,的确不能直接使用子类对象去访问,但通过反射,还是能够访问。并且把上面重写的本质解释出来,才是这个问题的最佳答案。

评论区有个兄弟的评论,也很合理:
评论区的评论

有什么不对或不懂的地方,欢迎讨论交流

今天的文章java 父类private_子类调用父类private方法「建议收藏」分享到此就结束了,感谢您的阅读。

版权声明:本文内容由互联网用户自发贡献,该文观点仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 举报,一经查实,本站将立刻删除。
如需转载请保留出处:https://bianchenghao.cn/72315.html

(0)
编程小号编程小号

相关推荐

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注