Java中常用的类

Object类

1. Object类是所有Java类的根父类

2. 如果在类的声明中未使用extends关键字指明其父类，则默认父类为java.lang.Object类
 
3. Object类中的功能(属性、方法)就具有通用性。

属性：无
方法：equals() / toString() / getClass() /hashCode() / clone() / finalize()/wait() 、 notify()、notifyAll()

4. Object类只声明了一个空参的构造器

equals()

==和equals()的区别

• ==运算符

1. 可以使用在基本数据类型变量和引用数据类型变量中

2. 如果比较的是基本数据类型变量：比较两个变量保存的数据是否相等。
（不一定类型要相同）-->有自动类型提升

3. 如果比较的是引用数据类型变量：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

4. 补充： == 符号使用时，必须保证符号左右两边的变量类型一致。

• equals()方法的使用

5. 是一个方法，而非运算符

6. 只能适用于引用数据类型

7. Object类中equals()的定义：

	public boolean equals(Object obj) {
		        return (this == obj);
		  }
8.  说明：Object类中定义的equals()和==的作用是相同的：
比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体

9. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，
比较的不是两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
 
10. [重点] 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体
内容"是否相同。那么，我们就需要对Object类中的equals()进行重写. 重写的原则：比较两
个对象的实体内容是否相同.

public class EqualsTest {
	public static void main(String[] args) {
		
		//基本数据类型
		int i = 10;
		int j = 10;
		double d = 10.0;
		System.out.println(i == j);//true  自动类型提升
		System.out.println(i == d);//true
		
		boolean b = true;
//		System.out.println(i == b);  布尔值不可以 -->没有类型提升
		
		char c = 10;
		System.out.println(i == c);//true
		
		char c1 = 'A';
		char c2 = 65;
		System.out.println(c1 == c2);//true
		
		//引用类型：
		Customer cust1 = new Customer("Hwang",21);
		Customer cust2 = new Customer("Hwang",21);
		System.out.println(cust1 == cust2);//false
		
		String str1 = new String("Hwang");
		String str2 = new String("Hwang");
		System.out.println(str1 == str2);//false
		System.out.println("****************************");
		System.out.println(cust1.equals(cust2));//false--->true
		System.out.println(str1.equals(str2));//true
		
		Date date1 = new Date(32432525324L);
		Date date2 = new Date(32432525324L);
		System.out.println(date1.equals(date2));//true
		
		
	}
}
//记录：上课时老师写的笔记

• 重写equals()

public class Customer {
	
	private String name;
	private int age;
	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 Customer() {
		super();
	}
	public Customer(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}

	//自动生成的equals()
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Customer other = (Customer) obj;
		if (age != other.age)
			return false;
		if (name == null) {
			if (other.name != null)
				return false;
		} else if (!name.equals(other.name))
			return false;
		return true;
	}
//重写的原则：比较两个对象的实体内容(即：name和age)是否相同

