【Java SE】抽象类与接口

超、凢脫俗 2024-03-08 03:17 81阅读 0赞

**目录**

【1】抽象类

【1.1】抽象类概念

【1.2】抽象类语法

【1.3】抽象类特性

【1.4】抽象类的作用

【2】接口

【2.1】接口的概念

【2.2】语法规则

【2.3】接口使用

【2.4】接口特性

【2.5】实现多个接口

【2.6】接口间的继承

【2.7】接口使用实例

【2.8】Clonable 接口和深拷贝

【2.9】抽象类和接口的区别

【3】Object类

【3.1】打印对象信息toString方法

【3.2】对象比较equals方法

【3.3】hashcode方法

--------------------

## **【1】抽象类**  ##

### **【1.1】抽象类概念**  ###

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的，**如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类**。

**【比如】**

![87c5c5c66e434084ba27f2ca68517568.png][]

![ab3f52205fc543f0801f56e9a3916d98.png][]

在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape的各种子类的 draw 方法来完成的. 像这种没有实际工作的方法, 我们可以把它设计成一个 **抽象方法(abstract method), 包含抽象方法的类我们称为抽象类(abstract class)**。

### **【1.2】抽象类语法**  ###

在Java中，一个类如果被 abstract 修饰称为抽象类，抽象类中被 abstract 修饰的方法称为抽象方法，抽象方法不用给出具体的实现体。

// 抽象类：被abstract访问修饰符修饰。
    abstract class Shape {
        // 抽象方法：被abstract访问修饰符修饰，没有方法体。
        public abstract void draw();
        abstract void calArea();
    
        // 抽象类也是类，也可以增加普通方法和属性。
        public double getArea() {
            return _arga;
        }
       
        protected double _arga; // 字段：面积
    }

**【注意】**抽象类也是类，内部可以包含普通方法和属性，甚至构造方法。

### **【1.3】抽象类特性**  ###

1.  抽象类不能直接实例化对象

Shape shape = new Shape();
    
    // 编译出错
    Error:(30, 23) java: Shape是抽象的; 无法实例化

1.  抽象方法不能是 private 的

abstract class Shape {
    	abstract private void draw();
    }
    
    // 编译出错
    Error:(4, 27) java: 非法的修饰符组合: abstract和private

**【注意】**抽象方法没有加访问限定符时，默认是public。

1.  抽象方法不能被final和static修饰，因为抽象方法要被子类重写

public abstract class Shape {
    	abstract final void methodA();
    	abstract public static void methodB();
    }
    
    // 编译报错：
    // Error:(20, 25) java: 非法的修饰符组合: abstract和final
    // Error:(21, 33) java: 非法的修饰符组合: abstract和static

1.  抽象类必须被继承，并且继承后子类要重写父类中的抽象方法，否则子类也是抽象类，必须要使用 abstract 修饰。

// 抽象类：被abstract访问修饰符修饰。
    abstract class Shape {
        // 抽象方法：被abstract访问修饰符修饰，没有方法体。
        public abstract void draw();
    
        protected double _area; // 字段：面积
    }
    
    // 矩形类
    class Rect extends Shape {
        private double length;
        private double width;
        Rect(double length, double width){
            this.length = length;
            this.width = width;
        }
        public void draw(){
            System.out.println("矩形: length= "+length+" width= " + width);
        }
        public void calcArea(){
            _area = length * width;
        }
    }
    
    // 圆类：
    class Circle extends Shape{
        private double r;
        final private static double PI = 3.14;
        public Circle(double r){
            this.r = r;
        }
        public void draw(){
            System.out.println("圆：r = "+r);
        }
        public void calcArea(){
            _area = PI * r * r;
        }
    }
    
    // 三角形类：
    abstract class Triangle extends Shape {
        private double a;
        private double b;
        private double c;
        @Override
        public void draw() {
            System.out.println("三角形：a = "+a + " b = "+b+" c = "+c);
        }
        // 三角形：直角三角形、等腰三角形等，还可以继续细化
        //@Override
        //double calcArea(); // 编译失败：要么实现该抽象方法，要么将三角形设计为抽象类
    }

