- 1.Object类
- 2.JavaBean
- 2.1 `getter`和`setter`
- 2.2 `success`和`isSuccess`
- 3.equals和hashCode的关系
- 3.1 `equals`的多种写法
- 3.2 `equals`和`hashCode`
- 4.对象的clone方法
- 4.1 浅拷贝和深拷贝
- Java中的所有类都默认继承自一个类(java.lang.Object)。是所有类的超类,即使在写代码时没有明确指定,也会默认继承这个类。
- Object中定义的方法
- clone():创建并返回此对象的副本。
- equals(Object obj):指示其他对象是否“等于”此对象。
- hashCode():返回对象的哈希码值。
- notify():唤醒正在等待这个对象的监视器的单个线程。
- notyfyAll():唤醒正在等待这个对象的监视器的所有线程。
- toString():返回对象的字符串表示形式。
- wait():使当前线程进入等待状态,直到另一个线程调用此对象的notify()方法或notifyAll()方法。
- finalize():当垃圾回收器决定回收某对象时,就会运行该对象的finalize()方法。
- 类:包含private属性和public方法
用户类
public class User {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
}
-
定义name属性,私有
-
定义两个方法,公共,用于访问私有属性
- getName:读方法,setter
- setName:写方法,getter
-
JavaBean标准
- 所有属性都是private的。
- 提供默认的构造函数。
- 提供一系列setter和getter方法。
- 实现Serializable接口。
普通参数propertyName定义setter/getter
publicget (); public void set ( a);
布尔类型的变量propertyName是单独定义的
public boolean is2.2 success和isSuccess(); public void set (boolean m);
关于“本次请求是否成功”的字段的定义
boolean success boolean isSuccess Boolean success Boolean isSuccess
- 变量命名时在success和isSuccess之间该如何选择?
- isSuccess在发生序列化可能导致参数转换异常。
- 在定义布尔类型的JavaBean,应该使用success这样的命名方式。
- Java中每个类都隐式地继承自Java.lang.Object类,并且会继承equals()和hashCode()两个方法
默认equals()的默认实现与”==“操作符一致
public boolean equals(Object obj) {
return (this == obj);
}
测试代码
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
}
public class EqualsTest {
public static void main(String[] args) {
Person person1 = new Person("Hollis");
Person person2 = new Person("Hollis");
Person person3 = person1;
System.out.println("person1 == person2 ? " + (person1.equals(person2)));
System.out.println("person1 == person3 ? " + (person1.equals(person3)));
}
}
测试结果
person1 == person2 ? false person1 == person3 ? true
- 没有重写equals方法,使用equals作比较,判断的是两个对象的引用是否相等。
一、IntelliJ IDEA中默认的实现方式
public boolean equals(Object o) {
if (this == o) { return true; }
if (o == null || getClass() != o.getClass()) { return false; }
Person person = (Person) o;
return name != null ? name.equals(person.name) : person.name == null;
}
二、基于java.util.Objects#equals
public boolean equals(Object o) {
if (this == o) { return true; }
if (o == null || getClass() != o.getClass()) { return false; }
Person person = (Person) o;
return Objects.equals(name, person.name);
}
三、基于Apache Commons Lang框架的实现方式
public boolean equals(Object o) {
if (this == o) { return true; }
if (o == null || getClass() != o.getClass()) { return false; }
Person person = (Person) o;
return new EqualsBuilder()
.append(name, person.name)
.isEquals();
}
3.2 equals和hashCode
- hashCode()方法是Object类中定义的方法,作用是返回对象的哈希值,返回值类型是int。
- 哈希值的作用是确定该对象在哈希表中的位置。
- 必须在每个重写equals()的类中重写hashCode(),不这么做将阻止类与所有基于散列的集合(HashMap、HashSet、Hahstable)一起正常工作。
- 在HashMap和HashSet等基于散列的集合中
- 会使用对象的hashCode值来确定该对象应该如何存储在集合中
- 并且再次使用hashcode来在其集合中定位对象
一个类,只重写了equals方法,而没有重写hashCode方法
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person person = (Person) o;
return Objects.equals(name, person.name);
}
}
public class EqualsTest {
public static void main(String[] args) {
Person person1 = new Person("Hollis");
Person person2 = new Person("Hollis");
HashSet set = new HashSet<>();
set.add(person1);
set.add(person2);
System.out.println(set.size());
// 结果输出:2
}
}
- 定义了Person类,只重写了equals方法,并没有重写hashCode方法
- 定义了两个值内容一样的对象,尝试将它们放入一个不能重复的Set
- 最后输出这个Set的元素个数是2,说明Set认为这两个对象是不相等的
给Person类添加equals和hashCode方法
public class Person {
private String name;
public Person(String name) {
this.name = name;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
Person person = (Person) o;
return Objects.equals(name, person.name);
}
@Override
public int hashCode() {
return Objects.hash(name);
}
}
public class EqualsTest {
public static void main(String[] args) {
Person person1 = new Person("Hollis");
Person person2 = new Person("Hollis");
HashSet set = new HashSet<>();
set.add(person1);
set.add(person2);
System.out.println(set.size());
// 结果输出:1
}
}
-
两个对象相等的严格定义
- 对象内容相等(equals()的结果)
- 哈希值也要相等(hashCode()的结果)
-
我们在重写equals方法时,一定要同时重写hashCode方法
- Java,lang,Object有一个clone方法,默认是浅拷贝(Shadow Clone)
- 浅拷贝(Shadow Clone):对基本数据类型进行值传递,对引用数据类型进行引用传递的拷贝。
- 深拷贝(Deep Clone):对基本数据类型进行值传递,为数据类型创建一个新的对象,并复制其内容。
浅拷贝
public class Address {
private String province;
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
@Override
public String toString() {
return new StringJoiner(",", Address.class.getSimpleName() + "[", "]")
.add("province='" + province + "'").toString();
}
}
public class PersonClone implements Cloneable {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address();
address.setProvince("ZheJiang");
PersonClone person1 = new PersonClone("Test", address);
PersonClone person2 = (PersonClone) person1.clone();
person2.getAddress().setProvince("JiangSu");
System.out.println(person1);
System.out.println(person2);
}
private String name;
private Address address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public PersonClone(String name, Address address) {
this.name = name;
this.address = address;
}
@Override
public String toString() {
return new StringJoiner(",", Person.class.getSimpleName() + "[", "]")
.add("name='" + name + "'")
.add("address=" + address)
.toString();
}
}
输出结果
Person[name='Test',address=Address[province='JiangSu']] Person[name='Test',address=Address[province='JiangSu']]
-
定义一个PersonClone类并实现Cloneable,类有两个属性,分别是String类型的name和Address类型的address
- Address是一个类,它包含了一个String类型的province属性。
-
创建一个PersonClone类的对象person1,然后使用clone方法复制一个新的对象并把它赋值给person2
-
只修改person2的address属性的province的值。最后发现person1和person2的值都发生了改变
深拷贝,重写clone方法
public class Address implements Cloneable{
private String province;
public String getProvince() {
return province;
}
public void setProvince(String province) {
this.province = province;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
@Override
public String toString() {
return new StringJoiner(",", Address.class.getSimpleName() + "[", "]")
.add("province='" + province + "'").toString();
}
}
public class PersonClone implements Cloneable {
public static void main(String[] args) throws CloneNotSupportedException {
Address address = new Address();
address.setProvince("ZheJiang");
PersonClone person1 = new PersonClone("Test", address);
PersonClone person2 = (PersonClone) person1.clone();
person2.getAddress().setProvince("JiangSu");
System.out.println(person1);
System.out.println(person2);
}
private String name;
private Address address;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Address getAddress() {
return address;
}
public void setAddress(Address address) {
this.address = address;
}
public PersonClone(String name, Address address) {
this.name = name;
this.address = address;
}
@Override
protected Object clone() throws CloneNotSupportedException {
PersonClone person = (PersonClone) super.clone();
person.setAddress((Address) address.clone());
return person;
}
@Override
public String toString() {
return new StringJoiner(",", Person.class.getSimpleName() + "[", "]")
.add("name='" + name + "'")
.add("address=" + address)
.toString();
}
}
输出结果
Person[name='Test',address=Address[province='ZheJiang']] Person[name='Test',address=Address[province='JiangSu']]
- 可以发现,对clone出来的新对象的修改并没有影响到原有的对象



