关于java访问权限

最新推荐文章于 2021-02-20 10:52:45 发布
最新推荐文章于 2021-02-20 10:52:45 发布
阅读量460 收藏
点赞数 1
分类专栏： java 文章标签： 访问控制权限 protected
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nmyangym/article/details/54178401
版权

关于java的访问权限，我做了一张表格，见下面：



测试代码如下：

这个是基本类，其输出对应上面表格“本类“那行。

/*
 * 这个是基本类，包为basic.
 * 在这个类里定义了四个不同访问权限的int型变量，同时定义了四个不同访问权限的方法。
 * 在这个类里，可以看到通过this
 * 20170109
 */
package basic;

public class SuperClass {
	
	private int f1;					//private 变量
	int f2;							//包访问权限变量。
	protected int f3;				//protected 访问权限变量。
	public int f4;					//public 访问权限变量。
	
	public SuperClass() {
		this.f1 = 1;
		this.f2 = 2;
		this.f3 = 3;
		this.f4 = 4;
		
	}
	public SuperClass(int f1, int f2, int f3,int f4) {
		this.f1 = f1;
		this.f2 = f2;
		this.f3 = f3;
		this.f4 = f4;
	}
	
	private int accessF1() {		//private 访问权限方法。
		return f1;
	}
	
	int accessF2() {				//(无修饰)包访问权限方法。
		return f2;
	}
	
	protected int accessF3() { 		//protected访问权限方法。
		return f3;
	}
	
	public int accessF4() {			//public 访问权限方法。
		return f4;
	}
	
	/**
	 * 测试通过this 访问变量和方法。this可以不写，这里主要是为了和其他本类对象（如下面的方法里的other)区别，
	 * 所以写上了。
	 */
	
	public void outPutByThis() {
		System.out.println(this.f1);//在本类中可以直接访问private 变量。
		System.out.println(this.accessF1());	//在本类中可以直接访问private 方法。
		System.out.println(this.f2);//在本类中可以直接访问无修饰变量。
		System.out.println(this.accessF2());	//在本类中可以直接访问无修饰方法。
		System.out.println(this.f3);//在本类中可以直接访问protected 变量。
		System.out.println(this.accessF3());	//在本类中可以直接访问protected 方法。
		System.out.println(this.f4);//在本类中可以直接访问public 变量。
		System.out.println(this.accessF4());	//在本类中可以直接访问public 方法。
	}
	
	/**
	 * 测试通过同类其他对象访问四种访问权限变量和方法的能力。
	 * @param other
	 */
	public void outPutBySuperClassObject(SuperClass other) {
		System.out.println(other.f1);	//在本类中可以访问其他本类对象(不是this)的private 变量。
		System.out.println(other.accessF1());	// 在本类中可以访问其他本类对象(不是this)的private 方法。
		System.out.println(other.f2);	//在本类中可以访问其他本类对象(不是this)的无修饰 变量。
		System.out.println(other.accessF2());	// 在本类中可以访问其他本类对象(不是this)的无修饰方法。
		System.out.println(other.f3);	//在本类中可以访问其他本类对象(不是this)的protected 变量。
		System.out.println(other.accessF3());	// 在本类中可以访问其他本类对象(不是this)的protected 方法。
		System.out.println(other.f4);	//在本类中可以访问其他本类对象(不是this)的public 变量。
		System.out.println(other.accessF4());	// 在本类中可以访问其他本类对象(不是this)的public 方法。	
	}
	
	/**
	 * 程序入口。
	 * @param args
	 */
	public static void main(String[] args) {
		SuperClass s1 = new SuperClass(1,11,111,1111);
		s1.outPutByThis();
		SuperClass s2 = new SuperClass(2,22,222,2222);
		s1.outPutBySuperClassObject(s2);
	}
}

下面两个类都是SuperClass类的子类，OtherSonClassInSamePackage是与SuperClass在同一个包，OtherSonClassInDifferentPackage与SuperClass不在同一个包，用于后面的代码测试。 

package basic;

public class OtherSonClassInSamePackage extends SuperClass {
	public OtherSonClassInSamePackage() {
		super();
	}
	public OtherSonClassInSamePackage(int f1, int f2, int f3, int f4) {
		super(f1,f2,f3,f4);
	}
}
package test;

import basic.SuperClass;

public class OtherSonClassInDifferentPackage extends SuperClass {
	public OtherSonClassInDifferentPackage() {
		super();
	}
	public OtherSonClassInDifferentPackage(int f1, int f2, int f3,int f4) {
		super(f1,f2,f3,f4);
	}
	
}

下面是同包子类的测试代码，对应上面表格“同包子类”输出。 

/*
 * 测试调用环境为同包中的子类，多种对象对不同修饰符的变量和方法的访问权限。
 * 引入test.OtherSonClassInDifferentPackage是为了测试在同包子类中非同包子类对象对
 * 4种访问权限变量和方法的访问能力。
 * 20170109
 */
