3-Object类

Object类

1. equals()

/*
 * equals()方法和 == 运算符 的区别
 *
 * 1、==：运算法
 *      1.1 可以在基本数据类型和引用数据类型中使用
 *      1.2 如果比较的基本数据类型：比较的是两个基本数据类型变量保存的数据是否相等（不一定类型要相同）
 *      1.3 如果比较的是引用数据类型：比较两个对象的地址值是否相同.即两个引用是否指向同一个对象实体
 *
 * 2、equals()方法的使用
 * 1. 是一个方法，而非运算符
 * 2. 只能适用于引用数据类型
 * 3. Object类中equals()的定义：
 *    public boolean equals(Object obj) {
	        return (this == obj);
	  }
 *    说明：Object类中定义的equals()和==的作用是相同的：比较两个对象的地址值是否相同.
 *    即两个引用是否指向同一个对象实体
 *
 * 4. 像String、Date、File、包装类等都重写了Object类中的equals()方法。重写以后，比较的不是
 *    两个引用的地址是否相同，而是比较两个对象的"实体内容"是否相同。
 *
 * 5. 通常情况下，我们自定义的类如果使用equals()的话，也通常是比较两个对象的"实体内容"是否相同。
 * 	  那么，我们就需要对Object类中的equals()进行重写.
 *    重写的原则：比较两个对象的实体内容是否相同.
 */

2. toString()

/*
 * 1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()，返回类名和它的引用地址
 *
 * 2. Object类中toString()的定义：
 *   public String toString() {
        return getClass().getName() + "@" + Integer.toHexString(hashCode());
     }
 *
 * 3. 像String、Date、File、包装类等都重写了Object类中的toString()方法。
 *    使得在调用对象的toString()时，返回"实体内容"信息
 *
 * 4. 自定义类也可以重写toString()方法，当调用此方法时，返回对象的"实体内容"
 */

//equals()和toString()方法使用举例：
public class T1equalsAndtoString {

    @Test
    public void test1(){

        //基本数据类型
        int i = 10;
        int j = 10;
        double d = 10.0;
        char c = 10;
        System.out.println(i == c);//true
        System.out.println(i == j);//true
        System.out.println(i == d);//true
        char c1 = 'A';
        int c2 = 65;
        System.out.println(c1 == c2);//true
        System.out.println();


        //引用数据类型
        Customer cust1 = new Customer("abc", 12);
        Customer cust2 = new Customer("abc", 12);
        System.out.println(cust1 == cust2);//false
        System.out.println(cust1.equals(cust2));//重写equals后，比较的是实体内容。true
        System.out.println();


        //像String、Date、File、包装类等都重写了Object类中的equals()方法
        Date date1 = new Date(32432525324L);
        Date date2 = new Date(32432525324L);
        System.out.println(date1.equals(date2));
        System.out.println();


        Customer cust3 = new Customer("Tom",21);
//        1. 当我们输出一个对象的引用时，实际上就是调用当前对象的toString()，返回类名和它的引用地址
        System.out.println(cust3.toString());//com.atguigu.java1.Customer@15db9742-->Customer[name = Tom,age = 21]
        System.out.println(cust3);//com.atguigu.java1.Customer@15db9742-->Customer[name = Tom,age = 21]

        String str = new String("MM");
        System.out.println(str);//MM

        Date date = new Date(4534534534543L);
        System.out.println(date.toString());//Mon Sep 11 08:55:34 GMT+08:00 2113
    }


class Customer{

    private String name;
    private int age;

    public Customer() {
    }

    public Customer(String name, int age) {
        this.name = name;
        this.age = age;
    }


    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }


    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }


//    //自动实现重写的equals()方法：ctrl+shift+s快捷键
//    @Override
//    public boolean equals(Object o) {
//        if (this == o) return true;
//        if (!(o instanceof Customer)) return false;
//        Customer customer = (Customer) o;
//        return getAge() == customer.getAge() &&
//                Objects.equals(getName(), customer.getName());
//    }

    //自动实现重写toString()