1.  抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类。
2.  抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量。

### **【1.4】抽象类的作用**  ###

抽象类本身不能被实例化, 要想使用, 只能创建该抽象类的子类. 然后让子类重写抽象类中的抽象方法。

有些人可能会说了, 普通的类也可以被继承呀, 普通的方法也可以被重写呀, 为啥非得用抽象类和抽象方法呢?

> 确实如此. 但是使用抽象类相当于多了一重编译器的校验。

使用抽象类的场景就如上面的代码, 实际工作不应该由父类完成, 而应由子类完成. 那么此时如果不小心误用成父类了, 使用普通类编译器是不会报错的. 但是父类是抽象类就会在实例化的时候提示错误, 让我们尽早发现问题。

> 很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量用户不去修改, 不就相当于常量嘛? 但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们。
> 
> 充分利用编译器的校验, 在实际开发中是非常有意义的。

## **【2】接口** ##

### **【2.1】接口的概念** ###

在现实生活中，接口的例子比比皆是，比如：笔记本上的USB口，电源插座等。

![0ec68525560f4672bce8293a334aac66.png][]

电脑的USB口上，可以插：U盘、鼠标、键盘...所有符合USB协议的设备电源插座插孔上，可以插：电脑、电视机、电饭煲...所有符合规范的设备通过上述例子可以看出：**接口就是公共的行为规范标准，大家在实现时，只要符合规范标准，就可以通用。在Java中，接口可以看成是：多个类的公共规范，是一种引用数据类型。**

### **【2.2】语法规则**  ###

接口的定义格式与定义类的格式基本相同，将class关键字换成 interface 关键字，就定义了一个接口。

interface ISharp {
        int size = 10;  // 默认是public static final
        void dorw();    // 默认是public abstract
    
        // 接口中的方法不能实现，如果非要实现需要加default
        public default void func01() {
            System.out.println("默认方法");
        }
    
        // 接口中可以有静态方法
        public static void func02() {
            System.out.println("静态方法");
        }
    }

**【提示】**

1.  创建接口时, 接口的命名一般以大写字母 I 开头。
2.  接口的命名一般使用 "形容词" 词性的单词。
3.  阿里编码规范中约定, 接口中的方法和属性不要加任何修饰符号, 保持代码的简洁性。

### **【2.3】接口使用**  ###

接口不能直接使用，必须要有一个"实现类"来"实现"该接口，实现接口中的所有抽象方法。

public class 类名称 implements 接口名称{
    	// ...
    }

**【注意】**子类和父类之间是extends 继承关系，类与接口之间是 implements 实现关系。

**【接口使用代码实例】**

/** - 定义接口
     */
    interface ISharp {
        public abstract void drow();
    }
    /** - 继承接口
     */
    class Rect implements ISharp {
        @Override
        public void drow() {
            System.out.println("矩形！");
        }
    }
    /** - 继承接口
     */
    class Flower implements  ISharp {
        @Override
        public void drow() {
            System.out.println("花！");
        }
    }
    
    /** - 继承接口
     */
    class Cyclic implements  ISharp {
        @Override
        public void drow() {
            System.out.println("圆！");
        }
    }
    
    public class Main {
        public static void drowMap(ISharp iSharp) {
            iSharp.drow();
        }
        
        public static void main(String[] args) {
            // 接口实现多态：向上转型
            drowMap(new Rect());
            drowMap(new Flower());
            drowMap(new Cyclic());
        }
    }

**【接口实例代码】**

