雪里温柔，水边明秀，不及Java 抽象类和 Object类

本篇会加入个人的所谓‘鱼式疯言’

❤️❤️❤️鱼式疯言:❤️❤️❤️此疯言非彼疯言
而是理解过并总结出来通俗易懂的大白话,
小编会尽可能的在每个概念后插入鱼式疯言,帮助大家理解的.
🤭🤭🤭可能说的不是那么严谨.但小编初心是能让更多人能接受我们这个概念！！！

在这里插入图片描述

前言

在上一篇面向对象编程的系列中，我们认识了 类和对象，并熟悉了面向对象编程的三大特效

而在本篇文章中将继续围绕着前面的故事展开续写，进行 抽象类和 Object 的讲解

一. 抽象类

1. 抽象类的初识

在面向对象的概念中，所有的对象都是通过类来描绘的，但是反过来，并不是所有的类都是用来描绘对象的

如果一个类中没有包含足够的信息来描绘一个具体的对象，这样的类就是抽象类。

比如：

在这里插入图片描述
在打印图形例子中, 我们发现, 父类 Shape 中的 draw 方法好像并没有什么实际工作, 主要的绘制图形都是由 Shape
的各种子类的 draw 方法来完成的

在这里插入图片描述

像这种没有实际工作的方法, 我们可以把它设计成一个抽象方法(abstractmethod),

包含抽象方法的类我们称为抽象类(abstract class).

2. 抽象类语法

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

abstract public class Shape {

    abstract  public  void draw();

    abstract void calcArea();
    
    // 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
    }
    
    protected double area; // 面积
}

以上现象表明我们的抽象方法是在抽象类中的

故没有抽象类的抽象方法是不存在的 , 换言之，抽象方法必须在抽象类中

并且抽象类中是可以包含 不止抽象方法还有我们普通类的都有的成员变量和成员方法

3.举个栗子

abstract public class Shape {

    abstract  public  void draw();

    abstract void calcArea();

    // 抽象类也是类，也可以增加普通方法和属性
    public double getArea(){
        return area;
    }

    protected double area; // 面积
}


class Triangle extends Shape{

    @Override
    public void draw() {
        System.out.println("正在画三角形！");
    }

    @Override
    void calcArea() {
        System.out.println("正在计算三角形面积！");
    }

}


class Test {
    public static void main(String[] args) {
        Shape s=new Triangle();
        s.draw();
        s.calcArea();
    }
}

在这里插入图片描述
在上面的代码中我们发生了继承，向上转型，动态绑定，多态。

是的，所以我们可以这么说吧，我们的抽象类就是为了多态服务的

下面小编就来说说我们的抽象类的独有的特性吧 💕 💕 💕

4. 抽象类的特性

抽象类不能被实例化对象

在这里插入图片描述

2. 抽象方法不能被 private 修饰

在这里插入图片描述

抽象方法不能被final 和 static 修饰

在这里插入图片描述

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

在这里插入图片描述

抽象类中不一定包含抽象方法，但是有抽象方法的类一定是抽象类

抽象类中可以有构造方法，供子类创建对象时，初始化父类的成员变量

鱼式疯言

全面总结下

有图有真相

在这里插入图片描述

二. Object类

啥是object类呢，这个类是用来干嘛的呢，下面小编来介绍下我们强大的让人发麻的 Object类

1. Obejct 类的初识

Object 是 Java 默认提供的一个类。

Java里面除了 Object类，所有的类都是存在继承关系的。

默认会继承Object父类。

即所有类的对象都可以使用Object的引用进行接收。

2. 举个栗子

在这里插入图片描述
以上想象是不是有发生了向上转型呢，没错，

我们的 new 的子类对象由我们的父类引用来接收，由此发生了向上转型

更充分的说明了一点我们的Object类是所有类的父类，是默认继承下来的

但小伙伴们有没有想过一个问题我们的 Object 类存在是用来做什么的呢

小伙伴们先看张图哦，答案马上揭晓 💖 💖 💖

在这里插入图片描述
对于 整个Object类中的方法需要实现全部掌握。

而本篇文章当中，我们主要来熟悉这几个方法：

toString()方法，equals()方法，hashcode()方法

下面让小编带着宝子们逐个分析

