考考大家：protected修饰符，你真的弄明白了吗？

Question

现大家看看为什么，问题所见注释：package pk2.a;
public class A {
protected int i = 1; protected void protect() {
System.out.println("A::protect");
}
}package pk2.b;
import pk2.a.A;
public class B extends A {}package pk2.b;
import pk2.a.A;
public class C {
void g() { 
                  //B与C是同包，而B又拥有这些方法与属性，为什么不能访问？
A a2 = new B();
//!! a2.protect();
//!! System.out.println(a2.i);
             
                  //问题与上面一样
B b1 = new B();
//!! b1.protect();
//!! System.out.println(b1.i);
}
}package pk3.a;
public class A {
protected int i = 1;
protected void protect() {
System.out.println("A::protect");
}
}package pk3.b;
import pk3.a.A;
public class B extends A {}package pk3.a;
import pk3.b.B;
public class C {
void g() {
                  //现在C与B不在同一包，为什么又可以访问它的属性与方法了呢？
B b1 = new B();
b1.protect();
System.out.println(b1.i);
}
}package pk4.a;
public class A {
protected int i = 1;
protected void protect() {
System.out.println("A::protect");
}
}package pk4.b;
import pk4.a.A;
public class B extends A {
protected void protect() {
System.out.println("A::protect");
}
}package pk4.a;
import pk4.b.B;
public class C {
void g() {
                  //为什么B的方法不能访问了，而属性还要以呢？
B b1 = new B();
//!! b1.protect();
System.out.println(b1.i);
} public static void main(String[] args) {
new C().g();
}
}

Answer 1

试着回答下：第一个，因为protected时候，只能同一个类、包、子类内访问，而C类不是其中的任何一个，继承之后只能子类访问；
第二个，因为与A在同一个包；
第三个，因为B重载了A的方法，属于B了（差不多吧），C与A同包，与B不同包，所以可以访问A的属性，不能访问方法了；
我觉得差不多是这样，没有实践过，希望有点帮助^.^

Answer 2

这主要是多态问题，A a = new B(); 不管实例a 那个子类的具体事例，以A类为准。protected 是在同一包内的可以访问。所以只有和A在同一包内才可以访问。

Answer 3

lz
请你核对下程序 按照你的思路 我把你的代码 放入Eclipse中  不能编译....你说的访问的方法根本不能通过.......其实不用这么麻烦proctected只有两种访问权限
包内和 子类不是父子类关系的 只能在包内访问........ 当父类与子类位于同一包中时，不管是子类对象还是父类对象都可以访问protected，但是它们的意义是不一样的；对于子类对象，之所以可以访问是因为：子类从父类继承了protected成员，理所当然可以访问；父类对象（在子类中创建的）之所以可以访问是因为protected提供了包访问极限！    当父类与子类位于不同包中时，protected成员就只能通过子类对象来访问（因为protected对于子类是可见的），而父类对象不再可以访问！不过，可以访问static 成员（因为protected的包访问极限已失去作用）理解了就可以了....... 

Answer 4

o  我搞错了没看见 你的A和C在同一个包内
嘿嘿 

Answer 5

回楼主 第一个 B并不拥有A的protected的方法和属性  可以通过反射查看除了public的东西 其他的都不能被继承 包括default protected private protected能被子类访问  是说能在子类的内部访问

Answer 6

除了public的东西 其他的都不能被继承 包括default protected private ？？不能被继承，越来越晕了

Answer 7

protected是可以被子类继承的一个修饰。
在同包中是和public有一样的效果。
但不在同包中则会表现出与private一样的效果，但有一点是除外的protected可以被继承的。

Answer 8

我要换一个观点 所有东西都是可以被继承的 包括public private protected default
ps: 我靠啊 这个问题就是说法不同 到底内存怎么分配的 我没有研究过 应该说分配了内存就算被继承吧?
你们去研究下告诉我?
我可以说private是能被继承的 但是不能被访问 因为能被继承和能被访问是俩概念
我也可以说private的 既然都不能访问 还能叫继承?
连有的sun的工程师都在争论这个问题 我不管了 eclipse说了算 我靠

Answer 9

刚翻了官方文档 private不能被继承 public和protected能被继承 就这样8.2.1.2   Inheritance with public and protected
Given the class Point:
package points;
public class Point {
public int x, y;
protected int useCount = 0;
static protected int totalUseCount = 0;
public void move(int dx, int dy) {
x += dx; y += dy; useCount++; totalUseCount++;
}
}
the public and protected fields x, y, useCount and totalUseCount are in
ited in all subclasses of Point. 
Therefore, this test program, in another package, can be compiled succ
fully:
class Test extends points.Point {
public void moveBack(int dx, int dy) {
x -= dx; y -= dy; useCount++; totalUseCount++;
}
}
8.2.1.3   Inheritance with private
In the example:
class Point {
int x, y;
void move(int dx, int dy) {
x += dx; y += dy; totalMoves++;
}
private static int totalMoves;
void printMoves() { System.out.println(totalMoves); }
}
class Point3d extends Point {
int z;
void move(int dx, int dy, int dz) {
super.move(dx, dy); z += dz; totalMoves++;
}
}
the class variable totalMoves can be used only within the class Point; it is not
inherited by the subclass Point3d. A compile-time error occurs because method
move of class Point3d tries to increment totalMoves.

Answer 10

不能放在java code里?还是?

Answer 11

楼主的第三问改成如下可能更有迷惑性：
package pk4.a;
public class A {
    protected int i = 1;
    protected void protect() {
        System.out.println("A::protect");
    }
}package pk4.b;
import pk4.a.A;
public class B extends A {
    protected void protect() {
        System.out.println("A::protect");
    }
}package pk4.a;
import pk4.b.B;
public class C {
    void g() {
                  //这样的话编译为什么就又通过了呢？
        A b1 = new B();
        //!! b1.protect();
        System.out.println(b1.i);
    }    public static void main(String[] args) {
        new C().g();
    }
}