8-抽象类和接口_抽象类接口-CSDN博客

本文链接：https://blog.csdn.net/m0_72536301/article/details/129716744

一.抽象类

1.1 抽象类的概念

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

比如，动物类都有自己的name，有age，都会eat，但是根据这些成员我们能判断出动物是什么吗？

是一条狗？一只猫？还是一条鱼？又或者四不像？

动物选手1号

动物选手2号

动物选手3号

潜力选手4号

我们先给动物类定义一些属性和行为

class Animal {
//定义成员变量
String name;
int age;

//定义吃饭行为
public void eat() {
System. out.println(this.name+"在吃饭！");
}
}

再来定义继承动物的狗类和猫类

class Dog extends Animal {
public void eat() {
System. out.println(this.name+"在啃骨头！");
}
}

class Cat extends Animal {
public void eat() {
System. out.println(this.name+"在摸鱼！");
}
}

观察上面的代码就会发现，猫类和狗类都把eat方法重写了，说明Animal类里面的eat方法不需要具体的实现代码，可以改成这样

class Animal {
String name;
int age;

public void eat() {
}
}

为了让代码更简洁，可不可以不要'{}'，而是直接在这个方法的后面加上' ; '呢

实际上是可以的，但是需要借助abstract关键字，表示这是一个抽象方法

public abstract void eat() ;

像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstract method), 包含抽象方法的类我们称为抽象类

1.2 抽象类的特性

下面的内容会很多，各位看官一定要耐心！

1.抽象类和抽象方法前必须要有abstract修饰

2.抽象类中可以有普通成员变量或方法

3.抽象类可以没有抽象方法，有抽象方法的类一定是抽象类

4.抽象类不能实例化

5.如果一个普通类继承了抽象类，这个普通类就要重写抽象类中的所有未被重写的抽象方法

6.如果一个类不想全部重写抽象类的抽象方法，这个类也要被定义成抽象类

如果觉得有点绕，不防看看下图图解

先是定义了一个抽象类Animal，类体里面有抽象方法eat和sleep

定义了Fish类来继承Animal，但是这个类只是重写了sleep方法，所以Fish也必须是抽象类

定义了GoldFish类继承鱼类，如果想让GoldFish实例化出一个金鱼，就必须把它定义成普通类，所以它必须重写未被重写的抽象方法eat

总而言之，所有被普通类继承的抽象方法至少要被重写一次

你以为这就完了？其实还有两条规则😆

7.抽象类方法要满足被重写的要求（不能被private，static，final修饰，不能是构造方法）

8.抽象类中可以存在构造方法，在子类实例化时帮助父类成员初始化

为了便于更好的理解上面的规则，我们上代码看一下

1.3 抽象类举例

拿我们的固定嘉宾Animal举例吧

下面是Animal类的定义

abstract class Animal {
private String name;
private int age;

//定义Animal类的构造方法
Animal(String name,int age) {
this.name=name;
this.age=age;
}

//定义抽象方法eat和play
public abstract void eat();
public abstract void play();
}

接下来定义一直陪伴我们的朋友---

class Dog extends Animal {

Dog(String name,int age) {
super(name,age);
}

@Override
public void eat() {
System. out.println("汪汪汪~要啃骨头");
}

@Override
public void play() {
System. out.println("汪汪汪~在拿耗子");
}
}

class Cat extends Animal {

Cat(String name, int age) {
super(name, age);
}

@Override
public void eat() {
System. out.println("喵喵喵~在吃鱼");
}

@Override
public void play() {
System. out.println("喵喵喵~在玩毛球");
}
}

结合前面学过的继承和多态，来看看下面的test代码会运行出什么结果吧

public class Test {
public static void func(Animal animal) {
animal.eat();
animal.play();
}
public static void main(String[] args) {
func(new Dog("小白",2));
System. out.println("************************");
func(new Cat("小黑",1));
}
}

运行结果

看到这里，是不是还有疑问？既然普通类可以被继承，也能被重写，为啥非要把Animal定义成抽象类捏？不急，接着往下翻

1.4 抽象类的作用

因为抽象类并不能完整地描述一个实体，对比普通类，抽象类本身不能被实例化，只能创建子类，让子类实例化出对象。可以说抽象类存在的最大意义就是被继承。

