Java 面向对象（中）2 —— Object类、包装类

最新推荐文章于 2022-04-12 00:14:49 发布

原创最新推荐文章于 2022-04-12 00:14:49 发布 · 616 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java

程序设计语言基础专栏收录该内容

21 篇文章

订阅专栏

本文详细介绍了Java中的Object类，包括`==`与`equals()`的区别，展示了如何重写`equals()`和`hashCode()`方法。此外，还探讨了包装类的使用，基本数据类型与包装类之间的转换，以及`toString()`方法的作用。同时，提供了单元测试案例和实际编程练习，帮助读者深入理解这些概念。

1 Object类

1.1 面试题： == 和 equals() 区别

1.1.1 重写equals()代码

1.2 Object类的使用练习题

1.3 mini Project（重写equals）

1.4 ToString 类

1.4.1 mini Project 综合考察：重写 equals和toString

2.3.1 基本数据类型 --->包装类：调用包装类的构造器

2.3.2 包装类--->基本数据类型:调用包装类Xxx的xxxValue()

2.3.3 常用！自动拆箱装箱：基本数据类型 <——> 包装类

2.3.4 常用！基本数据类型、包装类--->String类型：调用String重载的valueOf(Xxx xxx)

2.3.5 常用！String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)

2.4 面试题

2.5 mini Project

1 Object类

1.1 面试题： == 和 equals() 区别

/*
* 一、回顾 == 的使用：
* == ：运算符
* 1. 可以使用在基本数据类型变量和引用数据类型变量中 —— 两种变量都适用
* 2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。（不一定类型要相同）
* 如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
* 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

* 二、equals()方法的使用：
* 1. 是一个方法，而非运算符
* 2. 只能适用于引用数据类型
* 3. Object类中equals()的定义：
* public boolean equals(Object obj) {
   return (this == obj);
   }
* 说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

* 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
* 两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
  * 对于自定义的类型也要重写equals()方法——否则用的还是Object里面的

* 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。那么，我们
* 就需要对Object类中的equals()进行重写.
* 重写的原则：比较两个对象的实体内容是否相同.

package com.lee.java1;

public class EqualsTest {
	public static void main(String[] args) {
		int i = 10;
		int j = 10;
		double d = 10.0;
		
		System.out.println(i == j);
		System.out.println(i == d);//int > double
		
		char c = 10;
		System.out.println(i == c);//true
		
		//不能和boolean一起玩
		boolean b = true;
		//System.out.println(i == b);
		
		//引用类型
		Customer cust1 = new Customer("Tom", 21);
		Customer cust2 = new Customer("Tom", 21);
		System.out.println(cust1 == cust2);//false 地址值不一样
		
		String str1 = new String("atguigu");
		String str2 = new String("atguigu");
		System.out.println(str1 == str2);//false
		
		System.out.println("**************************************");
		System.out.println(cust1.equals(cust2));//false--->true
		System.out.println(str1.equals(str2));//true String 重写过
	}
}

参考 String equals() 重写 Customer equals()

1.1.1 重写equals()代码

    public boolean equals(Object anObject) {
        if (this == anObject) {
            return true;
        }
        if (anObject instanceof String) {
            String anotherString = (String)anObject;
            int n = value.length;
            if (n == anotherString.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;
            }
        }
        return false;

	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		if (obj instanceof Customer) {
			Customer cust = (Customer)obj;
			//比较两个对象的每个属性是否都相同
			if (this.age == cust.age && this.name.equals(cust.name)) {
				return true;
			}
		}
		return false;
	}

1.2 Object类的使用练习题

1.3 mini Project（重写equals）

package com.lee.exer2;

public class OrderTest {
	public static void main(String[] args) {
		Order order1 = new Order(1001, "AA");
		Order order2 = new Order(1001, new String("BB"));
		
		System.out.println(order1.equals(order2));
		
		Order order3 = new Order(1001, "BB");
		System.out.println(order2.equals(order3));
		
		//String的内容在常量池。
		//常量池如果定义了两个值一样的变量，则新的指针指向原先的对象
//		String s1 = "BB";
//		String s2 = "BB";
//		System.out.println(s1 == s2);//true
		
	}
}

class Order {
	private int orderId;
	private String orderName;
	
	public int getOrderId() {
		return orderId;
	}
	public void setOrderId(int orderId) {
		this.orderId = orderId;
	}
	public String getOrderName() {
		return orderName;
	}
	public void setOrderName(String orderName) {
		this.orderName = orderName;
	}
	public Order(int orderId, String orderName) {
		super();
		this.orderId = orderId;
		this.orderName = orderName;
	}
	
	@Override
	public boolean equals(Object obj) {
		if (this == obj) {
			return true;
		}
		
		if (obj instanceof Order) {
			//强转 调用order的属性
			Order order = (Order)obj;
			return this.orderId == order.orderId && 
					this.orderName.equals(order.orderName);
		}
		return false;
	}
	
}

1.4 ToString 类

/*
* Object类中toString()的使用：
*
* 1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()
*
* 2. Object类中toString()的定义：
* public String toString() {
return getClass().getName() + "@" + Integer.toHexString(hashCode());
}
*
* 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。
* 使得在调用对象的toString()时，返回"实体内容"信息
*
* 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
*/

