Java类Object

int i = 10;
double d = 10.0;
boolean result = (i == d);

public class Equals {
    public static void main(String[] args) {
        A a = new A();
        A b = a;
        A c = b;
        System.out.println(a == c); // true
        System.out.println(b == c); // true
        B bObj = a;
        System.out.println(bObj == c);  // true
    }
}
 
class A extends B{}
class B {}

// 返回一个布尔值
public boolean equals(Object obj) {
	// 上面讲过， == 是判断对象的地址引用是否相等
	// 如果调用者和传入的参数的对象地址相等，则返回true
	return (this == obj);
}

// 返回一个布尔值
public boolean equals(Object anObject) {
	// 判断地址值是否相等，如果相等，则认为两个对象是相等的
    if (this == anObject) {
        return true;
    }
    // 判断传入的对象是否是String类或者是否是子类(因为String类被final修饰，所以没有子类)
    // 如果是的话则进行下一步判断
    if (anObject instanceof String) {
    	// 如果传入的对象是String，则将该对象转为String对象
        String anotherString = (String)anObject;
        int n = value.length;
        // 判断传入的字符串长度是否和调用者的字符串长度相等
        // 如果相等，则进行下一步判断
        if (n == anotherString.value.length) {
        	// 将调用者和传入的字符串转换为char类型的数组
            char v1[] = value;
            char v2[] = anotherString.value;
            int i = 0;
            while (n-- != 0) {
            	// 循环比较数组每个元素是否相等，如果有一个不相等
            	// 则返回false，两个字符串是不相等的
                if (v1[i] != v2[i])
                    return false;
                i++;
            }
            // 如果循环结束还没有返回false的话，则这两个字符串是相等的
            return true;
        }
    }
    // 如果传入的对象不是String类型的，或者两个字符串长度不同，则返回false
    return false;
}

// 返回一个布尔值
public boolean equals(Object obj) {
	// 判断传入的对象是否是Integer类的对象
    if (obj instanceof Integer) {
    	// 如果是的话，将该对象转为Integer类对象，并获取该对象的值
    	// 如果值相等，则返回true，不相等则返回false
        return value == ((Integer)obj).intValue();
    }
    // 如果传入的对象不是Integer类的对象，则返回false
    return false;
}

class Student {
    private String name;
    private int age;
    private char gender;
 
    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
	
	// (省略)get方法和set方法.....
}

    public static void main(String[] args) {
        Student stu1 = new Student("张三", 10, '男');
        Student stu2 = new Student("张三", 10, '男');
        System.out.println(stu1.equals(stu2));
    }

class Student {
    private String name;
    private int age;
    private char gender;
 
    // 重写Object类的equals的方法
    public boolean equals(Object obj) {
        // 首先判断传入的对象和该对象的地址值相同
        // 则直接返回true，  这里this指的是当前对象
        if (this == obj) {
            return true;
        }
        // 判断传入的对象是否是Student类型的对象
        // 如果是，再比较，如果不是，返回false
        if (obj instanceof Student) {
            // 类型转换，将转入的对象转换为Student类型的对象
            // 只有向下转型了，才能够比较两个对象里面的值
            Student stu = (Student) obj;
            // 这里判断的是，如果调用该方法的对象的名字和传入参数对象的名字相等，并且年龄相等，并且性别也相等
            // 则返回true，如果其中一个不相等，这个布尔表达式就会返回false
            return this.name.equals(stu.getName()) && this.age == stu.getAge() && this.gender == stu.gender;
        }
        return false;
    }
 
    public Student(String name, int age, char gender) {
        this.name = name;
        this.age = age;
        this.gender = gender;
    }
    
	// (省略)get方法和set方法.....
}

public static boolean equals(Object a, Object b) {
	return (a == b) || (a != null && a.equals(b));
}

public String toString() {
	// getClass().getName()：返回的是类的全类名(包名+类名)
	// Integer.toHexString()：返回的是将传入的对象转换成16进制的字符串
	// hashCode()：上面讲过，返回的是该对象的哈希值
    return getClass().getName() + "@" + Integer.toHexString(hashCode());
}

class BB {
    private String name;
 
    public BB(String name) {
        this.name = name;
    }
	// （省略）get方法和set方法.....
}

    public static void main(String[] args) {
        BB bb = new BB("小明");
        System.out.println(bb.toString());
    }

class BB {
    private String name;
    
    // （省略）构造器、get方法和set方法.....
 
    public String toString() {
        return "BB{" + "name='" + name + '\'' + '}';
    }
}

public class Finalize {
    public static void main(String[] args) {
        Cat cat = new Cat();
        // 此时，当Cat对象没有被引用的时候，垃圾回收器就会销毁对象
        // 在销毁对象之前，会调用该对象的finalize方法
        // 可以在finalize方法中写入自己的业务代码
        // 如果不重写finalize方法则默认调用Object中的方法
        cat = null;
    }
}
 
class Cat {
    @Override
    protected void finalize() throws Throwable {
        System.out.println("清理垃圾.....");
        System.out.println("销毁对象.....");
    }
}

    public static void main(String[] args) {
        Cat cat = new Cat();
        cat = null;
        System.gc();
        System.out.println("程序退出了...");
    }