Java---抽象类与接口

前言

上期我们介绍了类与对象的知识点，那么这期我先为大家带来关于抽象类与接口的具体的讲解，希望大家能更进一步理解Java中的特点，下节再为大家介绍两大特性的详解。

一、抽象类

1.抽象类的概念

在面向对象的概念中，所有的对象都是通过类来进行描绘的，但是并不是所有的类来进行描绘对象的。
如果一个类中没有足够的信息内容来回一个具体的对象，那么这种类就是抽象类。

2.抽象类的语法

1.抽象类都是被abstract类修饰的叫做抽象类

public abstract class A{}

2.抽象类中的成员方法用abstract修饰的方法，叫做抽象方法

public abstract class A{public abstract void test();//抽象方法
}

3.抽象类的特点

1. 通过上述方法我们可以得知：一个类中有抽象方法，那么这个类必是抽象类
2. 抽象类中也可以有普通成员变量和普通成员方法
   比如：

abstract class Shape{public int a = 10;//普通成员变量public void draw(){//普通成员方法System.out.println("画图形");}public abstract void draw2();//抽象方法
}

3. 抽象类不能直接实例化

public static void main(String[] args) {Shape shape = new Shape();}    

抽象类不能实例化，那么是用来干什么的呢？
当然是用来被继承的了，所以抽象类也可以实现了向上转型

4. 抽象类中的方法是不能被private修饰的

    private abstract void draw2();

5. final 和 abstract 两者不能同时存在，被abstract修饰的方法就是要被继承的与重写的，而final修饰的不能被重写和继承，属于是密封类和密封方法

public abstract final void draw2();

6. 抽象方法不能被static修饰，因为抽象方法要被子类重写，而static是属于类本身的方法

public static final void draw2();

7. 当一个普通类继承了这个抽象类之后，这个普通类一定要重写这个抽象类的当中的所有的抽象方法

abstract class Shape{public int a = 10;public void draw(){System.out.println("画图形");}public abstract void draw2();//抽象方法public void test(){}
}
class React extends Shape{@Overridepublic void draw2() {System.out.println("矩形");}
}
class Flower extends Shape{@Overridepublic void draw2() {System.out.println("花" );}
}

8. 子类如果不想重写抽象方法，那么就把子类也设为抽象类
   比如这有一个子类A

abstract class A extends Shape{public abstract void testDemo();
}

但是我们会想到，如果一直设计为抽象子类，那么它们的抽象方法怎么办？

class  B extends A{@Overridepublic void draw2() {}@Overridepublic void testDemo() {}
}

所以B继承了A,A继承了Shape，两个类都是抽象类，所以这个普通类B类就要重写两个方法

9. 当一个抽象类A不想被一个普通类B继承，此时可以把这个B类变成抽象类，那么在当一个普通类C继承这个抽象类B之后,C要重写B和A的里面的所有抽象方法

4.抽象类的操作

给出完整的代码，让我们分析一下：

abstract class Shape{public int a = 10;public void draw(){System.out.println("画图形");}public abstract void draw2();public void test(){}public Shape() {//既然它不能实例化，但是可以让子类调用帮助这个抽象类初始化它自己的成员}
}
class React extends Shape{@Overridepublic void draw2() {System.out.println("矩形");}
}
class Flower extends Shape{@Overridepublic void draw2() {System.out.println("花" );}
}
public class Test {public static void drawMap(Shape shape) {shape.draw2();}public static void main(String[] args) {Shape shape = new React();drawMap(new React());drawMap(new Flower());}

Shape shape1 = new React();
Shape shape2 = new Flower();

这个操作是向上转型，在我们调用了一些抽象方法的时候，由于我们将其抽象方法进行了重写，进而发生了动态绑定，从而发生多态。

 	public static void drawMap(Shape shape) {shape.draw2();}

这个方法我们来接收Shape类型，但是由于子类继承父类，构成了协变类型，也会发生向上转型，往里面传入了参数时，再调用抽象方法，这个时候发生了动态绑定，就会发生了多态

new React() new Flower() 这种没有名字的对象 —> 匿名对象
匿名对象的缺点：每次使用，都得去重新实例化
所以我们可以使用向上转型的直接赋值，来去传进参数