所以，定义一个抽象类相当于多了一层编译器的校验。

很多功能不应该由父类去完成，而是应该让子类自己定义，在这种情况下，如果我们不小心new了一个抽象父类，编译器不会袖手旁观。普通父类并没有这个特权。

很多语法存在的意义都是为了 "预防出错", 例如我们曾经用过的 final 也是类似. 创建的变量不允许用户去修改，但是加上 final 能够在不小心误修改的时候, 让编译器及时提醒我们.

二.接口

2.1 接口的概念

在现实生活中，接口的例子比比皆是，比如下面这个插排

如果你拿着一个两头的充电器，就不能使用这个插排

所以接口就是公共的行为规范标准，只要在实现时符合规范标准，就可以通用

在Java中，接口可以看成是多个类的公共规范

2.2 接口的语法规则

把class换成interface，就可以定义一个接口

public interface 接口名称{
抽象方法
}

接口的定义一般有以下规则（不强制）

1.接口名称前面一般加上'I'修饰
2.接口中的属性和方法一般不加修饰符，保持代码简洁性

2.3 接口的特性

规则也有很多，请冲一杯咖啡慢慢理解

1.接口内的方法都是抽象方法，除了被defult修饰的方法（JDK1.8后引入的）和静态方法

2.接口内的方法默认被public abstract修饰

3.接口内的成员变量都默认被public static final修饰，在定义时要初始化

4.接口不能new出对象

5.接口不能有代码块和构造方法

比如，定义一个插排的充电接口

public interface IChargeUSB {

int capacity=10;//定义一个成员表示容量
private String color="red";//error，不允许有除了public，static，final的其他修饰符

static {
capacity=100;
}//error，接口内部不允许有代码块

//定义一个可以实现的方法
//方法前面不允许添加除了public，abstract以外的修饰符
default void open() {
System. out.println("已经连通，可以充电了！");
}

//定义一个抽象方法
void close();

//定义一个静态方法获取容量
static int getCapacity() {
return capacity;
}
}

既然有了充电接口这个标准，想要使用它就必须与类联系到一起，看看语法是怎么规定的吧

6.一个类想要实现一个接口，需要用implements关联

7.普通类实现了一个接口，就必须重写接口内所有的抽象方法

8.接口内被default修饰的方法可重写可不重写，被static修饰的方法不能被重写

9.如果实现接口的类不想全部重写接口的抽象方法，就必须定义成抽象类

来定义你手上的手机或者面前的电脑实现这个接口吧

public class Phone implements IChargeUSB{

@Override
public void open() {
System. out.println("您的手机已充上电！");
}//被default修饰的方法，可重写可不重写

@Override
public void close() {
System. out.println("您的手机已断开充电线！");
}//抽象方法，必须重写

}

下面来定义电脑

public class Computer implements IChargeUSB{

@Override
public void close() {
System. out.println("您的电脑已断开电源");
}
}

接口和抽象类一样，都可以通过引用子类对象向上转型，从而实现多态，来体会一下吧

public class Test {

public static void func(IChargeUSB usb) {
usb.open();
usb.close();
}

public static void main(String[] args) {
System. out.println("插排容量为："+IChargeUSB. getCapacity());
func(new Phone());
System. out.println("*********************");
func(new Computer());
}
}

输出结果

别看接口不能和类一样实例化，每个接口也都有自己对应的字节码文件

建议每个java文件里只放一个接口或者一个类

2.4 实现多个接口

在继承和多态里面提到，Java中是没有多继承的，但是现实生活中一个类仅仅继承一个父类是不够的

比如Animal类，只能给它定义全部动物的共同属性---name，age，只能给它定义全部动物的共同行为---eat，sleep

但是狗和猫除了会吃饭睡觉，还会撒娇，会捉老鼠，他们还有很多共同的功能...

实现多个接口就是为了解决多继承的问题

一个类只能继承一个基类，可以实现多个接口

来拿Animal举例

abstract public class Animal {
//定义成员变量
private String name;
private int age;

//定义抽象方法
public abstract void eat();
public abstract void sleep();

//定义构造方法
Animal(String name,int age) {
this.name=name;
this.age=age;
}

//定义public方法获取成员变量
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;
}
}

然后我们再定义狗类和猫类的共同功能