3. toString()方法

我们 toString（）方法主要是负责我们的打印工作

<1>. Object类

在Object类中的 tostring()方法是这样的


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

所以就会出现这样的打印

在这里插入图片描述

<2>. 子类

当我们需要打印对象内容时，我们就重写我们的方法

class Preson {

   public int age;
   public String name;

    public Preson(int age, String name) {

        this.age = age;
        this.name = name;
    }

    @Override
    public String toString() {
        return "Preson{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}


class  Test {
    public static void main(String[] args) {
        Preson preson=new Preson(18,"小罗");
        System.out.println(preson);

    }


}

在这里插入图片描述

这时就发挥了我们 toString（）方法的打印的效果

鱼式疯言

当我们未重写toString方法时打印的是伪地址

当我们重写了toString方法时打印的是当前对象的内容

4. equals() 方法

在我们的Java中，用 == 比较时

可能会出现以下不同类型的比较

a.如果==左右两侧是基本类型变量， 比较的是变量中值是否相同

b.如果==左右两侧是引用类型变量， 比较的是引用变量地址是否相同

c.如果要比较对象中内容，必须重写 Object中的equals方法，因为equals方法默认也是按照地址比较的：

<1>. Object类

在我们Object类中的 equals方法

// Object类中的equals方法
public boolean equals(Object obj) {
return (this == obj); // 使用引用中的地址直接来进行比较
}

在这里插入图片描述

实际上我们看到当小伙伴们的 false

本质上是比较这两个对象的地址，

因为是new出来的对象，所以地址一定是不一样的

<2>. 子类

那如果宝子们要比较这两个对象的内容是否相等的话就需要 重写我们equals（）方法

class Preson {

   public int age;
   public String name;

    public Preson(int age, String name) {

        this.age = age;
        this.name = name;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Preson preson = (Preson) o;
        return age == preson.age && Objects.equals(name, preson.name);
    }

}


class  Test {
    public static void main(String[] args) {
        Preson preson1=new Preson(18,"小罗");
        Preson preson2=new Preson(18,"小罗");
        int a=10,b=10;

        System.out.println(a==b); // true
        System.out.println(preson1==preson2); // false
        System.out.println(preson1.equals(preson2)); // true

    }


}

这时我们是不是成功了 😁 😁 😁

当我们重写方法时，我们就直接比较对象中所有成员变量的内容，

只有全部都相等，才会返回 true 否则就是 false

鱼式疯言

Object类中 equals 比地址

子类中 equals 比内容

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

5. hashcode（）方法

回忆下我们讲过的toString（）方法的源码：

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

我们看到了hashCode()这个方法，他帮我算了一个具体的对象位置

这里面涉及数据结构，但是小伙伴们还没学数据结构，没法讲述，所以我们只能说它是个内存地址。然后调用Integer.toHexString()方法，将这个地址以16进制输出。

<1>. Object类

public native int hashCode();

该方法是一个native方法，底层是由C/C++代码写的。我们看不到。

我们认为两个名字相同，年龄相同的对象，将存储在同一个位置

如果不重写hashcode()方法，我们可以来看栗子

代码如下：

class Preson {

   public int age;
   public String name;

    public Preson(int age, String name) {

        this.age = age;
        this.name = name;
    }



}


class  Test {
    public static void main(String[] args) {
        Preson preson1=new Preson(18,"小罗");
        Preson preson2=new Preson(18,"小罗");

        System.out.println(preson2.hashCode());
        System.out.println(preson1.hashCode());

    }


}

在这里插入图片描述

从中我们看到了为什么之前 == 返回 false 的原因了，也清楚的明白了打印出的就是我们的地址了

在我们Object类中的 hashcode（）中是用来打印不同对象的不同地址的

如果对象而不在乎它的内容

<2>. 子类

class Preson {

   public int age;
   public String name;

    public Preson(int age, String name) {

        this.age = age;
        this.name = name;
    }


    @Override
    public int hashCode() {
        return Objects.hash(age, name);
    }
}


class  Test {
    public static void main(String[] args) {
        Preson preson1=new Preson(18,"小罗");
        Preson preson2=new Preson(18,"小罗");

        System.out.println(preson2.hashCode());
        System.out.println(preson1.hashCode());

    }


}