package basic;

import test.OtherSonClassInDifferentPackage;

public class SonClassInSamePackage extends SuperClass {
	public SonClassInSamePackage() {
		super();
	}
	public SonClassInSamePackage(int f1, int f2,int f3,int f4) {
		super(f1,f2,f3,f4);
	}
	/**
	 * 测试类的直接访问能力。(可以省去this).
	 */
	public void outPutByThis() {
		//System.out.println(this.f1);//不能在同包子类中直接访问父类private 变量，提示
										//The field SuperClass.f1 is not visible
		//System.out.println(this.accessF1());//不能在同包子类中直接访问父类private 方法，提示
										//The method accessF1() from the type SuperClass is not visible
		System.out.println(this.f2);//可以在同包子类中直接访问父类无修饰变量。
		System.out.println(this.accessF2());	//可以在同包子类中直接访问父类无修饰方法。
		System.out.println(this.f3);//可以在同包子类中直接访问父类protected 变量。
		System.out.println(this.accessF3());	//可以在同包子类中直接访问父类protected 方法。
		System.out.println(this.f4);//可以在同包子类中直接访问父类public 变量。
		System.out.println(this.accessF4());	//可以在同包子类中直接访问父类public 方法。
	
	}
	
	/**
	 * 测试在类里访问同类（SonClassInSamePackage）其他对象对四种变量和方法的访问能力。
	 * @param s
	 */
	public void outPutByAnotherSameClassObject(SonClassInSamePackage s) {
		//System.out.println(s.f1);	//不能在同包子类中 通过其他同类对象(不是this)直接访问父类的private 变量，提示
									//The field SuperClass.f1 is not visible
		//System.out.println(s.accessF1());	//不能在同包子类中 通过其他同类对象(不是this)直接访问父类的private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		System.out.println(s.f2);	//可以在同包子类中 通过其他同类对象(不是this)直接访问父类的无修饰 变量。
		System.out.println(s.accessF2());	//可以在同包子类中 通过其他同类对象(不是this)直接访问父类的无修饰方法。
		System.out.println(s.f3);	//可以在同包子类中 通过其他同类对象(不是this)直接访问父类的protected 变量。
		System.out.println(s.accessF3());	//可以在同包子类中 通过其他同类对象(不是this)直接访问父类的protected 方法。
		System.out.println(s.f4);	//可以在同包子类中 通过其他同类对象(不是this)直接访问父类的public 变量。
		System.out.println(s.accessF4());	//可以在同包子类中 通过其他同类对象(不是this)直接访问父类的public 方法。	
	}
	
	/**
	 * 测试在同包子类中通过其他同包内子类（OtherSonClassInSamePackage）对象对4种变量和方法的访问能力。
	 * @param os
	 */
	public void outPutByOtherSonClassInSampPackage(OtherSonClassInSamePackage os) {
		//System.out.println(os.f1);//不能在同包子类中 通过同包其他子类访问父类 的private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(os.accessF1());	//不能在同包子类中 通过同包其他子类访问父类 的private 方法,提示
								//The method accessF1() from the type SuperClass is not visible
		System.out.println(os.f2);	//可以在同包子类中 通过同包其他子类访问父类 的无修饰 变量。
		System.out.println(os.accessF2());	//可以在同包子类中 通过同包其他子类访问父类 的无修饰方法。
		System.out.println(os.f3);	//可以在同包子类中 通过同包其他子类访问父类 的protected 变量。
		System.out.println(os.accessF3());	//可以在同包子类中 通过同包其他子类访问父类 的protected 方法。
		System.out.println(os.f4);	//可以在同包子类中 通过同包其他子类访问父类 的public 变量。
		System.out.println(os.accessF4());	//可以在同包子类中 通过同包其他子类访问父类 的public 方法。	

	
	}
	/**
	 * 测试在同包子类中 通过其他非同包内子类（OtherSonClassInDifferentPackage）对象对4种变量和方法的访问能力。
	 * @param osd
	 */
	public void outPutByOtherSonClassInDifferentPackage(OtherSonClassInDifferentPackage osd) {
		//System.out.println(osd.f1);//不能在同包子类中 通过非同包其他子类对象访问父类 的private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(osd.accessF1());	//不能在同包子类中 通过非同包其他子类对象访问父类 的private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		//System.out.println(osd.f2);	//不能在同包子类中 通过非同包其他子类对象访问父类 的无修饰 变量,提示
									//The field SuperClass.f2 is not visible
		//System.out.println(osd.accessF2());	//不能在同包子类中 通过非同包其他子类对象访问父类 的无修饰方法。
									//The method accessF2() from the type SuperClass is not visible
		System.out.println(osd.f3);	//可以在同包子类中 通过非同包其他子类对象访问父类 的protected 变量。
		System.out.println(osd.accessF3());	//可以在同包子类中 通过非同包其他子类对象访问父类 的protected 方法。
		System.out.println(osd.f4);	//可以在同包子类中 通过非同包其他子类对象访问父类 的public 变量。
		System.out.println(osd.accessF4());	//可以在同包子类中 通过非同包其他子类对象访问父类 的public 方法。	

	}
	
