Java语言高级-03常用API第二部分-第1节Object类

Object类的toString方法

package demo16;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/*
	java.lang.Object
	类 Object是类层次结构的根(父)类
	每个类（Person,Student...）都是使用Object 作为超（父）类
	所有对象（包括数组）都实现这个类的方法
 */
public class Demo01ToString {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/**
		 Person类默认继承了Object类，所以可以使用object类中的toString方法
		 String toString() 返回该对象的字符串表示
		 
		 */
		Person p = new Person("张三",10);
		String s = p.toString();
		System.out.println(s);
		
		//直接打印对象的名字，其实就是调用对象的toString
		//p = p.toString();打印对象在堆内存中的地址值
		System.out.println(p);//重写之后打印什么，就输出什么
		
		//看一个类是否重写了toString，直接打印这个对象即可，如果没有重写toString方法那么打印的是对象的地址值
		Random r = new Random();
		System.out.println(r);
		
		Scanner sc = new Scanner(System.in);
		System.out.println(sc);//
		 
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);//[1,2,3]
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package demo16;

public class Person {
	private String name;
	private int age;

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	/*
	 直接打印对象的地址值没有意义，需要重写object类中的toString方法
	 打印对象的属性（name，age）
	 */
	 
	@Override
	public String toString() {
		//return "abc";
		return "Person(name=" + name +",age="+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;
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

Object类的equals方法

package demo16;

public class Demo02Equals {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 	Person类默认继承了Object类，所以可以使用Object类的equals方法
		 	Boolean equals(Object obj)指定其他某个对象是否与此对象“相等”
		 	equals方法源码：
		 		public boolean equals(Object obj){
		 			return (this == obj);
		 		}
		 		参数：
		 			Object obj：可以传递任意的对象
		 			**比较运算符，返回的是一个布尔值 true false
		 			*基本数据类型：比较的是值
		 			*引用数据类型：比较的是两个对象的地址值
		 			this是谁？那个对象调用的方法，方法中的this就是那个对象；p1调用的equals方法所以this就是p1
		 			obj是传递过来的参数p2
		 			this == obj -->p1 == p2
		 */
		Person p1 = new Person("迪丽热巴",18);
		Person p2 = new Person("古力娜扎",19);
		System.out.println("p1:"+p1);
		System.out.println("p2:"+p2);
		
		p1 = p2;//把p2的地址值赋值给p1
		
		boolean b = p1.equals(p2);
		System.out.println(b);

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

package demo16;

public class Person {
	private String name;
	private int age;

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	/*
	 直接打印对象的地址值没有意义，需要重写object类中的toString方法
	 打印对象的属性（name，age）
	 */
	 
//	@Override
//	public String toString() {
//		//return "abc";
//		return "Person(name=" + name +",age="+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;
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

重写object类中的Equals方法

package demo16;

import java.util.ArrayList;
import java.util.Random;
import java.util.Scanner;

/*
	java.lang.Object
	类 Object是类层次结构的根(父)类
	每个类（Person,Student...）都是使用Object 作为超（父）类
	所有对象（包括数组）都实现这个类的方法
 */
public class Demo01ToString {

	public static void main(String[] args) {
		// TODO Auto-generated method stub

		/**
		 Person类默认继承了Object类，所以可以使用object类中的toString方法
		 String toString() 返回该对象的字符串表示
		 
		 */
		Person p = new Person("张三",10);
		String s = p.toString();
		System.out.println(s);
		
		//直接打印对象的名字，其实就是调用对象的toString
		//p = p.toString();打印对象在堆内存中的地址值
		System.out.println(p);//重写之后打印什么，就输出什么
		
		//看一个类是否重写了toString，直接打印这个对象即可，如果没有重写toString方法那么打印的是对象的地址值
		Random r = new Random();
		System.out.println(r);
		
		Scanner sc = new Scanner(System.in);
		System.out.println(sc);//
		 
		ArrayList<Integer> list = new ArrayList<>();
		list.add(1);
		list.add(2);
		list.add(3);
		System.out.println(list);//[1,2,3]
	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

package demo16;

public class Person {
	private String name;
	private int age;

	public Person() {
		super();
		// TODO Auto-generated constructor stub
	}
	
	public Person(String name, int age) {
		super();
		this.name = name;
		this.age = age;
	}
	
	/*
	 直接打印对象的地址值没有意义，需要重写object类中的toString方法
	 打印对象的属性（name，age）
	 */
	 
//	@Override
//	public String toString() {
//		//return "abc";
//		return "Person(name=" + name +",age="+age+"}";
//	}
	
	/*
	 Object类的equals方法，默认比较的是两个对象的地址值，没有意义
	 所以我们要重写equals方法，比较两个对象的属性（name，age）
	 问题：
	 	隐含着一个多态
	 	多态的弊端，无法使用子类的特有内容（属性和方法）
	 	解决：可以使用向下转型（强转）把object类型转换为Person
	 */

//	@Override
//	public boolean equals(Object obj) {
//		//增加一个判断，传递的参数obj如果是this本身，直接true，提高程序效率
//		if(obj == this) {
//			return true;
//		}
//		
//		//增加一个判断，传递的参数obj如果是nul，直接返回false，提高程序的效率
//		if(obj == null) {
//			return false;
//		}
//		//增加一个判断，防止类型转换一次ClassCastException
//		if(obj instanceof Person) {
//			
//			//先使用向下转型，把obj转化为Person类型
//			Person p = (Person)obj;
//			//比较两个对象的属性，一个对象是this(obj),一个对象是p(obj->p2)
//			boolean b = this.name.equals(p.name) && this.age == p.age;
//			return b;
//		}
//		//不是Person类型直接返回false
//		return false;
//	}
	


	public String getName() {
		return name;
	}
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + age;
		result = prime * result + ((name == null) ? 0 : name.hashCode());
		return result;
	}

	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		
		if (obj == null)
			return false;
		//getClass()!=obj.getClass()使用反射技术，判断obj是不是Person类型 
		//等效与 obj instanceof Person
		if (getClass() != obj.getClass())
			return false;
		Person other = (Person) 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;
	}

	public void setName(String name) {
		this.name = name;
	}
	public int getAge() {
		return age;
	}
	public void setAge(int age) {
		this.age = age;
	}
	
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

package demo16;

import java.util.ArrayList;

public class Demo02Equals {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		/*
		 	Person类默认继承了Object类，所以可以使用Object类的equals方法
		 	Boolean equals(Object obj)指定其他某个对象是否与此对象“相等”
		 	equals方法源码：
		 		public boolean equals(Object obj){
		 			return (this == obj);
		 		}
		 		参数：
		 			Object obj：可以传递任意的对象
		 			**比较运算符，返回的是一个布尔值 true false
		 			*基本数据类型：比较的是值
		 			*引用数据类型：比较的是两个对象的地址值
		 			this是谁？那个对象调用的方法，方法中的this就是那个对象；p1调用的equals方法所以this就是p1
		 			obj是传递过来的参数p2
		 			this == obj -->p1 == p2
		 */
		Person p1 = new Person("迪丽热巴",18);
		//Person p2 = new Person("古力娜扎",19);
		Person p2 = new Person("迪丽热巴",18);
		System.out.println("p1:"+p1);
		System.out.println("p2:"+p2);
		
		//p1 = p2;//把p2的地址值赋值给p1
		ArrayList<String> list = new ArrayList<>();
		
		boolean b = p1.equals(p1);
		System.out.println(b);

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

Objects类的Equals方法

package demo16;

import java.util.Objects;

public class Demo03Objects {

	public static void main(String[] args) {
		String s1 = "abc";
		//String s1 = null;
		String s2 = "abc";
		//boolean b = s1.equals(s2);//NullPointerException null是不能调用方法的，就会抛出空指针异常
		//System.out.println(b);
		/*
		 	Objects类的equals方法,对两个对象积进行比较，防止空指针异常
		 	public static boolean equals(Object a,Object b){
		 		return (a == b)||(a != null && a.equals(b));
		 	}
		 
		 */
		boolean b2 = Objects.equals(s1, s2);
		System.out.println(b2);

	}

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26