使用Object.clone()时碰到的protected权限问题

之前一直对protect中的子孙类不同包情况有两种可能，不太理解。

最近在使用clone()的时候发现报错，查资料就发现这个问题。

Protect修饰的方法，在不同包时候，可以访问该方法，但是不能在包外创建新的对象调用方法。

即protected权限成员可以被非同包的子类访问，指子类内部可以直接使用父类protected成员；而不是在外部创建子类对象，通过子类对象访问父类protected成员。

使用clone()进行浅拷贝

public class CloneTest1
{
  public static void main(String[] args) throws Exception
  {
    Student1 student = new Student1();
    student.setAge(24);
    student.setName("niesong");
    Student1 student2 = (Student1)student.clone();
    //这个是调用下面的那个方法，然后把这个这个对象Clone到student
    System.out.println("Age:" + student2.getAge() + " " + "Name:" + student2.getName());
    System.out.println("---------------------");
    student2.setAge(23);
    //克隆后得到的是一个新的对象，所以重新写的是student2这个对象的值
    System.out.println(student.getAge());
    System.out.println(student2.getAge());
  }
}
//克隆的对象必须实现Cloneable这个接口，而且需要重写clone方法
class Student1 implements Cloneable
{
  private int age;
  //定义为private说明这个成员变量只能被被当前类中访问，如果外部需要获得，那么就只能通过getAge方法进行获取
  private String name;
  public int getAge()
  {
    return age;
  }
  public void setAge(int age)
  {
    this.age = age;
  }
  public String getName()
  {
    return name;
  }
  public void setName(String name)
  {
    this.name = name;
  }
  @Override
  public Object clone() throws CloneNotSupportedException
  {
    Object object = super.clone();
    return object;
  }
}

使用clone()进行深拷贝

public class CloneTest2
{
  public static void main(String[] args) throws Exception
  {
    Teacher teacher = new Teacher();
    teacher.setAge(40);
    teacher.setName("teacher zhang");
    Student2 student2 = new Student2();
    student2.setAge(14);
    student2.setName("lisi");
    student2.setTeacher(teacher);
    Student2 student3 = (Student2)student2.clone();
    //这里是深复制，所以这时候Student2中的teacher就是teacher这个对象的一个复制，就和student3是student2的一个复制
    //所以下面teacher.setName只是对他原来的这个对象更改，但是复制的那个并没有更改
    System.out.println(student3.getAge());
    System.out.println(student3.getName());
    System.out.println(student3.getTeacher().getAge());
    teacher.setName("teacher niesong");//不会又任何影响
    System.out.println(student3.getTeacher().getName());
  }
}
class Student2 implements Cloneable
{
  private int age;
  private String name;
  private Teacher teacher;
  public int getAge()
  {
    return age;
  }
  public void setAge(int age)
  {
    this.age = age;
  }
  public String getName()
  {
    return name;
  }
  public void setName(String name)
  {
    this.name = name;
  }
  public Teacher getTeacher()
  {
    return teacher;
  }
  public void setTeacher(Teacher teacher)
  {
    this.teacher = teacher;
  }
  @Override
  public Object clone() throws CloneNotSupportedException
  {
    //这一步返回的这个student2还只是一个浅克隆，
    Student2 student2 = (Student2)super.clone();
    //然后克隆的过程中获得这个克隆的student2，然后调用这个getTeacher这个方方法得到这个Teacher对象。然后实现克隆。在设置到这个student2中的Teacher。
    //这样实现了双层克隆使得那个teacher对象也得到了复制。
    student2.setTeacher((Teacher)student2.getTeacher().clone());
    //双层克隆使得那个teacher对象也得到了复制
    return student2;
  }
}
class Teacher implements Cloneable
{
  private int age;
  private String name;
  public int getAge()
  {
    return age;
  }
  public void setAge(int age)
  {
    this.age = age;
  }
  public String getName()
  {
    return name;
  }
  public void setName(String name)
  {
    this.name = name;
  }
  @Override
  public Object clone() throws CloneNotSupportedException
  {
    return super.clone();
  }
}