toString：

1.每创建一个类时，都要重写 toString 方法，这是敲代码的基本素养；

2.重写规则：简单明了；

3.String 类中也有toString方法（SUN公司写的）；

equals：

1.每创建一个类时，都要重写 equals 方法（因为 equals 方法比较的是地址，而我们需要比较对象的内容），这也是敲代码的基本素养；

2.作用：用来比较两个对象是否一致 / 相等；

3.重写规则：看自己的需求（你认为什么东西相等的时，对象相同）；

注意：java 中比较基本数据类型大小一律用 “ == ” ，比较引用数据类型用 “ equals方法 ” ； 

辅助理解代码；

import java.util.Objects;
class People{
    private int old;
    private String name;
    public People() {
    }
    public People(int old, String name) {
        this.old = old;
        this.name = name;
    }
    public int getOld() {
        return old;
    }
    public void setOld(int old) {
        this.old = old;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String toString() {
        return "People{" +
                "old=" + old +
                ", name='" + name + '\'' +
                '}';
    }
    //两个人什么时候指的是同一个人？(在此类中只有年龄与名字两种属性的情况下)？那就年龄且名字相同呗
    public boolean equals(Object o) {
        //若导入的对象就是此对象，那肯定相同
        if (this == o) return true;
        //若导入的对象地址为空指针或者对象不是此类的实例，那肯定不同
        if (o == null ||!(o instanceof People)) return false;
        //执行到这里对象 o 一定是 people 的实例，所以可以直接进行向下转型
        People p = (People) o;
        return this.old == p.old && this.name.equals(p.name);
    }
}
class Room{
    //房间号
    private int no;
    //房间类型
    private String type;
    //房间是否空闲
    private boolean status;
    public Room() {
    }
    public Room(int no, String type, boolean status) {
        this.no = no;
        this.type = type;
        this.status = status;
    }
    public int getNo() {
        return no;
    }
    public void setNo(int no) {
        this.no = no;
    }
    public String getType() {
        return type;
    }
    public void setType(String type) {
        this.type = type;
    }
    public boolean isStatus() {
        return status;
    }
    public void setStatus(boolean status) {
        this.status = status;
    }
    public String toString() {
        return "Room{" +
                "no=" + no +
                ", type='" + type + '\'' +
                ", status=" + status +
                '}';
    }
    //俩个房间什么时候指的是同一房间？只要房间号相同，那必然就是一个房间呀
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null ||!(o instanceof Room)) return false;
        Room r= (Room) o;
        return this.no==r.no;
    }
}
public class 重写equals {
    public static void main(String[] args) {
        People p1=new People(10,"张三");
        People p2=new People(20,"张三");
        People p3=new People(10,"李四");
        People p4=new People(10,"张三");
        System.out.println(p1.equals(p2)?"是同一人":"不是同一人");
        System.out.println(p1.equals(p3)?"是同一人":"不是同一人");
        System.out.println(p1.equals(p4)?"是同一人":"不是同一人");
        Room r1=new Room(101,"单人间",true);
        Room r2=new Room(101,"单人间",false);
        Room r3=new Room(201,"单人间",true);
        System.out.println(r1.equals(r2)?"是同一房间":"不是同一房间");
        System.out.println(r1.equals(r3)?"是同一房间":"不是同一房间");
        //简洁明了
        System.out.println(p1);
        //简洁明了
        System.out.println(r1);
    }
}

运行结果：
--------------------------
不是同一人
不是同一人
是同一人
是同一房间
不是同一房间
People{old=10, name='张三'}
Room{no=101, type='单人间', status=true}

Process finished with exit code 0

Object 类中的 finalize ( ) 方法：

1.格式： protected void finalize ( ) throws Throwable   {   方法体    }

2.作用：可以类比静态代码块，因在类加载时，会执行静态代码块中的的代码，所以又称为类加载时机；而在对象内存被垃圾回收器回收时，在其类体中的 finalize ( ) 方法就会执行，所以又叫做垃圾回收时机；

举个栗子：（当qq对象被垃圾回收器回收时，会输出：” qq即将被销毁 “）

class qq{
    protected void finalize() throws Throwable {
        System.out.println("qq即将被销毁！");
    }
}

package与import：
1.package：出现在 java源文件的第一行；格式： package + 包名；

2.import：出现在所有类之上；格式：import + 完整类名 / 包名 . * ;  ，例如：import  java . util . Scanner ；//完整包名，或写成  import  java . util . *  ；//都可以访问” Scanner “类；

3.注意：导包中的 “ * ” 只限于类名，例如：import java.* ； //这样就是错误的；

  访问权限修饰符（按权限大小排序）：

修饰对象：属性（4个都行）/方法（4个都行）/类（public / 默认 ）/接口（public / 默认）

内部类：

1.分类：静态内部类（类似于静态变量）；实例内部类（类似于实例变量）；局部内部类（类似于局部变量）；

2.由于内部类的缺点（代码可读性差；类没有名字，无法重复使用），所以内部类几乎不用；

3.就匿名内部类稍微记一下：

public class pra{
    public static void main(String[] args) {
        //对Math对象中的sum方法进行重写，正常应该找一个子类继承Math，再对其方法进行重写，但也可以通过匿名内部类的方法覆盖对其进行重写：
        int z=new Math(){
            public int sum(int x, int y) {
                return x+y;
            }
        }.sum(1,2);
        System.out.println(z);
    }
}
class Math {
    public int sum(int x,int y){
        return 0;
    }
}

运行结果：
------------------
3

Process finished with exit code 0

随笔：

1..Object 类中的 hashCode 方法：

1)格式： public native int hashCode ( ) ;   （native 表示底层调用C++程序）

2)作用：通过 哈希算法 运算对象内存地址得到的一个值；

举个栗子：

public class pra{
    public static void main(String[] args) {
        Math math1=new Math();
        System.out.println(math1.hashCode()+"------将math1储存的对象内存地址通过哈希算法得到的值");
        Math math2=new Math();
        System.out.println(math2.hashCode()+"------将math2储存的对象内存地址通过哈希算法得到的值");
    }
}
class Math {
}

运行结果：
-------------------
1163157884------将math1储存的对象内存地址通过哈希算法得到的值
1956725890------将math2储存的对象内存地址通过哈希算法得到的值

Process finished with exit code 0

由于博主目前只是一只猿宝宝，所以有些地方可能说的有些片面，若前辈们能够指点一二就更好了      （～￣(OO)￣)ブ

来源：https://www.cnblogs.com/Burning-youth/p/15552666.html