Java面向对象——API(3)----Object类、包装类、包装类常用方法、自动装箱拆箱

1. Object

是所有类的鼻祖，所有类都直接或间接继承了Object，万物皆对象，为了多态

Object中有两个经常被派生类重写的方法：toString()和equals()

调用Object类的toString()时默认返回：类的全称@地址，没有参考意义，所以常常重写toString()来返回具体属性的值。

注意：String、StringBuilder等都重写了toString()来返回字符串内容了

public class ObjectDemo {
    public static void main(String[] args) {
        /*
          输出引用变量时默认会调用Object类的toString()方法
          该方法返回的字符串格式为: 类的全称@地址
          但通常这个返回结果对我们的开发是没有意义的
          我们真正想输出的应该是对象的属性值，我们认为Object类的toString()并不能满足需求
          因此常常需要重写toString()来返回具体的属性值
         */
        Point p = new Point(100,200);
        System.out.println(p); //输出引用类型变量时会默认调用Object类的toString()
        System.out.println(p.toString());
    }
}

import java.util.Objects;

/**
 * 点
 */
public class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

调用Object类的equals()时默认比较的是还是==(即比较地址)，没有参考意义，所以常常重写equals()来比较具体的属性值

注意

String类已经重写equals()来比较字符串内容了，但StringBuilder并没有

重写equals()的基本原则：

原则上要比较两个对象的属性值是否相同

两个对象必须是同一类型的，若类型不同则返回false

public class ObjectDemo {
    public static void main(String[] args) {
        /*
          调用Object类的equals()，内部还是在使用==比较地址，没有实际意义
          若想比较对象的属性值是否相同，我们认为Object的equals()并不能满足需求
          因此常常需要重写equals()
         */
        /*
        Point p1 = new Point(100,200);
        Point p2 = new Point(100,200);
        System.out.println(p1==p2); //false，==比较的是地址
        //因为Point类重写了equals()方法，
        //所以此处调用的是重写之后的equals()，比较的是属性的值是否相同
        System.out.println(p1.equals(p2)); //true
        */

        String s1 = new String("hello");
        String s2 = new String("hello");
        //String类重写了equals()来比较字符串内容是否相同
        System.out.println(s1.equals(s2)); //true

        StringBuilder builder1 = new StringBuilder("hello");
        StringBuilder builder2 = new StringBuilder("hello");
        //StringBuilder类没有重写equals()，因此调用的还是Object类的equals()，比较的还是地址
        System.out.println(builder1.equals(builder2)); //false

        //s1与builder1的类型不同，所以equals()一定为false
        System.out.println(s1.equals(builder1)); //false
    }
}


package apiday02;

import java.util.Objects;

/**
 * 点
 */
public class Point {
    private int x;
    private int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    @Override
    public String toString() {
        return "Point{" +
                "x=" + x +
                ", y=" + y +
                '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Point point = (Point) o;
        return x == point.x && y == point.y;
    }

    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }
}

2、包装类

java中的基本数据类型int，double等不是对象，无法通过向上转型获取到Object提供的方法，而像String却可以，只因为String是一个类而不是一个类型。基本数据类型由于这样的特性，导致无法参与转型，泛型等过程。为了弥补这个缺陷，java提供了包装类，包装类都在java.lang包下面。

包装类作用：
1）提供了一系列实用的方法，作为基本数据类型对应的类类型，提供了一系列实用的对象操作，如类型转换。
2）集合不允许存放基本数据类型数据，存放数字时，要用包装类型。
3）包含了每种基本数据类型的相关属性，如最大值、最小值、所占位数等
//获取基本数据类型的相关属性
System.out.println(Byte.SIZE);// 8
System.out.println(Byte.MIN_VALUE);// -128
System.out.println(Byte.MAX_VALUE);// 127
4）所有包装类都是final类型，不能创建它们的子类
5）JDK1.5后，允许基本数据类型和包装类型进行混合数学运算，包装类并不是用来取代基本数据类型的，在基本数据类型需要用对象表示时使用

基本类型和包装类的对应关系：
byte-Byte int-Integer short-Short long-Long float-Float
double-Double boolean-Boolean char-Character

基本数据类型的长度（位-bit）-- 一个字节占8位，char两个字节，可以存放汉字。
System.out.println(Byte.SIZE); // 8
System.out.println(Short.SIZE); // 16
System.out.println(Integer.SIZE); // 32
System.out.println(Long.SIZE); // 64
System.out.println(Float.SIZE); // 32
System.out.println(Double.SIZE); // 64
System.out.println(Character.SIZE);// 16

