欢迎您访问程序员文章站本站旨在为大家提供分享程序员计算机编程知识!
您现在的位置是: 首页  >  IT编程

[ Java学习基础 ] Java的封装性与访问控制

程序员文章站 2022-07-05 11:38:08
Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的,访问控制分为4个等级:私有、默认、保护和公有,具体规则如下表: 1.私有级别 私有级别的关键字是private,私有级别的成员变量和方法只能在其所在类的内部*使用,在其他的类中则不允许直接访问。私有级别限制性最高。示例代码如下: 上 ......

      Java面向对象的封装性是通过对成员变量和方法进行访问控制实现的,访问控制分为4个等级:私有、默认、保护和公有,具体规则如下表:

[ Java学习基础 ] Java的封装性与访问控制

1.私有级别

      私有级别的关键字是private,私有级别的成员变量和方法只能在其所在类的内部*使用,在其他的类中则不允许直接访问。私有级别限制性最高。示例代码如下:

 1 // PrivateClass.java文件
 2 public class PrivateClass {            
 3     private int x;                     
 4 
 5     public PrivateClass() {            
 6         x = 100;
 7     }
 8     private void printX() {            
 9         System.out.println("Value Of x is" + x);
10     }
11 }
12 
13 
14 // HelloWorld.java文件调用PrivateClass
15 public class HelloWorld {
16     public static void main(String[] args) {
17 
18         PrivateClass p;
19         p = new PrivateClass();
20 
21         //编译错误,PrivateClass中的方法 printX()不可见
22         p.printX();                    
23     }
24 }

    上述代码第2行声明PrivateClass类,其中的代码第3行是声明私有实例变量x,代码第5行是声明公有的构造方法。代码第8行声明私有实例方法。HelloWorld类中代码第22行会有编译错误,因为PrivateClass中printX()的方法是私有方法。

2.默认级别

     默认级别没有关键字,也就是没有访问修饰符,默认级别的成员变量和方法,可以在其所在类内部和同一个包的其他类中被直接访问,但在不同包的类中则不允许直接访问。示例代码如下:

 1 // DefaultClass.java文件
 2 package com.Kevin;
 3 
 4 public class DefaultClass {
 5 
 6     int x;                            
 7 
 8     public DefaultClass() {
 9         x = 100;
10     }
11 
12     void printX() {                   
13         System.out.println("Value Of x is" + x);
14     }
15 
16 }

上述代码第6行的x变量前没有访问限制修饰符,代码第12行的方法也是没有访问限制修饰符。它们的访问级别都有默认访问级别。

在相同包(com.Kevin)中调用DefaultClass类代码如下:

 1 // com.Kevin包中HelloWorld.java文件
 2 package com.Kevin;
 3 
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7 
 8         DefaultClass p;
 9         p = new DefaultClass();
10         p.printX();
11     }
12 }

默认访问级别可以在同一包中访问,上述代码可以编译通过。

在不同的包中调用DefaultClass类代码如下:

 1 // 默认包中HelloWorld.java文件
 2 import com.Kevin.DefaultClass;
 3 
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7 
 8         DefaultClass p;
 9         p = new DefaultClass();
10         // 编译错误,DefaultClass中的方法 printX()不可见
11         p.printX();
12     }
13 }

      该HelloWorld.java文件与DefaultClass类不在同一个包中,printX()是默认访问级别,所以p.printX()方法无法编译通过。

3.共有级别

     公有级别的关键字是public,公有级别的成员变量和方法可以在任何场合被直接访问,是最宽松的一种访问控制等级。示例代码如下:

 1 // PublicClass.java文件
 2 package com.Kevin;
 3 
 4 public class PublicClass {
 5 
 6     public int x;                 
 7 
 8     public PublicClass() {
 9         x = 100;
10     }
11 
12     public void printX() {        
13         System.out.println("Value Of x is" + x);
14     }
15 
16 }

上述代码第6行的x变量是公有级别,代码第12行的方法也是公有级别。调用PublicClass类代码如下:

 1 // 默认包中HelloWorld.java文件
 2 import com.Kevin.PublicClass;
 3 
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7 
 8         PublicClass p;
 9         p = new PublicClass();
10         p.printX();
11     }
12 }

      该HelloWorld.java文件与PublicClass类不在同一个包中,可以直接访问公有的printX()方法。

4.保护级别

      保护级别的关键字是protected,保护级别在同一包中完全与默认访问级别一样,但是不同包中子类能够继承父类中的protected变量和方法,这就是所谓的保护级别,“保护”就是保护某个类的子类都能继承该类的变量和方法。示例代码如下:

 1 // ProtectedClass.java文件
 2 package com.Kevin;
 3 
 4 public class ProtectedClass {
 5 
 6     protected int x;                     
 7 
 8     public ProtectedClass() {
 9         x = 100;
10     }
11 
12     protected void printX() {            
13         System.out.println("Value Of x is " + x);
14     }
15 
16 }

上述代码第6行的x变量是保护级别,代码第12行的方法也是保护级别。

在相同包(com.Kevin)中调用ProtectedClass类代码如下:

 1 // 默认包中HelloWorld.java文件
 2 package com.Kevin;
 3 
 4 import com.Kevin.ProtectedClass;
 5 
 6 public class HelloWorld {
 7 
 8     public static void main(String[] args) {
 9 
10         ProtectedClass p;
11         p = new ProtectedClass();
12         // 同一包中可以直接访问ProtectedClass中的方法 printX()
13         p.printX();
14 
15     }
16 }

同一包中保护访问级别与默认访问级别一样,可以直接访问ProtectedClass的printX()方法,上述代码可以编译通过。

在不同的包中调用ProtectedClass类代码如下:

 1 // 默认包中HelloWorld.java文件
 2 import com.Kevin.ProtectedClass;
 3 
 4 public class HelloWorld {
 5 
 6     public static void main(String[] args) {
 7 
 8         ProtectedClass p;
 9         p = new ProtectedClass();
10         // 编译错误,不同包中不能直接访问保护方法printX()
11         p.printX();
12 
13     }
14 }

该HelloWorld.java文件与ProtectedClass类不在同一个包中,不同包中不能直接访问保护方法printX(),所以p.printX()方法无法编译通过。

在不同的包中继承ProtectedClass类代码如下:

 1 // 默认包中SubClass.java文件
 2 import com.Kevin.ProtectedClass;
 3 
 4 public class SubClass extends ProtectedClass {
 5 
 6     void display() {
 7         //printX()方法是从父类继承过来
 8         printX();                            
 9         //x实例变量是从父类继承过来
10         System.out.println(x);               
11     }
12 }

      不同包中SubClass从ProtectedClass类继承了printX()方法和x实例变量。代码第8行是调用从父类继承下来的方法,代码第10行是调用从父类继承下来的实例变量。

 

提示 访问成员有两种方式:一种是调用,即通过类或对象调用它的成员,如p.printX()语句;另一种是继承,即子类继承父类的成员变量和方法。

  • 公有访问级别任何情况下两种方式都可以;

  • 默认访问级别在同一包中两种访问方式都可以,不能在包之外访问;

  • 保护访问级别在同一包中与默认访问级别一样,两种访问方式都可以。但是在不同包之外只能继承访问;

  • 私有访问级别只能在本类中通过调用方法访问,不能继承访问。

 

提示 访问类成员时,在能满足使用的前提下,应尽量限制类中成员的可见性,访问级别顺序是:私有级别→默认级别→保护级别→公有级别。

 

上一篇: Hello world!

下一篇: Python3 常用模块