Java：19-Object类的概述和使用

各个方面都自在

已于 2024-07-06 18:40:35 修改

阅读量202

点赞数

分类专栏：笔记文章标签： java

于 2022-01-05 02:27:19 首次发布

本文链接：https://blog.csdn.net/qq_59609098/article/details/122315189

版权

笔记专栏收录该内容

115 篇文章 10 订阅

订阅专栏

Object类的概述

Object类的概述------------------------------

java.lang.Object类是Java语言中类层次结构的根类，也就是说任何一个类都是该类的直接或者间接子类，有就不是

如果定义一个Java类时没有使用extends关键字声明其父类，则其父类为 java.lang.Object 类，有就不是，当然，你也可以手动的继承Object

Object类定义了"对象"的基本行为，被子类默认继承

常用的方法------------------------------

Object()
int hashCode()
String toString()
Class<?> getClass()

equals的重写和优化------------------------------

用于判断调用对象是否与参数对象相等

该方法默认比较两个对象的地址是否相等，与 == 运算符的结果一致，若希望比较两个对象的内容，则需要重写该方法

若该方法被重写后，则应该重写hashCode方法来保证结果的一致性

package com.lagou.task11;

import java.util.Objects;

/**
 *
 */
public class Student extends Object{ //若没有继承其他类，则默认继承Object类（根类）
    private int id; //用于描述学号的成员变量
    private String name; //用于描述姓名的成员变量

    public Student() {
    }

    public Student(int id, String name) {
        setId(id);
        setName(name);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        if(id > 0) {
            this.id = id;
        }else{
            System.out.println("学号不合理哦");
        }
    }

    public String getName() {
        return name;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return id == student.id &&
                Objects.equals(name, student.name);
    }

//一般来说，大多数的hashCode重写都是使用数字，因为比较高效，且容易计算，只是并不能保证完全相同而已，但是对与高效而言，这点问题是可以忽略或者可以进行解决的
    @Override
    public int hashCode() {
        return Objects.hash(id, name);
    }

    @Override
    public String toString() {
        return "Student{" +
                "id=" + id +
                ", name='" + name + '\'' +
                '}';
    }
    //alt+insert可以出现快捷打印代码，如set和get方法，构造方法，重写方法，equals和hashCode方法等
/*
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

        if (id != student.id) return false;
        return name != null ? name.equals(student.name) : student.name == null;
    }

    @Override
    public int hashCode() {
        int result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        return result;
    }


 */
    /**
     * 为了比较两个对象的内容，也就是学号信息需要重写该方法
     */
    //Student this = s1;
    //Object obj = s2;
    /*
    @Override
    public boolean equals(Object obj) {
        //当调用对象和参数对象指向同一个对象时，则内容一定相同
        if(this == obj) return true;
        //当调用对象不为空，而参数对象为空时，则内容一定不相等
        if(obj == null) return false; //当if语句后面只有一条语句时，大括号可以不写
        //判断obj指向的对象是否为Student类型的对象，若是则条件成立，否则条件不成立
        if (obj instanceof Student){
            Student ts = (Student) obj;
            //return this.getId() == ts.getId();//以学号作为基准判断两个对象是否相等
            //int类型是基本数据类型，内存空间中放的就是数据本身，使用 == 可以判断数据是否相同
            //return this.getName() == ts.getName();
            //以姓名作为基准判断两个对象是否相等，String是引用数据类型，内存空间中放的是地址
            //使用 == 判断地址是否相同，也就是判断两个对象中姓名字符串的地址是否相同，不够完美
            return this.getName().equals(ts.getName());
        }
        //否则类型不一致没有可比性，则内容一定不相等
        return false;

    }

     */
        /**
         * 为了使得该方法的结果与equals方法的结果保持一致，从而满足Java官方的常规协定
         * 需要重写该方法
         * 双方都需要对照id来操作
         */
        /*
        @Override
        public int hashCode() {
            //return getId(); //不在代表内存地址的编号了
             final int type = 12;
             //return type*31 + getId();
            return type*31 + getName().hashCode();
        }

         */
    /**
     *为了返回更有意义的字符串数据，则需要重写该方法
     */
    /*
    @Override
    public String toString() {
        return "Student[id = " + getId() + ",name = " + getName() + "]";
    }

     */
}

package com.lagou.task11;

        import javax.swing.text.Style;

/**
 *
 */
