1. Object的方法

Object：所有类的父类，可以接受所有类的对象

1.1 public String toString() {} :获取对象信息

默认输出的是对象的地址码，通过覆写方法改变
例：Object类的输出

public class Test {
    public static void fun(Object obj){
        //输出对象的地址码
        //默认调用的是Object的toString方法
        System.out.println(obj);  //等价于obj.toString()
    }
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(20);
        Object object = person;

        fun(person);
        fun(object);

    }
}
/**
com.csdn.qh.Person@4554617c
com.csdn.qh.Person@4554617c
*/

例：覆写toString()方法

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


    public String getName() {
        return name;
    }

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

    public Integer getAge() {
        return age;
    }

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

    public String toString(){
        return "Name:"+this.getName()+",Age:"+this.getAge();
    }
}

public class Test {
    public static void fun(Object obj){
        //默认调用的是Object的toString方法
        //通过覆写父类方法，调用的是子类覆写的方法
        System.out.println(obj);  
    }
    public static void main(String[] args) {
        Person person = new Person();
        person.setAge(20);
        person.setName("张三");
        Object object = person;

        fun(person);
        fun(object);

    }
}
/**
Name:张三,Age:20
Name:张三,Age:20
*/

1.2.public boolean equals(Object obj){} :对象比较

在String类中有使用equals方法，str.equals(str2) ----用来比较这两个字符串的内容是否相等，说明了String类覆写了Object的equals方法。
在String类中覆写了equals方法，源代码解析：

public boolean equals(Object anObject) {
        if (this == anObject) {              //判断对象是否相等（地址进行判断）
            return true;
        }
        if (anObject instanceof String) {      //判断anObject是否是String的实例化对象
            String anotherString = (String)anObject;   //转换成String类
            int n = value.length;
            if (n == anotherString.value.length) {
                char v1[] = value;
                char v2[] = anotherString.value;
                int i = 0;
                while (n-- != 0) {
                    if (v1[i] != v2[i])
                        return false;
                    i++;
                }
                return true;
            }
        }
        return false;     //不是String类
    }

例：写一个Person类的equals方法

public boolean equals(Object obj) {
        if (obj == null){
            return false;
        }

        //this和obj是同一个对象（地址）
        if(this == obj){
            return true;
        }

        //this和obj不是同一个对象（比较内容）
        //比较的是name和age
        if(obj instanceof Person){  //obj是否是Person类的实例化对象
            //比较所有属性
            Person that = (Person)obj;
            return this.getName().equals(that.getName())&& this.getAge()== that.getAge();
        }

        //不是Person类对象实例化的
        return false;
    }

2.接受所有引用型数据类型

Object能够接受Java所有类型的对象（类，接口，数组）
举例如下：

interface Message{
    void print();
}
public class Test {
    public static void main(String[] args) {
        //Object能够接受Java所有类型的对象（类，接口，数组）
        //1.Object接受数组
        Object object  = new int[]{1,2,3,4};

        //int[] 是引用类型数据，是objec子类，必须进行强转
        int[] intArray = (int[]) object;

        for(int value:intArray){
            System.out.println(value+",");
        }

        //2.object接收接口类型
        Object object1 = new Message(){
            @Override
            public void print() {
                System.out.println("hello java");
            }
        };
        //向下转型
        Message message = (Message) object1;
        message.print();

        //基本数据类型转到引用数据类型
        Object object2 = 10;
        System.out.println(object2);

    }
}

3.包装类

作用：就是将基本数据类型转换为引用数据类型
基本数据的包装类：
1. 对象型（Object的直接子类 —直接继承Object）：Boolean,Character(char)
2. 数值型（继承自Number）：Byte,Double,Short,Integer(int),Float
装箱：int -----> Integer
拆箱：Integer ----> int
例：拆箱和装箱

public class Test1 {
    public static void main(String[] args) {
        Integer integer = new Integer(10);  //10->装箱->integer
        int intValue = integer.intValue();   //integer ->拆箱->intValue

        System.out.println(intValue);  //10
    }
}

例：JDK自动拆箱和装箱

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

        //JDK自动装箱和拆箱
        //1.包装类
        //2.自动装箱、拆箱

        Object object = 10;
        int value = (int)object;

        Number number = 10;  //Integer直接继承Number
        Object object1 = false; //Boolean直接继承自Object

        Integer x = 55;  //自动装箱，变成new Integer(55);

        System.out.println(++x*5);//自动拆箱  x.intValue
        
    }
}

Integer比较

public class Test1 {
    public static void main(String[] args) {
        //基于String赋值的方式 ---->内存池
        //包装Integer直接跟内存有关，而是Integer内部做了缓存

        //不直接new，直接赋值，会产生缓存，值在[-128,127]
        Integer a = 100;
        Integer b = 100;

        Integer c = new Integer(100);
        Integer d = new Integer(100);

        Integer g = 666;
        Integer h = 666;

        //使用缓存
        System.out.println(a == b);   //true
        System.out.println(a.equals(b));  //true

        System.out.println(g == h);    //false
        System.out.println(g.equals(h));   //true

        //不使用缓存
        System.out.println(c == d);  //false
        System.out.println(c.equals(d));   //true
        
    }
}

Object的方法使用

Object方法使用