	/**
	 * 程序入口。
	 * @param args
	 */
	public static void main(String[] args) {
		SonClassInSamePackage s1 = new SonClassInSamePackage(1,11,111,1111);
		s1.outPutByThis();
		SonClassInSamePackage s2 = new SonClassInSamePackage(2,22,222,2222);
		s1.outPutByAnotherSameClassObject(s2);
		OtherSonClassInSamePackage os = new OtherSonClassInSamePackage(3,33,333,3333);
		s1.outPutByOtherSonClassInSampPackage(os);
		OtherSonClassInDifferentPackage osd = new OtherSonClassInDifferentPackage(4,44,444,4444);
		s1.outPutByOtherSonClassInDifferentPackage(osd);
	}
}


下面的代码是同包非子类测试代码，既然不是子类，注意this 在这里肯定是不行的，对应上面表格“同包非子类”输出。

/*
 * 测试同包中的非子类，不同对象对不同修饰符的变量和方法访问能力。
 * 这种情况，this不能用了。
 * 20170109
 */
package basic;


import test.OtherSonClassInDifferentPackage;


public class NonSonClassInSamePackage {
	public SuperClass s1 = new SuperClass(1,11,111,1111);
	public SuperClass s2 = new SuperClass(2,22,222,2222);
	
	/*
	 * 非本类，非子类不能使用this了。
	 */
	/*
	public void outPutByThis() {
		System.out.println(this.f1);//不能在同包非子类 中通过this访问SuperClass的 private 变量。
		System.out.println(this.accessF1());//不能在同包非子类中 通过this访问SuperClass的 private 方法。
		System.out.println(this.f2);//不能在同包非子类中通过this访问SuperClass的无修饰变量。
		System.out.println(this.accessF2());//不能在同包非子类中通过this访问SuperClass的无修饰方法。
		System.out.println(this.f3);//在同包非子类中通过this访问SuperClass的protected变量。
		System.out.println(this.accessF3());//不能在同包非子类中通过this访问SuperClass的protected方法。
		System.out.println(this.f4);//不能在同包非子类中通过this访问SuperClass的public变量。
		System.out.println(this.accessF4());//不能在同包非子类中通过this访问SuperClass的public方法。
	}
	*/
	/**
	 * 这个方法本是测试对同类其他对象（非this)的访问能力，但是因为现在这个类（NonSonClassInSamePackage）与SuperClass
	 * 没有关系，所以无意义。所以，这里是测试SuperClass对象在与SuperClass所在类同包但非其子类里对4种变量和方法的访问权限。
	 * @param s
	 */
	public void outPutBySuperClassObject(SuperClass s) {
		//System.out.println(s.f1);	//不能在同包非子类中 通过SuperClass对象访问访问其private 变量。
		//System.out.println(s.accessF1());	//不能在同包非子类中 通过SuperClass对象访问访问其private 方法。
		System.out.println(s.f2);	//可以在同包非子类 中通过SuperClass对象访问其无修饰 变量。
		System.out.println(s.accessF2());	//可以在同包非子类中 通过SuperClass对象访问其无修饰方法。
		System.out.println(s.f3);	//可以在同包非子类中 通过SuperClass对象访问其protected 变量。
		System.out.println(s.accessF3());	//可以在同包非子类中 通过SuperClass对象访问其protected 方法。
		System.out.println(s.f4);	//可以在同包非子类中 通过SuperClass对象访问其public 变量。
		System.out.println(s.accessF4());	//可以在同包非子类中 通过SuperClass对象访问其public 方法。	
	}
	
	/**
	 * 测试在同包非子类中，其他同包子类（OtherSonClassInSamePackage）对象对四种变量的访问能力。
	 * @param os
	 */
	public void outPutByOtherSonClassInSampPackage(OtherSonClassInSamePackage os) {
		//System.out.println(os.f1);//不能在同包非子类中 通过同包其他子类对象访问其父类 的private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(os.accessF1());	//不能在同包非子类中 通过同包其他子类对象访问其父类 的private 方法,提示
								//The method accessF1() from the type SuperClass is not visible
		System.out.println(os.f2);	//可以在同包非子类中 通过同包其他子类对象访问其父类 的无修饰 变量。
		System.out.println(os.accessF2());	//可以在同包非子类中 通过同包其他子类对象访问其父类 的无修饰方法。
		System.out.println(os.f3);	//可以在同包非子类中 通过同包其他子类对象访问其父类 的protected 变量。
		System.out.println(os.accessF3());	//可以在同包子类中 通过同包其他子类对象访问其父类 的protected 方法。
		System.out.println(os.f4);	//可以在同包子类中 通过同包其他子类对象访问其父类 的public 变量。
		System.out.println(os.accessF4());	//可以在同包子类中 通过同包其他子类对象访问其父类 的public 方法。		
	}
	