	public static void main(String[] args) {Shape shape1 = new React();Shape shape2 = new Flower();drawMap(shape1);drawMap(shape2);}

5.抽象类的作用

我们都知道普通的类也能被继承，那还需要抽象类来做什么？
但是我们正常都需要跟业务和实际情况来进行选择，
使用抽象类相当于多了一重编译器的校验：
使用抽象类的场景就如上面的代码，实际工作不应该由父类完成，而应由子类完成.。
那么此时如果不小心误用成父类了，使用普通类编译器是不会报错的；
但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。
意义：
很多语法存在的意义都是为了 “预防出错”, 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不
就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.
充分利用编译器的校验, 在实际开发中是非常有意义的.

二、接口

1.接口的概念

比如：我们都知道电脑上面有USB接口，可以插些：U盘，鼠标等符合USB协议的设备；

接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。
在Java中，接口可以看成是多个类的公共规范，是一种引用数据类型。

2.接口语法

public interface 接口名称{//抽象方法//成员变量
}

一般的接口名称前加一个I字母。

interface IShape{//一般情况下我们以I开头来表示接口的int a = 10;void draw();default void test(){System.out.println("test()");}public static void test2(){System.out.println(" static test2()");}
}

在这个接口中我没有看到修饰符，难道是默认的吗？
并不是默认的！
原因这是在接口中，成员变量默认是被public static final修饰的，成员方法是抽象方法，但是默认被public abstract修饰的但是这种我们一般不写
接口中的方法一般不能实现，都是抽象方法，但是从JDK8之后，可以支持default修饰的成员方法和static修饰的成员方法中可以有具体的实现（即主体）

3.接口的使用与特性

1. 接口的成员方法必须是默认为public abstract来修饰的。
   其他修饰符不可以；private 和 protected还有default均不可以，都会出现报错
   接口类型也是一种引用类型
2. 接口不能有普通成员方法，也不能有成员变量

interface IShape{//一般情况下我们以I开头来表示接口的private int a = 10;void draw();default void test(){System.out.println("test()");}public void test2(){System.out.println(" static test2()");}
}

就算你写成了public的成员变量，这时候也是默认成public static final修饰的，所以不会出现错误

3. 接口不能被new关键字来进行实例化，但是也可以用向上转型

IShape iShape = new IShape();

4. 类实现了接口，那么该子类就要重写接口中的所有抽象的方法，用implements关键字来实现

class Rect implements IShape{@Overridepublic void draw() {System.out.println("矩形");}
}
class Flower implements IShape{@Overridepublic void draw() {System.out.println("花");}
}

5. 如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类

abstract class A implements IShape{}

当然了，还是要还的，因为他只能被用来继承，所以这种类被继承后还是需要重写接口中的方法

6. 当一个类实现了接口当中的方法之后，当前类中的方法不能不加public，因为原来接口中的方法是public修饰的，所以重写的方法要大于等于public的范围，所以必须是public修饰

class Rect implements IShape{@Overridevoid draw() {System.out.println("矩形");}
}

7. 接口当中，不能使用构造方法和静态代码块

interface IShape{//一般情况下我们以I开头来表示接口的public IShape(){}static{}
}

4.实现多个接口

在Java中，类和类之间是单继承的，一个类只能有一个父类，即Java中不支持多继承，但是一个类可以实现多个接口。
在父类中是放入一些共性的特点，而不是特有的，是共有的
比如我们创建了一个动物类，再创建几个具体的动物的类，再分别创建几个接口：

//游泳接口
public interface ISwimming {void swim();
}

//跑步接口
public interface IRunning {void run();
}

//飞行接口
public interface IFlying {void fly();
}

//动物类：
public abstract class Animals {public String name;public int age;public Animals(String name, int age) {this.name = name;this.age = age;}public abstract void eat();
}

鸟可以进行飞行和跑步，所以实现这两接口,并且继承了动物类

//鸟类
public class Bird extends Animals implements IFlying, IRunning {public Bird(String name, int age) {super(name, age);//帮助父类进行构造，用super来进行访问父类}@Overridepublic void eat() {System.out.println(this.name + "正在吃饭!");}@Overridepublic void fly() {System.out.println(this.name + "正在用翅膀飞！");}@Overridepublic void run() {System.out.println(this.name + "正在用鸟腿跑！");}
}

狗类是可以进行跑步和游泳，所以实现这两个接口，并且继承了父类

//狗类
public class Dog extends Animals implements IRunning, ISwimming {public Dog(String name, int age) {super(name, age);//帮助父类进行构造}@Overridepublic void eat() {System.out.println(this.name + "正在吃狗粮！");}@Overridepublic void run() {System.out.println(this.name + "正在用狗腿跑！");}@Overridepublic void swim() {System.out.println(this.name + "正在狗腿游泳！");}
}

主类

public class Test {public static void test1(Animals animals){animals.eat();}public static void test4(IFlying iFlying){iFlying.fly();}public static void test2(IRunning iRunning){iRunning.run();}public static void test3(ISwimming iSwimming){iSwimming.swim();}public static void main(String[] args) {Bird bird = new Bird("小鸟",1);Dog dog = new Dog("小狗",10);test1(dog);test1(bird);test2(bird);test2(dog);System.out.println("============");test3(dog);//test3(bird);bird没有实现swimming的接口System.out.println("============");test4(bird);//test4(dog);dog没有实现了flying的接口}
}

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口。

语法上先继承后实现，否则会报错
继承表示是其中的一种，接口表示的是它具有什么特性，能做什么。

这时候我们在创建一个机器人类：

public class Robot implements IRunning {@Overridepublic void run() {System.out.println("机器人在跑！");}
}

比如我们在主类中测试

test2(new Robot());

那么这种操作的好处是什么？
时刻牢记多态的好处, 让我们忘记类型. 有了接口之后, 类的使用者就不必关注具体类型,
而只关注某个类是否具备某种能力

我们创建了这个机器人类，实现了跑步的接口，所以直接去实现调用test2的方法，这个时候我们就可以发现了这个接口，回避了向上转型会使其更加灵活。

5.接口之间的继承

在Java中，类和类之间是单继承的，但是一个类可以实现多个接口，接口与接口之间可以多继承。
用接口达到多继承的目的。
接口的继承用extends关键字

interface A{void testA();
}
interface B{void testB();
}
interface C{void testC();
}
interface D extends B,C{//D 这个接口具备了B和C接口的功能//并且D还可以有自己的方法void testD();
}

在接口中是进行抽象方法的声明，所以接口之间继承不用重写抽象方法
当类来实现这个D接口的时候，我们要重写D接口中的方法和D所继承的接口中的方法

public class Test implements D{@Overridepublic void testB() {}@Overridepublic void testC() {}@Overridepublic void testD() {}//就如同子孙类一样

总结：
接口间的继承相当于把多个接口合并在一起。
在接口中是进行抽象方法的声明，所以接口之间继承不用重写抽象方法。

6.接口的实例

(1).对象大小的比较

当我们先给出了几个对象，从而想要按照一定顺序比较其中内容的大小
我们先创建了一个Student类

class Student {public String name ;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

这个时候我们再创建一个主类

public class Test {public static void main(String[] args) {Student student1 = new Student("zhangsan", 10);Student student2 = new Student("lisi", 15);System.out.println(student1 > student2);}
}    

这么运行会出现错误；（因为两者都是引用类型，无法直接进行比较）

所以这个时候我们用接口来实现这个自定义类型的比较，所以分别是 Comparable和Comparator接口

(1).Comparable接口

这个是接口Comparable中的源码

这个接口中涉及到后续的泛型，关于这个泛型到后期的数据结构我们在详细的讲解
如果我们要实现比较的方法，就要用compareTo这个方法，
当然如果直接使用：

System.out.println(student1.compareTo(student2));

因为compareTo是Comparable中的方法，所以要想使用这个方法，就要实现这个接口，并指定比较的类型用<>

class Student implements Comparable<Student>{public String name ;public int age;public Student(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}@Overridepublic int compareTo(Student o) {//重写的CompareTo方法return this.age - o.age;//大于0，则前者大于后者//小于0，前者小于后者//this.age表示的是student1，o.age表示的是student2}
}public class Test {public static void main(String[] args) {Student student1 = new Student("zhangsan", 10);Student student2 = new Student("lisi", 15);System.out.println(student1.compareTo(student2));}
}

如果我们给出的是student的对象数组，让其大小进行排序，不作对student类进行修改，只在主类中进行实例化

import java.util.Arrays;
public class Test {public static void main(String[] args) {//利用对象数组Student[] students = new Student[3];students[0] = new Student("zhangsan",10);students[1] = new Student("lisi",2);students[2] = new Student("liwu",18);Arrays.sort(students);//这个时候要用comparable来进行一定的顺序排序.System.out.println(Arrays.toString(students));}
}

因为通过comparable这个接口来进行查找一定的内容，从而按一定的内容来进行比较大小
当然，我们想要按其他内容的时候进行排序，需要改动某些代码，这时候就容易会导致某些错误。

(2).Comparator接口

Comparator接口中有compare的方法为默认权限，所以我们调用这个方法
这种方式叫做比较器,在类的外部进行实现

class Student2{public String name;public int age;@Overridepublic int compareTo(Student2 o) {return this.age - o.age;}public Student2(String name, int age) {this.name = name;this.age = age;}@Overridepublic String toString() {return "Student{" +"name='" + name + '\'' +", age=" + age +'}';}
}

比如我们要按对象的年龄大小进行比较,这时候再创建一个age类,实现了Comparator这个接口

class AgeComparator implements Comparator<Student2>{@Overridepublic int compare(Student2 o1, Student2 o2) {return o1.age - o2.age;}
}

这个时候我们先把在外部的类实例化,进而要比较需要两个对象的变量传递到compare方法中去,从去重写这个方法,
并且发生向上转型(参数类型)

import java.util.Comparator;
public class Test2 {public static void main(String[] args) {Student2 student1 = new Student2("zhangsan", 10);Student2 student2 = new Student2("lisi", 15);AgeComparator ageComparator = new AgeComparator();System.out.println(ageComparator.compare(student1, student2));}
}

当我们按照name进行比较的时候,这个时候在创建了Name类,再去实现了Comparator这个接口

class NameComparator implements Comparator<Student2>{@Overridepublic int compare(Student2 o1, Student2 o2) {return o1.name.compareTo(o2.name);}
}

name是引用类型，不能进行相减来进行比较，但是我们发现了String类中也有去实现Comparable的方法
所以我们只需要重写compareTo方法即可

当然我们还是需要进行将Name类进行类的实例化

