Java 访问权限修饰符public,private,protected和不写的区别 --转载

最新推荐文章于 2023-09-21 19:16:01 发布

禅与编程艺术

最新推荐文章于 2023-09-21 19:16:01 发布

阅读量897

点赞数 1

分类专栏： jv

jv 专栏收录该内容

45 篇文章 0 订阅

订阅专栏

https://blog.csdn.net/qq_21808961/article/details/80410067

https://www.runoob.com/w3cnote/java-protected-keyword-detailed-explanation.html

访问控制修饰符

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

public : 对所有类可见。

protected : 对同一包内的类和所有子类可见。子类可以跨包继承父类的protected 成员和方法。

default (即缺省，什么也不写）: 在同一包内可见

private : 在同一类内可见。

我们可以可以通过以下表来说明访问权限：

修饰符	当前类	同一包内	子孙类	其他包	其他包子孙类
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	N	Y/N（说明）
`default`	Y	Y	N	N	N
`private`	Y	N	N	N	N

公有访问修饰符-public

被声明为 public 的类、方法、构造方法和接口能被任何其他类访问。

如果几个相互访问的 public 类分布在不同的包中，则需要导入相应 public 类所在的包。由于类的继承性，类所有的公有方法和变量都能被其子类继承。

以下函数使用了公有访问控制：


    
    
      
      
       
       
      
      
      
      
       
       
        
        public static void main(String[] arguments) {
       
       
      
      

      
      
       
       
      
      
      
      
       
          
        
        // ...
       
       
      
      

      
      
       
       
      
      
      
      
       
       
        
        }

Java 程序的 main() 方法必须设置成公有的，否则，Java 解释器将不能运行该类。

受保护的访问修饰符-protected

protected 需要从以下两个点来分析说明：

基类的 protected 成员是包内可见的，被声明为 protected 的变量、方法和构造器能被同一个包中的任何其他类访问；并且对子类可见；
子类与基类不在同一包中：那么在子类中，子类实例可以访问其从基类继承而来的 protected 方法，而不能访问基类实例的protected方法。

protected 访问修饰符不能修饰类和接口，方法和成员变量能够声明为 protected，但是接口的成员变量和成员方法不能声明为 protected。

子类能访问 protected 修饰符声明的方法和变量，这样就能保护不相关的类使用这些方法和变量。

下面的父类使用了 protected 访问修饰符，子类重写了父类的 openSpeaker() 方法。


       
       
         
         
          
          
         
         
         
         
          
          
           
           class AudioPlayer {
          
          
         
         

         
         
          
          
         
         
         
         
          
             
           
           protected boolean openSpeaker(Speaker sp) {
          
          
         
         

         
         
          
          
         
         
         
         
          
                
           
           // 实现细节
          
          
         
         

         
         
          
          
         
         
         
         
          
          
           
              }
          
          
         
         

         
         
          
          
         
         
         
         
          
          
           
           }
          
          
         
         

         
         
          
          
         
         
         
         
          
           
          
          
         
         

         
         
          
          
         
         
         
         
          
          
           
           class StreamingAudioPlayer extends AudioPlayer {
          
          
         
         

         
         
          
          
         
         
         
         
          
             
           
           protected boolean openSpeaker(Speaker sp) {
          
          
         
         

         
         
          
          
         
         
         
         
          
                
           
           // 实现细节
          
          
         
         

         
         
          
          
         
         
         
         
          
          
           
              }
          
          
         
         

         
         
          
          
         
         
         
         
          
          
           
           }

如果把 openSpeaker() 方法声明为 private，那么除了 AudioPlayer 之外的类将不能访问该方法。

如果把 openSpeaker() 声明为 public，那么所有的类都能够访问该方法。

如果我们只想让该方法对其所在类的子类可见，则将该方法声明为 protected。

默认访问修饰符-不使用任何关键字

使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。

私有访问修饰符-private

私有访问修饰符是最严格的访问级别，所以被声明为 private 的方法、变量和构造方法只能被所属类访问，并且类和接口不能声明为 private。

声明为私有访问类型的变量只能通过类中公共的 getter 方法和setter方法被外部类访问。

private 访问修饰符的使用主要用来隐藏类的实现细节和保护类的数据。

下面的类使用了私有访问修饰符：


      
      
        
        
         
         
        
        
        
        
         
         
          
          public 
          
          class Logger {
         
         
        
        

        
        
         
         
        
        
        
        
         
            
          
          private String format;
         
         
        
        

        
        
         
         
        
        
        
        
         
            
          
          public String getFormat() {
         
         
        
        

        
        
         
         
        
        
        
        
         
               
          
          return 
          
          this.format;
         
         
        
        

        
        
         
         
        
        
        
        
         
         
          
             }
         
         
        
        

        
        
         
         
        
        
        
        
         
            
          
          public void setFormat(String format) {
         
         
        
        

        
        
         
         
        
        
        
        
         
               
          
          this.format = format;
         
         
        
        

        
        
         
         
        
        
        
        
         
         
          
             }
         
         
        
        

        
        
         
         
        
        
        
        
         
         
          
          }

实例中，Logger 类中的 format 变量为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个 public 方法：getFormat() （返回 format的值）和 setFormat(String)（设置 format 的值）

访问控制和继承

请注意以下方法继承的规则：

父类中声明为 public 的方法在子类中也必须为 public。
父类中声明为 protected 的方法在子类中要么声明为 protected，要么声明为 public，不能声明为 private。
父类中声明为 private 的方法，不能够被继承。

参考：菜鸟教程：Java 修饰符

很多介绍Java语言的书籍(包括《Java编程思想》)都对protected介绍的比较的简单，基本都是一句话，就是: 被 protected 修饰的成员对于本包和其子类可见。这种说法有点太过含糊，常常会对大家造成误解。实际上，protected的可见性在于两点：

基类的 protected 成员是包内可见的，并且对子类可见；
若子类与基类不在同一包中，那么在子类中，子类实例可以访问其从基类继承而来的protected方法，而不能访问基类实例的protected方法。

我们可以通过以下几个关于protected方法可见性的例子来进一步掌握protected关键字。在碰到涉及protected成员的调用时，首先要确定出该protected成员来自何方，其可见性范围是什么，然后就可以判断出当前用法是否可行了，看下面七个例子：

实例 1

package p1 ; public class Father1 { protected void f ( ) { } // 父类Father1中的protected方法 }

package p1;
public class Son1 extends Father1 {}

package p11;
public class Son11 extends Father1{}

package p1;
public class Test1 {
public static void main(String[] args) {
Son1 son1 = new Son1();
son1.f(); // Compile OK ----（1）
son1.clone(); // Compile Error ----（2）

    </span><span class="hl-identifier">Son11</span><span class="hl-code"> </span><span class="hl-identifier">son</span><span class="hl-code"> = </span><span class="hl-reserved">new</span><span class="hl-code"> </span><span class="hl-identifier">Son11</span><span class="hl-brackets">(</span><span class="hl-brackets">)</span><span class="hl-code">;    
    </span><span class="hl-identifier">son11</span><span class="hl-code">.</span><span class="hl-identifier">f</span><span class="hl-brackets">(</span><span class="hl-brackets">)</span><span class="hl-code">; </span><span class="hl-comment">//</span><span class="hl-comment"> Compile OK     ----（3）</span><span class="hl-comment"></span><span class="hl-code">
    </span><span class="hl-identifier">son11</span><span class="hl-code">.</span><span class="hl-identifier">clone</span><span class="hl-brackets">(</span><span class="hl-brackets">)</span><span class="hl-code">; </span><span class="hl-comment">//</span><span class="hl-comment"> Compile Error     ----（4）</span><span class="hl-comment"></span><span class="hl-code">
</span><span class="hl-brackets">}</span><span class="hl-code">

}

对于上面的示例，首先看(1)(3)，其中的f()方法从类Father1继承而来，其可见性是包p1及其子类Son1和Son11，而由于调用f()方法的类Test1所在的包也是p1，因此（1）(3)处编译通过。其次看(2)(4)，其中的clone()方法的可见性是java.lang包及其所有子类，对于语句"son1.clone();"和"son11.clone();"，二者的clone()在类Son1、Son11中是可见的，但对Test1是不可见的，因此（2）(4)处编译不通过。

实例 2

package p2 ; class MyObject2 { protected Object clone ( ) throws CloneNotSupportedException { return super . clone ( ) ; } }

package p22;
public class Test2 extends MyObject2 {
public static void main(String args[]) {
MyObject2 obj = new MyObject2();
obj.clone(); // Compile Error ----（1）

   </span><span class="hl-identifier">Test2</span><span class="hl-code"> </span><span class="hl-identifier">tobj</span><span class="hl-code"> = </span><span class="hl-reserved">new</span><span class="hl-code"> </span><span class="hl-identifier">Test2</span><span class="hl-brackets">(</span><span class="hl-brackets">)</span><span class="hl-code">;
   </span><span class="hl-identifier">tobj</span><span class="hl-code">.</span><span class="hl-identifier">clone</span><span class="hl-brackets">(</span><span class="hl-brackets">)</span><span class="hl-code">; </span><span class="hl-comment">//</span><span class="hl-comment"> Complie OK         ----（2）</span><span class="hl-comment"></span><span class="hl-code">
</span><span class="hl-brackets">}</span><span class="hl-code">

}

对于(1)而言，clone()方法来自于类MyObject2本身，因此其可见性为包p2及MyObject2的子类，虽然Test2是MyObject2的子类，但在Test2中不能访问基类MyObject2的protected方法clone()，因此编译不通过;对于(2)而言，由于在Test2中访问的是其本身实例的从基类MyObject2继承来的的clone()，因此编译通过。

实例 3

package p3 ; class MyObject3 extends Test3 { }

package p33;
public class Test3 {
public static void main(String args[]) {
MyObject3 obj = new MyObject3();
obj.clone(); // Compile OK ------（1）
}
}

对于(1)而言，clone()方法来自于类Test3，因此其可见性为包p33及其子类MyObject3，而（1）正是在p33的类Test3中调用，属于同一包，编译通过。

实例 4

package p4 ; class MyObject4 extends Test4 { protected Object clone ( ) throws CloneNotSupportedException { return super . clone ( ) ; } }

package p44;
public class Test4 {
public static void main(String args[]) {
MyObject4 obj = new MyObject4();
obj.clone(); // Compile Error -----（1）
}
}

对于(1)而言，clone()方法来自于类MyObject4，因此其可见性为包p4及其子类(此处没有子类)，而类Test4却在包p44中，因此不满足可见性，编译不通过。

实例 5

package p5 ;

class MyObject5 {
protected Object clone() throws CloneNotSupportedException{
return super.clone();
}
}
public class Test5 {
public static void main(String[] args) throws CloneNotSupportedException {
MyObject5 obj = new MyObject5();
obj.clone(); // Compile OK ----(1)
}
}

对于(1)而言，clone()方法来自于类MyObject5，因此其可见性为包p5及其子类(此处没有子类)，而类Test5也在包p5中，因此满足可见性，编译通过。

实例 6

package p6 ;

class MyObject6 extends Test6{}
public class Test6 {
public static void main(String[] args) {
MyObject6 obj = new MyObject6();
obj.clone(); // Compile OK -------（1）
}
}

对于(1)而言，clone()方法来自于类Test6，因此其可见性为包p6及其子类MyObject6，而类Test6也在包p6中，因此满足可见性，编译通过。

实例 7

package p7 ;

class MyObject7 extends Test7 {
public static void main(String[] args) {
Test7 test = new Test7();
test.clone(); // Compile Error ----- (1)
}
}

public class Test7 {
}

对于(1)而言，clone()方法来自于类Object，因此该clone()方法可见性为包java.lang及其子类Test7，由于类MyObject7不在此范围内，因此不满足可见性，编译不通过。

文章来源：http://blog.csdn.net/justloveyou_/article/details/61672133

			</div>

禅与编程艺术

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
Java 访问权限修饰符public,private,protected和不写的区别 --转载

https://blog.csdn.net/qq_21808961/article/details/80410067https://www.runoob.com/w3cnote/java-protected-keyword-detailed-explanation.html 访问控制修饰符Java中，可以使...
复制链接

扫一扫