	/**
	 * 测试在同包非子类中 通过其他非同包内子类（OtherSonClassInDifferentPackage）对象对4种变量和方法的访问能力。
	 * @param osd
	 */
	public void outPutByOtherSonClassInDifferentPackage(OtherSonClassInDifferentPackage osd) {
		//System.out.println(osd.f1);//不能在同包非子类中 通过其他非同包子类对象访问其父类 的private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(osd.accessF1());	//不能在同包非子类中 通过其他非同包子类对象访问其父类 的private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		//System.out.println(osd.f2);	//不能在同包子类中 通过其他非同包子类对象访问其父类 的无修饰 变量,提示
									//The field SuperClass.f2 is not visible
		//System.out.println(osd.accessF2());	//不能在同包非子类中 通过其他非同包子类对象访问其父类 的无修饰方法。
									//The method accessF2() from the type SuperClass is not visible
		System.out.println(osd.f3);	//可以在同包非子类中 通过其他非同包子类对象访问其父类 的protected 变量。
		System.out.println(osd.accessF3());	//可以在同包非子类中 通过其他非同包子类对象访问其父类 的protected 方法。
		System.out.println(osd.f4);	//可以在同包非子类中 通过其他非同包子类对象访问其父类 的public 变量。
		System.out.println(osd.accessF4());	//可以在同包非子类中 通过其他非同包子类对象访问其父类 的public 方法。	


	}
	public static void main(String[] args) {
		NonSonClassInSamePackage nsc = new NonSonClassInSamePackage();
		nsc.outPutBySuperClassObject(nsc.s2);
		OtherSonClassInSamePackage os = new OtherSonClassInSamePackage(3,33,333,3333);
		nsc.outPutByOtherSonClassInSampPackage(os);
		OtherSonClassInDifferentPackage osd = new OtherSonClassInDifferentPackage(4,44,444,4444);
		nsc.outPutByOtherSonClassInDifferentPackage(osd);
	}
}


下面的代码测试非同包的子类，对应上面表格的“非同包子类” 输出。


/*
 * 测试调用环境为非同包中的子类，不同修饰符的访问权限。
 * 可以用this.
 * 20170109
 */
package test;


import basic.OtherSonClassInSamePackage;
import basic.SuperClass;


public class SonClassInDifferentPackage extends SuperClass {
	public SonClassInDifferentPackage(){
		super();
	}
	public SonClassInDifferentPackage(int f1, int f2, int f3,int f4) {
		super(f1,f2,f3,f4);
	}
	
	public void outPutByThis() {
		//System.out.println(this.f1);//不能在非同包子类中 直接访问父类private 变量，提示
									//The field SuperClass.f1 is not visible
		//System.out.println(this.accessF1());//不能在非同包子类中 直接访问父类private 方法，提示
										//The method accessF1() from the type SuperClass is not visible
		//System.out.println(this.f2);//不能在非包子类中直接访问父类无修饰变量,提示
										//The field SuperClass.f2 is not visible
		//System.out.println(this.accessF2());	//不能在非同包子类中直接访问父类无修饰方法。
									//The method accessF2() from the type SuperClass is not visible
		System.out.println(this.f3);//可以在非同包子类中直接访问父类protected 变量。
		System.out.println(this.accessF3());	//可以在非同包子类中直接访问父类protected 方法。
		System.out.println(this.f4);//可以在非同包子类中直接访问父类public 变量。
		System.out.println(this.accessF4());	//可以在非同包子类中直接访问父类public 方法。
	
	}
	
	/**
	 * 测试在非同包子类里同类（SonClassInDifferentPackage）其他对象对四种变量和方法的访问能力。
	 * @param s
	 */
	public void outPutByAnotherSameClassObject(SonClassInDifferentPackage s) {
		//System.out.println(s.f1);	//不能在非同包子类中 通过同类其他对象(不是this)直接访问其父类的private 变量，提示
									//The field SuperClass.f1 is not visible
		//System.out.println(s.accessF1());	//不能在非同包子类中 通过同类其他对象(不是this)直接访问其父类的private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		//System.out.println(s.f2);	//不能在非同包子类中 通过同类其他对象(不是this)直接访问其父类的无修饰 变量，提示
									//The field SuperClass.f2 is not visible
		//System.out.println(s.accessF2());	//不能在非同包子类中 通过同类其他对象(不是this)直接访问其父类的无修饰方法，提示
									//The method accessF2() from the type SuperClass is not visible
		System.out.println(s.f3);	//可以在非同包子类中 通过同类其他对象(不是this)直接访问其父类的protected 变量。
		System.out.println(s.accessF3());	//可以在非同包子类中 通过同类其他对象(不是this)直接访问其父类的protected 方法。
		System.out.println(s.f4);	//可以在非同包子类中 通过同类其他对象(不是this)直接访问其父类的public 变量。
		System.out.println(s.accessF4());	//可以在非同包子类中 通过同类其他对象(不是this)直接访问其父类的public 方法。	
	}
	
