【JavaSE笔记】Java常用类及其方法（一）_Object

本期知识点：

Object 类的常用方法

类 Object (java.lang.Object)

类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

常用的方法：

1. public int hashCode():返回该对象的哈希码值。
2. public final Class<?> getClass():返回此Object正转运行的类。
3. public String toString() :返回该对象的字符串表示。
4. public boolean equals(Object obj) :指示其他某个对象是否与此对象相等。
5. protected Object clone()：创建并返回此对象的一个副本，返回的值是Object类型。
6. protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

方法：

1. public int hashCode() 

a. 返回的是该对象的哈希码值,哈希码值他是通过哈希表(Hashtable)里面的哈希算法算出来的,可以理解为地址值(整数)。
b. 不同对象的，hashCode()一般来说不会相同。但是，同一个对象的hashCode()值肯定相同。

		class Student {
			
		}
		public class Demo01 {
			public static void main(String[] args) {
				Student a = new Student();
				System.out.println("a的：");
				System.out.println(a);//Object类中常用方法.Student@48e206ff
				//public int hashCode():
				System.out.println(a.hashCode());//622762082
			
				Student b = new Student();
				System.out.println("b的：");
				System.out.println(b);
				System.out.println(b.hashCode());
				
				Student c = a;
				System.out.println("c的(把a赋值给c)：");
				System.out.println(c);
				System.out.println(c.hashCode());
				//public final Class<?> getClass():返回此Object正在运行的类:
				Student d = new Student();
				Class e = d.getClass();
				System.out.println("e的：");
				System.out.println(e);//class Object类中常用方法.Student
				String f = e.getName();
				System.out.println(f);//Object类中常用方法.Student 表示当前Student类的一个全路径名称!
			}
}

2. public final Class getClass()

a. 返回此Object正转运行的类
b. 可以通过Class类中的一个方法，获取对象的真实类的全名称。