public class StudentTest {
    public static void main(String[] args) {
        //使用有参方式构造Student类型的两个对象并判断是否相等
        //由于现实生活中，名字有可能相同，学号不同，那么我们就要重写equals方法
        //来比较学号
        Student s1 = new Student(1001,"张飞");
        //Student s2 = new Student(1002,"关羽");
        Student s2 = new Student(1001,"张飞");
        //Student s2 = s1; //表示s2和s1都指向了同一个对象，地址相同了
        //下面调用从Object类中继承下来的equals方法，该方法默认比较两个对象的地址
        //当Student类重写equals方法后，则调用重写以后的版本
        //boolean b1 = s1.equals(s2); //在鼠标位置那里，按下ctrl加鼠标左键可以看选中的源代码
        //Student s3 = null;
        //boolean b1 = s1.equals(s3);
        Student s3 = s1;
        boolean b1 = s1.equals(s3);
        /*
        Object的equals方法的源代码
        public boolean equals(Object obj) {
                return (this == obj);
        }
        //equals方法在非null引用上实现等价关系，因为null引用调用对象会发生空指针异常
        */
        System.out.println("b1 = " + b1);
        System.out.println(s1 == s2);
        System.out.println("-----------------------------");
        //下面调用从Object类中继承下来的hashCode方法，获取调用对象的哈希码值（可以看成内存地址的编号）
        //当Student类中重写hashCode方法后，则调用重写以后的版本
        int ia = s1.hashCode();
        int ib = s2.hashCode();
        System.out.println("ia = " + ia);
        System.out.println("ib = " + ib);
        //s1和s2用equals方法比较，结果为true，用hashCode方法，结果地址不同
        //本来hashCode方法结果要与equals的结果一致的，但我们重写了equals方法
        //那么我们也要重写hashCode方法，使得结果一致，官方的常规协定
        //之所以要这样规定，是因为一些java类中，如HashMap，HashSet会使用到他们，或者一些其他java自带的类（或者也说包括工具类），所以hashCode和equals方法的一致性主要是为了确保在Java中使用一些自带的类，如哈希表（如HashMap、HashSet）等数据结构时能够正常工作，如果这些数据结构在操作过程中没有依赖于hashCode和equals方法，则不需要考虑它们的一致性问题，然而，在实践中，许多Java类和数据结构都依赖于这两个方法的一致性来保证正确的行为，这也是为什么我们需要保证一致的原因，而不是必须一致，所以如果单纯的不考虑开发因素，你也可以不一致
        System.out.println("-----------------------------");
        //下面调用从Object类中继承下来的toString方法，获取调用对象的字符串形式：包名.类名@哈希码值的十六进制
        //当Student类中重写toString方法后，则调用重写以后的版本：Student[id = 1001,name = 张飞]
        String str1 = s1.toString();
        System.out.println("str1 = " + str1); //com.lagou.task11.Student@55d
        //为了返回更有意义的数据，所以我们重写toString方法
        System.out.println("-----------------------------");
        System.out.println(s1);
        //当打印一个引用变量时会自动调用toString方法
        String str2 = "hello" + s1;
        System.out.println("str2 = " + str2);
    }
}

在这里插入图片描述

hashCode方法------------------------------

返回对象的哈希码值，哈希码值可以称为内存地址的编号

用于获取调用对象的哈希码值（内存地址的编号）

若两个对象调用equals方法相等，则各自调用该方法的结果必须相同

若两个调用对象equals方法不相等，则各自调用该方法的结果应该不相同

为了使得该方法与equals方法保持一致，需要重写该方法

toString方法------------------------------

用于获取调用对象的字符串形式

该方法默认返回的字符串为：包名.类名@哈希码值的十六进制

为了返回更有意义的数据，需要重写该方法

使用print或println打印引用或字符串拼接引用都会自动调用该方法，因为底层都操作了他的该方法，自己看源码就行了

Class<?> getClass()------------------------------

用于返回调用对象执行时的Class实例，反射机制使用

equals和hashCode方法的生成------------------------------

在以后的开发中，上述这些方法其实不需要我们主动去写

包的名称和功能------------------------------

java.lang包：该包是Java语言的核心包，并且该包中的所有内容由Java虚拟机自动导入

如：System类、String类、…

java.util包：该包是Java语言的工具包，里面提供了大量工具类以及集合类等

如：Scanner类、Random类、List集合、…

java.io包：该包是Java语言中的输入输出包，里面提供了大量读写文件相关的类等

如：FileInputStream类、FileOutputStream类、…

java.net包：该包是Java语言中的网络包，里面提供了大量网络编程相关的类等

如：ServerSocket类、Socket类、…

java.sql 包：该包是Java语言中的数据包，里面提供了大量操作数据库的类和接口等

如：DriverManager类、Connection接口、…

包装类的概念------------------------------

通常情况下基本数据类型的变量不是对象

为了满足万物皆对象的理念就需要对基本数据类型的变量进行打包封装处理变成对象