所有包装类都可将与之对应的基本数据类型作为参数，来构造它们的实例：
Integer integer1 = new Integer(100);
Double double1 = new Double(100.12);
Boolean boolean1 = new Boolean(true);
Character character1 = new Character('a');
除Character类外，其他包装类可将一个字符串作为参数构造它们的实例:
Integer integer2 = new Integer("200");
Double double2 = new Double("200.12");

注意：
1.Boolean类构造方法参数为String类型时，若该字符串内容为true(不考虑大小写)，则该Boolean对象表示true，否则表示false
Boolean b2 = new Boolean("True");
Boolean b3 = new Boolean("TRUE");
Boolean b4 = new Boolean("OK");
2.当包装类构造方法参数为String 类型时，字符串不能为null，且该字符串必须可解析为相应的基本数据类型的数据，否则编译通过，运行时NumberFormatException异常
Integer a2 = new Integer("");// NumberFormatException: For input string: ""
Integer a3 = new Integer(null);// NumberFormatException: null
Integer a4 = new Integer("abc");// NumberFormatException: For input string: "abc"

3、包装类的常用方法

valueOf
Integer intValue = Integer.valueOf(345);
除Character类外，其他包装类都可以如下操作：
Integer intValue = Integer.valueOf("456");

xxxValue()--包装类转换为基本数据类型
Integer in1 = new Integer(123);
int in2 = in1.intValue();

toString()--以字符串形式返回包装对象表示的基本类型数据
String str = Integer.toString(50);//自动装箱并调用toString()方法，这也是将基本类型转换为包装类的好处。
String sex = Character.toString('男');
// String str = String.valueOf(21); -- String类提供的方法

parseXXX()：把字符串转换为相应的基本数据类型数据（Character除外）
int num1 = Integer.parseInt("100");
System.out.println(num1); //100
boolean bool = Boolean.parseBoolean("false");

4、包装类的自动装箱和拆箱

装箱：基本类型转换为包装类的对象  
拆箱：包装类对象转换为基本类型的值

//自动装箱
Integer in = 10;
System.out.println(in);// 10
  
//自动拆箱
Integer inn = new Integer(10);
int n = inn + 10;
System.out.println(n);// 20

5. 示例

 ```java
 public class IntegerDemo {
     public static void main(String[] args) {
         //演示包装类的常用操作:
         //1)可以通过包装类来获取基本类型的取值范围:
         int max = Integer.MAX_VALUE; //获取int的最大值
         int min = Integer.MIN_VALUE; //获取int的最小值
         System.out.println("int的最大值为:"+max+"，最小值为:"+min);
         long max1 = Long.MAX_VALUE; //获取long的最大值
         long min1 = Long.MIN_VALUE; //获取long的最小值
         System.out.println("long的最大值为:"+max1+"，最小值为:"+min1);
 
         //2)包装类可以将字符串类型转换为对应的基本类型-------必须熟练掌握
         String s1 = "38";
         int age = Integer.parseInt(s1); //将字符串s1转换为int类型
         System.out.println(age); //38---int类型
         String s2 = "123.456";
         double price = Double.parseDouble(s2); //将字符串s2转换为double类型
         System.out.println(price); //123.456---double类型
 
         /*
         //触发自动装箱特性，会被编译为: Integer i = Integer.valueOf(5);
         Integer i = 5; //基本类型到包装类型----装箱
         //触发自动拆箱特性，会被编译为: int j = i.intValue();
         int j = i; //包装类型到基本类型--------拆箱
         */
 
         /*
         Integer i1 = new Integer(5);
         Integer i2 = new Integer(5);
         System.out.println(i1==i2); //false，因为==比较的是地址
         System.out.println(i1.equals(i2)); //true，Integer类中重写了equals()比较值
 
         //Integer.valueOf()会复用-128到127范围内的数据---使用valueOf()更多一些
         Integer i3 = Integer.valueOf(5);
         Integer i4 = Integer.valueOf(5);
         System.out.println(i3==i4); //true
         System.out.println(i3.equals(i4)); //true，Integer类中重写了equals()比较值
          */
     }
 }
 ```

Java面向对象——API(3)----Object类、包装类、包装类常用方法、自动装箱拆箱

1. Object

2、包装类

3、包装类的常用方法

4、包装类的自动装箱和拆箱

5. 示例

推荐阅读更多精彩内容