public String getName();以 String 的形式返回此 Class 对象所表示的实体（类、接口、数组类、基本类型或 void）名称。

		class Student {
			
		}
		public class Demo01 {
			public static void main(String[] args) {
				//public final Class<?> getClass():返回此Object正在运行的类:
				Student d = new Student();
				Class e = d.getClass();
				System.out.println("e的：");
				System.out.println(e);//class Object类中常用方法.Student
				String f = e.getName();
				System.out.println(f);//Object类中常用方法.Student 表示当前Student类的一个全路径名称!
}

3. public String toString() 

a. 返回该对象的字符串表示。

通常 toString()方法会返回一个“以文本方式表示”此对象的字符串，通常toString 方法会返回一个“以文本方式表示”此对象的字符串。结果应是一个简明但易于读懂的信息表达式。建议所有子类都重写此方法。

b. toString()相当于：

s.getClass.s.getName()+"@"+该方法所在的类名.toHexDtring(int i)

c. Integer类：是int类的一个包装类型！

i. public static String toHexString(int i):以16进制无符号整数形式返回一个整数参数的字符串表示形式。

int 基本类型——>Integer类

char基本类型——>character类

ii. 注意:

直接输出对象名称，和toString()一样，前提是在自定义的类中没有重写toString()方法；自己手动添加toString()方法，不需要手动添加，在自定义一个类的时候，可以在适当的情况下重写toString()方法。

d. 源码：

public String toString() {

return getClass().getName() + "@" + Integer.toHexString(hashCode());

}

getClass():返回的当前正在运行的类。
getName():返回的是全路径名称，是以String字符串形式显示出来
@:地址标记
Integer.toHexString(hashCode()):返回一个整数的16进制数据。

		class Student3{
				private String name;
				private int age;
				public Student3() {
					super();
				}
				public Student3(String name, int age) {
					super();
					this.name = name;
					this.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;
				}
				//重写toString()方法
			//	@Override
			//	public String toString(){
			//		return "姓名："+name+" 年龄："+age;
			//	}
				//自动生成toString()方法
				@Override
				public String toString() {
					return "Student3 [name=" + name + ", age=" + age + "]";
				}
			}
			public class Demo03 {
				public static void main(String[] args) {
					Student3 a = new Student3("Tom",20);
					System.out.println(a.hashCode());//366712642
					//没有重写toString()方法时 //Object类中常用方法.Student3@15db9742
					//重写后
					System.out.println(a.toString());//Student3 [name=Tom, age=20]
					
					//getClass的Object类的方法。getName()是 Class类中的方法。
					/*
					 * toString()相当于：
					 * s.getClass.s.getName()+"@"+该方法所在的类名.toHexDtring(int i)
					 * */
					System.out.println(a.getClass());//class Object类中常用方法.Student3
					System.out.println(a.getClass().getName());//Object类中常用方法.Student3
					System.out.println("@");//@
					System.out.println(Integer.toHexString(a.hashCode()));//15db9742
				}
}

4. public boolean equals(Object obj)

a. 指示其他某个对象是否与此对象相等。

b. 源码：

public boolean equals(Object obj) {

return (this == obj);

}

判断此对象(当前类的对象this),obj实际的对象,判断对象是否相等。

比较两个对象是否相等，看两个对象中的内容是否相同，就需要去重写equals()方法。

c. (面试题) ==和equals()的区别？

i. ==比较的是两个对象的地址值。操作符专门用来比较两个变量的值是否相等，也就是用于比较变量所对应的内存中所存储的数值是否相同，要比较两个基本类型的数据或两个引用变量是否相等，只能用==操作符。

ii. 默认比较的是地址值:String重写了Object中的toString()方法,比较的是内容是否相同。equals方法是用于比较两个独立对象的内容是否相同，就好比去比较两个人的长相是否相同，它比较的两个对象是独立的。

			class Student2{
				private String name ;
				private int age ;
				
				public Student2() {
					super();	
				}
				
				public Student2(String name, int age) {
					super();
					this.name = name;
					this.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;
				}
				
				@Override
				public String toString() {
					return "Student2 [name=" + name + ", age=" + age + "]";
				}
				//equals的方法重写 
			
				@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;
					if (getClass() != obj.getClass())
						return false;
					Student2 other = (Student2) 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 class equals {
				public static void main(String[] args) {
					//创建对象
					Student2 a = new Student2("Tom",20);
					Student2 b = new Student2("Tom",20);
					//public boolean equals(Object obj)
					//没有重写equals()方法。false 
					System.out.println(a.equals(b));//重写了equals()方法.true;
					Student2 c = new Student2();
					//创建第三个变量
					Student d = new Student();
					System.out.println(c.equals(d));//false;
				}
}

5. protected Object clone()

a. 创建并返回此对象的一个副本，返回的值是Object类型。

创建并返回此对象的一个副本，这种克隆机制十分高效，而且二者之间完全隔离

b. 自定义类实现克隆步骤：

i.自定义类实现 Cloneable接口，这是一个标记性接口，实现这个接口的类的对象可以实现自我克隆。

ii.自定义类中重写Object类的clone()方法。

iii.重写clone()方法时通过super.clone()调用Object类的clone()方法来得到该对象的副本，并返回该副本。

c. 注意

i. 克隆和两个引用指向同一个对象的区别?

ii. Object类clone()方法虽然简单，易用，但仅仅是一种”浅克隆”,它只克隆该对象所有的Field值，不会对引用类型的Field所引用的对象进行克隆。开发中，我们也可以实现对象的”深度克隆”

例:

			class Student4 extends Object implements Cloneable{
				private String name;
				private int age;
				
				public Student4(){
					super();
				}
				public Student4(String name, int age) {
					this.name = name;
					this.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;
				}
				
				//重写clone，前提是该类必须实现Cloneable接口
				@Override
				protected Object clone() throws CloneNotSupportedException {
					return super.clone();
				}
				
			}
			public class clone_finalize {
				public static void main(String[] args) throws CloneNotSupportedException {
					//创建对象
					Student4 a = new Student4();
					a.setName("Tom");
					a.setAge(19);
					System.out.println(a.getName()+" "+a.getAge());
					System.out.println("———————————");
					//不用clone时
					System.out.println("不用clone的时候");
					Student4 c = a;
					System.out.println(c.getName()+" "+c.getAge());
					System.out.println("———————————");
					//使用clone创建该Student4对象的一个副本
					System.out.println("使用clone创建对象副本");
					Object obj = a.clone();//在main里加 throws CloneNotSupportedException
					Student4 b = (Student4) obj;//将父类引用强制类型转换成子类对象。
					System.out.println(b.getName()+" "+b.getAge());
					System.out.println("———————————");
				}
}

6. protected void finalize()

a. 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。子类重写 finalize 方法，以配置系统资源或执行其他清除。
b. 当垃圾回收器确定不存在对该对象的更多引用时，垃圾回收器不会马上回收垃圾，由对象的垃圾回收器调用此方法。什么时候调用这个方法不确定,要看GC垃圾回收器这个线程什么时候空闲!(System类)
c. 主要针对堆内存。

最后

以上就是从容雪碧为你收集整理的【JavaSE笔记】Java常用类及其方法（一）_Object的全部内容，希望文章能够帮你解决【JavaSE笔记】Java常用类及其方法（一）_Object所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。