JAVA零基础小白自学日志——第二十三天

今日摘要：再谈访问范围

1.访问范围权限关键字

项目	同一个类	同一个包	子类	全部
private（私有）	✔
default（默认）	✔	✔
protected（受保护的）	✔	✔	✔（对象必须存在于继承状态下）
public（公共）	✔	✔	✔	✔

2.private（私有）

建立一个范围类（ClassPermission）用来测试访问范围控制

package com.hf.hw.beginnerjourna.one;

//范围类
public class ClassPermission {//建立一个范围类用来测试访问范围控制
	
	//属性
	private int x;//用private（私有）修饰变量x
		
	//方法
	public void outPut() {//建立一个应用私有变量x的方法
		this.x = 20;
		System.out.println("同一个类内调用private私有变量x： " + this.x);
	}//end outPut()
}//end ClassPermission

建立一个范围类（ClassPermission）的同包子类（PrivatePermission）

package com.hf.hw.beginnerjourna.one;

//范围类的同包子类
public class PrivatePermission extends ClassPermission {

	public void outPut02() {
		ClassPermission cp = new ClassPermission();
//		cp.x = 10;	//在这里提示变量不可见
        System.out.println("这是同包下子类的输出");
		cp.outPut();	
	}//end outPut02
}//end PrivatePermission

建立一个同包测试类（Test00），以便输出结果

package com.hf.hw.beginnerjourna.one;

//测试类
public class Test00 {

	public static void main(String[] args) {
		ClassPermission pr = new ClassPermission();
		pr.outPut();
//		pr.x = 30; //在这里提示变量不可见
        PrivatePermission pr2 = new PrivatePermission();
		pr2.output02();
	}//end main
}//end Test00

屏蔽掉两条错误代码后的输出结果：

同一个类内调用private私有变量x： 20
这是同包下子类的输出
同一个类内调用private私有变量x： 20

总结一下：
当我们在类public class ClassPermission{}中定义了一个私有的整型变量“x”private int x; 这个变量在定义它的类中，可以在成员内直接调用，但是却无法在同一个包下不同类中（包括它的子类）调用，调用的结果就是提示这个变量不可见，从这点就可以很明确的看出private（私有）的访问范围仅限于定义它的那个类；

3.default（默认）

建立一个属于com.hf.hw.beginnerjourna.one包的范围类（ClassPermission）用来测试访问范围控制

package com.hf.hw.beginnerjourna.one;

//范围类
public class ClassPermission {

	// 属性
	int x;//default默认，不要写修饰词，写了会报错

	// 方法
	public void outPut() {
		x = 20;
		System.out.println("同一个类内调用default默认变量x： " + this.x);
	}
}

建立一个范围类（ClassPermission）的同属com.hf.hw.beginnerjourna.one包的子类（DefaultPermission）

package com.hf.hw.beginnerjourna.one;

public class DefaultPermission extends ClassPermission {
	public void output02() {
		ClassPermission cp = new ClassPermission();
		
		System.out.println("这是同包下子类调用父类default默认变量x: " + cp.x);
		cp.outPut();				
	}
}

建立一个同属com.hf.hw.beginnerjourna.one包的测试类（Test00），以便输出结果

package com.hf.hw.beginnerjourna.one;

//测试类
public class Test00 {

	public static void main(String[] args) {
		ClassPermission pr = new ClassPermission();
		pr.outPut();
		System.out.println("这是同包下不同类调用default默认变量x: "+ pr.x);
		DefaultPermission pr2 = new DefaultPermission();
		pr2.output02();
	}
}

同包下的测试结果输出

同一个类内调用default默认变量x： 20
这是同包下不同类调用default默认变量x: 20
这是同包下子类调用父类default默认变量x: 0
同一个类内调用default默认变量x： 20

下面来看不同包下的情况：
建立一个与范围类（ClassPermission）的不同包的子类（DefaultPermission），此子类属于com.hf.hw.beginnerjourna.two包

package com.hf.hw.beginnerjourna.two;

import com.hf.hw.beginnerjourna.one.ClassPermission;