而负责将这些变量声明为成员变量进行对象化处理的相关类，叫做包装类

Person p = new Person(); //对象 p只是用来存的，可以单独使用new Person()
int num = 10; //不是对象 num也是用来存的，可以单独使用10
//所以我们要将num与类关联起来
//如
public class MyInt{
    private int num = 10;
}
//这样的可以不用写，因为Java官方写好了，如下面的包装类

在这里插入图片描述

Integer类的概述------------------------------

public final class Integer
extends Number
implements Comparable<Integer>
//Comparable<Integer>，比较器接口

public abstract class Number
extends Object
implements Serializable
//Serializable，序列化接口

java.lang.Integer类内部包装了一个int类型的变量作为成员变量

主要用于实现对int类型的包装并提供int类型到String类之间的转换等方法

常用的常量------------------------------

public static final int MAX_VALUE，表示int类型可以描述的最大值，即2^31-1
public static final int MIN_VALUE，表示int类型可以描述的最小值，即-2^31
public static final int SIZE，表示int类型采用二进制补码形式的位数
public static final int BYTES，表示int类型所占的字节个数
public static final Class TYPE，表示int类型的Class实例

常用的方法------------------------------

Integer(int value)，根据参数指定的整数来构造对象（已过时）
Integer(String s)，根据参数指定的字符串来构造对象 （已过时）
int intValue()，获取调用对象中的整数值并返回
static Integer valueOf(int i)，根据参数指定整数值得到Integer类型对象
boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
String toString()，返回描述调用对象数值的字符串形式
static int parseInt(String s)，将字符串类型转换为int类型并返回
static String toString(int i)，获取参数指定整数的十进制字符串形式
static String toBinaryString(int i)，获取参数指定整数的二进制字符串形式
static String toHexString(int i)，获取参数指定整数的十六进制字符串形式
static String toOctalString(int i)，获取参数指定整数的八进制字符串形式

package com.lagou.task11;

/**
 *
 */
public class IntegerTest {
    public static void main(String[] args) {
        //打印Integer类中常用的常量数值
        System.out.println("最大值是：" + Integer.MAX_VALUE); //2^31-1
        System.out.println("最小值是：" + Integer.MIN_VALUE); //-2^31
        System.out.println("所表示二进制的位数是：" + Integer.SIZE); //32
        System.out.println("所占的字节个数是：" + Integer.BYTES); //4
        System.out.println("对应int类型的Class实例是：" + Integer.TYPE); //int，没有想到竟然不是Integer，实际上是他规定的真正操作的实例，并不是Class哦
        System.out.println("--------------------------");
        //使用构造方法来构造Integer类型的对象并打印
        //Integer(int value)，根据参数指定的整数来构造对象（已过时）
        //Integer it1 = new Integer(123);
        //System.out.println("it1 = " + it1); //123
        // 自动调用toString方法得到String类型
        //Integer(String s)，根据参数指定的字符串来构造对象 （已过时）
        //Integer it2 = new Integer("456");
        //System.out.println("it2 = " + it2); //456
        //上述方法已过时，建议使用valueOf(int i)方法取代之
        //static Integer valueOf(int i),根据参数指定整数值得到Integer类型对象
        //该方法里的源代码用到了自动装箱（注意：自动装箱也会应用到Object，也就是说，如果是Object接收，也会进行处理的）
        Integer it3 = Integer.valueOf(123); //return new Integer(i)
        //相当于从int类型到Integer类型的转换,这种操作叫做装箱
        System.out.println("it3 = " + it3); //123
        Integer it4 = Integer.valueOf("456");
        //相当于从String类型到Integer类型的转换
        System.out.println("it4 = " + it4); //456
        //自动调用toString方法得到的是String类型
        //int intValue(),获取调用对象中的整数值并返回
        //相当于从Integer类型到Int类型的转换,这种操作就是拆箱
        int ia = it4.intValue(); //return value;
        System.out.println("获取到的整数数据是：" + ia); //456
        //得到的是int类型
        System.out.println("--------------------------");
        //从Java5开始增加了自动装箱和自动拆箱的机制
        Integer it5 = 100; //类似于Integer it5 = Integer.valueOf(100);
        //直接通过赋值运算符实现自动装箱（上面的解释）
        int ib = it5; //类似于int ib = it5.intValue();
        //直接通过赋值运算符实现自动拆箱（上面的解释）
        //并不是注释一定是解释下面的，只是大多数如此而已，这里是解释上面的
        System.out.println("it5 = " + it5); //100
        System.out.println("ib = " + ib); //100
        //自动拆箱和自动装箱的底层机制就是调用方法
        System.out.println("--------------------------");
        //装箱和拆箱的笔试考点
        Integer it6 = 127; //128
        Integer it7 = 127; //128 ，一般int比较就是相等的，因为没有操作类
        Integer it8 = new Integer(127); //new Integer(128);
        Integer it9 = new Integer(127); //new Integer(128);
        System.out.println(it6 == it7); //128的结果 比较地址 false 127的结果true
        //之所以结果为true是因为Integer的自动装箱池自动将-128到127的整数装箱完毕
        //即赋值时指向同一个地址，直接取用自动装箱池的对象
        //之所以不装箱int范围的对象，是考虑内存空间，因为不需要很多对象，所以只装箱byte范围的对象
        //若根据需要可以通过JVM调优，来修改范围，以后会讲到JVM调优
        System.out.println(it6.equals(it7)); //128和127的结果 比较内容 true
        System.out.println(it8 == it9); //128和127的结果 比较地址 false
        //之所以不为true是因为这是你创建的，不是用自动装箱池的对象，即不指向同一个地址
        System.out.println(it8.equals(it9)); //128和127的结果 比较内容 true
        System.out.println("--------------------------");
        //实现静态方法的调用
        int ic = Integer.parseInt("200");
        //static int parseInt(String s)，将字符串类型转换为int类型并返回
        //int ic = Integer.parseInt("200a");
        //编译ok,运行发生NumberFormatException数字格式异常，因为有字母
        System.out.println("字符串转化为整数的结果是：" + ic); //200
        //static String toString(int i)，获取参数指定整数的十进制字符串形式
        System.out.println("根据参数指定的整数获取对应的十进制字符串是：" + Integer.toString(ic)); //200
        //static String toBinaryString(int i)，获取参数指定整数的二进制字符串形式
        System.out.println("根据参数指定的整数获取对应的二进制字符串是：" + Integer.toBinaryString(ic));
        //11001000
        //static String toHexString(int i)，获取参数指定整数的十六进制字符串形式
        System.out.println("根据参数指定的整数获取对应的十六进制字符串是：" + Integer.toHexString(ic)); 
        //c8
        //static String toOctalString(int i)，获取参数指定整数的八进制字符串形式
        System.out.println("根据参数指定的整数获取对应的八进制字符串是：" + Integer.toOctalString(ic)); 
        //310
        //boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
        System.out.println(it6.equals(it7)); //true
        //String toString()，返回描述调用对象数值的字符串形式
        System.out.println(it6.toString()); //127
    }
}

