2020.7.21

学习内容：

 1、Object 类及其方法

Java中所有类都默认继承Object类，Object是Java所有类的父类

Object是类层次结构的根类，每个类都使用Object作为超类，所有对象（包括数组）都实现这个类的方法

Object类的常用方法:

 

 2、对象中的克隆

（1）Java对于克隆有一些限制：

1. 被克隆的类必须自己实现Cloneable 接口，以指示Object . clone() 方法可以合法地对该类实例进行按字段复制。Cloneable接口实际上是个标识接口，没有任何接口方法
2. 实现Cloneable 接口的类应该使用公共方法重写 Object . clone（它是受保护的），某个对象实现了此接口就克隆它是不可能的
3. 在 Java . lang.Object类中克隆方法的定义

   创建并返回此对象的一个副本。表明是一个受保护的方法，同一个包中可见/按照惯例，返回的对象应该通过调用 super . clone 获得

（2）浅层克隆和深层克隆  

Java克隆主要分为浅层克隆和深层克隆

 浅层克隆：主要复制基本对象的值

深层克隆：当类存在聚合关系时，克隆就必须考虑聚合对象的克隆，可以复制引用类型的字段

浅层克隆：

package day01;
public class CloneDemo {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person p = new Person("任我行",35);
        Person p2=(Person)p.clone();
        System.out.println("克隆前："+p.getName()+","+p.getAge());
        System.out.println("克隆后："+p2.getName()+","+p2.getAge());
        if(p==p2)
        System.out.println("p和p2的地址相等！");
        else
             System.out.println("p和p2的地址不相等！！");
    }
}
class Person implements Cloneable{
    private String name;
    private int age;
    public Person(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;}
    public void setName(String name) {
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age=age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
 }

深层克隆

package day01;
public class CloneDeepDemo {
    public static void main(String[] args) throws CloneNotSupportedException{
        Person per = new Person("令狐冲",20);
        P p=new P(per);
        P p2=(P)p.clone();
        System.out.println("克隆前："+p.getPer().getName()+","+p.getPer().getAge());
        System.out.println("克隆后："+p2.getPer().getName()+","+p2.getPer().getAge());
        if(p==p2)
        System.out.println("p和p2的地址相等！");
        else
             System.out.println("p和p2的地址不相等！！");
        if(p.getPer()==p2.getPer())
            System.out.println("p中的Person对象与p2中的Person对象相等！");
        else
            System.out.println("p中的Person对象与p2中的Person对象不相等！");
    }
}
class P implements Cloneable{
    Person per;
    public P(Person per) {
        this.per=per;
    }
    public Person getPer() {
        return per;
        }
    public void setPer(Person per) {
        this.per=per;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException{
        P p =(P)super.clone();
        p.per=(Person)this.per.clone();
        return p;
    }
 }
class Person implements Cloneable{
    private String name;
    private int age;
    public Person(String name,int age) {
        this.name=name;
        this.age=age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name=name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age=age;
    }
    @Override
    protected Object clone() throws CloneNotSupportedException{
        return super.clone();
    }
}

遇到的问题：

 1、什么是超类？

超类 ：用java术语来讲,被继承的类称为超类，继承的类称为子类。面向对象编程的最重要的特色之一就是能够使用以前创建的类的方法和域。通过简单的类来创建功能强大的类，可以大幅地节省编程时间，更重要的是，这样做可以减少代码出错的机会。要在以前的类上构造新类，就必须在类声明中扩展这个类。通过扩展一个超类，可以得到这个类的一个新副本，并且可以在其上添加其他功能。如果对这个新类并不做任何添加工作，那么，它的工作情况与超类完全相同，新类中会含有超类所声明和继承的、具有访问权限的所有方法和域。在使用超类时以下两点需要注意：

1. 在子类的构造方法里第一行都会存在默认（隐式）的super(); 会调用父类的无参构造方法    ==>即默认存在super()。
2. 如果存在显式的super调用父类的构造方法，那么隐式的调用就不会存在。

明天要学习的内容：

 Java的继承，super关键字