今日摘要：再谈访问范围

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（公共）

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

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