Double类的概述------------------------------

public final class Double
extends Number
implements Comparable<Double>
//Comparable<Double>，比较器接口

public abstract class Number
extends Object
implements Serializable
//Serializable，序列化接口

java.lang.Double类型内部包装了一个double类型的变量作为成员变量

主要用于实现对double类型的包装并提供double类型到String类之间的转换等方法

常用的常量------------------------------

public static final int SIZE，表示double类型的二进制位数
public static final int BYTES，表示double类型的字节个数
public static final Class TYPE，表示double类型的Class实例

常用的方法------------------------------

Double(double value)，根据参数指定的浮点数据来构造对象（已过时）
Double(String s)，根据参数指定的字符串来构造对象 （已过时）
double doubleValue()，获取调用对象中的浮点数据并返回
static Double valueOf(double d)，根据参数指定浮点数据得到Double类型对象
boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
String toString()，返回描述调用对象数值的字符串形式
static double parseDouble(String s)，将字符串类型转换为double类型并返回
boolean isNaN()，判断调用对象的数值是否为非数字

package com.lagou.task11;

/**
 *
 */
public class DoubleTest {
    public static void main(String[] args) {
        //打印Double类中常用的常量数值
        System.out.println("所表示二进制的位数是：" + Double.SIZE); //64
        System.out.println("所占的字节个数是：" + Double.BYTES); //8
        System.out.println("对应double类型的Class实例是：" + Double.TYPE); //double
        //Double(double value)，根据参数指定的浮点数据来构造对象（已过时）
        Double ia = new Double(1.0);
        System.out.println("ia = " + ia); //1.0
        //Double(String s)，根据参数指定的字符串来构造对象 （已过时）
        Double ib = new Double("1.0");
        System.out.println("ib = " + ib); //1.0
        //boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
        System.out.println(ia.equals(ib)); //true
        //String toString()，返回描述调用对象数值的字符串形式
        System.out.println(ia.toString()); //1.0
        // 1.在Java5之前装箱和拆箱的实现
        // 实现了从double类型到Double类型的转换，装箱
        //static Double valueOf(double d)，根据参数指定浮点数据得到Double类型对象
        //static Boolean valueOf(boolean b)，根据参数指定布尔数值得到Boolean类型对象
        Double db1 = Double.valueOf(3.14);
        System.out.println("db1 = " + db1); // 3.14
        // 实现了从Double类型到double类型的转换，拆箱
        //double doubleValue()，获取调用对象中的浮点数据并返回
        //boolean booleanValue()，获取调用对象中的布尔数值并返回
        double d1 = db1.doubleValue();
        System.out.println("d1 = " + d1); // 3.14

        System.out.println("---------------------------------------------");
        // 2.从Java5开始实现自动装箱和自动拆箱
        //没提供自动装箱池
        Double db2 = 3.14;
        double d2 = db2;

        System.out.println("---------------------------------------------");
        // 3.实现静态方法和成员方法的调用
        //static double parseDouble(String s)，将字符串类型转换为double类型并返回
        //static boolean parseBoolean(String s)，将字符串类型转换为boolean类型并返回
        double d3 = Double.parseDouble("13.14");
        System.out.println("d3 = " + d3); // 13.14
        //boolean isNaN()，判断调用对象的数值是否为非数字
        System.out.println("db2对象的判断结果是：" + db2.isNaN()); // false 不是非数字
        Double db3 = Double.valueOf(0 / 0.0);
        System.out.println("db2对象的判断结果是：" + db3.isNaN()); // true  是非数字
    }

}

