Java：常用类

绝对路径：完整路径，带上盘符；

相对路径：将该项目作为根目录；

Object类概述：类层次结构的根类，所有的类间接或直接的继承该类；public Object(),建议所有的子类重写该方法；

public int hashCode() 

public final Class getClass()

public String toString()

成员变量：使用private修饰的变量

成员方法：一个无参，一个带所有参数的方法；

成员方法：setXxx/getXxx

toString：自动生成即可

package com.one;
//建议所有子类重写此方法
public class ObjectDemo1 {
    public static void main(String[] args) {
        StudentsClass studentsClass=new StudentsClass();
        studentsClass.setName("小白");
        studentsClass.setAge(15);
        System.out.println(studentsClass);
//        com.one.StudentsClass@4554617c
//        重写tostring方法后
//        StudentsClass{name='小白', age=15}
        System.out.println(studentsClass.toString());
//        com.one.StudentsClass@4554617c
//        重写tostring方法后
//        StudentsClass{name='小白', age=15}

//        public void println(Object x) {  // x=studentsClass
//        String s = String.valueOf(x);
//        synchronized (this) {
//            print(s);
//            newLine();
//        }
//    }

//        public static String valueOf(Object obj) {//obj=x
//            return (obj == null) ? "null" : obj.toString();
//        }

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

package com.one;

public class StudentsClass extends Object {
    String name;
    int age;
    public StudentsClass(){}

    public StudentsClass(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

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

public boolean equals(Object obj)

重写可以比较内容自动重写

public class StudentsClass2 {
    String name;
    int age;
    public StudentsClass2(){}
    public StudentsClass2(String name, int age) {
        this.name = name;
        this.age = age;
    }

    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;
    }

    @Override
    public String toString() {
        return "StudentsClass2{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
//重写equals方法
    @Override
    public boolean equals(Object o) {
//        this-------s1
//        o----------s2
//        比较地址值是否相同，如果相同就返回true
        if (this == o) return true;
//        判断参数是否为null，
//        判断两个对象是否来自于同一个类；
        if (o == null || getClass() != o.getClass()) return false;

        StudentsClass2 that = (StudentsClass2) o;
//        比较年龄是否相同
        if (age != that.age) return false;
//        比较姓名是否相同
        return name != null ? name.equals(that.name) : that.name == null;
    }

}
class ObjectDemo2{
    public static void main(String[] args) {
        StudentsClass2 s1=new StudentsClass2();
        s1.setName("小白");
        s1.setAge(18);

        StudentsClass2 s2=new StudentsClass2();
        s2.setName("小白");
        s2.setAge(18);

        System.out.println(s1==s2);
//        结果为false：因为这里比较的是地址值
        System.out.println(s1.equals(s2));
//        结果为false：
//        public boolean equals(Object obj) {
//        this-----s1
//        ogj------s2
//        return (this == obj);
//    }
//        重写equals方法后结果为true
    }
}

protected void finalize()：

当垃圾收集器确定不在有对该对象的引用时，垃圾收集器在对象上调用该对象。一个子类覆盖了处理系统资源或执行其他清理的finalize方法。

protected Object clone()：

执行特定的克隆工作。

其他包中想要使用被protected使用super关键字调用。

clone的方法object执行特定的操作

首先，如果此类不实现接口Cloneable,则抛出CloneNotSupportExpetion

一个类想要使用clone()，就必须实现Cloneable接口

通过观察API发现，Cloneable接口中没有常量没有抽象方法，今后看到类似的，我们都称之为标记接口。

拷贝在IT行业中常见两种；

浅拷贝：浅拷贝是指我们拷贝出来的对象的内部引用类型变量和原来内部引用类型变量的地址值是一样的，但是整个拷贝出来的对象和原对象不是同一个地址值；

深拷贝：全部拷贝对象的内容，包括内存的引用类型，也进行拷贝，拷贝的时候重新创建一个对象，成员变量值和被拷贝的一样，但是今后在对引用数据类型的变量进行修改，不会影响到原来被拷贝的。

package com.one;
import java.util.Objects;
class Student3 extends Object implements Cloneable{
    private String name;
    private int age;
    private Demo demo;
    public Student3(){}

    public Student3(String name, int age, Demo demo) {
        this.name = name;
        this.age = age;
        this.demo = demo;
    }

    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 Demo getDemo() {
        return demo;
    }

    public void setDemo(Demo demo) {
        this.demo = demo;
    }

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}
public class StudentClass3 {
    public static void main(String[] args)throws CloneNotSupportedException {
        Demo demo = new Demo();
        Student3 s1=new Student3("小白",15,demo);
        System.out.println(s1.toString());
//        Student3{name='小白', age=15, demo=com.one.Demo@4554617c}
        Object obj=s1.clone();
        System.out.println(obj.toString());
//        Student3{name='小白', age=15, demo=com.one.Demo@4554617c}

        //拷贝前的demo与拷贝后demo的地址值做比较
        //发现demo地址值是一样的
        System.out.println( s1.getDemo().hashCode());
//        1163157884
        Student3 s2=(Student3) obj;
        System.out.println(s2.getDemo().hashCode());
//        1163157884

        System.out.println(s1.hashCode());
//        1956725890
        System.out.println(s2.hashCode());
//        1956725890
//         拷贝前整体对象的地址值与拷贝后整体对象的地址值
//        发现拷贝后的地址值与原来对象的地址值不一样
    }
}