Object类及其方法

java.lang.Object下

类Object是类层次结构的根（父）类。

每个类（Person,Student...)都使用Object作为超（父）类。

所有对象（包括数组）都实现这个类的方法。

目录

 

1.这里是Object下的toString方法：

2.Object类的equals方法，

3.Object类中equals方法空指针异常问题

---

 

1.这里是Object下的toString方法：

package jason.lh.object学习.toString方法;

/**
 * @Author: Jason
 * @Date: 2019/8/21 13:33
 * @Version 1.0
 */
public class Person {
    private String name;
    private int age;

    public Person() {
    }

    @Override
    public String toString() {
       return "Hello";
    }

    public Person(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;
    }
}

 

package jason.lh.object学习.toString方法;

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

public class DemoToString {
    public static void main(String[] args) {
        //Preson类默认继承了Object类，所以可以使用Object类中的toString方法
        //String toString()返回该对象的字符串表示
        Person person = new Person("小明",15);
        String s =person.toString();

        System.out.println(s);  //地址值jason.lh.object学习.toString方法.Person@1540e19d

        //直接打印对象的名字，其实就是调用对象的toString person = person.toString();
        System.out.println(person);

        /*  看一个类是否重写了toString方法，直接打印这个类的对象即可，
            如果没有重写toString方法那么打印的对象是地址值。
        */
        Random random = new Random();  //没有重写toString
        System.out.println(random);

        Scanner scanner = new Scanner(System.in);   //重写了
        System.out.println(scanner);


        ArrayList list = new ArrayList<>();  //重写了toString方法
        list.add(1);
        list.add(2);
        list.add(3);
        System.out.println(list);
    }

}

 

2.Object类的equals方法，

默认比较的是两个对象的地址值，没有意义

所以我们要重点写equals方法，比较两个对象的属性（name，age）

 

问题：

隐含着一个多态

多态的弊端：无法使用子类特有的内容（属性和方法）

Object obj= person2 = new Person("古力娜扎",19);

 

解决：可以使用向下转型（强转）把obj类型转换为Person

@Override
public boolean equals(Object obj) {
    //增加一个判断，传递的参数obj如果是null，直接返回false，提高程序的效率
    if(obj==null)return false;
    //增加一个判断，传递的参数obj如果是this本身，直接返回true，提高程序的效率
    if(obj==this)return true;

    //增加一个判断，防止类型转换一次ClassCastException
    if (obj instanceof Person) {
        Person person = (Person) obj;   //使用向下转型，把obj转换成为Person类型
        //比较两个对象的属性，一个对象是this（person1），一个是person（obj——>person2）
        boolean b = this.name.equals(person.name) && this.age == person.age;
        return b;
    }
    //不是Person直接返回false
    return false;
}

 

package jason.lh.object学习.toString方法;

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

    public Person() {
    }

//    @Override
//    public String toString() {
//       return "Hello";
//    }


    @Override
    public boolean equals(Object obj) {
        //增加一个判断，传递的参数obj如果是null，直接返回false，提高程序的效率
        if(obj==null)return false;
        //增加一个判断，传递的参数obj如果是this本身，直接返回true，提高程序的效率
        if(obj==this)return true;

        //增加一个判断，防止类型转换一次ClassCastException
        if (obj instanceof Person) {
            Person person = (Person) obj;   //使用向下转型，把obj转换成为Person类型
            //比较两个对象的属性，一个对象是this（person1），一个是person（obj——>person2）
            boolean b = this.name.equals(person.name) && this.age == person.age;
            return b;
        }
        //不是Person直接返回false
        return false;
    }

    public Person(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;
    }
}

还可以通用快捷键自我创建：

 

 

@Override
public boolean equals(Object o) {
    if (this == o) return true;
   // getClass()!= o.getClass() 使用反射技术，判断o是否是Person类型
    if (o == null || getClass() != o.getClass()) return false;
    Person person = (Person) o;
    return age == person.age &&
            Objects.equals(name, person.name); //防止空指针异常
}

 

Person类默认继承了Object类，所以可以使用Object类的equals方法

boolean equals(Object obj) 指示其他某个对象是否与此对象“相等”。

equals方法源码;

public boolean equals(Object obj){

return (this == obj);

 

}

参数;

Object obj:可以传递任意的对象

== 比较运算符，返回的是一个布尔值 true false

基本数据类型：比较的是值

引用数据类型：比较的是两个对象的地址值

public class DemoEquals {
    public static void main(String[] args) {

        Person person1 = new Person("迪丽热巴", 18);
        Person person2 = new Person("古力娜扎", 19);
        System.out.println("person1" + person1);
        System.out.println("person2" + person2);
     //   person1=person2;  //把person2的地址赋值给person1  b为true
        boolean b = person1.equals(person2);
        System.out.println(b);
    }


}

 

3.Object类中equals方法空指针异常问题

 

在刚才IDEA自动重写equals代码中，使用到了java.util.Object类，那么这个类是什么呢？

 

在JDK7添加了一个Objects工具类，它提供了一些方法来操作对象，它由一些静态的实用方法组成，

这些方法是null-save（空指针安全的）或null-tolerant（容忍空指针的），用于计算对象的hashcode,

返回对象的字符串表示形式、比较两个对象。

 

在比较两个对象的时候，Object的equal方法容易抛出空指针异常，而Object类中的equals方法就

优化了这个问题。如下：

public class DemoObjects {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "aBc";
        System.out.println(s1.equals(s2));

        String s3 = null;
        System.out.println(s3.equals(s1)); //NullPointerException null不能调用方法的 就会抛出空指针异常

    }
}

Objects类的equals方法：对两个对象进行比较，防止空指针异常

public static boolean equals(Object a, Object b){

return (a== b)||(a != null && a.equals(b));

}

public class DemoObjects {
    public static void main(String[] args) {
        String s1 = "abc";
        String s2 = "aBc";
        System.out.println(s1.equals(s2));

        String s3 = null;
       // System.out.println(s3.equals(s1)); //NullPointerException null不能调用方法的 就会抛出空指针异常

        /*
        Objects类的equals方法：对两个对象进行比较，防止空指针异常
        public static boolean equals(Object a, Object b){
               return (a== b)||(a != null && a.equals(b));
               }
         */
        boolean b = Objects.equals(s3,s1);
        System.out.println(b);
    }
}