[再学编程思想]第六章访问权限控制

快来打我* 2022-04-25 02:18 209阅读 0赞

***访问控制（隐藏具体实现）与“最初的实现并不恰当”有关***

从最大权限到最小权限依次为：public、protected、包访问权限、private

### 一.包：库单元 ###

包内包含有一组类，他们在单一的名字空间之下被组织在了一起。

java标准发布中有一个工具库，它被组织在java.util名字空间之下，java.util包中有一个叫做ArrayList的类，使用ArrayList的一种方式是使用其全名java.util.ArrayList来指定。

这会使得程序变得冗长，因此可以使用import关键字导入：import java.util.ArrayList；

如果想使用java.util包下的其他类仍然是不可用的所以可以使用“\*”（通配符）：import java.util.ArrayList;

导入的原因是为了给每个类创建一个唯一标识符，可以想象如果别人也写了相同的类名，这个时候包的出现就十分有必要。

当编写一个java源文件的时候，此文件通常被称为编译单元（有时候也称为转义单元）每个编译单元都必须有一个后缀.java而在便一单元内则可以有一个public类，该类的名称必须与文件的名称相同，每个便一单元只能有一个public类，否则编译器就不会接受，如果在该编译单元之中还有额外的类，那么包之外的世界是无法看到这些类的，这是因为他们不是public类，并且他们主要是为了public类提供支持的。

**代码组织：**

**   ** 当编译一个.java文件的时候，在.java文件中每一个类都会有一个输出文件，名称与每个.java文件中的每个类名称相同，后缀为.class。所以编译少数java文件通常会出现大量的.class 文件。与编译型语言编译过程不同的是，java可运行程序是一组可以打包并压缩为一个java文档文件的.class文件，java解释器负责这些文件的查找、装载、解释。

类库实际上是一组类文件，没个文件都有一个public类，以及任意数量的非public类，因此每个文件都有一个构件，如果希望这些构件从属同一个群组，就可以使用关键字package；

package access;
    public class Myclass{
        //....
    }

表示Myclass是access包下的

**    创建独一无二的包名：**

将所有文件收入一个子目录是java解决混乱问题的一种方式，还可以解决另外两个问题：怎样创建独一无二的名称以及怎么查找有可能隐藏于目录结构中某处的类，这些任务是通过将.class文件所在的路径位置编码成package的名称来实现的。

按照惯例，package名称第一部分是反顺序的域名，例如：com.sihgyu

此技巧的第二部分是把package名称分解为你机器的上一个目录。所以当java程序运行并且需要加载.class文件的时候，它就可以确定.class文件在目录中所处的位置。

**  \*\*java解释器运行过程：**

**   ** 首先，找出环境变量CLASSPATH，CLASSPATH包含一个或多个目录，用作查找.class文件的根目录，从根目录开始，解释器获取包的名称并将每个句点替换成反斜杠，以从CLASSPATH根中产生一个路径名称，得到的路径会与CLASSPATH中的各个不同的项相连接，解释器就在这些目录中查找与你索要创建的类名称相关的.class文件。

### 二.Java访问权限修饰符 ###

public,protected,private这几个java访问权限修饰词在使用时，是置于类中每个成员的定义之前的--无论它是一个域还是一个方法，每个访问权限修饰符仅控制它所修饰的特定定义的访问权。

**包访问权限：**

默认访问权限没有任何关键字，但通常是指包访问权限，这就意味着当前的包中的所有其他类对那个成员都有访问权限，但对于这个包之外的所有类，这个成员却是private，由于一个编译单元只能隶属于一个包所以经由包访问权限，处于同一个编译单元中的所有类彼此之间都是自动可访问的。

包访问权限允许将包内所有相关的类组合起来，以使它们彼此之间可以轻松地互相作用，当把类组织起来放进一个包内，也就给他们的包访问权限成员赋予了互相访问的权限。

**public：**接口访问权限

使用关键字public，就意味着public之后紧跟着的成员声明自己对每个人都是可以用的，尤其是使用类库的客户端程序员更是如此。

**private：**你无法访问

关键字private的意思是除了包含该成员的类之外，其他任何类都无法访问这个成员。由于处于同一个包内的其他类是不可以访问private的，因此这等于说是自己隔离了自己，从另一方面说让许多人共同合作来创建一个包也是不大可能的，为此private就允许你随意改变该成员，而不必考虑这样做是否会影响到包内其他的类。

**protected：**声明protected的方法和成员变量能被同一个包内的所有类所访问，就像默认修饰符package一样，也能被该类的子类所访问，子类可以和父类不在同一个包中。

### 三.接口和实现 ###

访问权限控制常被称为是具体实现的隐藏。把数据和方法包装进类中，以及具体实现的隐藏，常共同被称作是封装，其结果是一个同时带有特征和行为的数据类型。

访问权限控制将权限的边界划在了数据类型的内部，第一个原因是要设定客户端程序员可以使用和不可以使用的边界，可以在结构中建立自己的内部机制，而不必担心客户端程序员会偶然的将内部机制当成他们可以使用的部分。

第二个原因是将接口和具体实现分离。如果结构是用于一组程序之中，客户端程序员除了可以向接口发送信息之外什么都不能做，那么就可以随意更改所有不是public的东西，而不会破坏客户端的代码。

### 四.类的访问权限 ###

如果希望某个类可以为某个客户端程序员使用，就可以通过把关键字public作用于整个类的定义来达到目的。

//: access/Lunch.java
    // 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) Create a static object and return a reference
      // 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();
      }
    } ///:~

Soup1和Soup2类展示了如何通过将所有的构造器指定为private来阻止直接创建某个类的实例，请一定要牢记，如果没有明确的至少创建一个构造器的话，就会帮你创建一个默认构造器。

在Soup1中创建一个static的方法，它创建一个Soup1的对象并且返回，如果想要在Soup1返回之前做一些额外的工作，或者记录到底创建了多少个Soup1对象这种方法是好的。

public class A{
    
        public static void main(String[] args){
            Soup1 s =  Soup1.makeS();
            Soup1 s1 = Soup1.makeS();
            System.out.println(s.i);
    
        }
    }
    class Soup1{
        public static int i = 0;
    
        private Soup1(){
    
        }
        public static Soup1 makeS(){
        
            i ++;
            return new Soup1();
        }
    }

Soup2其实是一个单例模式的应用，即只能创建该类的一个对象。