java.lang.Number类是个抽象类，是上述几个类（也是所有整型和浮点的包装类的父类）的父类来描述所有类共有的成员

Boolean类的概述------------------------------

public final class Boolean
extends Object
implements Serializable, Comparable<Boolean>
//Serializable，序列化接口
//Comparable<Boolean>，比较器接口

java.lang.Boolean类型内部包装了一个boolean类型的变量作为成员变量

主要用于实现对boolean类型的包装并提供boolean类型到String类之间的转换等方法

常用的常量------------------------------

public static final Boolean FALSE，对应基值为false的对象
public static final Boolean TRUE，对应基值为true的对象
public static final Class TYPE，表示boolean类型的Class实例

常用的方法------------------------------

Boolean(boolean value)，根据参数指定的布尔数值来构造对象（已过时）
Boolean(String s)，根据参数指定的字符串来构造对象 （已过时）
boolean booleanValue()，获取调用对象中的布尔数值并返回
static Boolean valueOf(boolean b)，根据参数指定布尔数值得到Boolean类型对象
boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
String toString()，返回描述调用对象数值的字符串形式
static boolean parseBoolean(String s)，将字符串类型转换为boolean类型并返回

package com.lagou.task11;

public class BooleanTest {


    public static void main(String[] args) {

        System.out.println("对应基值为false的对象是：" + Boolean.FALSE);
        System.out.println("对应基值为true的对象是:" + Boolean.TYPE);
        System.out.println("boolean类型的Class实例是：" + Boolean.TYPE);
        //Boolean(boolean value)，根据参数指定的布尔数值来构造对象（已过时）
        Boolean ia = new Boolean(true);
        System.out.println("ia = " + ia); //true
        //Boolean(String s)，根据参数指定的字符串来构造对象 （已过时）
        Boolean ib = new Boolean("false");
        System.out.println("ib = " + ib); //false
        //boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
        System.out.println(ia.equals(ib)); //false
        //String toString()，返回描述调用对象数值的字符串形式
        System.out.println(ia.toString()); //true
        // 1.在Java5之前采用方法进行装箱和拆箱
        // 相当于从boolean类型到Boolean类型的转换，装箱
        Boolean bo1 = Boolean.valueOf(true);
        System.out.println("bo1 = " + bo1); // true
        boolean b1 = bo1.booleanValue();
        System.out.println("b1 = " + b1); // true

        System.out.println("----------------------------------------------");
        // 2.从Java5开始支持自动装箱和拆箱
        Boolean bo2 = false;
        boolean b2 = bo2;
        System.out.println("b2 = " + b2); // false

        System.out.println("----------------------------------------------");
        // 3.实现从String类型到boolean类型的转换
        //boolean b3 = Boolean.parseBoolean("112");
        // 该方法的执行原理是：只要参数数值不为true或者TRUE时，则结果就是false，查手册和源码
        boolean b3 = Boolean.parseBoolean("TRUE");
        System.out.println("b3 = " + b3); // true
    }
}

Character类的概述------------------------------

public final class Character
extends Object
implements Serializable, Comparable<Character>
//Serializable，序列化接口
//Comparable<Character>，比较器接口

java.lang.Character类型内部包装了一个char类型的变量作为成员变量

主要用于实现对char类型的包装并提供字符类别的判断和转换等方法