/** - (基础方法)定义接口
     */
    interface USB {
        public abstract void openDevice();
        public abstract void closeDevice();
    }
    
    /** - (继承接口)鼠标
     */
    class Mouse implements USB {
    
        @Override
        public void openDevice() {
            System.out.println("打开鼠标");
        }
    
        @Override
        public void closeDevice() {
            System.out.println("关闭鼠标");
        }
    
        public void click() {
            System.out.println("点击鼠标");
        }
    }
    
    /** - (继承接口)键盘
     */
    class KeyBoard implements USB {
    
        @Override
        public void openDevice() {
            System.out.println("打开键盘");
        }
    
        @Override
        public void closeDevice() {
            System.out.println("关闭键盘");
        }
    
        public void inPut() {
            System.out.println("键盘输入");
        }
    }
    
    /** - 电脑
     */
    class Computer {
        public void powerOn() {
            System.out.println("打开电脑");
        }
        public void powerOff() {
            System.out.println("关闭电脑");
        }
        public void useDevice(USB usb) {
            usb.openDevice();
            if(usb instanceof Mouse) {
                Mouse mouse = (Mouse)usb;
                mouse.click();
             } else if (usb instanceof KeyBoard) {
                KeyBoard keyBoard = (KeyBoard)usb;
                keyBoard.inPut();
            }
            usb.closeDevice();
        }
    }
    
    public class Main {
        public static void main(String[] args) {
            Computer computer = new Computer();
            computer.powerOn();
    
            /* 使用设备(类里面的函数处理类型判断) */
            computer.useDevice(new Mouse());
            computer.useDevice(new KeyBoard());
    
            computer.powerOff();
        }
    }

### **【2.4】接口特性**  ###

1.  接口类型是一种引用类型，但是不能直接new接口的对象。

public class TestUSB {
    	public static void main(String[] args) {
    		USB usb = new USB();
    	}
    } 
    // Error:(10, 19) java: day20210915.USB是抽象的; 无法实例化

1.  接口中每一个方法都是public的抽象方法, 即接口中的方法会被隐式的指定为 **public abstract**（只能是public abstract，其他修饰符都会报错)

public interface USB {
    	// Error:(4, 18) java: 此处不允许使用修饰符private
    	private void openDevice();
    	void closeDevice();
    }

1.  接口中的方法是不能在接口中实现的，只能由实现接口的类来实现 。

public interface USB {
    	void openDevice();
    	// 编译失败：因为接口中的方式默认为抽象方法
    	// Error:(5, 23) java: 接口抽象方法不能带有主体
    	void closeDevice(){
    		System.out.println("关闭USB设备");
    	}
    }

1.  重写接口中方法时，不能使用默认的访问权限。

public interface USB {
        void openDevice(); // 默认是public的
        void closeDevice(); // 默认是public的
    }
    public class Mouse implements USB {
        @Override
        void openDevice() {
            System.out.println("打开鼠标");
        }
        // ...
    }
    // 编译报错，重写USB中openDevice方法时，不能使用默认修饰符
    // 正在尝试分配更低的访问权限; 以前为public

1.  接口中可以含有变量，但是接口中的变量会被隐式的指定为 **public static final**变量

public interface USB {
        double brand = 3.0; // 默认被：final public static修饰
        void openDevice();
        void closeDevice();
    }
    
    public class TestUSB {
        public static void main(String[] args) {
            System.out.println(USB.brand); // 可以直接通过接口名访问，说明是静态的
            // 编译报错：Error:(12, 12) java: 无法为最终变量brand分配值
            USB.brand = 2.0; // 说明brand具有final属性
        }
    }

1.  接口中不能有静态代码块和构造方法。

public interface USB {
        // 编译失败
        public USB(){
        } 
        {} // 编译失败
        void openDevice();
        void closeDevice();
    }

1.  接口虽然不是类，但是接口编译完成后字节码文件的后缀格式也是.class
2.  如果类没有实现接口中的所有的抽象方法，则类必须设置为抽象类
3.  JDL 1.8中：接口中还可以包含default方法。
4.  如果你不想重写接口的方法，将类增加abstract，那么就把这个类定义为抽象类，但是如果这个类被其它类继承，那么就必须重写。

**【总结】**

*  使用interface来修饰接口。
 *  接口当中的成员方法，不能有具体的实现，默认都是public的。
    
     *  抽象方法：默认是public abstract的方法。
     *  JDK1.8开始，允许有可以实现的方法，但是这个方法只能是由default修饰的。
     *  接口中可以有静态方法。
 *  成员变量默认是public static final 修饰的。
 *  接口不能被实例化。
 *  类和接口之间采用implements实现关系。