public class DefaultPermission extends ClassPermission {
	public void output02() {
		ClassPermission cp = new ClassPermission();		
//		System.out.println("这是不同包下子类调用父类default默认变量x: " + cp.x);
		cp.outPut();				
	}
}

建立一个属于com.hf.hw.beginnerjourna.two包的测试类（Test01），以便输出结果

package com.hf.hw.beginnerjourna.two;

import com.hf.hw.beginnerjourna.one.ClassPermission;

public class Test01 {

	public static void main(String[] args) {
		ClassPermission pr = new ClassPermission();
		pr.outPut();
//		System.out.println("这是不同包下不同类调用default默认变量x: "+ pr.x);
	}
}

后面这两个属于com.hf.hw.beginnerjourna.two包的类和子类，均不能调用com.hf.hw.beginnerjourna.one保内public class ClassPermission{}定义的默认（default）变量“x”，int x; 由此可见default（默认）访问范围，仅限于含有定义这个属性或方法的那个类所处的包内；

4.protected（受保护的）

建立一个属于com.hf.hw.beginnerjourna.one包的范围类（ClassPermission）用来测试访问范围控制

package com.hf.hw.beginnerjourna.one;

//范围类
public class ClassPermission {

	// 属性
	protected int x = 100;

	// 方法
	public void outPut() {
		x = 20;
		System.out.println("同一个类内调用protected修饰的受保护变量x： " + this.x);
	}
}

建立一个范围类（ClassPermission）的同属com.hf.hw.beginnerjourna.one包的子类（ProtectedPermission）

package com.hf.hw.beginnerjourna.one;

public class ProtectedPermission extends ClassPermission {
	public void output02() {
		ClassPermission cp = new ClassPermission();
		
		System.out.println("这是同包下子类调用父类protected修饰的受保护变量x: " + cp.x);
		cp.outPut();
		
		ProtectedPermission cpp = new ProtectedPermission();
		cpp.x = 60;
		System.out.println("这是同包下子类继承关系调用父类protected修饰的受保护变量x: " + cpp.x);
	}
}

建立一个同属com.hf.hw.beginnerjourna.one包的测试类（Test00），以便输出结果

package com.hf.hw.beginnerjourna.one;

//测试类
public class Test00 {

	public static void main(String[] args) {
		ClassPermission pr = new ClassPermission();
		pr.outPut();
		System.out.println("这是同包下同一个类调用protected修饰的受保护变量x: "+ pr.x);
		ProtectedPermission pr2 = new ProtectedPermission();
		pr2.output02();
	}
}

同包下输出结果

同一个类内调用protected修饰的受保护变量x： 20
这是同包下同一个类调用protected修饰的受保护变量x: 20
这是同包下子类调用父类protected修饰的受保护变量x: 100
同一个类内调用protected修饰的受保护变量x： 20
这是同包下子类继承关系调用父类protected修饰的受保护变量x: 60

下面是不同包子类的调用结果
建立一个与范围类（ClassPermission）的不同包的子类（ProtectedPermission），此子类属于com.hf.hw.beginnerjourna.two包

package com.hf.hw.beginnerjourna.two;

import com.hf.hw.beginnerjourna.one.ClassPermission;

public class ProtectedPermission extends ClassPermission {
	public static void main(String[] args)  {
		
		ClassPermission pr = new ClassPermission();
//		pr.x = 20;
		
		ProtectedPermission cp = new ProtectedPermission();

		System.out.println("这是不同包下子类继承关系调用父类protected修饰的受保护变量x: " + cp.x);				
	}
}

屏蔽掉错误语句后的输出结果

这是不同包下子类继承关系调用父类protected修饰的受保护变量x: 100

从以上运行结果不难看出，在同包中protected修饰和default修饰的变量访问结果是相同的，但是在不同包中，子类可以通过继承调用不同包中父类被protected修饰过的变量，这里需要强调的是，通过继承才可以调用，不能直接调用

5.public（公共）

这个就没有什么好说的了，不用看代码大家也都能明白，这个谁都可以访问，无论同包不同包，只要导包了，就能访问；

明天我们继续讨论访问范围，不过不是范围修饰词所管理的范围，而是内部类