常用的常量------------------------------

public static final int SIZE，表示char类型的二进制位数
public static final int BYTES，表示char类型的字节个数
public static final Class TYPE，表示char类型的Class实例

常用的方法------------------------------

Character(char value)，根据参数指定的字符数据来构造对象（已过时）
char charValue()，获取调用对象中的字符数据并返回
static Character valueOf(char c)，根据参数指定字符数据得到Character类型对象
boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
String toString()，返回描述调用对象数值的字符串形式
static boolean isUpperCase(char ch)，判断参数指定字符是否为大写字符
static boolean isLowerCase(char ch)，判断参数指定字符是否为小写字符
static boolean isDigit(char ch)，判断参数指定字符是否为数字字符
static char toUpperCase(char ch)，将参数指定的字符转换为大写字符
static char toLowerCase(char ch)，将参数指定的字符转换为小写字符

package com.lagou.task11;

public class CharacterTest {

    public static void main(String[] args) {
        System.out.println("char类型的二进制位数是：" + Character.SIZE);
        System.out.println("char类型的字节个数是：" + Character.BYTES);
        System.out.println("char类型的Class实例是：" + Character.TYPE);
        //Character(char value)，根据参数指定的字符数据来构造对象（已过时）
        Character ia = new Character('a');
        System.out.println("ia = " + ia); //a
        //没有字符串的构造方法创建方式
        Character ib = new Character('b');
        //boolean equals(Object obj)，比较调用对象与参数指定的对象是否相等
        System.out.println(ia.equals(ib)); //false
        //String toString()，返回描述调用对象数值的字符串形式
        System.out.println(ia.toString()); //a
        // 1.在Java5之前调用方法实现装箱和拆箱机制
        // 相当于从char类型到Character类型的转换，装箱
        //static Character valueOf(char c)，根据参数指定字符数据得到Character类型对象
        Character ca1 = Character.valueOf('a');
        System.out.println("ca1 = " + ca1); // a
        // 从Character类型向char类型的转换，拆箱
        char charValue()，获取调用对象中的字符数据并返回
        char c1 = ca1.charValue();
        System.out.println("c1 = " + c1); // a

        System.out.println("----------------------------------------");
        // 2.从Java5开始支持自动装箱和拆箱
        Character ca2 = 'b';
        char c2 = ca2;
        System.out.println("c2 = " + c2); // b

        System.out.println("----------------------------------------");
        // 3.实现字符类型的判断以及转换
        //static boolean isUpperCase(char ch)，判断参数指定字符是否为大写字符
        System.out.println(Character.isUpperCase(c2)); // 判断是否为大写字母  false
        //static boolean isLowerCase(char ch)，判断参数指定字符是否为小写字符
        System.out.println(Character.isLowerCase(c2)); // 判断是否为小写字母  true
        //static boolean isDigit(char ch)，判断参数指定字符是否为数字字符
        System.out.println(Character.isDigit(c2));     // 判断是否为数字字符  false
        //static char toUpperCase(char ch)，将参数指定的字符转换为大写字符
        System.out.println("转换为大写字符是：" + Character.toUpperCase(c2)); // B
        //static char toLowerCase(char ch)，将参数指定的字符转换为小写字符
        System.out.println("转换为小写字符是：" + Character.toLowerCase(c2)); // b
    }
}

//自动装箱池：
/*
范围：
Integer自动装箱池的范围是-128~127 
Byte,Short,Long范围是-128~127 
Character范围是0~127 
Float和Double没有自动装箱池
*/

包装类的使用总结------------------------------

基本数据类型转换为对应包装类的方式调用包装类的构造方法或静态方法（xxx.valueOf方法）即可

获取包装类对象中基本数据类型变量数值的方式调用包装类中的xxxValue方法即可

字符串转换为基本数据类型的方式调用包装类中的parseXxx方法即可

Math类的概述------------------------------

public final class Math
extends Object

java.lang.Math类主要用于提供执行数学运算的方法，如：对数，平方根

常用的方法------------------------------

static int max(int a, int b)，返回两个参数中的最大值
static int min(int a, int b)，返回两个参数中的最小值
static double pow(double a, double b)，返回第一个参数的幂
static int abs(int a)，返回参数指定数值的绝对值
static long round(double a)，返回参数四舍五入的结果
static double sqrt(double a)，返回参数的平方根
static double random()，返回0.0到1.0的随机数，[0.0 ~ 1.0)，包括0.0，不包括1.0

package com.lagou.task11;

/**
 * 编程实现对Math类中常用方法的测试
 */
public class MathTest {

