文档章节

Java 访问限制符 在同一包中或在不同包中:使用类创建对象的权限 & 对象访问成员变量与方法的权限 & 继承的权限 & 深入理解protected权限

o
 osc_a22drz29
发布于 2019/03/26 23:03
字数 2277
阅读 3
收藏 0
amp

精选30+云产品,助力企业轻松上云!>>>

一、实例成员与类成员

1. 当类的字节码被加载到内存, 类中类变量、类方法即被分配了相应内存空间、入口地址(所有对象共享)。

2. 当该类创建对象后,类中实例变量被分配内存(不同对象的实例变量互不相同,即分配了不同的内存空间);

 类中实例方法被分配入口地址(创建第一个对象时分配;方法的入口地址被所有的对象共享;所有对象都不存在时,方法的入口地址才被取消)。

3在同一类中,类中的实例方法总是可以操作该类中的实例变量和类变量;类方法总是可以操作该类中的类变量。(与访问限制符没有关系)    

 

二、使用类创建对象的权限 & 对象访问成员变量与方法的权限

1. 在同一包中:

可以在任何另外一个类中使用public类与友好类创建对象;

创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。

2. 不在同一包中:import语句

可以在任何另外一个类中使用public类创建对象;

创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。

 

三、继承的权限

1. 子类与父类在同一包中,子类继承父类中不是private的成员变量与方法。

2. 子类与父类不在同一包中时,子类只继承父类中的protected和public访问权限的成员变量与方法。

 

四、深入理解protected权限

*注意!!!

对于protected的成员变量与方法,

可以被同一包中的其它类(包括子类)访问,同时也能被不同包中的子类访问;

当不在同一个包,不存在继承时,对于其他包中的类而言是不能访问的。

* 总结: 

1. 子类可以通过继承获得不同包父类的protected权限成员变量和成员方法,在子类中可以直接访问

2. 在子类中可以通过子类的对象访问父类的protected成员变量和方法

 

3. 在子类中反而不能通过父类的对象访问父类的protected成员变量和方法

4.在子类中不能通过其他子类的对象访问父类的protected成员变量和方法

5.在与子类同包的其他类中不能通过子类的对象访问父类的protected成员变量和方法

关于protected权限的子类访问方式

https://blog.csdn.net/blacktal/article/details/81198579

 

 

 1 package lab5_2_a;
 2 
 3 public class Parent {
 4     private int f1 = 11;
 5     int f2 = 12;
 6     protected int f3 = 13;
 7     public int f4 = 14;
 8     private void fm1() {
 9         System.out.println("in fm1()");
10     }
11     void fm2() {
12         System.out.println("in fm2()");
13     }
14     protected void fm3() {
15         System.out.println("in fm3()");
16     }
17     public void fm4() {
18         System.out.println("in fm4()");
19     }
20     
21     public static void main(String[] args){
22         /*当类的字节码被加载到内存,
23          * 类中类变量、类方法即被分配了相应内存空间、入口地址(所有对象共享)。
24          */
25         //在同一类中,类中的实例方法总是可以操作该类中的实例变量和类变量;类方法总是可以操作该类中的类变量。
26         Parent p = new Parent();    
27         /*Parent类创建对象,类中实例变量被分配内存(不同对象的实例变量互不相同,即分配了不同的内存空间);
28          * 类中实例方法被分配入口地址
29          * (创建第一个对象时分配;方法的入口地址被所有的对象共享;所有对象都不存在时,方法的入口地址才被取消)。
30          */
31         
32         p.fm1();
33         p.fm2();
34         p.fm3();
35         p.fm4();
36     }
37 }

 

 1 package lab5_2_a;
 2 
 3 public class Child extends Parent {
 4     private void cm1() {
 5         System.out.println("in cm1()");
 6     }
 7     void cm2() {
 8         System.out.println("in cm2()");
 9     }
10     protected void cm3() {
11         System.out.println("in cm3()");
12     }
13     public void cm4() {
14         System.out.println("in cm4()");
15     }
16     
17     public static void main(String[] args){
18         Child c = new Child();
19         c.cm1();
20         c.cm2();
21         c.cm3();
22         c.cm4();
23         //继承:子类与父类在同一包中,子类继承父类中不是private的成员变量与方法
24         //c.fm1();
25         c.fm2();
26         c.fm3();
27         c.fm4();
28     }
29 }
package lab5_2_a;

