java学习日记-Object类

最新推荐文章于 2023-03-23 00:27:58 发布

人间味是清欢

最新推荐文章于 2023-03-23 00:27:58 发布

阅读量279

点赞数

分类专栏：后端 java 文章标签： java 学习后端 eclipse

本文链接：https://blog.csdn.net/shy_love1/article/details/124356495

版权

java 同时被 2 个专栏收录

39 篇文章 0 订阅

订阅专栏

后端

23 篇文章 0 订阅

订阅专栏

1. Object类

Object是所有类的父类或者祖宗类

如果一个类没有定义父类，那么它的父类就是Object类

Object类路径为 java.lang.Object

数组对象，实现类对象以看做是Object类的子类对象

public class Object { 
	
    //获取当前对象的类对象
    public final native Class<?> getClass();
    
	//获取哈希值
    public native int hashCode();
    
    //比较两个对象是否相等
    public boolean equals(Object obj) {
        return (this == obj);
    }
    
    //定义打印对象的表现形式
    public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
    }
    //对象回收的回调方法
    protected void finalize() throws Throwable { }
    
    //关于线程的方法
    public final native void notifyAll();
    public final native void notify();
    public final native void wait(long timeout) throws InterruptedException;
    public final void wait(long timeout, int nanos) throws InterruptedException {
    	//方法体
    }
    public final void wait() throws InterruptedException {
        wait(0);
    }

}

1.1 getClass()

public final native Class<?> getClass();

getClass()获取该对象的类对象，就是该对象的数据类型,该方法无法重写。

package com.qf;

public class Demo01 {

	public static void main(String[] args) {
		
		Student s1 = new Student();
		Student s2 = new Student();
		
		/*
		 * getClass()  返回的当前对象的类对象，说白了返回的就是   数据类型  
		 *  - 我们可以通过此方法，判断两个对象是不是一种数据类型
		 */
		Class c1 = s1.getClass();
		Class c2 = s2.getClass();
		//com.qf.Student
		System.out.println(c1);
		System.out.println(c2);
		System.out.println(c1 == c2);
		
		/*
		 * 数组的对象，也被看做是Object子类对象
		 */
		String[] arr = new String[5];
		//class [I ,  class [D , class [Ljava.lang.String;
		System.out.println(arr.getClass()); 
		System.out.println(arr.hashCode());
		
		
	}
}

/*
 * 1. Student没有定义父类，那么默认父类为Object类
 * 2. Student类就继承Object类中所有的非私有的属性和方法
 */
class Student {
	
	//重写父类的hashCode()方法
	public int hashCode() {
		return 1111;
	}

}

1.2 hashCode()

public native int hashCode();

hashCode()获取对象在堆内存中地址的一种整数的表现形式，记住是一种表现形式，不是对象的地址，子类可以重写hashCode()方法，可以自己定义表现的形式。

package com.qf;

public class Demo01 {

	public static void main(String[] args) {
		
		Student s1 = new Student();
		Student s2 = new Student();
		
		/*
		 * hashCode() 返回当前对象的内存地址，是一种整数的表现形式
		 * 1. 不同的对象，hashCode值会最大程度的不相等
		 * 		会最大程度的让两个对象的hashCode值不相等
		 * 2. 我们可以重写hashCode()方法
		 * 		意思我们想把内存中的表现形式，按照我们的意愿表现，但是对象该保存在什么位置还是在什么位置
		 */
		int hc1 = s1.hashCode();
		int hc2 = s2.hashCode();  // 341223
		
		System.out.println(hc1);
		System.out.println(hc2);
			
	}
}

/*
 * 1. Student没有定义父类，那么默认父类为Object类
 * 2. Student类就继承Object类中所有的非私有的属性和方法
 */
class Student {
	
	//重写父类的hashCode()方法
	public int hashCode() {
		return 1111;
	}

}

1.3 equals()

equals()用于判断两个对象是否相等

如果子类不重写equals方法，执行的就是Object中定义equals方法，逻辑很简单，除了自己和自己比较为true，其他任何情况都为false。
如果子类重写了equals方法，那就按照子类的逻辑进行比较

    public boolean equals(Object obj) {
        return (this == obj);
    }

参数数据类型为Object，可以传递任何类型数据
该方法可以重写，按照自己的逻辑判断两个对象是否比较相等
重写equals方法时，也要重写hashCode方法，让两个equals为true的对象，hashCode值也相同

package com.qf;

public class Demo02 {