//解锁捉耗子功能
public interface ICatch {
void catchMouse();
}

//解锁玩耍功能
public interface IPlay {
void play();
}

这样就可以完善狗和猫了

注意：必须先继承类才能实现接口，也就是说extends必须放在implements的前面

//狗类继承了Animal抽象类，并且实现了ICatch和IPlay接口
public class Dog extends Animal implements ICatch,IPlay{
//帮助完成父类成员初始化
Dog(String name, int age) {
super(name, age);
}

@Override
public void eat() {
System. out.println(getName()+"正在吃狗粮");
}

@Override
public void sleep() {
System. out.println("汪汪汪~"+getName()+"在睡觉");
}

@Override
public void catchMouse() {
System. out.println("汪汪汪~"+getName()+"在拿耗子");
}

@Override
public void play() {
System. out.println("汪汪汪~"+getName()+"在接飞盘");
}
}

public class Cat extends Animal implements ICatch,IPlay{

//帮助完成父类成员初始化
Cat(String name, int age) {
super(name, age);
}

@Override
public void eat() {
System. out.println(getName()+"在吃鱼");
}

@Override
public void sleep() {
System. out.println("喵喵喵~"+getName()+"在晒太阳睡大觉");
}

@Override
public void catchMouse() {
System. out.println("喵喵喵~"+getName()+"在看旺财拿耗子");
}

@Override
public void play() {
System. out.println("喵喵喵~"+getName()+"在玩毛球");
}
}

如果我们想要实现动物的功能或者获取动物的属性，可以接收Animal类的引用，如果想要实现ICatch和IPlay的功能，可以接收ICatch和IPlay的引用

public static void funcAnimal(Animal animal) {
System. out.println("Hello，I'm"+animal.getName()+"我今年"+animal.getAge()+"岁了");
animal.eat();
animal.sleep();
}
public static void funcICatch(ICatch icatch) {
icatch.catchMouse();
}
public static void funcIPlay(IPlay iplay) {
iplay.play();
}

现在到了收获结果的时候了

public static void main(String[] args) {
Dog dog=new Dog("旺财",2);
funcAnimal(dog);
Cat cat=new Cat("小白",1);
funcICatch(cat);
funcIPlay(cat);
}

运行结果

不论是抽象类还是接口，都可以通过向上转型实现多态

我猜你肯定会问到：

为啥还要多增添两个接口？直接把它们的功能给Animal类然后继承不就完事嘛！
答曰：不是所有的动物都会多管闲事去拿耗子，博主就对耗子不感兴趣

使用接口可以让我们忽略类，只要某个对象有这个接口，它就可以实现这个接口的方法

比如再定义一个模型火车

public class Toy implements IPlay{
@Override
public void play() {
System. out.println("呜呜~我会沿着轨道跑");
}
}

这时候只要调用funcIPlay方法，这个火车也可以用来逗隔壁邻居家的傻儿子玩

public static void main(String[] args) {
funcIPlay(new Toy());
}

2.5 接口之间的继承

一个接口可以继承多个接口，从而实现这个接口功能的扩展

接口之间的继承要用到关键字extends，语法规则如下

interface A extends B,C {
}

上面的代码让接口A继承了接口B和接口C，如果有某个类想要实现接口A，就要把接口B和接口C的抽象方法全部重写

你肯定又要问了

为什么不直接把testA,B,C三个功能直接给接口C？还在这里脱裤子放屁
答曰：通过这种接口间相互继承的方式，可以实现代码的低耦合。如果更改了C接口，实现A接口和B接口的类不会受到影响

2.6 常用的接口

下面的接口全部是针对自定义类型

2.6.1 数组排序Comparable

先定义一个学生类

class Students {
//定义学生类成员变量，姓名，身高，成绩
String name;
int height;
double score;

//定义构造方法
public Students(String name, int height, double score) {
this.name = name;
this.height = height;
this.score = score;
}
}

现在全班有20个学生，他们班主任面前有个两难的问题，究竟是按身高还是按成绩给学生排座呢？

先不管班主任的问题，你有没有想过这些学生能排序吗？

对于类型元素是基本数据类型的数组，可以用Arrays.sort()实现排序

public static void main(String[] args) {
int[] array={2,5,9,3,0};
Arrays. sort(array);
System. out.println(Arrays. toString(array));
}
输出结果
[0, 2, 3, 5, 9]