package com.lee.java1;

import java.sql.Date;

public class ToString {
	public static void main(String[] args) {
		Customer cust1 = new Customer("Tom", 21);
		System.out.println(cust1.toString());//com.lee.java1.Customer@15db9742
		System.out.println(cust1);//com.lee.java1.Customer@15db9742
		
		String str = new String("MM");
		System.out.println(str);
		
		Date date = new Date(41442414421L);
		System.out.println(date.toString());
	}
	
}

1.4.1 mini Project 综合考察：重写 equals和toString

快捷键：shift + alt + s

利用快捷键生成get / set这不是考察的重点
单参构造器如何利用了父类的空参构造器？
三参构造器如何传递参数给父类的双参构造器？
重写equals时的逻辑很重要
利用快捷键重写tuString

//父类
package com.lee.exer3;

public class GeometricObject {
	protected String color;
	protected double weight;
	
	protected GeometricObject() {
		super();
		this.color = "white";
		this.weight = 1.0;
		
	}
	protected GeometricObject(String color, double weight) {
		super();
		this.color = color;
		this.weight = weight;
	}
	public String getColor() {
		return color;
	}
	public void setColor(String color) {
		this.color = color;
	}
	public double getWeight() {
		return weight;
	}
	public void setWeight(double weight) {
		this.weight = weight;
	}
}

//子类
//争取独立写出我注释的内容


package com.lee.exer3;

public class Circle extends GeometricObject {
	private double radius;

//	public Circle() {
//		super();
//		radius = 1.0;
////		color = "white";
////		weight = 1.0;
//	}
//
//	public Circle(double radius) {
//		super();
//		this.radius = radius;
//	}
//	
//	public Circle(double radius,String color,double weight) {
//		super(color,weight);
//		this.radius = radius;
//	}

	public double getRadius() {
		return radius;
	}

	public void setRadius(double radius) {
		this.radius = radius;
	}
	//求圆的面积
	public double findArea(){
		return 3.14 * radius * radius;
	}
	//比较两个圆的半径是否相等，如相等，返回true。
	@Override
//	public boolean equals(Object obj) {
//		
//		if(this == obj){
//			return true;
//		}
//		
//		if(obj instanceof Circle){
//			Circle c = (Circle)obj;
//			return this.radius == c.radius;
//		}
//		
//		return false;
//		
//	}

	@Override
	public String toString() {
		return "Circle [radius=" + radius + "]";
	}
}

//测试类

package com.lee.exer3;

public class CircleTest {
	public static void main(String[] args) {
		Circle circle1 = new Circle(2.3);
		Circle circle2 = new Circle(3.3, new String("white"), 2.0);
		
		System.out.println("颜色是否相等：" + circle1.getColor().equals(circle2.getColor()));
		
		System.out.println("半径是否相等：" + circle1.equals(circle2));
		
		System.out.println(circle1);
		System.out.println(circle2.toString());
	}
}

2 包装类

2.1 单元测试

/*
* Java中的JUnit单元测试
*
* 步骤：
* 1.选中当前工程day13 - 右键选择：build path - add libraries - JUnit 4 - 下一步

* 2.创建Java类，进行单元测试。
* 此时的Java类要求：① 此类是public的 ②此类提供公共的无参的构造器

* 3.此类中声明单元测试方法。
* 此时的单元测试方法：方法的权限是public, 没有返回值，没有形参

   @Test
   public void testEquals() {

   }
* 4.此单元测试方法上需要声明注解：@Test,并在单元测试类中导入：import org.junit.Test;
*
* 5.声明好单元测试方法以后，就可以在方法体内测试相关的代码。
* 6.写完代码以后，左键双击单元测试方法名，右键：run as - JUnit Test
*
* 说明：
* 1.如果执行结果没有任何异常：绿条
* 2.如果执行结果出现异常：红条
*/

package com.lee.java2;

import org.junit.Test;

public class JUnitTest {
	int num = 10;
	
	@Test
	public void testEquals() {
		String s1 = "MM";
		String s2 = "MM";
		System.out.println(s1.equals(s2));
		
//		Object obj = new String("GG");
//		Date date = (Date)obj;
		
		System.out.println(num);
	}
}