6.1包：库单元 每编写一个JAVA源文件时，每个编译单元只能有一个public类，而且该类名字必须与文件的名称相同（文件名字为.java），否则编译就器就不会接受。
在该编译单元之中还有额外的类的话，那么在包之外的世界是无法看到这些类的。（这是因为他们不是public类，而且他们主要用来为主public类提供支持）
6.1.1代码组织 在编译少量的.java文件的时候回产生大量的.class文件。
类库实际上就是一组类文件。其中每个文件都有一个public类，以及任意数量的非public类，因此每一个文件都有一个构件。如果希望这些构件（每一个都有他们自己的独立的.java和.class文件）从属于同一个群组，就可以使用package。
在文件起始处写：package access;表示你在声明该编译单元是access类库的一部分。就是说你在声明该编译单元中的public类名称是位于access名称的保护下。任何想要使用该名称的人都必须使用前面给出的选择，指定全名或者与access结合使用关键字import。
//:access/mypackage/MyClass.java
package access.mypackage;
public class MyClass{
//....
}
表明在这个access/mypackage/目录下的一个MyClass.java文件使用了包权限管理。
现在如果有人想用这个MyClass类或者是access中的任何其他public类，必须使用关键字import来使access的名称可用。另外一个选择是给出完整的名称：
//:access/QualifiefMyClass.java
public class QualifiedMyClass{
public static void main(String[],args){
access.mypackage.MyClass();
}
}
关键字import可以使以上代码更加简洁：
//:access/QualifiefMyClass.java
inport access.mypackage.*;
public class QualifiedMyClass{
public static void main(String[],args){
access.mypackage.MyClass();
}
}
注意：表示包权限的其实是目录的最后一层。
package和import关键字允许你做的，是将单一的全局名字空间分隔开，使得无论多少人使用Internet以及Java开始编写类，都不会冲突。
6.1.2创建独一无二的包名字。
一个包从未真正的将被打爆的东西包装成单一文件，并且一个包可以有许多.class文件构成。
将所有的文件收入一个子目录还可以解决另外两个问题：怎样创建独一无二的名称以及怎样查找可能隐藏在目录结构中某处的类。
Java解释器的运行过程如下：首先，找出环境变量CLASSPATH，它包含一个或者多个目录，用作查找.class的根目录。从根目录开始，解释器获取包的名称并将每个据点替换成反斜杠，以从CLASSPATH根中产生一个路径名称（于是package foo.bar.baz就变成为foo\bar\baz或者foo/bar/baz）。得到的路径会与CLASSPATH中的各个不同的项相连接，解释器就在这些目录中查找你所要创建的类名称相关的.class文件。
对于112-113页的例子：当编译器碰到simple库的import语句时，就开始在CLASSPATH所指定的目录中查找，查找子目录net\mindview\simple,然后从已经编译的文件名称中找出名称相符者（对于Vetor而言是Vetor.class，对于List而言是List.class）。当然Vector和List中的类以及要使用的方法都必须是public的。
如何设置CLASSPATH:?
如果将两个含有相同名称的类库以“*”形式同时导入，如下：
import net.mindview.simple.*;
import java.util.*;
由于java.util.*也包含一个Vector类，这就潜在冲突了。
如果你像这样的代码 Vector v = new Vector();编译器就会出错误信息，强制你明确指明。你可能需要这样写
java.util.Vector v = new java.util.Vector();这样完全可以指明该Vector类的位置（配合CLASSPATH）所以除非还要使用java.util.*中的其他东西，否则就没有必要写import java.util.*语句了。
6.1.3定制工具库
我们创建自己代码减少或者消除重复的代码。例如我们已经用到的System.out.println()的别名可以减少输入负担，这种机制可以用于名为Print的类中，这样，我们在使用该类时可以用一个更具可读性的静态import语句来倒入：
//:net/mindview/util/Print.java
//Print methods that can be used without qualitfiers,using Java SE5 static import:
package net.mindview.util;
import java.io.*;
public class Print{
//Print with a newline;
public static void print(Object obj){
System.out.println(obj);
}
//Print with a newline by itself;
public static void print(){
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);
}
}///:-
可以使用打印便捷工具来打印String,无论需要换行（print()还是不需要换行printnb()）。
可以猜到这个文件的位置一定是在某一个以CLASSPATH位置开始，然后接着是net/mindview的目录下。编译完以后，就可以使用import static语句在你的系统上使用静态的print()和printnb()方法了。以如下方式使用：
//:access/PrintTest.java
// Uses the static printing methods in Print.java.
import static net.mindview.util.Print.*; //这里不应该是import static net.mindview.util.*;?
public class PrintTest{
public static viod main(String[] args){
print("available from now on!");
print(100);
print(100L);
printI(3.14159);
}
}
....115页实例；
从现在开始，你无论何时创建了有用的工具，都可以将它添加到你自己的类库中，你将看到本书中海油更多的构件添加到了net.mindview.util类库中。
6.1.4用import改变行为
Java没有C的条件编译，但是可以使用通过修改杯倒入的package的方法来实现调试目的，修改的方法是将你的程序中用到的代码从调试版改为发布版。
6.1.5对包使用的忠告
无论何时创建包，都已经在给定包名称的时候隐含指定了目录结构。这个包必须位于其名称所指定的目录之中，而该目录必须是在以CLASSPATH开始的目录中可以查询到的。
写程序的时候一定遵守“包的名称对应目录路径”。
6.2Java访问权限修饰词
public、protected和private这几个Java访问权限修饰词在使用时，是置于类中每个成员的定义之前的，无论他是一个域还是一个方法。每个访问权限修饰词仅控制它所修饰的特定定义的访问权。
如果不提供任何访问权限修饰词，则它意味着“包访问权限”。因此，无论如何，所有事物都具有某种形式的访问权限控制。
6.2.1包访问权限
默认访问权限没有任何关键字，但是通常是指包访问权限（有时也表示成friendly）。这就意味着当前包中所有的其他类对哪个成员都有访问权限。但是对于这个包之外的所有类，这个成员却是private。由于一个编译单元（一个文件）只能隶属于一个包，所以经由包访问权限，处于同一编译单元中所有彼此之间都是自动可以访问的。（处于同一包中的不同编译单元（不同文件）中的类是不是可以相互访问？？）
包访问权限允许将包内所有相关的类组合起来，以使它们彼此之间可以轻松的相互作用。当把类组织起来放进一个包内时，也就给他们的包访问权限的成员赋予了相互访问的权限，你“拥有”了该包内的程序代码，“只有你拥有的程序代码才可以访问你所拥有的其他程序代码”。应该说包访问权限为把类群聚在一个包中的做法提供了意义和理由。在Java中需要强制你一种合理的方式对他们加以组织。
有时候你可能想要排除这样的类-他们不应该访问在当前包中的类。与前面的包访问权限相反。
类控制着那些代码有权访问自己的成员，其他包内的类不能直接访问。取得对某成员的访问权限的唯一途径是：
1.使该成员成为public。于是无论是谁在哪里都可以访问该成员。
2，通过不加访问权限修饰词并将其他类放置于同一个包内的方式给成员赋予包访问权，于是包内的其他类就可以访问该成员了。
3.在下一章介绍的继承技术，继承而来的类既可以访问public成员还可以访问protected成员（不能访问private成员）。只有在两个类都处于同一个包内时候，他才可以访问访问包访问权限成员。
4.提供访问器（accessor）和变异器（mutator）方法（也称get/set方法），以读取和改变数值。对于OOP这是最优雅的方式。
6.2.2public：接口访问权限
使用public就意味着public之后紧跟着的成员声明自己对每个人都是可用的。尤其是使用类库的客户程序员更是如此。假设定义了一个包含下面编译单元的dessert包：
//:access/dessert/Cookie.java
//Creates a library
package access.dessert;
public class Cookie{
public Cookie(){
System.out.println("Cookie constructor");
}
void bite(){
System.out.println("bite");
}
}
Cookie.java问价必须位于dessert的子目录中，该子目录在access下（有问题没看第六章）不要错误的认为Java总是将当前目录视作查找行为的起点之一，如果你的CLASSPATH中缺少一个“.”作为路径之一的话，Java就不会查找那里。
现在创建一个使用Cookie的程序：
//:access/Dinner.java
//Uses the libary
import access.dessert.*;
public class Dinner{
public static void main(String[] args){
Cookie x = new Cookie();
//! x.bite();//can't access
}
}
可以创建一个Cookie对象，因为它的构造器是public而且类也是public的。（以后我们也会了解更多的public）但是由于bite()只向在dessert包中的类提供访问权，所以bite()成员在 Dinner.java中是无法访问的，因此编译器禁止你使用它。
默认包
但是下面的代码视乎坏了上述规则但是它可以编译：
//:access/Cake.java
//Access a class in a separate complation unit.
class Cake{
public static void main(String[] args){
Pie x = new Pie();
x.f();
}
Pie.f();
}
在第二个处于相同目录的文件中：
//:access/Pie.java
//The other class
class Pie(){
void f(){
System.out.println("Pie.f()");
}
}
或许你认为这两个文件毫不相干，但是Cake却可以创建一个Pie对象并调用他的f()方法！（为了是文件被编译，CLASSPATH中必须有“.”）通常会认为Pie和f()享有包访问权限，因而是不可以为Cake所用的。他们的确享有包访问权限，但这只是部分正确的。Cake.java可以访问他们的原因是因为他们处于相同的目录并且没有给自己设定任何包名称。java将这样的文件自动看作是隶属于该目录的默认包中，于是他们为该目录中所有其他文件的都提供了包访问权限。
6.2.3private：你无法访问
关键字private的意思是除了包含该成员的类以外，其他任何类都不能访问这个成员。由于处于同一个包内的其他类是不可以访问private成员的，因此等于说是自己隔离了自己。从另外一方面说让许多人共同合作来创建一个大包也是不大可能的，所以你睡意改变使用private修饰的成员不用考虑是不是会影响到其他的类。
默认的包访问权限通常已经提供了充足的隐藏措施。使用类的客户端程序员是无法访问包权限成员的。这样做很好，因为默认访问权限是一种我们常用的访问权限，同时也是一种在忘记添加任何访问权限控制时候能自动得到的权限，因此通常考虑是，哪些成员是要想明确公开给客户端程序员使用的，从而将它们什么味public而在最初，你可能不会认为自己经常会需要使用关键字private因为没有他照样可以工作。然而，事实很快证明。
对private的使用是多么重要，在多线程的环境下更是如此。
举例说明：
总结：类修饰符
1.类的可见性（public 与默认的区别）
控制符 对同个源文件中的类可见 对同个包中的类可见 对不同包中的类可见
public
默认
2.区分类的可见性与import的不同
只有可见才能被import
3.Java为什么要限制可见性
有的类似专门设计的不希望被外界看到
关键字final修饰class：使被修饰的类不能够被继承，主要应用于类库。普通开发人员用的较少。
方法修饰符
方法是类中的定义的方法。方法的访问控制符包括：
public：没有使用限制；
默认：只能在同一个包中被使用；
protected：只能被子类使用；（注意）
private：只能在本类中使用；（注意）
关于网上说的protected的使用的真实含义应该是：本包可以访问，子类可以继承；这两句话的含义很深。前半句，本包可以访问的意思是，只有在本包里面你才能够使用对象的实例来访问这个protected方法，在包外，就算你创建了该类的实例，也不能通过该实例来调用该protected方法。通过继承，子类不管在不在同一个包内都可以访问这个protected方法或者成员，就相当于访问子类自身的量是一样的。有的书上说的仅在本包中可见，意思就是在包外你除了使用规定的方式，是不能够使用的。
1）包
类库实际上是一组类文件。其中每个文件都有一个public类，以及任意数量的非public类。因此每个文件都有一个构件。如果希望这些构件从属于同一个群组，就可以使用包。
利用package和import关键字将单一的全局名字空间分割开。
package语句必须是文件中的第一行非注释程序代码。
从根目录开始，解释器获取包名称并将每个句点替换成反斜杠，得到 路径会与CLASSPATH中的各个不同的项相连接，解释器就在这些目录中查找与所要创建的类名称相关的.class文件（包括java解释器所在位置的标准目录）。
如果两个不同的包被同时引用，且包含相同的类名，在引用该类时，在类名前带包名可以解决该同名问题。
忠告：无论何时创建包，都已经在给定包的名称的时候隐含地指定了目录结构。这个包必须位于其名称所指定的目录中，而该目录必须是在以CLASSPATH开始的目录中可以查询到的。
（2）权限修饰词
public：接口访问权限。其成员声明对每个人可用。
默认包：如果类没有给自己设定任何包名称，java将这样的文件自动看作隶属于该目录的默认包中，它为该目录中所有其他的文件都提供了包访问权限。
private：私有访问权限。仅该类本身的成员可以使用private成员。
protected：继承访问权限。对该类的子类也可见，同时也提供包访问权限。
对构造函数使用private可以阻止别人直接访问某个特定的构造器。如果默认构造器是唯一定义的构造器，并且是private，它将阻止此类的继承。
访问权限的控制其实就是下表。
同一个类
同一个包
不同包的子类
不同包的非子类
Private
√
Default
√
√
Protected
√
√
√
Public
√
√
√
√
（3）类的访问权限
1、每个编译单元都只能有一个public类。
2、public类的名称必须完全与含有该编译单元的文件名相匹配，包括大小写。
3、编译单元内允许不带public类。
类既不可以是private的(这样会使得除该类之外，其他任何类都不可以访问它)，也不可以是protected（该条限制对内部类除外）。所以对于类的访问权限，仅有两个选择：包访问权限或public。如果不希望任何人对该类拥有访问权限，可以把所有构造器指定为private，从而阻止任何人创建该类的对象，但是有一个例外，就是你在该类的static成员内部可以创建。
示例如下：
package accessControl;
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(){//这种特定的模式被称为singleton（单例），因为只能创建它的一个对象，只能通过静态public方法访问
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();
}
}
java的访问权限修饰词从大到小权限依次是：public,proteced(继承权限)，包访问权限（没有关键词），private。
6.1包：类库单元
一个包里会有很多类，所以包也叫类库。在程序中经常看到
import java.util.ArrayList; 其中java.util就是一个包名，而ArrayList是包内的一个类，包内有很多类，该程序中只用到了ArrayList类，所以导入这个类。
package com.wangjing.Exercise;
public class MyPackage {//在这个类中可以封装各种常用方法自定义常用工具类库，例如输出方法等
void MyPackage(){
//构造方法
}
public void print1(){
System.out.print("C");
}
void print2(){} //默认访问权限，包访问权限
public static void print3(){ //静态方法
System.out.print("B");
}
public static void main(String[] args) {
System.out.print("A");
}
}
package com.wangjing.AccessLimitation;//构建包名最好是独一无二的，使用自己的域名wangjing.com
import com.wangjing.Exercise.MyPackage;//如果用到了另一个包中的某个方法，需要这样导入
import static com.wangjing.Exercise.MyPackage.*;//导入包中静态的方法，就可以直接调用print3了
public class packageUser {
public static void main(String[] args) {
MyPackage myp=new MyPackage(); //此时自动调用其构造方法
myp.print1(); //print1()是public方法
//myp.print2(); 因为print2方法在另一个包里不是public，访问权限是包访问权限
print3(); //静态方法print3无需创建对象就可以直接访问
myp.print3();
myp.main(args);
}
}/*output:CBBA*/
6.2 java访问权限修饰词
## 6.2.1包访问权限 ##
如果两个类A和B都是默认的访问权限，那么它们就会被放在同一个默认的包内，通过创建对象的方式就可以相互调用非private方法。
## 6.2.2public ：接口访问权限##
public声明的成员声明自己对每个人都是可用的。
## 6.2.3 private ：你无法访问该类##
除了包含该成员的类外，其他任何类都无法访该成员。有一种用法，构造器是private的，可以通过其他方法创建对象。
package com.wangjing.Exercise;
public class MyPackage {
private void MyPackage(){ //把构造方法声明为private，就不能用构造方法来创建对象了
//构造方法
}
public static MyPackage gouzao(){ //另一种创建创建对象的方法
return new MyPackage();
}
public void print1(){
System.out.print("C");
}
}
package com.wangjing.AccessLimitation;
import com.wangjing.Exercise.MyPackage;
import static com.wangjing.Exercise.MyPackage.*;
public class packageUser {
public static void main(String[] args) {
// MyPackage myp=new MyPackage(); //如果构造器是private，就不能用该方法创建对象
MyPackage myp=MyPackage.gouzao();//通过另一种public的gouzao()方法创建对象，直接用 类名.方法 调用
myp.print1(); //
}
}
## 6.2.4 继承访问权限 ##
package com.wangjing.Exercise;
public class MyPackage {
void MyPackage(){
System.out.println("基类");
}
public void print1(){
System.out.println("public基类方法");
}
void print3(){ //该基类方法是默认访问权限在导出类中不能直接调用
System.out.println("包访问权限的基类方法");
}
protected void print4(){ //如果把基类方法设置成protected，就可以在导出类中调用
System.out.println("继承权限的基类方法"); //同时该方法也具有包访问权限
}
}
class MyPackage2{
public void print1(){}
public static void main(String[] args){
MyPackage m=new MyPackage();
m.print4(); //验证protected具有包访问权限,另一个包内则不能访问
m.print3();
}
}
package com.wangjing.AccessLimitation;
import com.wangjing.Exercise.MyPackage;
import static com.wangjing.Exercise.MyPackage.*;
public class packageUser extends MyPackage {//继承自基类，就可以使用基类的protected方法
void packageUser(){
System.out.println("导出类");
}
public void print2(){
System.out.println("导出类方法");
}
public static void main(String[] args) {
packageUser pu=new packageUser();
pu.packageUser(); //如果构造方法已经显式的定义，就必须要显式的调用，否则不会调用
pu.print1();
pu.print2();
//pu.print3(); //由于print3方法具有包访问权限，不能调用
pu.print4(); //print4是protected权限的，通过继承可以使用
}
}/*output:导出类
public基类方法
导出类方法
继承权限的基类方法*/
6.3 接口和实现
访问权限的控制常被称为具体实现的隐藏。把数据和方法包装进类中，以及具体实现的隐藏，共同称为封装。
同时将接口和实现分离，客户端程序员不用知道具体的实现，可以直接使用接口。保证类库设计者可以随意更改类库，在提高类库性能的前提下，还不影响客户端程序员的代码。
6.4 类的访问权限
1.每个编译单元（文件）都只能有一个public类，但是可以包含多个包访问权限的其他类。这表示，每个编译单元都有一个单一的公共接口，用public类来表现。
2.类的权限只有两种：public和默认的访问权限。
3.如果不希望其他人拥有该类的访问权限，可以把该类的所有构造器指定为private，从而阻止任何人创建该类的对象。
Java提供了访问权限修饰词，访问权限控制的等级，从最大权限到最小权限依次为：public、protected、包访问权限（没有关键词）和private。
1.包：库单元
包内含有一组类 ，他们在单一的名字空间之下被组织在了一起。
1.1代码组织
编译型语言：编译产生一个中间文件（通常是obj），再与链接器与类库产生器产生的其他同类文件捆绑在一起。
Java可运行程序是一组可以打包并压缩为一个Java文档文件（JAR）的.class文件。Java解释器负责泽这些文件的查找、装载和解释。
1.2创建独一无二的包名
按照惯例package名称的第一部分是类创建者的反顺序的Internet域名。
Java解释器的运行过程如下：首先，找出环境变量CLASSPATH。CLASSPATH包含一个或多个目录，用作查找.class文件的根目录。从根目录开始，解释器获取包的名称并将每个句点替换成反斜杠，以从CLASSPATH根中产生一个路径名称。得到的路径会与CLASSPATH中的各个不同的项相连接，解释器就在这些目录中查找与你所要创建的类名称相关的.class文件。
使用JAR文件时候需要注意，JAR文件要完整路径名。类路径包括：CLASSPATH=.;C:\flavours\grape.jar；
2.Java访问权限修饰词
3.类的访问权限
1.每个编译单元都只能有一个public类。
2.public类的名称必须完全与含有该编译单元的文件名相匹配，包括大小写。
注意：类不可以是private或者protected的。只能是包访问权限或者public。如果不希望其他任何人对该类拥有访问权限，可以把所有的构造器都指定为private，从而阻止任何人创建该类的的对象，但是有一个例外，就是你在该类的static成员内部可以创建。
class soup{
private soup(){}
private static soup ps=new soup();
public static soup access(){
return ps;
}
public void f(){}
}
public class test{
void testsingleton(){
soup.access().f();
}
}
这个例子用到了所谓的设计模式---单例（singleton），这是因为你始终只能创建它的一个对象。
Java访问权限控制
Java有public、protect、friendly、private四种访问权限修饰词在使用时，是置于类中每个成员的定义之前的，无论是一个域还是一个方法。每个访问权限修饰词仅控制它所修饰的特定定义的访问权。并且这四访问权限的访问范围越来越小。
1、public：可以被任何class调用
2、protected：继承访问权限 即，既能被同一package中的classes访问，又能被protected成员所在class的subclass访问
实例如下：父类
public class AProtected {
public AProtected() {
System.out.println("AProtected");
}
protected void A() {
System.out.println("A()");
}
}子类
public class BPprotected extends AProtected {
public BPprotected() {
System.out.println("BPprotected");
}
public void chomp() {
System.out.println("chomp");
}
public static void main(String[] args) {
// TODO Auto-generated method stub
BPprotected bPprotected = new BPprotected();
bPprotected.chomp();
bPprotected.A();
}
} 3、friendly
1） 如果一个class内的数据成员或方法没有任何权限饰词，那么它的缺省访问权限就是friendly。同一个package内的其它所有classes都可以访问friendly成员，但对package以外的classes则形同private。
2）对于同一个文件夹下的、没有用package的classes，Java会自动将这些classes初见为隶属于该目录的default package，可以相互调用class中的friendly成员。如以下两个class分别在同一个文件夹的两个文件中，虽然没有引入package，但隶属于相同的default package
4、private：private成员只能在成员所属的class内被调用
实例如下：
class Sundae{
private Sundae() {}
static Sundae makeAsundae(){
return new Sundae();
}
}
public class TestPrivate {
public static void main(String[] args) {
Sundae sundae = Sundae.makeAsundae();
Sundae sundae2 = new Sundae();//报错
//The constructor Sundae() is not visible
}
}
1 包：库单元
Java代码文件，也可以成为编译单元（有时也成为转译单元）。
编译单元内有一个public类，该类名称必须与文件名称相同。
每个编译单元只能有一个public类。
Java包命名规则是必须全是小写字母。
package和import将单一的全局名字空间分开，使得不会出现名称冲突问题。
想要使用某类，需要指定全名或者使用import关键字，import可以使用该包中的public类。
使用静态导入 import static可以在系统中使用包中静态的方法。
2 Java访问权限修饰词
包访问权限：
不加修饰词，就是包访问权限。包内所有其他类对那个成员都有访问权限。对包外类都是private。
取得某成员访问权限的唯一途径是：
1、该成员是public
2、不加权限修饰词并将其他类放在同一个包内，包内其它成员可访问此成员。
3、继承而来的类既可以访问public又可以访问protected。
4、通过访问器和变异器方法（get/set方法），以读取和改变值。
public:接口访问权限：
任何人都可以访问它。不同包里的都可以。
默认包：
对于隶属于相同目录却没有给自己设定任何包名称的文件，Java默认其为该目录的默认包里，这样它们之间的包访问权限可以使它们互相访问。
private:私有
除了包含该类成员的类（这个private成员在的类）之外，任何其他类都无法访问这个成员。
好处：
1、可以控制如何创建该对象，别人必须使用特定构造器创建
2、对于辅助方法，可以指定其为private，防止误用它
protected:继承访问权限
protected成员除了只能被派生类使用外，还提供包访问权限。
3 接口和实现
访问权限的控制常被称为具体实现的隐藏，这被便是“封装”。
4 类的访问权限
1、每个编译单元（文件）只能有一个public类
2、public类的名称必须与文件名相匹配，包括大小写。
类只能是public或者包访问权限的，除了内部类
5 总结
控制对成员的访问有两个原因：
1、是用户不要去触碰不该触碰的部分
2、让库类设计者可以改变类内部工作的方式，而不必担心对客户端程序员产生重大影响。
java编程思想--6访问控制权限
猜你喜欢
转载自zhyp29.iteye.com/blog/2306461
今日推荐
周排行