    public static void main(String[] args) {
        //static int max(int a, int b)，返回两个参数中的最大值
        System.out.println("获取两个整数中最大值的结果是：" + Math.max(10, 20)); // 20
        //static int min(int a, int b)，返回两个参数中的最小值
        System.out.println("获取两个整数中最小值的结果是：" + Math.min(10, 20)); // 10
        //static double pow(double a, double b)，返回第一个参数的幂
        System.out.println("获取次方的结果是：" + Math.pow(2, 3)); // 8.0  体现double类型
        //static int abs(int a)，返回参数指定数值的绝对值
        System.out.println("获取绝对值的结果是：" + Math.abs(-5)); // 5
        //static long round(double a)，返回参数四舍五入的结果
        System.out.println("进行四舍五入的结果是：" + Math.round(3.14)); // 3
        //static double sqrt(double a)，返回参数的平方根
        System.out.println("该整数的平方根是：" + Math.sqrt(16)); // 4.0
        //static double random()，返回0.0到1.0的随机数
        System.out.println("生成的随机数是：" + Math.random());
        //随机数[0.0 ~ 1.0)，包括0.0，不包括1.0
        System.out.println(Math.round(3.5)); //4
        System.out.println(Math.sqrt(9)); //3.0
        System.out.println(Math.abs(-39)); //39
        System.out.println(Math.abs(89)); //89
        System.out.println(Math.pow(2,-2)); //0.25
        System.out.println(Math.random() * 4); //[0.0 ~ 4.0) ，包括0.0，不包括4.0，这里加上3也行
    }
}

BigDecimal类的概述------------------------------

public class BigDecimal
extends Number
implements Comparable<BigDecimal>
//Comparable<BigDecimal>，比较器接口

public abstract class Number
extends Object
implements Serializable
//Serializable，序列化接口

由于float类型和double类型在运算时可能会有误差

若希望实现精确运算则借助java.math.BigDecimal类型加以描述

常用的方法------------------------------

BigDecimal(String val)，根据参数指定的字符串来构造对象
BigDecimal add(BigDecimal augend)，用于实现加法运算
BigDecimal subtract(BigDecimal subtrahend)，用于实现减法运算
BigDecimal multiply(BigDecimal multiplicand)，用于实现乘法运算
BigDecimal divide(BigDecimal divisor)，用于实现除法运算

package com.lagou.task11;

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalTest {

    public static void main(String[] args) {

        // 1.构造BigDecimal类型的两个对象
        //BigDecimal(String val)，根据参数指定的字符串来构造对象
        BigDecimal bd1 = new BigDecimal("5.2");
        BigDecimal bd2 = new BigDecimal("1.3");
        // 2.使用构造完毕的对象实现加减乘除运算
        //BigDecimal add(BigDecimal augend)，用于实现加法运算
        System.out.println("实现加法运算的结果是：" + bd1.add(bd2)); // 6.5 返回的是本身类型的对象，打印使用toString的
        //BigDecimal subtract(BigDecimal subtrahend)，用于实现减法运算
        System.out.println("实现减法运算的结果是：" + bd1.subtract(bd2)); // 3.9
        //BigDecimal multiply(BigDecimal multiplicand)，用于实现乘法运算
        System.out.println("实现乘法运算的结果是：" + bd1.multiply(bd2)); // 6.76
        //BigDecimal divide(BigDecimal divisor)，用于实现除法运算
        System.out.println("实现除法运算的结果是：" + bd1.divide(bd2)); // 4

        System.out.println("---------------------------------------------------------------");
        // 3.实现精确运算
        System.out.println(0.1 + 0.2); // 0.30000000000000004
        BigDecimal bd3 = new BigDecimal("0.1"); //注意：建议使用字符串，不要使用0.1，因为这些处理通常都是字符串来的，使用0.1可能会在某些处理中出现精度问题
        BigDecimal bd4 = new BigDecimal("0.2");
        System.out.println("精确计算的结果是：" + bd3.add(bd4)); // 0.3

        System.out.println("---------------------------------------------------------------");
        // 4.注意事项
        BigDecimal bd5 = new BigDecimal("2");
        BigDecimal bd6 = new BigDecimal("0.3");
        //System.out.println("除法运算的结果是：" + bd5.divide(bd6)); //除不尽
        //无法保证精确结果
        //编译ok，运行发生ArithmeticException算术异常，可以操作舍入模式来解决
        //public static final RoundingMode HALF_UP，舍入模式向"最近邻居"舍入
        //如2/0.3为6.666...
        //取7
        //4/0.3为13.333...
        //取13
        //除非两个邻居等距，在这种情况下向上舍入，比如0.5，那么取1
        System.out.println("除法运算的结果是：" + bd5.divide(bd6, RoundingMode.HALF_UP)); // 7，一般到某个临界点，会操作舍入，或者判断出，必然无限循环（即出现了环），然后舍入
        
               
        //但是也要注意：无线不循环小数通常来说是不能进行精确描述的，也就是说，在实际判断中，上面的RoundingMode.HALF_UP，可以找到重复的而进行舍弃，但是无线不循环不行（实际上计算机也基本表达不出来）
        //但是RoundingMode.HALF_UP通常只需要看第一个小数即可，所以通常不考虑循环或者是不循环
    }
}