public class Inherit {
    public static void main(String[] args){
        Parent p = new Parent();
        /* 访问权限(在同一包中):
         *  可以在任何另外一个类中使用public类与友好类创建对象;
         *  创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。
         */
        //p.fm1();
        p.fm2();
        p.fm3();
        p.fm4();
        
        Child c = new Child();
        /* 访问权限(在同一包中):
         *  可以在任何另外一个类中使用public类与友好类创建对象;
         *  创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。
         */
        //c.cm1();
        c.cm2();
        c.cm3();
        c.cm4();
        //c.fm1();
        c.fm2();
        c.fm3();
        c.fm4();
    }
}
 1 package lab5_2_b;
 2 
 3 import lab5_2_a.Child;
 4 
 5 public class GrandChild extends Child {
 6     public static void main(String[] args){
 7         GrandChild g = new GrandChild();
 8         //继承:子类与父类不在同一包中时,子类只继承父类中的protected和public访问权限的成员变量与方法
 9         //g.cm1();
10         //g.cm2();
11         g.cm3();
12         g.cm4();
13         //继承:子类与父类不在同一包中时,子类只继承父类中的protected和public访问权限的成员变量与方法
14         //g.fm1();
15         //g.fm2();
16         g.fm3();
17         g.fm4();
18     }
19 }
 1 package lab5_2_b;
 2 
 3 public class GreatGrandChild extends GrandChild {
 4     public static void main(String[] args){
 5         GreatGrandChild g = new GreatGrandChild();
 6         //继承:子类与父类在同一包中,子类继承父类中不是private的成员变量与方法
 7         //g.cm1();
 8         //g.cm2();
 9         g.cm3();
10         g.cm4();
11         //继承:子类与父类在同一包中,子类继承父类中不是private的成员变量与方法
12         //g.fm1();
13         //g.fm2();
14         g.fm3();
15         g.fm4();
16     }
17 }
 1 package lab5_2_b;
 2 
 3 import lab5_2_a.*;
 4 
 5 public class Inherit {
 6     public static void main(String[] args){
 7         Parent p = new Parent();
 8         /* 访问权限(不在同一包中):import语句
 9          *  可以在任何另外一个类中使用public类创建对象;
10          *  创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。
11          */
12         //p.fm1();
13         //p.fm2();
14         //p.fm3();
15         p.fm4();
16         
17         Child c = new Child();
18         /* 访问权限(不在同一包中):import语句
19          *  可以在任何另外一个类中使用public类创建对象;
20          *  创建的对象能够通过“.”运算符操作自己类中public的成员变量与方法。
21          */
22         //c.cm1();
23         //c.cm2();
24         //c.cm3();
25         c.cm4();
26         //c.fm1();
27         //c.fm2();
28         //c.fm3();
29         c.fm4();
30         
31         GrandChild g = new GrandChild();
32         /* 访问权限(在同一包中):
33          *  可以在任何另外一个类中使用public类与友好类创建对象;
34          *  创建的对象能够通过“.”运算符操作自己类中不是private的成员变量与方法。
35          */
36         //g.cm1();
37         //g.cm2();
38         
39         //g.cm3();
40         /* 注意!!!
41          * 对于protected的成员变量与方法,
42          可以被同一包中的其它类(包括子类)访问,同时也能被不同包中的子类访问;
43          当不在同一个包,不存在继承时,对于其他包中的类而言是private(不能访问的)。
44          * 总结:        
45          1. 子类可以通过继承获得不同包父类的protected权限成员变量和成员方法,在子类中可以直接访问
46          2. 在子类中可以通过子类的对象访问父类的protected成员变量和方法
47          
48          3. 在子类中反而不能通过父类的对象访问父类的protected成员变量和方法
49          4.在子类中不能通过其他子类的对象访问父类的protected成员变量和方法
50          5.在与子类同包的其他类中不能通过子类的对象访问父类的protected成员变量和方法
51          */
52         
53         g.cm4();
54         //g.fm1();
55         //g.fm2();
56         
57         //g.fm3();
58         /* 注意!!!对于protected的成员变量与方法,
59          * 可以被同一包中的其它类(包括子类)访问,同时也能被不同包中的子类访问;
60          * 当不在同一个包,不存在继承时,对于其他包中的类而言是private(不能访问的)
61          * 总结:        
62          1. 子类可以通过继承获得不同包父类的protected权限成员变量和成员方法,在子类中可以直接访问
63          2. 在子类中可以通过子类的对象访问父类的protected成员变量和方法
64          
65          3. 在子类中反而不能通过父类的对象访问父类的protected成员变量和方法
66          4.在子类中不能通过其他子类的对象访问父类的protected成员变量和方法
67          5.在与子类同包的其他类中不能通过子类的对象访问父类的protected成员变量和方法
68          */
69         
70         g.fm4();
71     }
72 }

 