	/**
	 * 测试在非同包子类里 其他同包子类（OtherSonClassInSamePackage）对象对四种变量和方法的访问能力。
	 * @param os
	 */
	public void outPutByOtherSonClassInSampPackage(OtherSonClassInSamePackage os) {
		//System.out.println(os.f1);//不能在非同包子类中 通过同包其他子类对象访问其父类 的private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(os.accessF1());	//不能在非同包子类中 通过同包其他子类对象访问其父类 的private 方法,提示
								//The method accessF1() from the type SuperClass is not visible
		//System.out.println(os.f2);	//不能在非同包子类中 通过同包其他子类对象访问其父类 的无修饰 变量。
								The field SuperClass.f2 is not visible
		//System.out.println(os.accessF2());	//不能在非同包子类中 通过同包其他子类对象访问其父类 的无修饰方法。
								//The method accessF2() from the type SuperClass is not visible
		//System.out.println(os.f3);	//不能在非同包子类中 通过同包其他子类对象访问其父类 的protected 变量。
								//The field SuperClass.f3 is not visible
		//System.out.println(os.accessF3());	//不能在非同包子类中 通过同包其他子类对象访问其父类 的protected 方法。
								//The method accessF3() from the type SuperClass is not visible
		System.out.println(os.f4);	//可以在非同包子类中 通过同包其他子类对象访问其父类 的public 变量。
		System.out.println(os.accessF4());	//可以在非同包子类中 通过同包其他子类对象访问其父类 的public 方法。	
	}
	
	/**
	 * 测试在非同包子类里 其他 非 同包子类（OtherSonClassInDifferentPackage）对象对四种变量和方法的访问能力。
	 * @param osd
	 */
	public void outPutByOtherSonClassInDifferentPackage(OtherSonClassInDifferentPackage osd) {
		//System.out.println(osd.f1);//不能在非同包子类中 通过其他非同包子类对象访问其父类的 private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(osd.accessF1());	//不能在非同包子类中 通过其他非同包子类对象访问其父类的private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		//System.out.println(osd.f2);	//不能在非同包子类中 通过其他非同包子类对象访问其父类 的无修饰 变量,提示
									//The field SuperClass.f2 is not visible
		//System.out.println(osd.accessF2());	//不能在非同包子类中 通过其他非同包子类对象访问其父类 的无修饰方法。
									//The method accessF2() from the type SuperClass is not visible
		//System.out.println(osd.f3);	//不能在非同包子类中 通过其他非同包子类对象访问其父类 的protected 变量。
									//The field SuperClass.f3 is not visible
		//System.out.println(osd.accessF3());	//不能在非同包子类中 通过其他非同包子类对象访问其父类 的protected 方法。
									//The method accessF3() from the type SuperClass is not visible
		System.out.println(osd.f4);	//可以在非同包子类中 通过其他非同包子类对象访问其父类 的public 变量。
		System.out.println(osd.accessF4());	//可以在非同包子类中 通过其他非同包子类对象访问其父类 的public 方法。	


	}
	
	/**
	 * 程序入口
	 * @param args
	 */
	public static void main(String[] args) {
		SonClassInDifferentPackage s1 = new SonClassInDifferentPackage(1,11,111,1111);
		s1.outPutByThis();
		SonClassInDifferentPackage s2 = new SonClassInDifferentPackage(2,22,222,2222);
		s1.outPutByAnotherSameClassObject(s2);
		OtherSonClassInSamePackage os = new OtherSonClassInSamePackage(3,33,333,3333);
		s1.outPutByOtherSonClassInSampPackage(os);
		OtherSonClassInDifferentPackage osd = new OtherSonClassInDifferentPackage(4,44,444,4444);
		s1.outPutByOtherSonClassInDifferentPackage(osd);
	}
}

下面的代码测试非同包非子类，对应上面表格“非同包非子类”输出。 


/*
 * 测试非同包非子类，不同修饰符的访问权限。
 * this 不可用了。
 */
package test;

import basic.OtherSonClassInSamePackage;
import basic.SuperClass;

public class NonSonClassInDifferentPackage {
	SuperClass s1 = new SuperClass(1,11,111,1111);
	SuperClass s2 = new SuperClass(2,22,222,2222);
	
