About java access control

1. Access Control

2. Agenda
• 概述
• 包 - 命名空间
• 包命名规范
• 包与目录结构
• 类成员访问权限
• public
• 包访问权限
• private
• protected
• 接口和实现
• 类与程序单元

3. 概述
• Java提供了如下访问权限: 公共(public), 受保
护(protected), 包访问(无修饰符), 私有
(private); 访问权限的存在使得可以将程序接
口(保持不变或极少改变)公开给客户使用,
而对具体实现(容易变化)则进行隐藏;
• Java的包机制不仅提供了名字空间(避免类
名称污染), 而且为模块化编程提供了便利.
可以将同一个模块下面的代码放在同一个
包, 这样便于管理

4. 包 - 命名空间
import关键字
• 包是一个命名空间, 由多个组织在一起的类组成; 比如常用的由
JDK提供的java.util包, 下面有ArrayList/HashMap等数据结构, 会经
常被使用到;
• 包作为一个命名空间表示的含义是在不同的包下面可以有相同
的类名, 比如java.util.List和java.awt.List类名都是List但是在不同
的包下面;
• 包下面的类可以通过全名进行访问, 比如:
java.util.ArrayList list = new java.util.ArrayList();
也可以先使用import关键字引入, 然后使用:
import java.util.ArrayList;
......
ArrayList list = new ArrayList(); // 这里方式更为简便
另外如果需要引入包下面的多个类, 那么逐个import是
比较麻烦的, 可以使用.*的方式引入包下面的所有类, 比如:
import java.util.*;

5. 包命名规范
类名冲突
• 通常建议使用组织的域名对包进行命名, 以确
保包名的唯一性, 比如com.yourdomain.yourorg;
• 由于不同的包下面可以定义名称相同的类, 在
引入这些名字相同的类时就会造成类名冲突,
比如:
import java.util.List;
import java.awt.List;
......
List list = new ArrayList(); // 编译错误
这种情况下需要显式指定包名对类进行访问:
java.util.List list = new ArrayList();

6. 包与目录结构
• 当为Java类指定一个包时, 必须将类文件
(.java)放在与包名一致的目录结构中, 比如:
包名com.yourcompany.ui, 那么该包下面的所
有类文件都应该在目录com/yourcompany/ui
下面;

7. 类成员访问权限
• 公开
修饰符: public, 所有类都可以访问该成员; public
通常修饰类接口和static常量, 极少被用于修饰非static
属性;
• 包访问
修饰符: 无, 当前包下面的类(包括自己)可以访
问该成员;
• 受保护
修饰符: protected, 当前类及子类可访问;
• 私有
修饰符: private, 仅当前类可访问.

8. public
• 示例:
// Cookie类定义如下:
package access.dessert;
public class Cookie {
public Cookie() {...} // 公开访问
void bite() {...} // 包访问权限
}
// Dinner类的定义, 使用Cookie
package access;
import access.dessert.*;
public class Dinner {
public static void main(String[] args) {
Cookie x = new Cookie(); // 正确, 因为Cookie类以及构造方法都是public
// x.bite(); // 编译错误, bite方法是包访问权限,
// Dinner 与 Cookie不在同一个包内
}
}

9. 包访问
• 示例:
// Pie类定义如下:
package access;
class Pie {
void f() { System.out.println(“Pie.f()”); } // 包访问权限
}
// Cake类的定义, 使用Pie
package access;
class Cake {
public static void main(String[] args) {
Pie x = new Pie();
x.f(); // 正确访问, 在同一个包内
}
}

10. private
• 示例:
// Sundae类定义如下:
class Sundae {
private Sundae() {} // 私有构造器
static Sundae makeASundae() {
return new Sundae();
}
}
// IceCream类的定义, 使用Sundae
public class IceCream {
public static void main(String[] args) {
//! Sundae x = new Sundae(); // 不能调用Sundae构造函数, 因为是私有访问权限
Sundae x = Sundae.makeASundae();
}
}

11. protected
• 示例:
// Cookie类
package demo
public class Cookie {
public Cookie() {
System.out.println("Cookie constructor");
}
protected void bite() { // 受保护权限
System.out.println("bite");
}
}
// ChocolateChip类继承自Cookie,
// 可以访问Cookie类的受保护成员
public class ChocolateChip extends Cookie {
public ChocolateChip() {
System.out.println("ChocolateChip constructor");
}
public void chomp() {
bite(); // ok
}
public static void main(String[] args) {
ChocolateChip x = new ChocolateChip();
x.chomp();
}
}
示例: demo/Demo1.java

12. 接口和实现
• 在面向对象编程中, 访问控制, 隐藏实现以及封装都是同一个概
念; 本质上都是指仅提供公共接口, 隐藏具体的实现; 比如:
public class OrganizedByAccess {
public void pub1() { /* ... */ }
public void pub2() { /* ... */ }
public void pub3() { /* ... */ }
private void priv1() { /* ... */ }
private void priv2() { /* ... */ }
private void priv3() { /* ... */ }
private int i;
}
在这个类中, pub*方法都是该类提供出来的接口, 而priv*方法则是
具体的内部实现.

13. 类与程序单元
• 一个java文件被称为一个程序单元, 可以包
含多个java类; 一个程序单元内只能有一个
public类, 并且该类的名称应该与java文件的
名称相同, 比如SomeClass.java对应的是:
public class SomeClass...
• 类访问权限只能是public或者包访问权限, 不
能是private/protected.

14. END