o
粉丝 0
博文 500
码字总数 0
作品 0
私信 提问
加载中
请先登录后再评论。
java入门---修饰符&访问修饰符&非访问修饰符

Java语言提供了很多修饰符,主要分为以下两类: 访问修饰符 非访问修饰符 修饰符用来定义类、方法或者变量,通常放在语句的最前端。我们通过下面的例子来说明: public class className { /...

osc_ch5yaeax
2018/04/27
14
0
第31节:Java基础-类与对象

前言 Java基础-类与对象,方法的重载,构造方法的重载,static关键字,main()方法,this关键字,包,访问权限,类的继承,继承性,方法的重写,super变量。 方法的重载:成员方法的重载和构造...

osc_88wjsceo
2018/08/16
0
0
Java 权限protected关键字纠正

以前一直认为自己理解了Java四种权限访问,昨天突然编程时发现protected居然在子类中不能调用,然后越看越迷糊?????? public: Java语言中访问限制最宽的修饰符,一般称之为“公共的”...

osc_67he7idx
2018/12/10
2
0
Java中的public,protected,package-private和private之间有什么区别?

在Java中,关于何时使用每个访问修饰符(即默认(程序包私有), , 和 )的明确规则,同时使和以及继承都可以使用? #1楼 它实际上比简单的网格显示要复杂一些。 网格会告诉您是否允许访问,...

技术盛宴
2019/12/01
52
0
第31节:Java基础-类与对象

前言 Java基础-类与对象,方法的重载,构造方法的重载,static关键字,main()方法,this关键字,包,访问权限,类的继承,继承性,方法的重写,super变量。 方法的重载:成员方法的重载和构造...

达叔小生
2018/08/16
0
0

没有更多内容

加载失败,请刷新页面

加载更多

Spring Cloud开发人员如何解决服务冲突和实例乱窜?(IP实现方案)

点击上方“陶陶技术笔记”关注我 回复“资料”获取作者整理的大量学习资料! 一、背景 在我上一篇文章《Spring Cloud开发人员如何解决服务冲突和实例乱窜?》中提到使用服务的元数据来实现隔...

zlt2000
2019/09/06
0
0
Linux下diff命令用法详解

大家好,我是良许。 我们在平时工作的时候,经常要知道两个文件之间,以及同个文件不同版本之间有何异同点。在 Windows 下,有 beyond compare 这个好用的工具,而在 Linux 下,也有很多很强...

osc_th8jvcw7
59分钟前
7
0
万变不离其宗之UART要点总结

[导读] 单片机开发串口是应用最为广泛的通信接口,也是最为简单的通信接口之一,但是其中的一些要点你是否明了呢?来看看本人对串口的一些总结,当然这个总结并不能面面俱到,只是将个人认为...

osc_kyehmyzk
今天
7
0
kafka的认识、安装与配置

认识Kafka 花费越少的精力在数据移动上,就能越专注于核心业务 --- 《Kafka:The Definitive Guide》 认识 Kafka 之前,先了解一下发布与订阅消息系统:消息的发送者不会直接把消息发送给接收...

osc_wy8nhxhn
今天
0
0
使用pandas进行数据处理——DataFrame篇

  今天是pandas数据处理专题的第二篇文章,我们一起来聊聊pandas当中最重要的数据结构——DataFrame。   上一篇文章当中我们介绍了Series的用法,也提到了Series相当于一个一维的数组,只...

开源仔
今天
0
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部