第六章访问权限控制

红太狼 2022-12-12 04:39 173阅读 0赞

### 文章目录 ###

*   *   *   *   *  1.包：库元素
                 *   *  代码组织
                 *  2.Java访问权限修饰词
                 *   *  包访问权限
                     *  public：接口访问权限
                     *  private：你无法访问
                     *  protected：继承访问权限
                 *  4.类访问权限

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpYW5jNjY2_size_16_color_FFFFFF_t_70_pic_center]

**public > protected > 包访问权限 > private**

##### 1.包：库元素 #####

1.  每个编译单元必须有一个 .java 后缀的同名public类，每个编译单元只能有这样的一个public类。其他类用来给主public类提供支持
2.  ###### 代码组织 ######
    
    (1) 当编译一个 .java 文件时，在 .java 文件中的灭一个类都会有一个输出文件，而该输出文件名称应与 ”.java文件“每个类名相同，只是多了 .class 后缀（编译少量 .java 文件，出现大量 .class 文件）  
    (2) Java可运行程序是一组可以打包压缩成一个Java文档文件（JAR，使用java的java文档生成器）的 .class 文件  
    (3) Java解释器负责这些文件的 查找、装载、解释  
    (4) package 和 input 关键字允许将单一的全局名字空间分割开

##### 2.Java访问权限修饰词 #####

1.  如果不提供任何访问修饰词，则意味着它是包访问权限
2.  ###### 包访问权限 ######
    
    (1) 对于包内其他类都有访问权限，但对于包外的类则是 private  
    (2) 取得某成员的访问权限途径
    
        a. 该成员 public
        b. 不加访问修饰符，包内互相访问
        c. 继承而来的类，可以访问 public 成员、protected 成员
        d. 通过 访问器（accessor） 和 异变器（mutator）即 get/set成员
3.  ###### public：接口访问权限 ######
    
    (1) 使用关键字 public ，则成员每个人都可用
    
    (2) 默认包：两个类同处于相同的目录并且没有给自己设定任何包名称。java将这样的文件自动看作是隶属于该目录的默认包中
4.  ###### private：你无法访问 ######
    
    (1) 除了包含该成员类之外，任何类都无法访问（同一包的其他类也无法访问，相当于”隔离“）
    
    (2)
    
        class Sundae { 
        	   private Sundae() {  //无参构造器是private的
        	   }
           
        	   static Sundae makeASundae() { 
        		   return new Sundae();
        	   }
           }
           
           public class IceCream { 
        	   public static void main(String[] args) { 
        		   //! Sundae x = new Sundae(); //因为Sundae无参构造器是private的，无法创建！
        		   Sundae x = Sundae.makeASundae();
        	   }
           }
    
    (3) 想控制如何创建对象，并且阻止别人直接访问某个特定构造器（或全部构造器）不能通过构造器创建Sundae对象，而必须调用makeASundae()方法来达到此目的，默认构造器是 private ，它阻止此类的继承
5.  ###### protected：继承访问权限 ######
    
    (1) 基类创建者会希望某个特定成员，把它的访问权限只赋予 派生类 而不是所有类
    
    (2)
    
        package Chapter6.Example02.dessert;
        
            public class Cookie { 
                public Cookie() { 
                    System.out.println("Cookie constructor");
                }
        
                protected void bite() { 
                    System.out.println("bite");
                }
            } 
           ------------------------------------------------------------------------
           package Chapter6.Example02;
        
        	import Chapter6.Example02.dessert.*;
        
        	public class ChocolateChip extends Cookie { 
        		public ChocolateChip() { 
        			System.out.println("ChocolateChip constructor");
        		}
        
        		public void chomp() { 
        			//! bite(); // Cookie.bite()是protected的
        		}
        
        		public static void main(String[] args) { 
        			ChocolateChip x = new ChocolateChip();
        			x.chomp();
        		}
        	}

##### 4.类访问权限 #####

1.      package Chapter6.Example03;
        // Demonstrates class access specifiers. Make a class
        // effectively private with private constructors:
        
        class Soup1 { 
            private Soup1() { 
            }
        
            // (1) Allow creation via static method:
            public static Soup1 makeSoup() { 
                return new Soup1();
            }
        }
        
        class Soup2 { 
            private Soup2() { 
            }
        
            // (2) 创建一个对象并返回一个引用
            // upon request.(The "Singleton" pattern):
            private static Soup2 ps1 = new Soup2();
        
            public static Soup2 access() { 
                return ps1;
            }
        
            public void f() { 
            }
        }
        
        // Only one public class allowed per file:
        public class Lunch { 
            void testPrivate() { 
                // Can't do this! Private constructor:
                //! Soup1 soup = new Soup1();
            }
        
            void testStatic() { 
                Soup1 soup = Soup1.makeSoup();
            }
        
            void testSingleton() { 
                Soup2.access().f();
            }
        }
2.  其中Soup2用到了 singleton（单例）设计模式，因为你始终创建了一个对象，Soup2类的对象是作为Soup2的一个static private 成员而创建的所以有且仅有一个，而且除非是通过public方法access()，否则是无法访问到的

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L1RpYW5jNjY2_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/8596f11e1f944d549a7789b7f2337cb0.png