• 小测验

		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'是否相等？" + (it == ch1));//true
		System.out.println(“12和ch2是否相等？" + (12 == ch2));//true
		String str1 = new String("hello");
		String str2 = new String("hello");
		System.out.println("str1和str2是否相等？"+ (str1 == str2));//false
		System.out.println("str1是否equals str2？"+(str1.equals(str2)));//true
		System.out.println(“hello” == new java.util.Date()); //编译不通过，这个要注意！！！编译都通过不了！！！！

toString()

1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()

2. Object类中toString()的定义：
		public String toString() {
		        return getClass().getName() + "@" + Integer.toHexString(hashCode());//16进制的hash码值。
		     }
		     
3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。使得在调用对象的toString()时，返回"实体内容"信息。

4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"

@Override
	public String toString() {
		return "Customer [name=" + name + ", age=" + age + "]";
	}

面试题

• 1、

final、finally、finalize的区别？

• 2、

public void test() {
char[] arr = new char[] { 'a', 'b', 'c' };//abc
System.out.println(arr);//[I@16c0663d
int[] arr1 = new int[] { 1, 2, 3 };
System.out.println(arr1);//
double[] arr2 = new double[] { 1.1, 2.2, 3.3 };
System.out.println(arr2);//[D@23223dd8
}

包装类

1. 针对八种基本数据类型定义相应的引用类型—包装类（封装类）

2. 有了类的特点，就可以调用类中的方法，Java才是真正的面向对象

转换

JDK1.5之后，支持自动装箱，自动拆箱。但类型必须匹配。

• 基本数据类型包装成包装类的实例 --> 装箱

1.通过包装类的构造器实现：
	int i = 500; Integer t = new Integer(i);

2.还可以通过字符串参数构造包装类对象：
	Float f = new Float(“4.56”);
	Long l = new Long(“asdf”); //NumberFormatException 

• 代码

public class WrapperTest {
	@Test
	public void test1(){
		
		int num1 = 10;
//		System.out.println(num1.toString());
		Integer in1 = new Integer(num1);
		System.out.println(in1.toString());
		
		Integer in2 = new Integer("123");
		System.out.println(in2.toString());
		
		//报异常
//		Integer in3 = new Integer("123abc");
//		System.out.println(in3.toString());
		
		Float f1 = new Float(12.3f);
		Float f2 = new Float("12.3");
		System.out.println(f1);
		System.out.println(f2);
		
		Boolean b1 = new Boolean(true);
		Boolean b2 = new Boolean("TrUe");
		System.out.println(b2);
		Boolean b3 = new Boolean("true123");
		System.out.println(b3);//false
		
		
		Order order = new Order();
		System.out.println(order.isMale);//false
		System.out.println(order.isFemale);//null-->这个要特别注意！
	}
}
class Order{
	
	boolean isMale;
	Boolean isFemale;
}

• 获得包装类对象中包装的基本类型变量 -->拆箱

1. 调用包装类的.xxxValue()方法：
	boolean b = bObj.booleanValue();

• 代码

	@Test
	public void test2(){
		Integer in1 = new Integer(12);
		
		int i1 = in1.intValue();
		System.out.println(i1 + 1);
		
		
		Float f1 = new Float(12.3);
		float f2 = f1.floatValue();
		System.out.println(f2 + 1);
	}
	

自动装箱与拆箱

1. 自动装箱：基本数据类型 --->包装类

2. 自动拆箱：包装类--->基本数据类型

• 代码

	@Test
	public void test3(){
		//		int num1 = 10;
		//基本数据类型-->包装类的对象
		//		method(num1);//需要引用类型，传入基本类型，不报错-->自动装箱
		
		//自动装箱：基本数据类型 --->包装类
		int num2 = 10;
		Integer in1 = num2;//自动装箱
		
		boolean b1 = true;
		Boolean b2 = b1;//自动装箱
		
		//自动拆箱：包装类--->基本数据类型
		System.out.println(in1.toString());
		
		int num3 = in1;//自动拆箱
		
	}
	
	public void method(Object obj){
		System.out.println(obj);
	}

基本数据类型、包装类—>String类型

1. 方式1：连接运算

2. 方式2：调用String的valueOf(Xxx xxx)

总结：不管你是基本数据类型、包装类类型的，都可以调用valueOf(Xxx xxx)，将基本数据类型、包装类类型作为参数传进去。

• 代码

	@Test
	public void test4(){
		
		int num1 = 10;
		//方式1：连接运算
		String str1 = num1 + "";
		//方式2：调用String的valueOf(Xxx xxx)
		float f1 = 12.3f;
		String str2 = String.valueOf(f1);//"12.3"
		
		Double d1 = new Double(12.4);//d1 即为包装类
		String str3 = String.valueOf(d1);
		System.out.println(str2);
		System.out.println(str3);//"12.4"
		
	}

String类型 —>基本数据类型、包装类

1. String类型 --->基本数据类型、包装类：调用包装类的parseXxx(String s)
总结：parseXxx(String s)为静态方法，可以使用类名去调用。

• 代码

	@Test
	public void test5(){
		String str1 = "123";
		//错误的情况：
//		int num1 = (int)str1;
//		Integer in1 = (Integer)str1;
		//可能会报NumberFormatException
		//String str2 = "123abc"; 报NumberFormatException
		int num2 = Integer.parseInt(str1);
		System.out.println(num2 + 1);
		
		String str2 = "true1";
		boolean b1 = Boolean.parseBoolean(str2);
		System.out.println(b1);
	}
	

包装类的面试题

//1.
	Object o1 = true ? new Integer(1) : new Double(2.0);
	System.out.println(o1);//1.0
//2.
	Object o2;
	if (true)
	o2 = new Integer(1);
	else
	o2 = new Double(2.0);
	System.out.println(o2);//1
//3.
		public void method1() {
		Integer i = new Integer(1);
		Integer j = new Integer(1);
		System.out.println(i == j);//false
		Integer m = 1;
		Integer n = 1;
		System.out.println(m == n);//true
		Integer x = 128;
		Integer y = 128;
		System.out.println(x == y);//false
		}