	/*
	 * 非本类，非子类不能使用this了。
	 */
	/*
	public void outPutByThis() {
		System.out.println(this.f1);//不能在不同包非子类中通过this访问SuperClass的 private 变量。
		System.out.println(this.accessF1());//不能在不同包非子类中通过this访问SuperClass的 private 方法。
		System.out.println(this.f2);//不能在不同包非子类中通过this访问SuperClass的无修饰变量。
		System.out.println(this.accessF2());//不能在不同包非子类中通过this访问SuperClass的无修饰方法。
		System.out.println(this.f3);//不能在不同包非子类中通过this访问SuperClass的protected变量。
		System.out.println(this.accessF3());//不能在不同包非子类中通过this访问SuperClass的protected方法。
		System.out.println(this.f4);//不能在不同包非子类中通过this访问SuperClass的public变量。
		System.out.println(this.accessF4());//不能在不同包非子类中通过this访问SuperClass的public方法。
	}
	*/
	/**
	 * 这个方法本是测试对同类其他对象（非this)的访问能力，但是因为现在这个类（NonSonClassInDifferentPackage）与SuperClass
	 * 没有关系，所以无意义。所以，这里是测试SuperClass对象在与SuperClass所在类非同包非子类（NonSonClassInDifferentPackage
	 * 与SuperClass非同包非子类）里 对4种变量和方法的访问权限。
	 * @param s
	 */
	public void outPutBySuperClassObject(SuperClass s) {
		//System.out.println(s.f1);	//不能在非同包非子类中 通过SuperClass对象访问其private 变量，提示
									//The field SuperClass.f1 is not visible
		//System.out.println(s.accessF1());	//不能在非同包非子类中 通过SuperClass对象访问访问其private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		//System.out.println(s.f2);	//不能在非同包非子类中通过SuperClass对象访问其无修饰 变量，提示
									//The field SuperClass.f2 is not visible
		//System.out.println(s.accessF2());	//不能在非同包非子类中通过SuperClass对象访问其无修饰方法，提示
									//The method accessF2() from the type SuperClass is not visible
		//System.out.println(s.f3);	//不能在非同包非子类中通过SuperClass对象访问其protected 变量，提示
									//The field SuperClass.f3 is not visible
		//System.out.println(s.accessF3());	//不能在非同包非子类中通过SuperClass对象访问其protected 方法，提示
									//The method accessF3() from the type SuperClass is not visible
		System.out.println(s.f4);	//可以在非同包非子类中通过SuperClass对象访问其public 变量。
		System.out.println(s.accessF4());	//可以在非同包非子类中通过SuperClass对象访问其public 方法。	
	}
	
	/**
	 * 测试在非同包非子类中，其他同包子类（OtherSonClassInSamePackage）对象对四种变量的访问能力。
	 */
	public void outPutByOtherSonClassInSampPackage(OtherSonClassInSamePackage os) {
		//System.out.println(os.f1);//不能在非同包非子类中 通过其他同包子类对象访问其父类的 private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(os.accessF1());	//不能在非同包非子类中 通过其他同包子类对象访问其父类 的private 方法,提示
								//The method accessF1() from the type SuperClass is not visible
		//System.out.println(os.f2);	//不能在非同包非子类中 通过其他同包子类对象访问其父类 的无修饰 变量。
								The field SuperClass.f2 is not visible
		//System.out.println(os.accessF2());	//不能在非同包非子类中 通过其他同包子类对象访问其父类 的无修饰方法。
								//The method accessF2() from the type SuperClass is not visible
		//System.out.println(os.f3);	//不能在非同包非子类中 通过其他同包子类对象访问其父类 的protected 变量。
								//The field SuperClass.f3 is not visible
		//System.out.println(os.accessF3());	//不能在非同包非子类中 通过其他同包子类对象访问其父类 的protected 方法。
								//The method accessF3() from the type SuperClass is not visible
		System.out.println(os.f4);	//可以在非同包非子类中 通过其他同包子类对象访问其父类 的public 变量。
		System.out.println(os.accessF4());	//可以在非同包非子类中 通过其他同包子类对象访问其父类 的public 方法。	
	}
	
	/**
	 * 测试在非同包非子类中 通过其他非同包内子类（OtherSonClassInDifferentPackage）对象对4种变量和方法的访问能力。
	 * @param osd
	 */
	public void outPutByOtherSonClassInDifferentPackage(OtherSonClassInDifferentPackage osd) {
		//System.out.println(osd.f1);//不能在非同包非子类中 通过其他非同包子类对象访问其父类 的private 变量。提示
									//The field SuperClass.f1 is not visible
		//System.out.println(osd.accessF1());	//不能在非同包非子类中 通过其他非同包子类对象访问其父类 的private 方法,提示
									//The method accessF1() from the type SuperClass is not visible
		//System.out.println(osd.f2);	//不能在非同包非子类中 通过其他非同包子类对象访问其父类 的无修饰 变量,提示
									//The field SuperClass.f2 is not visible
		//System.out.println(osd.accessF2());	//不能在非同包非子类中 通过其他非同包子类对象访问其父类 的无修饰方法。
									//The method accessF2() from the type SuperClass is not visible
		//System.out.println(osd.f3);	//不能在非同包非子类中 通过其他非同包子类对象访问其父类 的protected 变量。
									//The field SuperClass.f3 is not visible
		//System.out.println(osd.accessF3());	//不能在非同包非子类中 通过其他非同包子类对象访问其父类 的protected 方法。
									//The method accessF3() from the type SuperClass is not visible
		System.out.println(osd.f4);	//可以在非同包非子类中 通过其他非同包子类对象访问其父类 的public 变量。
		System.out.println(osd.accessF4());	//可以在非同包非子类中 通过其他非同包子类对象访问其父类 的public 方法。	

	}
	
