第六章 访问权限控制

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()，否则是无法访问到的