### **【2.5】实现多个接口**  ###

在Java中，类和类之间是单继承的，一个类只能有一个父类，即**Java中不支持多继承**，但是**一个类可以实现多个接口**。下面通过类来表示一组动物

/** - 基类(动物)
     */
    class Animal {
        protected String _name;
        protected int _age;
    
        /* 构造函数 */
        public Animal(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }

另外我们再提供一组接口, 分别表示 "会飞的", "会跑的", "会游泳的"

/** - 接口(会飞)
     */
    interface IFlying {
        void flyint();
    }
    
    /** - 接口(会跑)
     */
    interface IRunning {
        void running();
    }
    
    /** - 接口(会游泳)
     */
    interface ISwimming {
        void swimming();
    }

接下来我们创建几个具体的动物 猫, 是会跑的

/** - 猫的行为
     */
    class Cat extends Animal implements IRunning {
        public Cat(String name, int age) {
            super(name, age);
        }
        @Override
        public void running() {
            System.out.println("我的名字叫：" + _name + "->我会跑！");
        }
    }

鱼, 是会游的

/** - 鱼的行为
     */
    class Fish extends Animal implements ISwimming {
        public Fish(String name, int age) {
            super(name, age);
        }
        @Override
        public void swimming() {
            System.out.println("我的名字叫：" + _name + "->我会游泳！");
        }
    }

鸭子，会游泳，会跑，会飞

/** - 鸭子行为
     */
    class Duck extends Animal implements IRunning, IFlying, ISwimming {
        public Duck(String name, int age) {
            super(name, age);
        }
    
        @Override
        public void flyint() {
            System.out.println("我的名字叫：" + _name + "->我会飞！");
        }
    
        @Override
        public void running() {
            System.out.println("我的名字叫：" + _name + "->我会飞游跑！");
        }
    
        @Override
        public void swimming() {
            System.out.println("我的名字叫：" + _name + "->我会游泳！！");
        }
    }

**【注意】**一个类实现多个接口时，每个接口中的抽象方法都要实现，否则类必须设置为抽象类。

提示, IDEA 中使用 ctrl + i 快速实现接口

public static void main(String[] args) {
        Cat cat = new Cat("猫", 20);
        cat.running();
        
        Fish fish = new Fish("鱼", 21);
        fish.swimming();
        
        Duck duck = new Duck("鸭子", 32);
        duck.swimming();
        duck.flyint();
        duck.running();
    }

上面的代码展示了 Java 面向对象编程中最常见的用法: 一个类继承一个父类, 同时实现多种接口. 继承表达的含义是 is - a 语义, 而接口表达的含义是 具有 xxx 特性 .

*  猫是一种动物, 具有会跑的特性。
 *  青蛙也是一种动物, 既能跑, 也能游泳。
 *  鸭子也是一种动物, 既能跑, 也能游, 还能飞。

这样设计有什么好处呢? 时刻牢记多态的好处, 让程序猿**忘记类型**. 有了接口之后, 类的使用者就不必关注具体类型,而只关注某个类是否具备某种能力

例如：只要会跑的都可以调用标准方法：

// 此方法：拥有会跑的接口的对象都可以进行传参，并且会自动调用。
    public static void run(IRunning runing) {
        runing.running();
    }
    
    public static void main(String[] args) {   
        // 自动调用行为，对比
        run(cat);
        // run(fish); // 鱼不会跑，所以不可以使用run方法
        run(duck);
    }

### **【2.6】接口间的继承** ###

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

接口可以继承一个接口, 达到复用的效果. 使用 extends 关键字。

**【实例代码】**

/** - 接口(会飞)
     */
    interface IFlying {
        void flyint();
    }
    
    /** - 接口(会跑)
     */
    interface IRunning {
        void running();
    }
    
    /** - 接口(会游泳)
     */
    interface ISwimming {
        void swimming();
    }
    
    /** - 接口的继承
     */
    interface ExtendInterface extends IFlying, IRunning, ISwimming {
    
    }
    
    /** - TestInter这个类需要实现所有的接口
     */
    class TestInter implements ExtendInterface {
    
        @Override
        public void flyint() {
    
        }
    
        @Override
        public void running() {
    
        }
    
        @Override
        public void swimming() {
    
        }
    }

通过接口继承创建一个新的接口 IAmphibious 表示 "两栖的". 此时实现接口创建的 Frog 类, 就继续要实现 run 方法, 也需要实现 swim 方法。

接口间的继承相当于把多个接口合并在一起

### **【2.7】接口使用实例** ###

在学习数组是时候，尝试过给数组进行排序：

public static void main(String[] args) {
        int[] array = {1,3,65,7,8,9,0,3,6};
        Arrays.sort(array);
        System.out.println(Arrays.toString(array)); // 打印结果[0, 1, 3, 3, 6, 7, 8, 9, 65]
    }

**【给对象数组排序方法一】**

再给定一个学生对象数组, 对这个对象数组中的元素进行排序(按年龄排序).

public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三", 12),
                new Student("李四", 23),
                new Student("王五", 42),
                new Student("赵六", 13),
        };
    }