//    @Override
//    public String toString() {
//        return "Customer{" +
//                "name='" + name + '\'' +
//                ", age=" + age +
//                '}';
//    }

    //重写equals()
    //重写的原则：比较两个对象的实体内容(即：name和age)是否相同
    @Override
    public boolean equals(Object obj) {
        //1. 判断地址值是否相同，相同则为同一个对象，那么实体内容肯定是相同的
        if(this == obj){
            return true;
        }

        if(obj instanceof Customer){
            Customer cust = (Customer)obj;
            //比较两个对象的每个属性是否都相同
            //age是基本数据类型，用==比较
            //name是字符串，用String中的equals比较
            if(cust.age == this.age && cust.name.equals(this.name)){
                return true;
            }else {
                return false;
            }
        }else {
            return false;
        }
    }

}

3. hashCode()

集合中讲到。。。

4. clone()

• 浅拷贝：浅拷贝是指拷贝对象时仅仅拷贝对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象。
• 深拷贝：深拷贝不仅拷贝对象本身，而且拷贝对象包含的引用指向的所有对象。

/*
 * 1. 对象赋值：两个引用指向相同的对象
 * 
 * 2. clone()浅拷贝：Object中的clone()方法是protected的，返回类型是Object的
 *      2.1 实现方式
 *          2.1.1 实现Cloneable接口，这是一个标记接口，自身没有方法。
 *          2.1.2 覆盖clone()方法，可见性提升为public
 *      2.2 特点：浅拷贝仅仅拷贝对象本身和对象中的基本变量，而不拷贝对象包含的引用指向的对象
 *          
 * 3. clone()深拷贝
 *
 * 4. 浅拷贝案例如下：
 */

public class T3clone {

    @Test
    //1. 对象赋值：两个引用指向相同的对象
    public void test1() throws Exception {
        Person p1 = new Person("abc", 10);
        Person p2 = p1;
        System.out.println(p1 == p2);//true
        p1.setAge(19);
        System.out.println(p2.toString());//Person{name='abc', age=19, address=null}
        System.out.println(p1.toString());//Person{name='abc', age=19, address=null}
    }

    @Test
    //浅拷贝是指拷贝对象时仅仅拷贝对象本身和对象中的基本变量
    public void test2() throws Exception{

        Person p1 = new Person("abc", 10);
        Person p3 = (Person) p1.clone();
        System.out.println(p3 == p1);//false
        p3.setName("efg");
        System.out.println(p3.toString());//Person{name='efg', age=10, address=null}
        System.out.println(p1.toString());//Person{name='abc', age=10, address=null}
    }

    @Test
    //而不拷贝对象包含的引用指向的对象
    public void teat3() throws Exception{

        Address address = new Address("north", 110.32);
        Person p4 = new Person("小米", 24, address);
        Person p5 = (Person)p4.clone();
        p5.setAddress(new Address("east", 102));
        System.out.println(p4 == p5);//false
        System.out.println(p4.toString());//Person{name='小米', age=24, address=Address{location='north', distance=110.32}}
        System.out.println(p5.toString());//Person{name='小米', age=24, address=Address{location='east', distance=102.0}}
    }
}


class Person implements Cloneable {

    private String name;
    private int age;
    private Address address;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public Person(String name, int age, Address address) {
        this.name = name;
        this.age = age;
        this.address = address;
    }

    public void setAddress(Address address) {
        this.address = address;
    }

    public Address getAddress() {
        return address;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public void setName(String name) {
        this.name = name;
    }

    public void setAge(int age) {
        this.age = age;
    }


    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address=" + address +
                '}';
    }

    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

class Address{

    private String location;
    private double distance;

    public String getLocation() {
        return location;
    }

    public double getDistance() {
        return distance;
    }

    public Address(String location, double distance) {
        this.location = location;
        this.distance = distance;
    }

    public void setLocation(String location) {
        this.location = location;
    }

    public void setDistance(double distance) {
        this.distance = distance;
    }

    @Override
    public String toString() {
        return "Address{" +
                "location='" + location + '\'' +
                ", distance=" + distance +
                '}';
    }
}