javase-object-210324-01

javase-object-210324-01

• 重写toString()
• 重写equals()
• 重写finalize()
• 重写hashCode()

---

Object下的类

---

重写toString()

/**
 * 重写toString方法
 * 如果输出类，会默认调用toString()
 * @author Administrator
 *
 */

public class Test01 {
	public static void main(String[] args) {
		People01 p = new People01("白光一","男");
		System.out.println(p);		// 默认调用
		System.out.println(p.toString());
		// 姓名：白光一 , 性别：男
 	}
}

class People01{
	private String name;
	private String sex;
	
	public People01() {}
	
	public People01(String name,String sex) {
		this.name = name;
		this.sex = sex;
	}
	
	public String getName() {
		return name;
	}
	public void setName(String name) {
		this.name = name;
	}
	public String getSex() {
		return sex;
	}
	public void setSex(String sex) {
		this.sex = sex;
	}

	@Override
	public String toString() {
		return "姓名：" + this.name + " , 性别："+this.sex;
	}
}

---

重写equals()

/*
 	重写equals() 
 	
 	源码如下：
	 	public boolean equals(Object obj) {
	        return (this == obj);
	    } 
	默认使用 == 比较，，，
	
	==  如果比较的的是引用对象，，则比较的是两个对象的内存地址
	
	String类中已经重写了equals() 方法
	
	当我们想比较两个对象的时候，，，必须重写equals()方法
	
	引用类型必须用 equals()方法 判断
	基本类型可以使用 == 判断
	
 */

public class Test02 extends Object{
	public static void main(String[] args) {
		People02 p1 = new People02("白光一","男",new Address("郑州","中原区"));
		People02 p2 = new People02("白光一","男",new Address("郑州","中原区"));
		People02 p3 = new People02("白光一","男",new Address("郑州","金水区"));
		People02 p4 = new People02("白光一01","男",new Address("郑州","中原区"));
		boolean flag01 = p1.equals(p2);
		boolean flag02 = p1.equals(p3);
		boolean flag03 = p1.equals(p4);
		boolean flag04 = p1.equals(p1);
		System.out.println(flag01);		// true
		System.out.println(flag02);		// false
		System.out.println(flag03);		// false
		System.out.println(flag01);		// true
		
//		boolean b = new Address("河南","郑州").equals(new Address("河南","新乡"));
//		System.out.println(b);  //false
	}
}


class People02{
	private String name;
	private String ID;
	Address address;
	
	public People02(){}
	public People02(String name,String ID,Address address) {
		this.name = name;
		this.ID = ID;
		this.address = address;
	}
	
	// 重写equals()方法，，，当人的姓名，ID，地址相同的时候才是一个人
	@Override
	public boolean equals(Object obj) {
		if(obj == null || !(obj instanceof People02))
			return false;
		
		if(this == obj) {
			return true;
		}
		
		People02 p = (People02)obj;
		if(this.name.equals(p.name) && this.ID.equals(p.ID) && this.address.equals(p.address))
			return true;
		
		return false;
	}
}

class Address{
	private String privace;			// 省份
	private String streetNum;		// 街道号码
	public Address() {}
	public Address(String privace,String streetNum) {
		this.privace =privace;
		this.streetNum = streetNum;
	}
	
	// 重写equals()方法，比较省份，街道是否一样
	@Override
	public boolean equals(Object obj) {
		if(obj == null || !(obj instanceof Address)) {
			return false;
		}
		
		if(this == obj) {
			return true;
		}
		
		Address a = (Address)obj;
		if(this.privace.equals(a.privace) && this.streetNum.equals(a.streetNum)) {
			return true;
		}
		
		return false;
	}
}

---

重写finalize()

 1.
 	垃圾回收finalize()
 	源码：jdk9之后就不建议使用了
	 	@Deprecated(since="9")
	    protected void finalize() throws Throwable { }

2.
	finalize()方法中只有一个方法体，里面没有代码，而且这个方法是被protected

3.
	这个方法需要程序员手动调用，JVM的垃圾回收期负责调用这个方法，
	不像equals，toString....方法是需要写代码调用的
	也就是你只需要在代码里实现就好
	
4.
	finalize()方法执行时机：
		当一个java对象即将被垃圾回收期回收的时候，立即回收期负责调用finalize()
		
5.
	如果希望在对象销毁时机执行一段代码（ 比如说：记录时间，记录日志....），
	只要将这段代码写入finalize()即可
	
6.
	static{...}
		静态代码块在类加载时刻执行，并只执行一次，这是SUN公司准备的类加载时机
        
     finalize()方法
     	同样也是SUN准备的一个时机，这个时机是垃圾回收时机
     	
7.
	Java中的垃圾回收器不是轻易启动的
	如果垃圾太少，或者时间没到等条件下，
	可能会启动，也可能不会启动
	

public class Test01{
    public static void main(String[] args) {
        Person p = new Person();

        // 把对象变成垃圾
        p = null;
//        // 多造垃圾
//        for (int i = 0; i < 20000000; i++) {
//            Person p1 = new Person();
//            p1 = null;
//        }

        // 建议启动垃圾回收器，，，也有可能不启动，几率高些而已
        System.gc();
    }
}

class Person{

    /*
        重写finalize()方法
        Person类型的对象被垃圾回收的时候，JVM垃圾回收器负责调用：p.finalize()
        不用自己调用
     */
    @Override
    protected void finalize() throws Throwable {
        System.out.println("我即将被销毁！！！！");
    }
}

---

重写hashCode()

	hashCode方法
	源码：  native 表示底层调用了c++的东西
		@HotSpotIntrinsicCandidate
	    public native int hashCode();
	    
	hashCode() 方法返回的的哈希值：
		实际上就是java对象的内存地址，经过哈希算法，得出的一个值，
		所以hashCode()方法返回的值，也可以等同看做一个java对象的地址

public class Test02 {
    public static void main(String[] args) {
        Ha ha = new Ha();
        int hCode = ha.hashCode();
        System.out.println(ha);     // object.Ha@1b6d3586
    }
}

class Ha{ }