BigInteger类的概念------------------------------

public class BigInteger
extends Number
implements Comparable<BigInteger>
//Comparable<BigInteger>，比较器接口

public abstract class Number
extends Object
implements Serializable
//Serializable，序列化接口

若希望表示比long类型范围还大的整数数据，则需要借助java.math.BigInteger类型描述

常用的方法------------------------------

BigInteger(String val)，根据参数指定的字符串来构造对象
BigInteger add(BigInteger val)，用于实现加法运算
BigInteger subtract(BigInteger val)，用于实现减法运算
BigInteger multiply(BigInteger val)，用于实现乘法运算
BigInteger divide(BigInteger val)，用于实现除法运算
BigInteger remainder(BigInteger val)，用于实现取余运算
BigInteger[] divideAndRemainder(BigInteger val)，用于实现取商和余数的运算

package com.lagou.task11;

import java.math.BigInteger;

public class BigIntegerTest {

    public static void main(String[] args) {

        // 1.构造两个BigInteger类型的对象并指定初始值
        //BigInteger(String val)，根据参数指定的字符串来构造对象
        BigInteger bi1 = new BigInteger("20");
        BigInteger bi2 = new BigInteger("8");
        // 2.实现加减乘除取余操作并打印
        //BigInteger add(BigInteger val)，用于实现加法运算
        System.out.println("实现加法运算的结果是：" + bi1.add(bi2)); // 28
        //BigInteger subtract(BigInteger val)，用于实现减法运算
        System.out.println("实现减法运算的结果是：" + bi1.subtract(bi2)); // 12
        //BigInteger multiply(BigInteger val)，用于实现乘法运算
        System.out.println("实现乘法运算的结果是：" + bi1.multiply(bi2)); // 160
        //BigInteger divide(BigInteger val)，用于实现除法运算
        System.out.println("实现除法运算的结果是：" + bi1.divide(bi2)); // 2
        //BigInteger remainder(BigInteger val)，用于实现取余运算
        System.out.println("实现取余运算的结果是：" + bi1.remainder(bi2)); // 4

        System.out.println("-----------------------------------------------------");
        // 3.一次性得到商和余数
        //BigInteger[] divideAndRemainder(BigInteger val)，用于实现取商和余数的运算
        BigInteger[] arr = bi1.divideAndRemainder(bi2);
        for (int i = 0; i < arr.length; i++) {
            System.out.println("下标为" + i + "的元素是：" + arr[i]); // 2 4
        }
    }
}

实际上他们之所以可以解决精度，一般都是翻倍解决（但是这样的解决通常考虑字符串，因为数字在变化时，可能会出现问题，他也并没有将其变成字符串，可能有其他的考虑影响吧，或者没有修复），比如都变成整数后，然后再变回来，像这样的思想，大概如此，可能有其他的操作来完成，并且可能给出限制（如除不尽就会报错，而不会舍弃结果的小数，寻常的直接打印2/0.3就会舍弃结果的小数的）

当然，前面也提到了随机数，这里可以说明一下，计算机是如何处理随机数的，实际上计算机的都是伪随机（并不是真正的随机），这里实现一下：

package com;

public class SimpleRandom {
    private long seed;   // 当前种子值
    private static final long a = 1664525;  // 乘数
    private static final long c = 1013904223; // 增量
    private static final long m = (long) Math.pow(2, 32); // 模（2的32次方）

    public SimpleRandom(long seed) {
        this.seed = seed;
    }

    // 生成下一个随机数
    public int nextInt() {
        seed = (a * seed + c) % m; //这是经过大量验证的比较好的表达式，具体可以百度，其中数字的选择通常也比较合理（具体百度）
        return (int) seed;
    }

    // 生成一个指定范围的随机数
    public int nextInt(int bound) {
        return Math.abs(nextInt()) % bound;
    }

    public static void main(String[] args) {
        SimpleRandom random = new SimpleRandom(System.currentTimeMillis()); // 使用当前时间毫秒作为种子

        for (int i = 0; i < 10; i++) {
            System.out.println(random.nextInt(100)); // 生成0到99之间的随机数
        }
    }
}