按照我们之前的理解, 数组我们有一个现成的 sort 方法, 能否直接使用这个方法呢?

Arrays.sort(students);
    System.out.println(Arrays.toString(students));
    
    // 报错：
    "C:\Program Files\Microsoft\jdk-11.0.16.101-hotspot\bin\java.exe" "-javaagent:D:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2022.3.2\lib\idea_rt.jar=53241:D:\Program Files\JetBrains\IntelliJ IDEA Community Edition 2022.3.2\bin" -Dfile.encoding=UTF-8 -classpath E:\Code\Java\L20230720_Java\out\production\L20230720_Java Test.Test
    Exception in thread "main" java.lang.ClassCastException: class Test.Student cannot be cast to class java.lang.Comparable (Test.Student is in unnamed module of loader 'app'; java.lang.Comparable is in module java.base of loader 'bootstrap')
    	at java.base/java.util.ComparableTimSort.countRunAndMakeAscending(ComparableTimSort.java:320)
    	at java.base/java.util.ComparableTimSort.sort(ComparableTimSort.java:188)
    	at java.base/java.util.Arrays.sort(Arrays.java:1249)
    	at Test.Test.main(Test.java:39)

仔细思考, 不难发现, 和普通的整数不一样, 两个整数是可以直接比较的, 大小关系明确. 而两个学生对象的大小关系怎么确定? 需要我们额外指定。

让我们的 Student 类实现 Comparable 接口, 并实现其中的 compareTo 方法

class Student implements Comparable<Student> {
        public String _name;
        public int _age;
    
        public Student(String name, int age) {
            this._name = name;
            this._age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "_name='" + _name + '\'' +
                    ", _age=" + _age +
                    '}';
        }
    
        @Override
        public int compareTo(Student s) {
            if (this._age > s._age) {
                return 1;
            } else if (this._age < s._age) {
                return -1;
            } else {
                return 0;
            }
    
        }
    }
    
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三", 12),
                new Student("李四", 23),
                new Student("王五", 42),
                new Student("赵六", 13),
        };
        Arrays.sort(students);
        System.out.println(Arrays.toString(students));
        // 打印结果：[Student{_name='张三', _age=12}, Student{_name='赵六', _age=13}, Student{_name='李四', _age=23}, Student{_name='王五', _age=42}]
    }

在 sort 方法中会自动调用 compareTo 方法. compareTo 的参数是 Object , 其实传入的就是 Student 类型的对象，然后比较当前对象和参数对象的大小关系(按分数来算)。

*  如果当前对象应排在参数对象之前, 返回小于 0 的数字;
 *  如果当前对象应排在参数对象之后, 返回大于 0 的数字;
 *  如果当前对象和参数对象不分先后, 返回 0;

再次执行程序, 结果就符合预期了

[Student{_name='张三', _age=12}, Student{_name='赵六', _age=13}, Student{_name='李四', _age=23}, Student{_name='王五', _age=42}]

