JAVA中的一些常用源码方法(toString、equals...)

toString

• 源码格式： public String toString()
  返回对象的字符串表示形式。 这个方法返回一个等于下列值的字符串：
  getClass().getName() + ‘@’ + Integer.toHexString(hashCode())
  如下例程，输出结果：
  timer.MyTime@b4c966a

• 输出引用时，会自动调用该引用的toString方法

• 一般为了使 toString 方法输出的数据简洁易懂，会对 toString 方法进行重写
  如下例程，重写后输出结果：
  1970年1月1日

public class TimeToString {
    public static void main(String[] args) {

        MyTime myTime = new MyTime(1970,1,1);

        String str = myTime.toString();
        System.out.println(str);

        System.out.println(myTime.toString());

        //调用引用时，会自动调用该引用的toString方法
        System.out.println(myTime);
    }
}

//默认继承Object类
class MyTime extends Object{
    int year;
    int month;
    int day;

    public MyTime() {
    }

    public MyTime(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }
    //重写toString方法
    public String toString(){
        return this.year+"年"+this.month+"月"+day+"日";
    }
}

equals

• 源码格式：
  public boolean equals(Object obj){
  return (this == obj);
  }

• equals 用于判断两个对象是否相等。

• 如果判断的是两个对象的引用，则比较的是两个对象的地址。

• 总结：
  java中基本数据类型比较是否相等，使用“==”
  java中所有的引用数据类型（包括字符串（String））使用 equals 来判断是否相等

public class TimeEquals {
    private int year;
    private int month;
    private int day;

    public TimeEquals() {
    }

    public TimeEquals(int year, int month, int day) {
        this.year = year;
        this.month = month;
        this.day = day;
    }

    public static void main(String[] args) {
        TimeEquals timeEquals1 = new TimeEquals(1970,1,1);
        TimeEquals timeEquals2 = new TimeEquals(1970,1,1);
        System.out.println(timeEquals1.equals(timeEquals2));
    }

    public int getYear() {
        return year;
    }

    public void setYear(int year) {
        this.year = year;
    }

    public int getMonth() {
        return month;
    }

    public void setMonth(int month) {
        this.month = month;
    }

    public int getDay() {
        return day;
    }

    public void setDay(int day) {
        this.day = day;
    }
    
    @Override
    public String toString() {
        return "TimeEquals{" +
                "year=" + year +
                ", month=" + month +
                ", day=" + day +
                '}';
    }
    
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        TimeEquals that = (TimeEquals) o;
        return year == that.year &&
                month == that.month &&
                day == that.day;
    }
}

String类已经重写了 toString 和 equals 方法。

hascode 方法：

• 源码格式：public native int hashCode();
• 这个方法不是抽象方法，带有 native 关键字，底层调用C++程序
• hashCode() 方法返回的是哈希码，是java对象的内存地址经过哈希算法得出的一个值，所以hashCode() 方法执行结果可以看做是一个java对象的内存地址。

public class HashCode {
    public static void main(String[] args) {
        HashCode hashCode = new HashCode();
        System.out.println(hashCode.hashCode());
        Test test = new Test();
        System.out.println(test.hashCode());
    }
}
class Test{
}

//运行结果：
284720968
793589513

Process finished with exit code 0

clone 方法：

• 源码格式：
  protected native Object clone() throws CloneNotSupportedException;

• 由 native 可见这也是底层调用C++程序

• 克隆的对象可能包含一些已经修改过的属性，保留着你想克隆对象的值，而new出来的对象的属性全是一个新的对象，对应的属性没有值，所以我们还要重新给这个对象赋值。即当需要一个新的对象来保存当前对象的“状态”就靠clone方法了

• 复制引用：
  Person p = new Person(23, “zhang”);
  Person p1 = p;
  

  复制对象：
  Person p = new Person(23, “zhang”);
  Person p1 = (Person) p.clone();
  
  图片来源：https://www.cnblogs.com/xzwblog/p/7230788.html

• 浅克隆：
  被复制对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用仍然指向原来的对象。换言之，浅复制仅仅复制所考虑的对象，而不复制它所引用的对象。

• 深克隆：
  被复制对象的所有变量都含有与原来的对象相同的值，除去那些引用其他对象的变量。那些引用其他对象的变量将指向被复制过的新对象，而不再是原有的那些被引用的对象。换言之，深复制把要复制的对象所引用的对象都复制了一遍。
  
  图片来源：https://blog.csdn.net/lovezhaohaimig/article/details/80372233
  Object o指的是克隆的对象中的引用所指向的另一个对象

public class CloneTest{
    public static void main(String[] args) throws CloneNotSupportedException {
        Student student1 = new Student(20,"张三");
        Student student2 = (Student) student1.clone();
        student2.setAge(22);
        student2.setName("王五");
        System.out.println("年龄："+student1.getAge()+"，姓名："+student1.getName());
        System.out.println("年龄："+student2.getAge()+"，姓名："+student2.getName());
    }
}
class Student implements Cloneable{
    private int age;
    private String name;

    public Student() {
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

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

    @Override
    public Object clone() throws CloneNotSupportedException {
        return super.clone();       //调用Clone()返回的是父类的clone对象
    }
}
//运行结果：
年龄：20，姓名：张三
年龄：22，姓名：王五

Process finished with exit code 0

finalize 方法（不重要）：

• 源码格式：
  protected void finalize() throws Throwable { }
• 这个方法从JDK9开始已经被弃用了
  源码中标注：@Deprecated(since=“9”)
  
• 这个方法不需要手动调用，JVM垃圾回收器负责调用，在垃圾回收时调用。
• 一般用来记录对象在JVM中被释放时的时间，即记录对象内存被释放的时间

public class TrashTest {
    public static void main(String[] args) {
        for(int i = 0 ; i < 10 ; i++){
            Boom tt = new Boom();
            tt = null;
            System.gc();           //建议启动垃圾回收器，运行阈值低了很多
        }
    }
}
class Boom{
    protected void finalize() throws Throwable{
        System.out.println(this+"即将被销毁");
    }
}

//运行结果（一部分）：
trash.Boom@33f40650即将被销毁
trash.Boom@78a6d9d9即将被销毁
trash.Boom@184ec5b4即将被销毁
trash.Boom@3759e3f0即将被销毁

Process finished with exit code 0