	public static void main(String[] args) {
		
		/*
		 * Object类型源码：
		  
		  public boolean equals(Object obj) {
		  	 return (this == obj);
		  }
		  
		 * 1. 所有的对象都可以调用该方法，比较和其他对象是否相等
		 * 2. 参数类型为Object,可以赋值任意类型数据
		 * 3. 默认比较的形式为  ==     默认除了自己和自己比较为true，其他任何形式都为false
		 */
		
		Person p1 = new Person();
		Person p2 = new Person();
		
		p1.codeId = "111";
		p2.codeId = "222";
		
		boolean r1 = p1.equals("ddd");	// p1 == "ddd"
		boolean r2 = p1.equals(p2);		// p1 == p2 (Object中方法)
		boolean r3 = p1.equals(p1);     // p1 == p1
		
		boolean r4 = p1.equals(null);    
		
		System.out.println(r1);
		System.out.println(r2);
		System.out.println(r3);
		System.out.println(r4);
		
		/*
		 * 实现逻辑，如果两个Person对象，他们的codeId属性相同，那么两个对象就相等（r2结果为true）
		 */
		
	}
}

/*
 * 1. Person没有定义父类，那么默认父类为Object类
 * 2. Person类就继承Object类中所有的非私有的方法
 */
class Person {
	//身份证号码
	String codeId;
	
	/*
	 * 重写equals方法
	 * 如何两个Person对象的cardId属性相同，则返回true
	 */
    public boolean equals(Object obj) {
    	
    	//1. 如果obj为null，直接返回false
    	if (obj == null) {
    		return false;
    	}
    	
    	//2. 如果传递的参数就是自己，直接返回true
    	if (this == obj) {
    		return true;
    	}
    	
    	//3. 如果传递的参数类型不是Person类型的对象，直接返回false
    	if(this.getClass() != obj.getClass()) {
    		return false;
    	}
    	
    	/*
    	 * 数据类型往下转
    	 * 
    	 * Pet p = new Dog();
    	 * 
    	 * Dog d = (Dog)p;
    	 */
    	
    	Person p = (Person) obj;
    	
        return (this.codeId == p.codeId);
    }
	
}

/*
 *  定义员工类， 有两个属性，姓名和员工编号 
 *  如果两个员工对象，员工编号相等，那么两个对象相等
 */

package com.qf;

public class Demo02_2 {
 
	public static void main(String[] args) {
		// equals()  
		
		Emp e1 = new Emp();
		Emp e2 = new Emp();
		e1.code = "aaa";
		e2.code = "aaa";
		
		boolean r1 = e1.equals(e2); // e1 是不是和e2相等  	e1 == e2
		boolean r2 = e1 == e2;		//如何时候，两个对象进行==比较，结果一定为false
		System.out.println(r1);
		System.out.println(r2); 
		
		
		System.out.println(e1.hashCode());
		System.out.println(e2.hashCode());
		/*
		 * Object中的equals()方法，不再使用了
		 * 新需求：如果两个Emp对象，他们的编号相等，那么两个对象就相等（equals方法结果为true）
		 */
		
	}
}

class Emp {
	String name;
	String code;
	
	
	   /*
	    * 通过手动选择属性，来自动生成重写后的equals
	    * 1. 右击
	    * 2. 选择source
	    * 3. Generate hashCode() and equals()
	    * 4. 选择对应的属性
	    * 	4.1 如果两个该类的对象，这些属性相等，equals的结果为true
	    * 	4.2 这些对象的hashCode值也会表现的相等 （做假要做全乎）
	    */
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((code == null) ? 0 : code.hashCode());
		return result;
	}
	
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Emp other = (Emp) obj;
		if (code == null) {
			if (other.code != null)
				return false;
		} else if (!code.equals(other.code))
			return false;
		return true;
	}
}

1.4 toString()

toString()定义打印对象时，显示的样式，子类可以重写该方法，自定义显示该对象的属性值

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

Object定义toString默认打印的是类路径+@+hashCode值转化为16进制的字符串
子类可通过手动选择属性，选择打印对象时，显示的属性

package com.qf;

public class Demo03 {

	public static void main(String[] args) {
		
		
		/*
		 * 
		       public String toString() {
			       return getClass().getName() + "@" + Integer.toHexString(hashCode());
			   }
			   
			   类的路径 + @ + hashCode值转化为16进制的字符串
			  
			 打印出来的这种形式，我们根本看不懂
			 
			 我们打印一个对象的目的：看这个对象中的属性值   
			 	父类中toString方法，是不能满足我们的需求的，我们可以重写toString方法
		 */
		
		Computer c = new Computer();
		c.setBrand("acer");
		c.setPrice(8900.0);
		c.setCpu("i7");
		
		/*
		 * 打印一个对象  ：  com.qf.Computer@15db9742
		 * 			   com.qf.Computer@15db9742
		 * 
		 * 当我们打印一个对象时，默认打印的是该对象执行toString()方法返回的字符串
		 */
		String str = c.toString();
		System.out.println(c);
		
		
		//把前面的类，全部生成打印所有属性的toString方法
	}
}