**【给对象数组排序方法二】**

class Student {
        public String _name;
        public int _age;
    
        public Student(String name, int age) {
            this._name = name;
            this._age = age;
        }
    
        @Override
        public String toString() {
            return "Student{" +
                    "_name='" + _name + '\'' +
                    ", _age=" + _age +
                    '}';
        }
    }
    
    /* 类似仿函数一样的年龄排序(比较器) */
    class AgeComparator implements Comparator<Student> {
        @Override
        public int compare(Student o1, Student o2) {
            return o1._age - o2._age;
        }
    }
    /* 类似仿函数一样的姓名排序(比较器) */
    class NameComparator implements  Comparator<Student> {
    
        @Override
        public int compare(Student o1, Student o2) {
            return o1._name.compareTo(o2._name);
        }
    }
    
    // 这样也是可以排序的，更灵活一些
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三", 12),
                new Student("李四", 23),
                new Student("王五", 42),
                new Student("赵六", 13),
        };
        AgeComparator comparator1 = new AgeComparator();
        NameComparator comparator2 = new NameComparator();
        Arrays.sort(students, comparator2);
        System.out.println(Arrays.toString(students));
    }

【注意事项】: 对于 sort 方法来说, 需要传入的数组的每个对象都是 "可比较" 的, 需要具备 compareTo 这样的能力. 通过重写 compareTo 方法的方式, 就可以定义比较规则。

为了进一步加深对接口的理解, 我们可以尝试自己实现一个 sort 方法来完成刚才的排序过程(使用冒泡排序) 。

