thinkinginjava学习笔记05_访问权限

Java中访问权限等级从大到小依次为：public、protected、包访问权限（没有关键词）、private；

以包访问权限为界限，public、protected分别能够被任意对象和继承的对象访问，而包访问权限（未加关键词的类、方法等）则不能在包外被访问；在一个类中，不能出现相同类成员；在同一个包中，不能够出现相同类；

public做为接口访问权限，将一些方法做为public，即将该方法做为接口，供其余程序调用；private权限下，除了包含该成员的类以外，其余任何类都没法访问该成员，用来隐藏一些类和方法；protected权限下，只有派生类具备访问权限，提供一个可继承的方法；没有关键词的权限成为包访问权限，对包内的类至关于public，对包外的类至关于private；访问权限的控制构成了实现的封装；

java中，类访问权限只能是public或者包访问权限（除了内部类）；一个编译单元最多有一个public类，该类的名字必须和文件的名称相同，并若是指定该类为public，则只有该类能够在该文件的包外部被调用；每一个编译单元能够有多个非public类，一个public类，全部这些类在编译的时候都会被编译成.class文件，Java可运行程序是一组能够打包而且压缩为java文档文件（JAR）的.class文件，解释器负责查找、装载和解释这些文件；

使用package语句，能够将编译单元的public类名称位于包名的保护伞下，使其名称在别的包中调用时具备惟一性；而且使用时，必须使用import关键字导入；

java建立包名称时，使用建立者域名的反顺序小写名称做为第一部分，以CLASSPATH做为根目录，将相应的包相对目录做为第二部分（每一个目录之间在调用时以点号链接）；

如，在CLASSPATH中添加$HOME/org/lozybean，将其做为包的ROOT之一，而后在该目录下新建util目录，而且编写了一个本身定义的java文件，而且使用package org.lozybean.util将该文件置于包文件名的保护下；在其余的任何地方，均可以使用import static org.lozybean.util.ClassName来导入编写好的静态方法，便可直接在当前文件中使用该静态方法，其余方法或者类（可访问的）则使用import便可；

 定制工具库；

新建java项目，并将java项目路径/bin（eclipase会在项目目录下自动添加src和bin目录）添加到JAVAPATH中；新建包：org.lozybean.util，并添加类：Print，添加定制的print工具

package org.lozybean.util;

 

//: org/lozybean/util/Print.java

// Print methods that can be used without

// qualifiers, using Java SE5 static imports:

 

 

import java.io.*;

 

public class Print {

 

    //Print with a newline;

    public static void println(Object obj){

        System.out.println(obj);

    }

    //Print a newline by itself;

    public static void println(){

        System.out.println();

    }

    //Print with no line break;

    public static void print(Object obj){

        System.out.print(obj);

    }

    //The new Java SE5 printf() (from C):

    public static PrintStream

    printf(String format,Object... args){

        return System.out.printf(format,args);

    }

}

 

新建一个类：Test.java，测试：

import static org.lozybean.util.Print.*;

 

publicclass Test{

    public static void main(String[] args){

        print("ok");

    }

}

 

如下示例给出两种特殊的实例化方式：

class Soup1{

    private Soup1(){};

    public static Soup1 makeSoup(){

        return new Soup1();

    }

}

class Soup2{

    private Soup2(){};

    private static Soup2 ps1 = new Soup2();

    public static Soup2 access(){

        return ps1;

    }

    public void f(){};

}

public class Lunch {

    void testPrivate(){

        //! Soup1 soup = new Soup1();

    }

    void testStatic(){

        Soup1 soup = Soup1.makeSoup();

    }

    void testSingleton(){

        Soup2.access().f();

    }

}

以上示例中，Soup1屏蔽了默认的构造方法（构造方法权限为private），而且添加静态方法返回一个实例化对象，经过这样的方式，能够在类内部记录每次实例化的过程；

Soup2则是实现了一个单件类（Ruby中做为语言特征），该类只能实例化一个对象，对于一些数据库操做时，单件类是比较有效的，避免每次实例化一个对象时都对数据库进行一次链接访问操做，而且能够避免一些同步问题；