访问权限修饰符

原文：https://blog.csdn.net/qq_37424916/article/details/107371305

	同一个类中	同一个包中	不同包的子类	不同包的无关类
public	✔	✔	✔	✔
protected	✔	✔	✔
无（包访问）	✔	✔
private	✔

不同包中子类: 不同包通过继承获得关系 不同包中的无关类: 不同包通过直接创建对象来获得关系

例子1

package p1;
public class Father1 {
    protected void f() {
    }    // 父类Father1中的protected方法
}

package p1;
public class Son1 extends Father1 {
}

package p2;
public class Son2 extends Father1{
}

package p1;
public class Test {
    public static void main(String[] args) {
        Son1 son1 = new Son1();
        son1.f(); // Compile OK     ----（1）
        son1.clone(); // Compile Error     ----（2）
		

        Son2 son = new Son2();    
        son2.f(); // Compile OK     ----（3）
        son2.clone(); // Compile Error     ----（4）

		Test t = new Test();
		t.clone; // Compile OK
		// 测试类test只可以使用test类的继承Object类而来的test.clone()方法
    }
}

看（2）（4），其中clone()方法所在类为Object类的protected方法，而Object类所在包为java.lang包。其可见性是java.lang包及其所有子类，对于语句 “son1.clone();” 和 “son2.clone(); ”，二者的clone()在类Son1、Son2中是可见的（可以使用的），但对Test类是不可见的，因此（2）（4）处编译不通过。

例子2

package P1;
public class MyObject {
	protected Object clone() throws CloneNotSupportedException{
		return super.clone();
	}
}


package P2;
import P1.MyObject;
public class Test extends MyObject {
	public static void main(String args[]) throws CloneNotSupportedException {
		MyObject obj = new MyObject();
		obj.clone(); // Compile Error         ----（1）

		Test tobj = new Test();
		tobj.clone(); // Complie OK         ----（2）
	}
}

对于（1）而言，clone()方法来自于类MyObject本身，因此其可见性为包p1及MyObject的子类，虽然Test是MyObject的子类，但是由于在子类中，只有本类实例可以访问其从基类继承而来的protected方法，而在子类中不能访问基类实例（对象）（所调用）的protected方法。（作为子类，Test类中建立超类实例，直接去访问超类的protected方法是不可以的），因此编译不通过。

例子3

package P1;
public class Test {
	public static void main(String args[]) throws CloneNotSupportedException {
		MyObject obj = new MyObject();
		obj.clone();   // Compile OK     ------（1）
	}
}

package P2;
public class MyObject extends Test {
}

对于（1）而言，由于父类中可以访问子类实例（对象）继承的父类protected修饰的方法（子父类访问权限特点：父类访问域大于子类），因此编译通过。

例子4

package P1;
public class Test {
	public static void main(String args[]) throws CloneNotSupportedException {
		MyObject obj = new MyObject();
		obj.clone(); // Compile Error      -----（1）
	}
}

package P2;
public class MyObject extends Test {
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}

对于（1）而言，clone()方法来自于类MyObject是其特有方法，因此其可见性为包p2及其子类(此处没有子类)，而类Test却在包p1中，因此不满足可见性，编译不通过。

若子类与基类（父类）不在同一包中，父类中不可以使用子类实例访问（父类中没有）子类中特有的（自己的）protected修饰的成员。（毕竟没有满足同一包内和继承获得protected成员的关系）

例子5

package P1;

public class MyObject {
	protected Object clone() throws CloneNotSupportedException{
		return super.clone();
	}
}

public class Test {
	public static void main(String[] args) throws CloneNotSupportedException {
		MyObject obj = new MyObject();
		obj.clone(); // Compile OK        ----(1)
	}
}

对于（1）而言，clone()方法来自于类MyObject，因此其可见性为包p1及其子类(此处没有子类)，而类Test也在包p1中，因此满足可见性，编译通过。

例子6

package p1;

class MyObject extends Test{
}

public class Test {
    public static void main(String[] args) throws CloneNotSupportedException {
        MyObject obj = new MyObject();
        obj.clone();        // Compile OK   -------（1）
    }
}

对于（1）而言，clone()方法来自于类Test，因此其可见性为包p1及其子类MyObject，而类Test也在包p1中，因此满足可见性，编译通过。

例子7

package p1;

public class Test {
}

class MyObject extends Test {
    public static void main(String[] args) {
        Test test = new Test();
        test.clone(); // Compile Error   ----- (1)
    }
}

对于（1）而言，首先，clone()方法所在类为Object默认根类，而Object类所在包为java.lang包。protected修饰的clone()方法其可见性是java.lang包及其所有子类，所以可以判断clone()方法所在包与子类不在同一个包中。

其次，若子类与基类不在同一包中时，子类中不能访问基类实例（对象）（所调用）的protected方法。 MyObject子类访问权限只满足本类示例的访问。

例子8

package A;    
public class Animal {    
    protected void crowl(String c){    
        System.out.println(c);    
    }    
}


package B;
import A.Animal;
class Cat extends Animal 
{  
    
}  

public class Rat extends Animal{  
	public void crowl(){  
        this.crowl("zhi zhi"); //没有问题，继承了Animal中的protected方法——crowl(String)  
        Animal ani = new Animal();
        ani.crowl("animail jiaojiao"); //wrong, The method crowl(String) from the type Animal is not visible 
        Cat cat=new Cat();  
        cat.crowl("miao miao"); //wrong, The method crowl(String) from the type Animal is not visible  
    }  
}

若子类与基类不在同一包中，子类不能访问基类实例的protected方法。

若子类与基类不在同一包中，子类不能访问亲兄弟实例所继承的protected修饰的方法。

例子9

package a;
public class A {     
	protected void m(){
		System.out.println("A m~~~");
	}
}


package b;
import a.A;
public class B extends A {
	void callM() {
		m();  // ok
		super.m(); // ok
		B b = new B(); // ok
		b.m(); // ok
	}
}


package b;
import a.A;
public class C extends A {
	void callM() {
		m(); // ok
		super.m(); // ok
		B b = new B(); // ok
		b.m();     //The method m() from type A is not visible
	}
}

若子类与基类不在同一包中，子类不能访问亲兄弟实例所继承的protected修饰的方法。