对于一个学生数组，Arrays还能帮助排序吗？

public class Test {
public static void main(String[] args) {
Students[] st=new Students[3];
st[0]=new Students("喜羊羊",125,98);
st[1]=new Students("美羊羊",115,80);
st[2]=new Students("懒羊羊",120,60);
Arrays. sort(st);
for(Students e:st) {
System. out.println(e);
}
}
}

运行结果就是：

点开异常，就会发现sort其实是把数组元素转换成了Comparable接口，并且调用了这个接口的compareTo方法，所以只要学生类实现了这个接口并且重写了compareTo方法，就可以实现排序

所以重新定义一下学生类，让它可以按照身高排序

我们先使用这种规则重写compareTo方法

如果自己的身高大于要对比对象的身高，返回一个大于0的整形数字

//实现Comparable接口
class Students implements Comparable<Students>{
    String name;
    int height;
    double score;
    public Students(String name, int height, double score) {
        this.name = name;
        this.height = height;
        this.score = score;
    }

//重写toString方法
    @Override
    public String toString() {
        return "Students{" +
                "name='" + name + '\'' +
                ", height=" + height +
                ", score=" + score +
                '}';
    }

//重写compareTo方法    
    @Override
    public int compareTo(Students o) {
        return this.height-o.height;//此处如果按照成绩排序，需要将结果强转成int
                                  //(int)(this.score-o.score)
    }
}

来看一下运行结果

从运行结果也可以看出，上面的运行规则可以让学生按照身高的升序排列，也可以推断出compareTo的使用方式

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

为了更好地理解Comparable接口，来用冒泡排序实现一下sort过程

public static void main(Comparable[] array) {
       for(int i=0;i<array.length-1;i++) {
           for(int j=0;j<array.length-i-1;j++) {
               if(array[j].compareTo(array[j+1])>0) {
                   Comparable ret=array[j];
                   array[j]=array[j+1];
                   array[j+1]=ret;
               }
           }
       }
    }

2.6.2 对象比较Comparator

前面的Comparable接口可以让我们实现排序，但也固定了学生排序的方式只能是按照身高，如果慢羊羊村长在上课的时候不想看见打鼾的懒羊羊，就要按照成绩进行排序

如果想实现一个类的多种排序方式，要用到Comparator接口

这时候就可以定义两个类分别实现compare方法

//按照身高排序
class heightComparator implements Comparator<Students> {
@Override
public int compare(Students o1, Students o2) {
return o1.height-o2.height;
}
}

//按照成绩排序
class scoreComparator implements Comparator<Students> {
@Override
public int compare(Students o1, Students o2) {
return (int)(o1.score-o2.score);
}
}

接下来分别按照身高和成绩比较美羊羊和懒羊羊

public class Test {
    public static void main(String[] args) {
        Students st1=new Students("懒羊羊",120,60);
        Students st2=new Students("美羊羊",115,80);
        heightComparator hc=new heightComparator();

        //定义身高比较器
        int ret=hc.compare(st1,st2);
        System.out.print("按照身高排序：");
        if(ret>0) {
            System.out.println(st1.name+">"+st2.name);
        } else if(ret<0) {
            System.out.println(st1.name+"<"+st2.name);
        } else System.out.println(st1.name+"="+st2.name);

        //定义分数比较器
        scoreComparator sc=new scoreComparator();
        ret=sc.compare(st1,st2);
        System.out.print("按照成绩排序：");
        if(ret>0) {
            System.out.println(st1.name+">"+st2.name);
        } else if(ret<0) {
            System.out.println(st1.name+"<"+st2.name);
        } else System.out.println(st1.name+"="+st2.name);
    }
}

2.6.3 对象克隆Cloneable

现在有一个手机对象

public class Phone {
//手机的成员变量
String color;
String brand;
Detail dt;

//手机的构造方法
public Phone(String color, String brand, Detail video) {
this.color = color;
this.brand = brand;
this.dt = video;
}
}

class Detail {
//手机大小
int size=10;
//手机重量
int height=10;
}

这部手机是属于你妈妈的，你正好想换新手机了，觉着妈妈的手机用着不错，想要克隆一部出来

这时候就要使用clone方法

