Object类常用类方法

Object类常用类方法

A.equals方法

==是一个比较运算符
 1. ==:既可以判断基本类型，又可以判断引用类型
 2. ==:如果判断基本类型，判断的是值是否相等。例子:int i = 10; double d = 10;
 3. ==:如果判断引用类型，判断的是地址是否相等，及判断是不是同一个对象。
 4.equals:是Object类中的方法，只能判断引用类型
 5.默认判断的是地址是否相等，子类中往往重写该方法，用于判断内容是否相等，例如Integer, String;

public class Equals01 {
	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.ouy.println(bObj == c);//true
	int num1 = 10;
	double num2 = 20;
	System.out.println(num1 == nums2);//true
	}
	/**
	*查看String类的equals源码
	*把Object的equals方法重写了，变成比较两个字符串的值是否相同
	
	public boolean equals(Object anObjec) {
		if (this == anObject) {//如果是同一个对象
			return true;
		}
		if (anObject instanceof String) {//判断类型
			String anotherString = (String) anObject;//向下转型
			int n = value.length;
			if (n == anthorString.value.length) { {//如果长度相同
			char v1[] = value;
			char v2[] = anotherString.value;
			int i = 0;
			while (n-- != 0) {//然后一个个字符比较
				if (v1[i] != v2[i]) 
					return false;
				i++;
				}
			}
		return true;
		*/	

	/**
	*查看Object的equals方法，
	*方法默认就是比较对象的地址是否相同
	*也就是判断两个对象是否为同一个对象
	public boolean equals(Object obj) {
		return (this == obj);
	}
	*/
	
	/**
	*看源码可知Integer也重写了Object的equals方法
	*变成了判了两个值是否相同
	public boolean equals(Object obj) {
		if (obj instanceof Integer) {
			return value == ((Integer) obj).intValue();
		}
		return false;
	}
	*/
	Integer integer1 = new Ineger(1000);
	Integer integer2 = new Ineger(1000);
	System.out.println(integer1 == integer2);//false
	System.out.println(integer1.equals(integer2));//true
	String str1 = new String("LiHuan");
	String str2 = new String("LiHua");
	System.out.println(str1 == str2);//false
	System.out.println(str1.equals(str2));//true
}
	class B{}
	class A extends B{}

如何重写equals方法

（看代码）应用实例：判断Person对象内容是否相等，如果两个Person对象的各个属性值都一样，则返回true，否则返回false

package allDays;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class EqualsExercise01 {
    public static void main(String[] args) {
        Person person01 = new Person("jack", 10, '男');
        Person person02 = new Person("jack", 10, '男');
        System.out.println(person01.equals(person02));

    }
}
//判断Person对象内容是否相等，
// 如果两个Person对象的各个属性值都一样，则返回true，否则返回false
class Person {
    private String name;
    private int age;
    private char gender;


    public Person(String name, int age, char gender) {
        this.gender = gender;
        this.age = age;
        this.name = name;
    }

    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 char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }

    //重写Object的equals方法
    public boolean equals(Object obj) {
        //判断如果比较的两个对象是同一个对象，则直接返回true
        if (this == obj) {
            return true;
        }
        //判断类型
        if (obj instanceof Person) {//是Person，我们才比较
            //进行向下转型，因为我们需要比较obj的各个属性
            Person p = (Person) obj;
            return this.name.equals(p.name) && this.age == p.age && this.gender == p.gender;
        }
        //如果不是Person，则直接返回false
        return false;
    }
}

package allDays;

/**
 * @author: ln
 * @data:
 * @description:equals方法补充练习
 */
public class EqualsExercise03 {
    public static void main(String[] args) {
        int it = 65;
        float fl = 65.0f;
        System.out.println("65和65.0f是否相等?" + (it == fl));//true

        char ch1 = 'A';
        char ch2 = 12;
        System.out.println("65和'A'是否相等？" + (65 == ch1));//t
        System.out.println("12和ch2是否相等？" + (12 == ch2));//t

        String str1 = new String("hello");
        String str2 = new String("hello");
        System.out.println("str1和str2是否相等?" + (str2 == str1));//f

        System.out.println("str1是否equalsstr2？" + (str1.equals(str1)));//t
    }
}