public static void bubbleSort(Comparable[] students) {
        for(int i = 0; i < students.length - 1; i++) {
            for(int j = 0; j < students.length - 1 - i; j++) {
                if(students[j].compareTo(students[j + 1]) > 0) {
                    // 交换
                    Comparable temp = students[j];
                    students[j] = students[j + 1];
                    students[j + 1] = temp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        Student[] students = new Student[]{
                new Student("张三", 12),
                new Student("李四", 23),
                new Student("王五", 42),
                new Student("赵六", 13),
        };
    
        bubbleSort(students);
        System.out.println(Arrays.toString(students));
    }

### **【2.8】Clonable 接口和深拷贝** ###

Java 中内置了一些很有用的接口, Clonable 就是其中之一.

Object 类中存在一个 clone 方法, 调用这个方法可以创建一个对象的 "拷贝". 但是要想合法调用 clone 方法, 必须要先实现 Clonable 接口, 否则就会抛出 CloneNotSupportedException 异常。

![e886db4dd25048a7a3b8457562b941e9.png][]

**【Clonable实例】**

class Person implements Cloneable {
        public int _id;
    
        // 重写克隆方法
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
        // 重写打印方法
        @Override
        public String toString() {
            return "Person{" +
                    "_id=" + _id +
                    '}';
        }
    }
    
    public class Main {
        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person();
            person._id = 99;
    
            // 克隆
            Person personClone = (Person)person.clone();
            // 查看克隆结果
            System.out.println(person);
            System.out.println(personClone);
        }
    }

**【浅拷贝 VS 深拷贝】**

Cloneable 拷贝出的对象是一份 "浅拷贝" 观察以下代码:

class Money {
        public double _m;
    }
    
    class Person implements Cloneable {
        public int _id;
        public Money _money = new Money();
    
        // 重写克隆方法
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    
        // 重写打印方法
    
        @Override
        public String toString() {
            return "Person{" +
                    "_id=" + _id +
                    ", _money=" + _money +
                    '}';
        }
    }
    
    public class Main {
        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person();
            person._money._m = 199;
    
            // 克隆
            Person personClone = (Person)person.clone();
            // 查看克隆结果
            System.out.println("person：" + person._money._m);
            System.out.println("personClone：" + personClone._money._m);
        }
    }
    
    // 打印结果：
    person：199.0
    personClone：199.0

**【视图】**

![bc615d771dff4b76be153cda1e9f34ca.png][]

**【深拷贝想要的结果是将\_money也要拷贝一份】**

class Money implements Cloneable {
        public double _m;
    
        @Override
        protected Object clone() throws CloneNotSupportedException {
            return super.clone();
        }
    }
    
    class Person implements Cloneable {
        public int _id;
        public Money _money = new Money();
    
        // 重写克隆方法
        @Override
        protected Object clone() throws CloneNotSupportedException {
            Person temp = (Person)super.clone();
            temp._money = (Money)this._money.clone();
            return temp;
        }
    
        // 重写打印方法
    
        @Override
        public String toString() {
            return "Person{" +
                    "_id=" + _id +
                    ", _money=" + _money +
                    '}';
        }
    }
    
    public class Main {
        public static void main(String[] args) throws CloneNotSupportedException {
            Person person = new Person();
            person._money._m = 199;
    
            // 克隆
            Person personClone = (Person)person.clone();
            personClone._money._m = 1000;
            // 查看克隆结果
            System.out.println("person：" + person._money._m);
            System.out.println("personClone：" + personClone._money._m);
        }
    }

**【视图】**

![6a876b960b484ba880138edf4c08ca6c.png][]

### **【2.9】抽象类和接口的区别**  ###

抽象类和接口都是 Java 中多态的常见使用方式. 都需要重点掌握. 同时又要认清两者的区别(重要!!! 常见面试题) 。

**核心区别**: 抽象类中可以包含普通方法和普通字段, 这样的普通方法和字段可以被子类直接使用(不必重写), 而接口中不能包含普通方法, 子类必须重写所有的抽象方法。

如之前写的 Animal 例子. 此处的 Animal 中包含一个 name 这样的属性, 这个属性在任何子类中都是存在的. 因此此处的 Animal 只能作为一个抽象类, 而不应该成为一个接口

class Animal {
    	protected String name;
    	public Animal(String name) {
    		this.name = name;
    	}
    }

【再次提醒】 抽象类存在的意义是为了让编译器更好的校验, 像 Animal 这样的类我们并不会直接使用, 而是使用它的子类.万一不小心创建了 Animal 的实例, 编译器会及时提醒我们。

![878989607b6d4be68dffd263ebfca771.png][]

## **【3】Object类**  ##

Object是Java默认提供的一个类。Java里面除了Object类，所有的类都是存在继承关系的。默认会继承Object父类。即所有类的对象都可以使用Object的引用进行接收。

**【范例】**使用Object接收所有类的对象。

class Person{}
    class Student{}
    public class Test {
        public static void main(String[] args) {
            function(new Person());
            function(new Student());
        }
        public static void function(Object obj) {
            System.out.println(obj);
        }
    } 
    //执行结果：
    Person@1b6d3586
    Student@4554617c

所以在开发之中，Object类是参数的最高统一类型。但是Object类也存在有定义好的一些方法。如下：

![55abab589c064144819535e851b5319c.png][]

对于整个Object类中的方法需要实现全部掌握。

本小节当中，我们主要来熟悉这几个方法：toString()方法，equals()方法，hashcode()方法。

### **【3.1】打印对象信息toString方法** ###

如果要打印对象中的内容，可以直接重写Object类中的toString()方法，之前已经讲过了，此处不再累赘。

// Object类中的toString()方法实现：
    public String toString() {
    	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

### **【3.2】对象比较equals方法**  ###

在Java中，==进行比较时： a.如果==左右两侧是基本类型变量，比较的是变量中值是否相同 b.如果==左右两侧是引用类型变量，比较的是引用变量地址是否相同 c.如果要比较对象中内容，必须重写Object中的equals方法，因为equals方法默认也是按照地址比较的：

**【实例代码演示】**

class Person {
        public String _name;
        public int _age;
    
        public Person(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }
    class Student {
        public String _name;
        public int _age;
    
        public Student(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }
    
    public class Test {
        public static void main(String[] args) {
            Person person1 = new Person("张三", 18);
            Person person2 = new Person("张三", 18);
            // 调用Object原本的equals()方法进行比较观察现象。
            System.out.println(person1.equals(person2));
            // 打印结果为false，为什么呢？
        }
    }

![dd3bdc0b51ba4346b37d9b7975e51ed8.png][]

需要重写equals()这个方法：

class Person {
        public String _name;
        public int _age;
    
        public Person(String name, int age) {
            this._name = name;
            this._age = age;
        }
    	
        // 重写equals()方法
        @Override
        public boolean equals(Object obj) {
            if (obj == null) {
                return false ;
            }
    
            if(this == obj) {
                return true ;
            }
    
            // 不是Person类对象
            if (!(obj instanceof Person)) {
                return false ;
            }
    
            Person per = (Person)obj;
            if(this._name.equals(per._name) && this._age == per._age) {
                return true;
            }
    
            return false;
        }
    }
    class Student {
        public String _name;
        public int _age;
    
        public Student(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
            Person person1 = new Person("张三", 18);
            Person person2 = new Person("张三", 18);
            System.out.println(person1.equals(person2));
    
        }
    }

**【总结】**比较对象中内容是否相同的时候，一定要重写equals方法。

### **【3.3】hashcode方法**  ###

回忆刚刚的toString方法的源码：

public String toString() {
    	return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }

我们看到了hashCode()这个方法，他帮我算了一个具体的**对象位置**，这里面涉及数据结构，但是我们还没学数据结构，没法讲述，所以我们只能说它是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出。

**【hashcode方法源码】**

public native int hashCode();

该方法是一个native方法，底层是由C/C++代码写的。我们看不到。 我们认为两个名字相同，年龄相同的对象，将存储在同一个位置，如果不重写hashcode()方法，我们可以来看示例代码：

class Person {
        public String _name;
        public int _age;
    
        public Person(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }
    class Student {
        public String _name;
        public int _age;
    
        public Student(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
            Person person1 = new Person("张三", 18);
            Person person2 = new Person("张三", 18);
            System.out.println(person1.hashCode());
            System.out.println(person2.hashCode());
    
        }
    }
    // 打印结果：
    2083562754
    1239731077

**【注意事项】**两个对象的hash值不一样 。

像重写equals方法一样，我们也可以重写hashcode()方法。此时我们再来看看。

class Person {
        public String _name;
        public int _age;
    
        public Person(String name, int age) {
            this._name = name;
            this._age = age;
        }
    	
        // 重写hashCode()方法
        @Override
        public int hashCode() {
            return Objects.hash(_name, _age);
        }
    }
    class Student {
        public String _name;
        public int _age;
    
        public Student(String name, int age) {
            this._name = name;
            this._age = age;
        }
    }
    
    
    public class Test {
        public static void main(String[] args) {
            Person person1 = new Person("张三", 18);
            Person person2 = new Person("张三", 18);
            System.out.println(person1.hashCode());
            System.out.println(person2.hashCode());
    
        }
    }
    // 打印结果：
    24022538
    24022538

**【注意】**哈希值一样。

**【结论】**

1.  hashcode方法用来确定对象在内存中存储的位置是否相同。
2.  事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

[87c5c5c66e434084ba27f2ca68517568.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/2dcb782e1a7540b193c8692ca0a8a29c.png
[ab3f52205fc543f0801f56e9a3916d98.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/074d65d056c347ee9a78e698b8664a84.png
[0ec68525560f4672bce8293a334aac66.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/5c70e12913854d8d848f72fc0da5cf68.png
[e886db4dd25048a7a3b8457562b941e9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/53dfd7bb3afb40239d4bc28d8ac251ff.png
[bc615d771dff4b76be153cda1e9f34ca.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/010eeb4a4eff446b8f65382348e518a4.png
[6a876b960b484ba880138edf4c08ca6c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/9c4e2a42f4524e86b5b29d66cd243200.png
[878989607b6d4be68dffd263ebfca771.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/ba96dd4299b64450aae21a9807c7c2d8.png
[55abab589c064144819535e851b5319c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/776664af7bdd478b85059cf4e36070a7.png
[dd3bdc0b51ba4346b37d9b7975e51ed8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/08/61bbd918ec914c73a5ba10aac9a386e7.png