Object类的hashCode()方法、getClass()方法：
package cn.itcast_01;
/*
* Object:类 Object 是类层次结构的根类。每个类都使用 Object 作为超类。
* 每个类都直接或者间接的继承自Object类。
*
* Object类的方法：
* public int hashCode():返回该对象的哈希码值。
* 注意：哈希值是根据哈希算法计算出来的一个值，这个值和地址值有关，但是不是实际地址值。
* 你可以理解为地址值。
*
* public final Class getClass():返回此Object的运行时类
* Class类的方法：
* public String getName()：以 String的形式返回此Class对象所表示的实体
*/
public class StudentTest {
public static void main(String[] args) {
Student s1 = new Student();
System.out.println(s1.hashCode()); // 11299397
Student s2 = new Student();
System.out.println(s2.hashCode()); // 24446859
Student s3 = s1;
System.out.println(s3.hashCode()); // 11299397
Student s = new Student();
Class c = s.getClass();
String str = c.getName();
System.out.println(str); // cn.itcast_01.Student
//链式编程
String str2 = s.getClass().getName();
System.out.println(str2);// cn.itcast_01.Student
}
}
package cn.itcast_01;
public class Student extends Object {
}
package cn.itcast_02;
/*
* public String toString():返回该对象的字符串表示。
*
* Integer类下的一个静态方法：
* public static String toHexString(int i)：把一个整数转成一个十六进制表示的字符串
*
* 这个信息的组成我们讲解完毕了，但是这个信息是没有任何意义的。所以，建议所有子类都重写该方法。
* 怎么重写呢?
* 把该类的所有成员变量值组成返回即可。
* 重写的最终版方案就是eclipse自动生成toString()方法。
*
* 注意：
* 直接输出一个对象的名称，其实就是调用该对象的toString()方法。
*/
public class StudentDemo {
public static void main(String[] args) {
Student s = new Student();
System.out.println(s.hashCode());
System.out.println(s.getClass().getName());
System.out.println(s.toString()); // cn.itcast_02.Student@42552c
// toString()方法的值等价于它
// getClass().getName() + '@' + Integer.toHexString(hashCode())
// 其实等价于this.getClass().getName()+'@'+Integer.toHexString(this.hashCode())
System.out.println(s.getClass().getName() + '@'+ Integer.toHexString(s.hashCode())); // cn.itcast_02.Student@42552c
System.out.println(s.toString()); // cn.itcast_02.Student@42552c
// 直接输出对象的名称，其实就是调用该对象的toString()方法
System.out.println(s);
}
}
package cn.itcast_02;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(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;
}
//eclipse自动生成
@Override
public String toString() {
return "Student [name=" + name + ", age=" + age + "]";
}
//自己写的
public String toString() {
return "姓名:" + name + ",年龄:" + age;
}
}
Object类的equals()方法：
如果equals()相等，hashCode()一定相等；
如果hashCode()相等，equals()不一定相等（Hash散列值有冲突的情况，虽然概率很低）。
package cn.itcast_03;
/*
* public boolean equals(Object obj):指示其他某个对象是否与此对象“相等”。
* 这个方法，默认情况下比较的是地址值。比较地址值一般来说意义不大，所以我们要重写该方法。
* 怎么重写呢?
* 一般都是用来比较对象的成员变量值是否相同。
* 重写的代码优化：提高效率，提高程序的健壮性。
* 最终版：
* 其实还是eclipse自动生成。
*
* 看源码：
* public boolean equals(Object obj) {
* //this - s1
* //obj - s2
* return (this == obj);
* }
*
* ==:
* 基本类型：比较的就是值是否相同
* 引用类型：比较的就是地址值是否相同
* equals:
* 引用类型：默认情况下，比较的是地址值。
* 不过，我们可以根据情况自己重写该方法。一般重写都是自动生成，比较对象的成员变量值是否相同
*/
public class StudentDemo {
public static void main(String[] args) {
Student s1 = new Student("林青霞", 27);
Student s2 = new Student("林青霞", 27);
System.out.println(s1 == s2); // false
Student s3 = s1;
System.out.println(s1 == s3); // true
System.out.println(s1.equals(s2)); // obj = s2; //false
System.out.println(s1.equals(s1)); // true
System.out.println(s1.equals(s3)); // true
Student s4 = new Student("风清扬",30);
System.out.println(s1.equals(s4)); //false
Demo d = new Demo();
System.out.println(s1.equals(d)); //类型转换异常 ClassCastException，所以要判断的是对象是否是某个类的对象，提高程序的健壮性
}
}
class Demo {
}
package cn.itcast_03;
public class Student {
private String name;
private int age;
public Student() {
super();
}
public Student(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;
}
//eclipse自动生成的
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())//判断字节码
return false;
Student other = (Student) 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 boolean equals(Object obj) {
//return true;
//这里要改进，根据这里比较的成员变量来决定返回true还是false
//这里其实要比价的就是name和age
//但是，name是String类型的，而String是引用类型的，所以，在这里不能直接用==比较，应该用equals()比较
//String的equals()方法是重写自Object类的，比较的是字符串的内容是否相同
//this -- s1
//obj -- s2
//我们要使用的是学生类的特有成员变量,所以要向下转型
Student s = (Student)obj; //s -- obj -- s2;
if(this.name.equals(s.name) && this.age == s.age) {
return true;
}else {
return false;
}
}*/
//代码优化
public boolean equals(Object obj) {
// 为了提高效率，如果本身和传过来的对象是同一个，直接返回true，不需要再向下转型了Student s = (Student) obj;
if (this == obj) {
return true;
}
// 为了提供程序的健壮性
// 我先判断一下，obj是不是学生的一个对象，如果是，再做向下转型，如果不是，直接返回false，避免出现类型转换异常 ClassCastException
// 这个时候，我们要判断的是对象是否是某个类的对象?
// 记住一个格式：对象名 instanceof 类名
// 表示：判断该对象名是否是该类名一个对象
if (!(obj instanceof Student)) {
return false;
}
// 如果是就继续
Student s = (Student) obj;
return this.name.equals(s.name) && this.age == s.age;
}
}
Object类的finalize()方法和clone()方法：
package cn.itcast_04;
/*
* protected void finalize()：当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。用于垃圾回收，但是什么时候回收不确定。
* protected Object clone():创建并返回此对象的一个副本。
* A:因为是protected修饰的，只能在子类访问到，要想在其他类中也访问到，需要在子类中重写该方法，alt+/自动生成
* B:让被克隆的类实现Cloneable接口
*
* Cloneable:此类实现了 Cloneable 接口，以指示 Object.clone() 方法可以合法地对该类实例进行按字段复制。
* 这个接口是标记接口(不含任何方法)，告诉我们实现该接口的类就可以实现对象的复制了。
这里说的是浅克隆，深克隆有兴趣的自己研究下
*/
public class StudentDemo {
public static void main(String[] args) throws CloneNotSupportedException {
//创建学生对象
Student s = new Student();
s.setName("林青霞");
s.setAge(27);
//克隆学生对象
Object obj = s.clone();
Student s2 = (Student)obj;
System.out.println(s.getName()+"---"+s.getAge()); //林青霞---27
System.out.println(s2.getName()+"---"+s2.getAge());//林青霞---27
//以前的做法
Student s3 = s;
System.out.println(s3.getName()+"---"+s3.getAge());//林青霞---27
System.out.println("---------");
//其实是有区别的
s3.setName("刘意");
s3.setAge(30);
System.out.println(s.getName()+"---"+s.getAge()); //刘意---30
System.out.println(s3.getName()+"---"+s3.getAge());//刘意---30
//相当于拿了一份，它的改动，对以前的没有影响
System.out.println(s2.getName()+"---"+s2.getAge());//林青霞---27
}
}
package cn.itcast_04;
public class Student implements Cloneable {
private String name;
private int age;
public Student() {
super();
}
public Student(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
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
public class StudentTest {
public static void main(String[] args) throws CloneNotSupportedException {
Address addr = new Address();
addr.setAdd("南京市");
Student s = new Student();
s.setName("林青霞");
s.setAge(27);
s.setAddr(addr);
Student s1 = (Student) s.clone();
System.out.println(s.getName() + "---" + s.getAge() + "---" + s.getAddr().getAdd()); // 林青霞---27---南京市
System.out.println(s1.getName() + "---" + s1.getAge() + "---" + s1.getAddr().getAdd());// 林青霞---27---南京市
addr.setAdd("西湖区");
/*
* 这就奇怪了，怎么两个学生的地址都改变了？
* 原因是浅复制只是复制了addr变量的引用，并没有真正的开辟另一块空间，将值复制后再将引用返回给新对象。
* 所以，为了达到真正的复制对象，而不是纯粹引用复制。我们需要将Address类可复制化，并且修改clone方法
*/
System.out.println(s.getName() + "---" + s.getAge() + "---" + s.getAddr().getAdd()); // 林青霞---27---西湖区
System.out.println(s1.getName() + "---" + s1.getAge() + "---" + s1.getAddr().getAdd());// 林青霞---27---西湖区
}
}
public class Address implements Cloneable {
private String add;
public String getAdd() {
return add;
}
public void setAdd(String add) {
this.add = add;
}
public Object clone() {
Address addr = null;
try {
addr = (Address) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return addr;
}
}
public class Student implements Cloneable {
private String name;
private int age;
private Address addr;
public Student() {
super();
}
public Student(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;
}
public Address getAddr() {
return addr;
}
public void setAddr(Address addr) {
this.addr = addr;
}
public Object clone() {
Student stu = null;
try {
stu = (Student) super.clone(); // 浅复制
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
stu.addr = (Address) addr.clone(); // 深度复制
return stu;
}
}
扫一扫
1853
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