B.hashCode()方法

1.Object类定义的hashCode方法会针对不同的对象返回不同的整数。(这一般是该对象内部地址转换成一个整数来实现。)
2.提高具有哈希结构的容器的xiaolv
3.两个引用，如果指向的是同一个对象，则哈希值肯定是一样的！
4.两个引用，如果指向的是不同对象，则哈希值是不一样的
5.哈希值主要是根据地址号码来的!，不能完全等价与地址值。

package allDays;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class HashCode_ {
    public static void main(String[] args) {
        AA aa = new AA();
        AA aa2 = new AA();
        AA aa3 = new AA();
        System.out.println("aa.hashCode =" + aa.hashCode());
        System.out.println("aa2.hashCode =" + aa2.hashCode());
        System.out.println("aa3.hashCode =" + aa3.hashCode());


    }
}
class AA{}

C.toString()方法

基本介绍:

1）：默认返回:全类名 + @ + 哈希值的十六进制。子类往往会重写toString方法，用于返回对象的属性信息。
2）：重写toString方法，打印对象或则拼接对象时，都会调用该对象的toString形式。
3）：当直接输出一个对象时，toString方法会被默认的调用。

package allDays;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class ToString_ {
    public static void main(String[] args) {
        /*
        Object 的toString()源码
        (1)getClass().getName() 类的全类名(包名 + 类名)
        (2)Integer.toHexString(hashCode()) 将对象的hashCode值转换成16进制字符串
        public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
         */

        Monster monster = new Monster("小妖怪", "巡山的", 1000);
        System.out.println(monster.toString() + "hashcode= " + monster.hashCode());

        System.out.println("==当直接输出一个对象时，toString方法会直接被默认调用===");
        System.out.println(monster);//等价monster.toString()
    }
}
class Monster {
    private String name;
    private String job;
    private double sal;

    public Monster(String name, String job, double sal) {
        this.name = name;
        this.job = job;
        this.sal = sal;
    }

    //重写toString方法，输出对象的属性
    //使用快捷键即可alt + insert -> toString

    @Override
    public String toString() {
        return "Monster{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                ", sal=" + sal +
                '}';
    }

    @Override
    protected void finalize() throws Throwable {
        System.out.println("fin....");
    }
}

D.finalize方法

基本介绍:

1）：当对象被回收时，系统自动调用该对象的finalize方法。子类可以重写该方法，做一些释放资源的操作。
2）：什么时候被回收:当某个对象没有任何引用时，则jvm就会认为这个对象是一个垃圾对象，就会使用垃圾回收机制来销毁该对象，在销毁该对象前，会先调用finalize方法。
3）：垃圾回收机制的调用，是由系统来决定(即有自己的GC
算法)，也可以通过System.gc()主动触发垃圾回收机制。

package allDays;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class ToString_ {
    public static void main(String[] args) {
        Car bwm = new Car("宝马");
        //这时car对象就是一个垃圾，垃圾回收器就会回收(销毁)对象，在销毁对象前，回调用
        //该对象的finalize方法
        //程序员可以在finalize中，写自己的业务逻辑代码(比如释放资源:数据库连接，或则打开文件)
        //如果程序员不重写finalize，那么就会调用Object类的finalize方法，默认处理
        //如果重写了finalize，就可以实现自己的逻辑
        bwm = null;
        System.gc();//主动调用垃圾回收器

        System.out.println("程序退出了.......");
    }
}
class Car {
    private String name;

    public Car(String name) {
        this.name = name;
    }

    //重写finalize

    @Override
    protected void finalize() throws Throwable {
        System.out.println("我们销毁汽车" + name);
        System.out.println("释放了某些资源.....");
    }
}