父类中protect方法调用的问题

Question

当我自己写代码，把父类放一个包中，子类放另一个包中，子类没有重写父类的protect方法，在子类包中直接访问父类的的
protect方法，不会提示错误。但是为什么当我直接调用java中写好的类中protect方法时会提示不可见？
比如 clone()方法，它是根类Object的方法，当没有重写clone()扩大权限时，直接在自己写的类中调用
提示 不可见？？这是怎么回事？？

Answer 1

protected  同package可见，子类可见

Answer 2

你是做static方法里面直接调用的吗？如果是的话，那肯定不行的。static是不能直接调用对象的非static方法的。因为调用static方法的时候不要求对象一定先初始化了。所以有可能对象根本都还没创建，那么如何能调用方法呢？

Answer 3

++,clone()方法是object类具有的，而所有类都是从object类派生出来的，可以直接调用啊，不存在修改权限问题。楼主具体是什么意思？

Answer 4

package Lang_1;
class Person1 implements Cloneable{
private String name=null; public Person1(String name) {
this.name = name;
}
public String toString() {
return "姓名"+this.getName();
} public String getName() {
return name;
} public void setName(String name) {
this.name = name;
}
public Object clone() throws CloneNotSupportedException{
return super.clone();

}  

}public class CloneDemo { public static void main(String[] args) throws CloneNotSupportedException  {
Person1 p1=new Person1("张三");
Person1 p2=(Person1)p1.clone();
                p2.setName("李四");
                System.out.println(p1);
                System.out.println(p2);
        
}}
上面的例子是使用java中以存在的Object类中的方法：
这而如果不使用public Object clone() throws CloneNotSupportedException{
return super.clone();} 
即不重写Object中的clone()方法。这儿Person1 p2=(Person1)p1.clone()会提示：
the method clone() from the type Object is not visble
下面是我自建的继承关系的的两个类：
package t0;public class Test {
   int a=1;
   int b=1;
   void say(){
System.out.println("hello");
   }   protected void result(){
       System.out.println(a+b);
   }
}package t1;import t0.Test;
public class Testson extends Test {
   public static void main(String[] args) {
Testson testson=new Testson();
testson.result();
   }}
这儿调用另一个包t0中父类受保护方法result()没有任何问题。
两种情况怎么解释？？

Answer 5

baidu的一段解释：
对于Object类，它的clone方法实现如下：
protected native Object clone() throws CloneNotSupportedException;也就是说，如果你在它的子类中没有覆盖clone方法，永远都是抛出一个CloneNotSupportedException，这就是为什么一调用就失败。要想使用的话，不仅要让子类实现Cloneable接口，还要覆盖这个clone方法。 如果用protected修饰，它的子类是可以访问的，所以子类调用的其实是Object的clone方法，而这个方法永远抛出一个CloneNotSupportedException：比如下面的代码是可以正常运行的:
public class Clone
{
    public static void main(String[] args)
    {
        Clone c = new Clone();
        try
        {
            c.clone();
        }
        catch (CloneNotSupportedException e)
        {
            e.printStackTrace();
        }
    }
}
如果Object的clone方法子类不能访问，那么c.clone()这句会编译失败。Object类的这个clone方法完全是为了子类覆盖它服务的，并不是让子类直接调用的，这也就是为什么在覆盖clone方法时一般到调用super.clone()的原因。clone方法是可以被覆盖的，但是必须实现Cloneable接口，所以你覆盖后，它就不会调用父类的方法，而调用你覆盖后的方法。

Answer 6

楼主的上面的程序涉及3个类：
Object(protectd 方法在此类里），Person1 (默认继承Object), CloneDemo(用于测试）。
你想在测试类里用Person1的对象p1,去调用其应继承的父类的clone()方法,因为Object和Person1 不在一个包里 ，所以编译出错。假设Object 和Person1在相同的包里，这是没问题的。下面的程序，只涉及到两个类，Test 和Testson,你在Testson里调用其父类的protected 方法没有问题。这是正常的。 现在你再加一个类，把Testson稍微改一下，再试一下，就会出现上面的问题了。
给你代码试试：/* file name is:Test.java
 */
package t0;public class Test
 {
  int a=1;
  int b=1;  void say()
  { 
     System.out.println("hello");
  }  protected void result()
  {
     System.out.println(a+b);
  }
}/* filename is TestProtected.java
 */
package t1;import t0.Test;class Testson extends Test
{
int c=0;        void display()
{
result(); //不同包子类直接可见。
}
}public class TestProtected
{
public static void main(String[] args)
{
Testson ts=new Testson();
ts.display();
//ts.result(); //编译报错.
}
}

Answer 7

而上面的程序，如果两个类都在一个包里，就不会报错了。
或者类似那个clone(), 在Testson里加上 public void result()
{
super.result();
}也可以。（我个人认为好像在父类和测试类之间架了座桥）。
我看资料上说，这也是protected 很"elabration"的地方。

Answer 8

谢了，之前看权限管理中protect的权限说明中有：只能在本包及不同包的子类访问，这儿证明了只能在不同包的子类访问

Answer 9

package t0;
public class Test {
   int a=1;
   int b=1;
   void say(){
 System.out.println("hello");
   }   protected void result(){
   System.out.println(a+b);
   }
}package t1;
import t0.Test;
public class Testson extends Test {
   public static void main(String[] args) {
 Testson testson=new Testson();
 testson.result();
   }}
这儿调用另一个包t0中父类受保护方法result()没有任何问题。
子类中没有重载父类的protect修饰的方法啊，是直接调用的。
这儿的result()的调用就另一个包package t1中，t1中存放子类。
楼上说只能在同一个包中直接调用父类的protect方法有问题啊