class Computer {
	private String brand;
	private double price;
	private String cpu;
	
	public String getBrand() {
		return brand;
	}
	public void setBrand(String brand) {
		this.brand = brand;
	}
	public double getPrice() {
		return price;
	}
	public void setPrice(double price) {
		this.price = price;
	}
	public String getCpu() {
		return cpu;
	}
	public void setCpu(String cpu) {
		this.cpu = cpu;
	}

	
	/*
	 * 重写了toString ， 我们就看打印一个对象的属性值
	 * 
	 * 我们也可以通过手动选择属性，自动生成toString方法
	 * 1. 右击
	 * 2. source
	 * 3. Generate toString()
	 * 4. 选择打印一个对象时，显示哪些属性值
	 */
	@Override
	public String toString() {
		return "Computer [brand=" + brand + ", price=" + price + ", cpu=" + cpu + "]";
	}
	
}

1.5 finalize()

gc:java垃圾回收，jvm会自动回收堆中垃圾对象，目的释放内存

垃圾对象：没有变量指向到该对象，意思这个对象没有用了

finalize()就是该对象被回收时，执行的方法

protected void finalize() throws Throwable { }

package com.qf;

public class Demo04 {

	public static void main(String[] args) {
		Cup c = new Cup("小帅哥的杯子");   //不会被回收
	
		new Cup("大可爱的杯子");			//会被回收，执行finalize方法
		
		/*
		 * 手动的执行垃圾回收:会对堆中的对象进行扫描，然后把垃圾对象回收
		 * 	如果不手动，jvm也会定期执行该方法
		 */
		System.gc();
		
	}
}

class Cup {
	
	String name;
	
	public Cup(String name) {
		super();
		this.name = name;
	}

	/*
	 * 重写finalize方法，当对象被回收时执行
	 * 
	 */
	protected void finalize() throws Throwable { 
		System.out.println(name+"被回收了---");
	}
}

2. 包装类

为了处理某种基本类型的数据，java为每一种基本类型提供一个类，用于定义该基本类型的属性和方法，那么这种类就叫做该基本类型的包装类

package com.qf;

public class Demo05 {

	public static void main(String[] args) {
		String age = "17";
		
		/*
		 * age加1
		 * 
		 * 我们需要把字符串17转化为整数17
		 */
		String newAge = age+1;
		System.out.println(newAge);
		
		
		String price = "3000.99";
		
		/*
		 * price减去1000
		 * 
		 * 我需要把字符串3000.99转化为小数3000.99
		 */
	//	price - 1000;
		
		
		/*
		 * 思考一个问题；我们要把这些方法定义在哪里呢
		 * 	我们的基本类型，不是类，既然不是类，就不能定义属性和方法
		 *  int -- Integer类    这个类可以定义关于int的属性，以及关于int数据类型的方法
		 *  int的属性：
		 *  	int数据类型的最大值，最小值
		 *  方法：
		 *  	把字符串转化为int类型数据
		 *  
		 *  我们就称呼为Integer类为int基本数据类型的包装类
		 *  
		 *  byte 	-- Byte
		 *  short   -- Short
		 *  int     -- Integer
		 *  long	-- Long
		 *  
		 *  float  	-- Float
		 *  double	-- Double
		 *  
		 *  boolean -- Boolean
		 *  
		 *  char    -- Character
		 *  
		 */
		
		//获取int数据类型的最大值
		int max = Integer.MAX_VALUE;   //2147483647
		int min = Integer.MIN_VALUE;   //-2147483648
		System.out.println(min);
		
		/*
		 * 操作关于int类型的方法
		 * 
		 * 把字符串类型的整数，转化为整数类型数据
		 */
		int a = Integer.parseInt(age);
		
		int na = a+1;
		System.out.println(na);
		
		
		String str2 = "2";				//分别转化为byte short int	
		String str3 = "1000000000000";  // long
		String str4 = "3.14";  			// float  double
		String str5 = "true";			// boolean
		
		
		double d = Double.parseDouble(str4);
		boolean b = Boolean.parseBoolean(str5);
		
	}
	
}