 NameComparator nameComparator = new NameComparator();System.out.println(nameComparator.compare(student1, student2));

关于对于自定义类型比较的总结:
Comparator这种方式的优势就是对于类的侵入性不强，会比较灵活
Comparable这种方式对于类的侵入性比较强，所以做好不要去改动原有的逻辑，比如我按名字排序这个时候就会容易发生变化
并且两者可以共存，互不干扰；因为comparable是对原有的类进行实现，comparator是对要比较内容的类而实现，所以互不干扰

(2).实现类的克隆

(1).类的克隆

Java中有许多的内置接口，而Cloneable就是一个非常有用的接口
Object类中有一个clone方法，调用这个对象可实现创建一个对象的“拷贝”，但是想要成功调用这个方法，就要实现这个其中的接口

class Person {public int age;public Person(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +" age=" + age +" }";}
}
public class Test3 {public static void main(String[] args){Person person1 = new Person(10);System.out.println(person1);Person person2 = person1.clone();System.out.println(person1);}
}

例如：我们创建一个person类，存入了一个年龄的成员变量，并重写了toString方法;
然后我们对Person类实例化，并存入了一个age为10的值让其构造方法为它自己进行初始化，这个时候我们直接打印了person1，这个时候我们再创建一个变量person2来接收person1的拷贝后的值。
但是如果我们直接这么做,直接去调用：

Person person1 = person.clone();

这个时候就会出现这种错误;
因为clone方法是在object类中的方法,所以我们点击查看clone的源码：

protected native Object clone() throws CloneNotSupportedException;

这个时候我们就会发现了这个clone方法是本地方法，是用C/C++来写的，所以我们也无法知道这个具体的过程实现，并且我们也看到了这个方法是被protected修饰的，它的访问权限是在不同包的子类可以访问不同包的父类被protected修饰的成员变量和方法， 但是也需要用super来访问，所以需要重写这个clone方法；

class Person {public int age;public Person(int age) {this.age = age;}@Overridepublic String toString() {return "Person{" +" age=" + age +" }";}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();//调用object类的方法来进行访问}
}

这个时候我们会发现还是有错误啊，但是这时候提示我们类型不兼容，因为Object类是所有的类的父类，但是其中clone方法是比较特殊的，它返回的是object类型，但是它并没有与Person构成显示的父与子的协变类型，所以这也反映了不构成重写的条件之一，所以会出现这种错误，但是我们把这个类型强制转换为Person类，所以就可以了

public class Test3 {public static void main(String[] args){Person person1 = new Person(10);System.out.println(person1);Person person2 = (Person) person1.clone();System.out.println(person1);}
}

这个时候在运行结果：

这个时候还是报了错误，告诉我们还有异常这错误，但是异常处理我们后期会详细讲解，因为clone方法的异常是受查异常/编译时异常，所以必须在编译时处理：

public class TestDemo {public static void main(String[] args) throws CloneNotSupportedException{//必须在编译时处理Person person1 = new Person(10);System.out.println(person1);Person person2 = (Person) person1.clone();System.out.println(person2);
}

但是我们运行完，还是会出现错误，这可是真愁人

CloneNotSupportedException，不支持克隆，告诉我们Person类不支持克隆
所以我们这时候就要提到前面所说的Cloneable接口了，这个时候我们就用Person实现这个接口，
那么运行结果：

这时候我们就完成了person2对person1的所指的对象的克隆
这个时候我们来看一下Cloneable这个接口：

Cloneable是一个空接口，我们可以在IDEA中去查看源码：
它是一个空接口，也作为一种标记接口，因为它用来证明当前类是可以被克隆的

在堆上，创建了一个对象，假设地址是0X98，那么在虚拟机栈上得到是person1所指这个对象的地址，通过clone的方法来进行克隆出堆中一个相同的一份的对象，但是两者（person1和person2）在堆上不是一个位置，所以person2这个克隆后的获得了一个新的地址0X88(假设的),所以我们通过 return super.clone() 来克隆。

那么就来总结一下Person person1 = person.clone();这个其中的所有的错误：

1. 修饰符的错误，protected，这一步用super.clone()访问object类，来重写这个clone方法
2. 异常，clone方法的异常是受查异常/编译时异常，所以必须在编译时处理，(在main后面加入throws)
3. 向下转型，进行强制转换,因为我们用的是object类中的clone方法，所以返回类型是固定的object类，而不是构成了协变类型。所以我们要进行向下转型，将其转换为子类；进行了上述的操作，还是会报错：CloneNotSupportedException，不支持克隆。
4. 所以我们要实现Cloneable这个接口，从而才能使用

我的理解：clone方法实现的具体操作，用super.clone来访问，Cloneable判断这个类是否支持克隆操作

(2).浅拷贝

这时候我们在Person类的基础上再重新创建了一个Money类，让它与其Person类构成组合

class Money{public double money = 19.9;
}
class Person1 implements Cloneable{public int age;public Money m;public Person1(int age) {this.age = age;this.m = new Money();//在构造方法中实例化一个money}@Overridepublic String toString() {return "Person{" +" age=" + age +" }";}@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
public class TestDemo {public static void main(String[] args) throws CloneNotSupportedException {Person1 person1 = new Person1(10);Person1 person2 = (Person1) person1.clone();System.out.println(person1);System.out.println(person2);System.out.println("===============");System.out.println(person1.m.money);System.out.println(person2.m.money);//先调用的是person1的成员变量m，//由于在构造方法中进行了m的实例化，所以我还可以调用Money类中的成员变量System.out.println("===============");//将person2进行修改，正常我们所期望的是只有person2进行修改，person1没有变化person2.m.money = 99.99;System.out.println(person1.m.money);System.out.println(person2.m.money);}
}

this.m = new Money();也就是在堆上的空余的空间再创建了一个实例化Money的对象，并且这个m在堆上那个原本的空间占有的一定内存空间。

person1.m.money为什么会这么调用money?
这个m是Peron1类的成员变量，但是我们也在Person1类中的构造方法去实例化Money这个类，所以这个m又是Money实例化的变量名，再用这个m来调用了Money类中的成员变量money

将person2进行修改，正常我们所期望的是只有person2进行修改，person1没有变化，

但是可惜的是两者都发生了变化。
所以我们可以通过图例来演示一下这个过程：

在虚拟机栈上，会创建两个空间分别是person1和person2，
person1所实例化的对象会在堆上创建一个对象的空间（地址为0x98），存入两个成员变量，但是其中m是Money类型即是引用类型，并且也是实例化了，所以那么也会是创建money类型的对象的空间（地址为0x65），这时候在对第一个对象中的成员变量m也会得到它实例化的地址
person1.clone()是把person1指向的对象进行克隆，但是没把这个对象的空间中成员变量m所指的对象进行克隆
所以那也意味着成员变量m还是指的是0x65的它自己的对象空间Money，这个对象的空间的成员变量是money
person2还是指的是第一次的对象中的对象的成员变量money；
所以这个时候堆money的修改还是一次就改变person1和person2所指的money的值，两者还是一样的

此时这个现象被称之为浅拷贝：并没有将对象中的对象去进行克隆

(3).深拷贝

class Money1 implements Cloneable{public double money = 19.9;@Overrideprotected Object clone() throws CloneNotSupportedException {return super.clone();}
}
class Person2 implements Cloneable{public int age;public Money1 m;public Person2(int age) {this.age = age;this.m = new Money1();//在构造方法中实例化一个money}@Overridepublic String toString() {return "Person{" +" age=" + age +" }";}@Overrideprotected Object clone() throws CloneNotSupportedException {Person2 tmp = (Person2) super.clone();//tmp.m类的调用成员变量，this.m.clone()中的this是指这个对象的成员变量m的引用tmp.m = (Money1) this.m.clone();//谁调用某个方法谁就是this，现在是person1来调用，那么person1就是thisreturn tmp;}
}
public class Test5 {public static void main(String[] args) throws CloneNotSupportedException{Person2 person1 = new Person2(10);Person2 person2 = (Person2) person1.clone();System.out.println(person1.m.money);System.out.println(person2.m.money);System.out.println("===============");person2.m.money = 99.9;System.out.println(person1.m.money);System.out.println(person2.m.money);   }
}

这时候我们把Money1类也进行实现了Cloneable的接口，这时候我们再对clone方法的重写，
但是我们会发现两者的重写的clone方法不同，在Person2类中的重写方法，创建一个临时变量tmp，通过将其向下转型变成了Person2类型，tmp.m是Person2类的调用成员变量m，this.m.clone()就是person1正在调用clone方法，这个时候先访问了Pesron2类中成员变量m，再去通过Money1类的实例化之后再调用clone方法，这个时候最终是Money1这个类型去调用这个方法；
但是我们会发现tmp是局部变量，除了生命作用域就会销毁，但是最终返回的是给person2，又因为person2是引用类型，会得到了tmp的地址。

所以我们可以通过图例来演示一下这个过程：

在虚拟机栈上，会创建两个空间分别是person1和person2，还有一个在person类中创建一个临时变量tmp，
因为是把对象的对象进行克隆，所以要再类中的另一个类（该类作为成员变量）中重写clone方法，但是在原有的类中的clone方法也需要进行修改
person1所实例化的对象会在堆上创建一个对象的空间（地址为0x98），存入两个成员变量，但是其中m是Money类型即是引用类型，
并且也是实例化了，所以那么也会是创建money类型的对象的空间（地址为0x65），这时候在对中的成员变量m也会得到它实例化的地址
因为我们还在Person类中修改了重写方法；通过创建了一个临时变量tmp也是为Person类型，先把外面的对象先进行克隆完成，
这时候再通过这个临时变量去调用Person类中的m(其实也就是类的引用),
由于我将m这个变量也进行了Money类的实例化的操作，所以这时候再用m去调用正常的clone方法，从而通过去调用Money类中的clone方法
这个就完成了克隆那么Money类的克隆的地址（0x888)，但是tmp是临时的局部的变量，出了作用域就销毁，最终返回的是给的是person2
[person2 = (Person2) person1.clone()]这个就是返回了person2么
因为它是类类型（引用类型）所以这个时候的person2就会得到它的地址（0x91）
最终person2和person1所指的两个值是不一样

此时这个现象被称之为深拷贝：完全将对象中的对象去进行克隆。

注意：深拷贝与浅拷贝就是看的是代码实现的过程，跟克隆方法没有关系

三、抽象类和接口的区别(面试常考)

(1).抽象类中可以有普通成员方法和成员变量，其中还可以有抽象方法，如果子类继承抽象类，必须要重写抽象类中的抽象方法，如果不想重写抽象方法，那么就要将子类设计为抽象类
一个类可以实现多个接口（模拟多继承），但是类与类之间的继承必须是单继承的关系，继承用extends关键字
(2).接口中不可以有普通的成员方法和成员变量，它的成员变量默认是public static final修饰，成员方法默认是public abstract修饰，如果类要实现接口，就要重写接口中的抽象方法
实现用implements关键字，接口之间也可以继承多个接口（这种操作也是多继承），这种操作不用父接口的抽象方法；但是用类实现时，要注意重写接口与被继承接口的所有的抽象方法。

这期内容就分享到这里了，希望大家可以获得新的知识，当然，如果有哪些细节和内容不足，欢迎大家在评论区中指出！