public static void main(String[] args) {
Phone mPhone=new Phone("white","huawei",new Detail());
Phone myPhone=mPhone.clone();
}

上面这串代码是不能使用的，想要使用clone方法就要先了解它的规则

可以看到，clone是Object类下的一个方法，会返回一个Object对象（Object是所有类的祖先，即使这个类没有显式定义继承了Object），这个方法由protected限制，可以被不同包的子类访问，native表示它的底层是由C/C++实现的，后面的抛异常以后再详细解释（目前我也不知道它的语法）

所以我们的目的就明确了，重写clone方法

public class Phone {
    String color;
    String brand;
    Detail dt;

    public Phone(String color, String brand, Detail video) {
        this.color = color;
        this.brand = brand;
        this.dt = video;
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class Detail {
    int size=10;
    int height=10;
}
class test {
    //仔细看main后面的内容，这是处理异常的方式
    public static void main(String[] args) throws CloneNotSupportedException {
      Phone mPhone=new Phone("white","huawei",new Detail());
      
      Phone myPhone=(Phone)mPhone.clone();//返回类型是Object，如果使用Phone接收要向下转型
    }
}

运行一下发现程序抛出了异常

翻译过来就是不支持克隆，解决方法：在克隆的类后面实现Cloneable接口

public class Phone implements Cloneable

实际上这个接口啥也没有实现...

Cloneable接口只是一个标志接口，表示这个类型的对象可以被克隆

所以你拥有了妈妈同款手机

public static void main(String[] args) throws CloneNotSupportedException {
Phone mPhone=new Phone("white","huawei",new Detail());
Phone myPhone=(Phone)mPhone.clone();
System. out.println("妈妈的手机："+mPhone);
System. out.println("我的新手机："+myPhone);//Phone和Detail类要先实现toString的重写，
//下文会给出完整代码
}

你又发现自己的idol王一博换了一个带有摩托图案的手机壳，既然买不起他的手机，就买同款手机壳吧，于是你手机的height属性变重了

myPhone.dt.height=11;
System. out.println("妈妈的手机:"+ mPhone.dt);
System. out.println("我的手机:"+myPhone.dt);

你妈妈奇怪的发现，诶，我手机咋也变沉了？

看图解

因为dt成员是个引用变量，所以它存储的是对象的地址，clone的时候只是把地址拷贝过去了，所以你的手机和妈妈的手机捆绑在一块了，这显然是不合理的

要进行深拷贝，就是把所有的对象都拷贝一遍！

//让手机里的Detail类型的成员进行拷贝，就是让Detail类重写clone方法
class Detail implements Cloneable{
    int size=10;
    int height=10;
    @Override
    public String toString() {
        return "Detail{" +
                "size=" + size +
                ", height=" + height +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

这也是不管用的，问题出在了哪里呢？

看Phone类的clone方法

它的clone方法只是调用了父类的clone，没有做其他的改变

应该改成下面这样

protected Object clone() throws CloneNotSupportedException {
Phone tmp=(Phone)super.clone();//使用Phone变量接收this对象通过父类克隆的对象
tmp.dt=(Detail)this.dt.clone();//拷贝dt并更改tmp指向的dt对象
return tmp;
}

用图来说话就是这样子的

我们再来打印输出刚才的结果

下面是完整的代码

public class Phone implements Cloneable{
    String color;
    String brand;
    Detail dt;

    public Phone(String color, String brand, Detail video) {
        this.color = color;
        this.brand = brand;
        this.dt = video;
    }

    @Override
    public String toString() {
        return "Phone{" +
                "color='" + color + '\'' +
                ", brand='" + brand + '\'' +
                ", dt=" + dt +
                '}';
    }


    @Override
    protected Object clone() throws CloneNotSupportedException {
        Phone tmp=(Phone)super.clone();
        tmp.dt=(Detail)this.dt.clone();
        return tmp;
    }
}
class Detail implements Cloneable{
    int size=10;
    int height=10;
    @Override
    public String toString() {
        return "Detail{" +
                "size=" + size +
                ", height=" + height +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
class test {
    public static void main(String[] args) throws CloneNotSupportedException {
      Phone mPhone=new Phone("white","huawei",new Detail());
      Phone myPhone=(Phone)mPhone.clone();
      System.out.println("妈妈的手机："+mPhone);
      System.out.println("我的新手机："+myPhone);
      myPhone.dt.height=11;
      System.out.println("妈妈的手机:"+ mPhone.dt);
      System.out.println("我的手机:"+myPhone.dt);
    }
}

2.7 Object类

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

也就是说，如果一个类没有显式继承某个基类，它也会默认继承Object类，如果它继承了某个基类，因为这个基类也是Object的子类，所以这个基类的子类多层继承了Object类

Object类提供了很多方法供我们使用

其中的toString和clone已经讲述过，接下来看getClass，hashCode和equals方法（其余的以后会提到）

2.7.1 getClass方法的使用

这个方法就是用来告知类的信息，也不能被重写，没有其他的功能

来看看它的使用

public static void main(String[] args) throws CloneNotSupportedException {
Phone mPhone=new Phone("white","huawei",new Detail());
Class<?> c=mPhone.getClass();
System. out.println(c);
}

输出结果

2.7.2 equals方法

在Java中，如果使用==判断两个对象，实际上比较的使它们的地址

public static void main(String[] args) throws CloneNotSupportedException {
Phone mPhone=new Phone("white","huawei",new Detail());
//克隆妈妈的手机
Phone myPhone=(Phone)mPhone.clone();

System. out.println(mPhone);//此时Phone类还未定义toString方法
System. out.println(myPhone);

System. out.println(myPhone==mPhone);
}

运行结果

但是我的手机在换手机壳之前是克隆的妈妈的手机呀，想更改默认的比较逻辑，让它们相等怎么办？

这时候要在类内部重写equals方法

 @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Phone phone = (Phone) o;
        return Objects.equals(color, phone.color) && Objects.equals(brand, phone.brand) && Objects.equals(dt, phone.dt);
    }

当然了，在自定义类型Detail里也要实现equals的重写，String类有自己的equals方法，调用就管

@Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Detail detail = (Detail) o;
        return size == detail.size && height == detail.height;
    }

你以为这些方法逻辑那么强，还要判断形参是不是null类型，博主考虑地也太周到了吧（嘿嘿，虽然最后一句话是我杜撰的，这个方法也不是我写的，就自夸一下下吧）

用idea快捷生成就行了

这样我们就可以看看根据我们的逻辑，两个手机是否相同了

public static void main(String[] args) throws CloneNotSupportedException {
      Phone mPhone=new Phone("white","huawei",new Detail());
      Phone myPhone=(Phone)mPhone.clone();
      System.out.println(myPhone.equals(mPhone));
}

2.7.3 hashCode方法

实际上我们在重写toString方法的时候见过它，只是我没有提

hashCode方法会返回这个对象的地址

class test {
public static void main(String[] args) throws CloneNotSupportedException {
Phone mPhone=new Phone("white","huawei",new Detail());
Phone myPhone=(Phone)mPhone.clone();
System. out.println(mPhone.hashCode());
System. out.println(myPhone.hashCode());
}
}
运行结果
460141958
1163157884

如果我们想让这两部手机的hash值一样，也可以重写hashCode方法

像生成equals方法一样用idea生成就行了（所有类型都要生成），然后你就会得到下面的代码

Phone类

@Override
public int hashCode() {
return Objects. hash(color, brand, dt);
}

Detail类

@Override
public int hashCode() {
return Objects. hash(size, height);
}

这时候再打印两部手机的hashCode值，就会发现他们是一样的

至于为啥非得重写它们的hashCode方法

事实上hashCode() 在散列表中才有用，在其它情况下没用。在散列表中hashCode() 的作用是获取对象的散列码，进而确定该对象在散列表中的位置。

建议所有自定义类型都把equals和hashCode方法重写一遍，反正用idea就好了

三.抽象类VS接口

下面的部分实际上是前面内容的简单总结

有些类不能完整地描绘出一个实体，就需要用到抽象类

只要有共同的功能，就可以实现同一个接口，接口可以打破类的限制

	抽象类	接口
成员组成	可以有各种成员	只能有public static final修饰的成员变量，只能有static或default修饰的方法或抽象方法
成员权限	可以有各种权限	只能是public权限
定义方式	abstract class	interface
被继承关键字	extends	implements
被继承个数	一个类只能继承一个抽象类	一个类可以实现多个接口
能否实例化	不能	不能