	/**
	 * 程序入口
	 * @param args
	 */
	public static void main(String[] args) {
		NonSonClassInDifferentPackage nsc = new NonSonClassInDifferentPackage();
		nsc.outPutBySuperClassObject(nsc.s2);
		OtherSonClassInSamePackage os = new OtherSonClassInSamePackage(3,33,333,3333);
		nsc.outPutByOtherSonClassInSampPackage(os);
		OtherSonClassInDifferentPackage osd = new OtherSonClassInDifferentPackage(4,44,444,4444);
		nsc.outPutByOtherSonClassInDifferentPackage(osd);
	}
}


nmyangym
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java通过session判断该用户是否具有该功能的操作权限_RBAC——权限
weixin_39948442的博客
12-11 1118
什么是 RBACRBAC（Role-BasedAccessControl ）基于角色的访问控制。 RBAC 认为权限的过程可以抽象概括为： 判断【Who 是否可以对 What 进行 How 的访问操作（Operator）】 Who：权限的拥用者或主体 What：权限针对的对象或资源 How：具体的权限 Operator：操作。表明对 What 的 How 操作。也就是 Privilege+Reso...
关于JavaScript的的高速缓存未命中分析【云图智联】
07-01 400
免费学习视频欢迎关注云图智联：https://e.yuntuzhilian.com/ 在本文中，我们将讨论创建和访问数据的方式可能对应用程序性能的影响。 介绍 JavaScript是一种非常高级的语言，在使用JavaScript开发的时候不必对存储器中的数据存储方式作过多的考虑。在本文中，我们将探讨数据如何存储在内存中，以及JavaScript中分发和访问数据的方式将如何影响CPU和内存的性能。 浪漫三角 当计算机需要进行一些计算任务时，计算机处理单元(CPU)需要数据进行处理，因此，根据手中
Java访问权限自测
幸福ITman汪文威的专栏
03-05 413
AccessAuthority.java: package cn.edu.xidian.w3ang.javabasic; /** * 当private方法或自带定义后却没有使用，又private类型的只能本类中访问，所以会有提示如下（）： * The method privateMethod() from the type AccessAuthority is never used loca
java实验3.(2)包的访问权限
I feel lost
04-14 532
这道题一共要建三个目录：C:\myproj\bin、C:\myproj\lib和C:\myproj\classes，也可以自己建所要的目录，三个目录不同就可以了，具体要求如下: n public的A.class和B.class属于包X.Y，该包存放在C:\myproj\classes中；public的C.class和D.class属于包S.T，把它们打包为E.jar文件中，并存放在C:\mypr
Java的访问权限
言兼的专栏
01-10 917
Java有四个方问权限，从宽松到严格排序，分别为：public, protected, default(包访问权限), private。
奇怪的知识：Java基于类的访问权限
訾博（ZiBo）的博客
02-20 121
目录 一、前言 二、概述 三、代码测试 代码： 运行结果： 一、前言 最近在阅读Java核心卷，读到4.3.7基于类的访问权限，这个知识真是令我耳目一新，我特意写代码测试了一下，还能可以！ 二、概述 我们都知道，使用private修饰的变量可以在本类的方法中使用this.变量名调用；但是！我从来没想到也可以调用该类的其他对象.变量名调用其私有变量，真是奇怪的知识！ 原文：一个方法可以访问所属类的所有对象的私有数据； 三、代码测试 代码： package com.zi...
Java访问权限原理与用法详解
08-25
"Java 访问权限原理与用法详解" Java 访问权限原理与用法详解是 Java 编程语言中非常重要的一个概念，它控制着类、方法和变量的访问权限，确保了程序的安全性和封装性。在本文中，我们将详细介绍 Java 访问权限的...
java四种访问权限实例分析
08-25
Java 四种访问权限实例分析 Java 中的访问权限控制是指本类及本类内部的成员（成员变量、成员方法、内部类）对其他类的可见性，即这些内容是否允许其他类访问。Java 中一共有四种访问权限控制，其权限控制的大小...
Java访问权限控制源代码
05-16
在提供的"Java访问权限控制源代码"中，可能包含示例类，这些类展示了如何使用不同的访问修饰符来控制类、变量和方法的可见性。`readme.md`文件可能包含了代码的介绍和使用指南。 通过学习和理解Java的访问权限控制...
Java访问权限控制源代码.zip
08-28
这个"Java访问权限控制源代码.zip"压缩包可能包含了示例代码，用于演示Java中的不同访问修饰符如何工作以及如何实施访问控制。现在，我们将深入探讨Java中的访问权限控制机制。 首先，Java提供了四种访问级别： 1....
超微IPMIVIEW
08-22
超微 ipmiview，智能管理接口，fence，远程管理
IBM-B24光纤交换机配置zone
11-07
本文详细介绍了如何在IBM-B24光纤交换机上配置zone
java权限访问控制系统.zip
05-10
权限访问控制管理后台 用途 ：rbac的权限访问控制管理后台 搭建方式 ： springBoot+myBatis+Maven+jsp+mysql 运行步骤 1.创建数据库 2.还原数据库（sql文件位于resource中） 3.启动应用 访问链接：localhost:8077/...
未签名的应用程序请求对系统进行无限制访问_iOS App签名的原理了解一下（下）...
weixin_39890629的博客
11-21 1125
加点东西：上述流程只解决了上面的第一个需求，也就是需要经过苹果的允许才可以安装，还未解决第二个避免被滥用的问题。怎么解决呢？苹果加了两个限制，一个是限制在苹果后天注册过的设备才可以安装，二是限制签名只能针对某个具体的App。在上述的第三步中，苹果用私钥A去签名我们本地公钥L时，实际上除了签名公钥L，还可以加上很多数据，这些数据都可以保证是经过苹果官方认证的，不会有被篡改的可能，那么我们就可以把Ap...
未签名的应用程序请求对系统进行无限制访问_(无代码)SpringCloud Alibaba介绍
weixin_39989875的博客
11-22 2390
SpringCloud Alibaba本篇目标：简要介绍Spring Cloud Alibaba 和其主要组件 Nacos，Sentinel，Seata。简介​ Spring Cloud Alibaba为分布式应用程序开发提供了一站式解决方案。它包含开发分布式应用程序所需的所有组件，使您可以轻松地使用Spring Cloud开发应用程序。使用Spring Cloud Alibaba，您只需要添...
通过session判断判断用户的操作权限
weixin_30270889的博客
06-08 388
客户请求端 --index.php: <?php date_default_timezone_set('Asia/Shanghai'); //设置正确的时区?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-tr...
未签名的应用程序请求对系统进行无限制访问_【云原生攻防研究】Istio访问授权再曝高危漏洞
weixin_39823269的博客
12-04 3772
一．概述在过去两年，以Istio为代表的Service Mesh的问世因其出色的架构设计及火热的开源社区在业界迅速聚集了一批拥簇者。Service Mesh不仅可以降低应用变更过程中因为耦合产生的冲突(传统单体架构应用程序代码与应用管理代码紧耦合)，也使得每个服务都可以有自己的团队从而独立进行运维。在给技术人员带来这些好处的同时，Istio的安全问题也令人堪忧，正如人们所看到的，微服务由于将单体架...
未签名的应用程序请求对系统进行无限制访问_HTTP请求是无状态的，那么负载均衡模式下session是如何同步的？...
weixin_39968436的博客
12-03 1576
我们知道，http请求是无状态的，但是事实上，业务总是有状态的，在交易类的电子商务网站，需要有购物车记录用户的购买信息，用户每次购买请求都是向购物车中增加商品;在社交类的网站中，需要记录用户的当前登录状态、最新发布的消息及好友状态等，用户每次刷新页面都需要更新这些信息。一般生产生的软件，出于用户量大的考虑，都是采用负载均衡模式的。用户每次请求可能不在同一服务器处理，那用户的session状态是怎么...
未签名的应用程序请求对系统进行无限制访问_OWASP Top 10 2017 10项最严重的 Web 应用程序安全风险 （完结篇）...
weixin_39646706的博客
11-29 1107
OWASP Top 10 2017 | 10项最严重的Web 应用程序安全风险(一)10项最严重的Web 应用程序安全风险(二)A7:2017 跨站脚本(XSS)当应用程序的新网页中包含不受信任的、未经恰当验证或转义的数据时，或者使用可以创建HTML或JavaScript的浏览器API更新现有的网页时，就会出现XSS缺陷。XSS让攻击者能够在受害者的浏览器中执行脚本，并劫持用户会话、破坏...
Java访问权限异常例子
最新发布
02-26
Java中的访问权限异常通常是指当试图访问另一个类中被声明为私有的变量、方法或构造函数时抛出的异常。例如，如果一个类A中声明了一个私有变量或方法，而另一个类B中尝试访问该变量或方法，则会引发访问权限异常。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值