为了保护数据防止来自外部的免费使用, 使用指定的关键字范围访问的属性和类的方法的面向对象的程序设计. Java使用一些补充存货控制访问对象的成分 :

• 公开: 主料公众, 从外面自由进出.
• 保护: 主料保护, 受限制的访问.
• 默认 (不写任何东西): 包内访问.
• 私人: 在类中访问.

1. 公共成员

主料公共部门是类可以与所有的程序和外部受众分享. 公共成员可以从内部和教室外进行访问:

例: 它的结构 2 包如下:

在该文件的内容我们如下:
* 打包带的组成部分GoiA ClassA1.java文件 (varA1变量和方法methodA1) 公众 (公开):

package GoiA;				// goi ten la GoiA

public class ClassA1 {
	public int varA1 = 5;		// bien cong khai ten la varA
	public void methodA1(){		// phuong thuc cong khai methodA1
		System.out.println("methodA1 trong ClassA1 la public");
	}
}

* ClassA2.java文件包中包含GoiA 1 使用ClassA1的部件methodA2方法.

package GoiA;			// goi GoiA

public class ClassA2 {		// ClassA2 su dung bien va phuong thuc cua ClassA1
	void methodA2(){		// phuong thuc methodA2 goi cac thanh phan cua ClassA1
		ClassA1 a1 = new ClassA1();		// tao doi tuong a1 thuoc lop ClassA1
		a1.methodA1();					// goi phuong thuc methodA1
		System.out.println("Bien varA1 = " + a1.varA1);		// in bien varA1
	}
}

* ClassA3.java文件位于GoiA继承和使用ClassA1的组成部分

package GoiA;

public class ClassA3 extends ClassA1{	// ClassA3 ke thua ClassA1
	void methodA3(){					// phuong thuc methodA3 goi methodA1()
		methodA1();
	}
}

切换GoiB软件包有 2 文件:
* ClassB1.java文件还称ClassA1的组件，如ClassA2文件是不同的，因为然而ClassB1包ClassA1所以我们需要导入它.

package GoiB;

import GoiA.ClassA1;		// import ClassA1 de su dung

public class ClassB1 {
	void methodB1(){		// phuong thuc methodB1 goi cac thanh phan cua ClassA1
		ClassA1 a1 = new ClassA1();		// tao doi tuong a1 thuoc lop ClassA1
		a1.methodA1();					// goi phuong thuc methodA1
		System.out.println("Bien varA1 = " + a1.varA1);		// in bien varA1
	}
}

* ClassB2.java文件还继承了传统ClassA1像ClassA3 ClassA1但需要导入ClassA1.

package GoiB;

import GoiA.ClassA1;

public class ClassB2 extends ClassA1{	// ClassB2 ke thua ClassA1
	void methodB2(){					// phuong thuc methodB2 goi methodA1()
		methodA1();
	}
}

因此，我们可以看到ClassA1的开放无处不在，当我们使用公共补.
我们可以得出以下图示快速言论:

2. 该组件保护

在包含它的包中的所有类和所有的类继承它 (包括类的其他包继承) 将有机会获得它.

还例如如上述, 我们有 2 包GoiA和GoiB与类, 只是改变ClassA1保护与以下组件 (CAC ClassA2, ClassA3, ClassB1, ClassB2保持):

*flie ClassA1.java

package GoiA;				// goi ten la GoiA

public class ClassA1 {
	protected int varA1 = 5;		// bien protected ten la varA
	protected void methodA1(){		// phuong thuc protected methodA1
		System.out.println("methodA1 trong ClassA1 la public");
	}
}

那么类ClassA2, ClassA3仍然可以访问ClassA1的组件，它也被称为GoiA与ClassA1, ClassB2同时也为其他包访问，但它继承ClassA1. 然而ClassB1无法访问.

*flie ClassB1.java

package GoiB;

import GoiA.ClassA1;		// import ClassA1 de su dung

public class ClassB1 {
	void methodB1(){		// phuong thuc methodB1 goi cac thanh phan cua ClassA1
		ClassA1 a1 = new ClassA1();
		a1.methodA1();										// loi truy nhap
		System.out.println("Bien varA1 = " + a1.varA1);		// loi truy nhap
	}
}

ClassB1故障

点评:

3. 默认组件

默认组件 (未申报的是什么) 它只允许最内层 1 进入包 (即使是传统). 任何访问或其他包继承不.

同样, 在我们的例子中为默认ClassA1的组合物, 同时ClassB1和ClassB2出现故障，因为它不是在同一个封装ClassA1.
* ClassA1.java文件

package GoiA;				// goi ten la GoiA

public class ClassA1 {
	int varA1 = 5;		// bien mac dinh ten la varA
	void methodA1(){		// phuong thuc mac dinh methodA1
		System.out.println("methodA1 trong ClassA1 la public");
	}
}

*flie ClassB1.java

package GoiB;

import GoiA.ClassA1;		// import ClassA1 de su dung

public class ClassB1 {
	void methodB1(){		// phuong thuc methodB1 goi cac thanh phan cua ClassA1
		ClassA1 a1 = new ClassA1();
		a1.methodA1();										// loi truy nhap
		System.out.println("Bien varA1 = " + a1.varA1);		// loi truy nhap
	}
}

*flie ClassB2.java

package GoiB;

import GoiA.ClassA1;

public class ClassB2 extends ClassA1{	// ClassB2 ke thua ClassA1
	void methodB2(){					// phuong thuc methodB2 goi methodA1()
		methodA1();						// loi truy nhap
	}
}

ClassB1, ClassB2出现故障ClassB2虽然我们可以宣布，延长ClassA1也无法使用组件ClassA1.

点评:

4. 私营部门

私营部门是最讳莫如深, 同样的唯一对象 1 新的类访问, 所有的访问或从其他类甚至在同一个类继承 1 包不可访问.

*flie ClassA1.java

package GoiA;				// goi ten la GoiA

public class ClassA1 {
	private int varA1 = 5;			// bien private ten la varA
	private void methodA1(){		// phuong thuc private methodA1
		System.out.println("methodA1 trong ClassA1 la public");
	}

	void methodA2(){
		methodA1();										// goi phuong thuc methodA1
		System.out.println("Bien varA1 = " + varA1);	// in bien varA1
	}
}

我们看到唯一的方法methodA2() 类也是一样ClassA1的私有组件可以访问, 即使ClassA2, ClassA3是相同的包无法访问GoiA.

点评:

因此，我们可以看到，公共部门的访问, 保护, 默认, 降低信息增加安全性的私人手段. 我们可以有后一个小数目:

帖参照:
– 课程Java面向对象编程 – 文本
– 课程Java面向对象编程 – 陈庭阙
– naynhoanhthichem.blogspot.com
还有一些教科书, 其他网站.