Java查漏补缺之protected

protected：
- 对于本包和子类可以访问。
- 与基类不在同一个包中的子类，只能访问自身从基类继承而来的受保护成员

1.

class MyObject {}

public class Test {

    public static void main(String[] args) {
       MyObject obj = new MyObject();
       obj.clone(); // Compile error.
    }
}

我们已经清楚Object.clone()是protected方法。这说明，该方法可以被同包（java.lang）下和它（java.lang.Object）的子类访问。这里是MyObject类（默认继承java.lang.Object）。

同样Test也是java.lang.Object的子类。那么为什么不可以在Test中访问Object的clone呢？

在Test中，访问的不是Test自身从Object继承来的受保护方法，而是MyObject从Object继承来的受保护方法（改为Test t = new Test();t.clone()是可以的），这跟Test是不是Object的子类没有任何关系，这里的场景就好像是跨包访问受保护方法，所以这个受保护方法在Test中是不可见的。要想他可见，只能把Test类定义到java.lang包中。

2.

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

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

MyObject2和Test2在同一包中，对于同一包中，protected是可以访问的

3.

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

package 2
public class Test3 extends MyObject3 {
    public static void main(String args[]) {
       MyObject3 obj = new MyObject3();
       obj.clone(); // Compile error.
       Test3 tobj = new Test3();
       tobj.clone();// Complie OK.
    }
}

第一次访问clone是跨包访问，虽然Test3继承了MyObject3 ，但是这跟继承不继承没关系；第二次访问跟继承有关系。

4.

class MyObject extends Test{}

public class Test {
  public static void main(String[] args) {
    MyObject obj = new MyObject();
    obj.clone(); // Compile ok.
  }
}

为什么可见呢？因为MyObject的clone方法继承自Test，而Test做为相对于Object的子类，是可以访问继承而来的属于它自己的受保护方法的

5.

package 1
class MyObject extends Test {
}

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

虽然处于不同的包，但子类的受保护方法实际上继承自父类，父类的自己的受保护方法对自己可见，其原理同示例4.

6.

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

package 2
public class Test {
  public static void main(String args[]) {
    MyObject obj = new MyObject();
    obj.clone(); // Compile error!
  }
}

这里不再访问Test中的clone了，而是子类自己的clone。父类访问不在同一个包中的子类的受保护方法，造成跨包访问。

7.

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

public class Test {

}

同一个包中，父类实例的clone方法在子类中依然不可见，原理同示例1，就是因为父类的clone方法，实际上来自java.lang.Object。

我们来想一下，为什么当子类和父类在不同包中，子类只能访问自身继承而来的受保护方法，而不能访问另一个子类继承而来的受保护方法，虽然这两个子类继承的是同一父类？

因为子类继承父类，在继承了父类的契约的同时，还以某种方式扩充了这个契约。假设某个子类作为其扩充之后的契约的一部分，对超类的受保护的成员值设置了限制。如果另一个子类可以访问这个子类继承来的受保护成员，那么它就可能破坏这个子类的契约，这肯定是禁止的。

当然了，也有一个例外，如果父类的这个受保护成员是static的，那么它的子类可以任意访问。为什么是静态的，就可以随意访问呢，因为父类的static方法不能被子类重写，也就不会破坏契约。

本文借鉴于 http://zhangjunhd.blog.51cto.com/113473/19287