Java lecture 13 Object类、包装类、自动拆装箱及冒泡排序

一、Object类

Object类是所有类的基类,也可以称之为万类之祖。

我们创建的所有类,默认都是直接继承或间接继承Object类,会有一个隐式的 extends Object写法。

为什么要有Object类,在Java这款语言设计中，开发Java人员认为,以后所有创建的类都应该有一些共性的内容,所以就设计Object,也就意味着这个类承载了所有类共性的内容。提供一系列基础的结构支撑。

需要学习两个方法：

alt+insert键可以快速生成构造方法、getter和setter方法。

1. toString():

往往有时候我们需要以更加便捷的方式 将当前对象的所有数据进行展示
 所以 java 设计Object类时,提供了一个toString的方法。

package objectdemo;
/**
 * Object使用演示类：
 * */
public class ObjectDemo {
    public static void main(String[] args) {
//        Object o = new Aoo(); //向上造型
//        Object o1 = new Boo();
       Point  p = new Point(1,2);//创建一个Point对象并把对象存给了p
​
        //但是往往有时候我们需要以更加便捷的方式 将当前对象的所有数据进行展示
        //所以 java 设计Object类时,提供了一个toString的方法。
        //规定：当我们在直接输出对象的时候 会直接调用Object类提供的toString()方法
​
        System.out.println(p);
​
    }
}

2.equals():

适用性：当若需要判断两个对象或多个对象之间内容是否一致时（不判断地址）,我们可以为当前对象的类型(类)添加具体判断的逻辑,主要实现就是重写Object类中的equals方法。

为什么要重写equals方法：因为Object类中提供equals方法内容还是用双等号判断对象的地址是否相同,而我们实际使用时,判断的是自定义的内容。例如：Point类对象需要判断的是对象之间的x y的数据是否相同。所以 父类方法 子类不受用,则重写实现即可。

重写equals方法的快捷方式：

alt+ insert 弹出窗口 选择 equals() and hashCode() 选择即可。  

@Override                   //p1对象 ---- o
    public boolean equals(Object o) {
        if (this == o) return true;
​
        //如果o对象为空  或者 当前对象类型 不等于 o这个对象的类型  若if中有一个条件成立 直接return false
        if (o == null || this.getClass() != o.getClass()) return false;
        Point p1 = (Point) o;
        return this.x == p1.x && this.y == p1.y;
    }
​
    @Override
    public int hashCode() {
        return Objects.hash(x, y);
    }
​

面试题： == 和 equals 的区别？

答：== 是 关系运算符中的判断是否相等的符号 ,== 判断的是变量中存储的内容是否相等。

在值类型中 == 代表判断变量内数值是否相等。在引用类型中== 代表判断变量内地址是否相等。

equals是Object类提供的方法,该方法中也是使用的 == 来去判断对象的地址是否相等的。

如果想要判断对象的内容是否相等,需要进一步重写equals方法来实现。

常用的String类,已经实现Object类中提供的equals ,用于比较字符串的内容是否相等。所以在比较两个字符串的内容是否相等的时候，要记得用.equals()来判断。

二、包装类

Java提供了包装类,分别对应8个基本数据类型。

包装类：基本数据类型都是以值而非对象的形式存在,因此没有面向对象的特性,但是为了让这些基本数据类型参与面向对象的开发,从而设计出对应的8个包装类,

目的就是可以让基本数据类型以对象的形式存在。

package wrapdemo;
​
/**
 * 包装类的使用演示类：
 */
public class WrapClassDemo {
    public static void main(String[] args) {
        /**    基本数据类型         包装类类型
         *      byte               Byte
         *      short              Short
         *      int                Integer
         *      long               Long
         *      float              Float
         *      double             Double
         *      boolean            Boolean
         *      char               Character
         */
        //将基本数据类型  存储给 对应的包装类的操作。
        int number = 128;
//        Integer i1 = new Integer(number);//不可复用的
//        Integer i2 = new Integer(number);
//          System.out.println(i1 == i2); false，因为两个地址不一样
​
        Integer i1 = Integer.valueOf(number);//Java推荐的用法，但是只能缓存1个字节的容量
        Integer i2 = Integer.valueOf(number);
        //System.out.println(i1 == i2);//true，可以复用
//        Byte.valueOf()
//          Short.valueOf()它们也可以使用这个方法
        但是double不行。
        double d = 1.23;
        Double d1 = Double.valueOf(d);//本质上直接new对象
        Double d2 = Double.valueOf(d);
        System.out.println(d1 == d2);//false
        System.out.println(d1.equals(d2));//true 这样才是内容的比对
​
        //数值类型的包装类 也支持 可以将其表示的数字 以基本数据类型进行返回。
        //注意：与基本数据类型直接互相赋值一样,小类型赋值给大类型 可以直接接收。
        //但是大类型再赋值给小类型过程中 可能会丢失精度。
        Integer i3 = Integer.valueOf(120);实例化一个i3,赋值为120
        int number2 = i3.intValue();把i3的值赋给number2
        System.out.println(number2);
        Double d3 = new Double(1.27);
        double dd = d3.doubleValue(); 把d3的值赋值给dd
        int i5 =(int)(d3.doubleValue());
        System.out.println(dd);
        System.out.println(i5);
​
        //包装类中都定义两个常量,分别对应是 该类型可容纳的最大值 和最小值
        System.out.println(Integer.MAX_VALUE);
        System.out.println(Integer.MIN_VALUE);
​
        //包装类还可以将字符串中的内容解析为对应的基本类型,但是前提是字符串中的数据正确。
        String line = "123";
        number2= Integer.parseInt(line)；就是把字符串里的内容变为原有的类型
        比如这里就是，把123变为原先的int类型
        System.out.println(number2);//数值 123
        line = "123.123";
        System.out.println(Double.parseDouble(line));//小数 123.123
    }
}
​

三、自动拆装箱 

JDK5之后,推出了一个新特性,自动拆装箱。

含义：编译器在遇到基本类型和引用类型互相赋值的情况时,会自动补充完成他们之间的转换代码。特性只是编译器认可,但是字节码文件中,并不不会存在可以直接互相赋值的情况。

拆箱：指的是将引用类型的数据 装载到 基本数据类型的一个过程。

装箱：指的是将基本类型的数据 装载到 引用数据类型的一个过程。

相当于，引用数据类型是个箱子。

  //拆装箱:
        int i = 123;
​
        //装箱：指的是将基本类型的数据 装载到  引用数据类型的一个过程。
        /**
         *  在字节码文件中 实际的写法如下：
         *  Integer integer = Integer.valueOf(i);
         */
        Integer integer = i; //编译器支持的
​
        //拆箱：指的是将引用类型的数据 装载到  基本数据类型的一个过程。
        /**
         * 在字节码文件中 实际写法如下：
         * int num = integer.intValue();
         */
        int num = integer;//编译器支持的

四、冒泡排序

冒泡的排序就是可以对一组数组中的数据进行升序(从小到大)或者降序(从大到小)的处理。

package sortdemo;
​
import java.util.Arrays;
​
/**
 * 冒泡排序的使用演示类：
 */
public class BubbleSortDemo {
    public static void main(String[] args) {
​
        /**
         *   冒泡的排序就是可以对一组数组中的数据进行升序(从小到大)或者降序(从大到小)的处理。
         *
         *        30,  50 , 80, 90 , 20 , 10     -----  数据
         *                第一轮
         *        30 , 50 , 80 , 20 , 10 , 90
         *          ①    ②   ③   ④    ⑤       ------第一轮 6个数据比较   比较了5次  确定最大值
         *                第二轮
         *        30 , 50 , 20 , 10 , 80         ------第二轮 5个数据比较   比较了4次  确定第二大值
         *          ①    ②   ③   ④
         *                第三轮
         *        30 , 20 , 10 , 50              ------第三轮 4个数据比较   比较了3次  确定第三大值
         *           ①   ②   ③
         *               第四轮
         *        20 , 10 , 30                   ------第四轮 3个数据比较   比较了2次  确定第四大值
         *           ①   ②
         *              第五轮
         *            10 ,20                     ------第五轮 2个数据比较   比较了1次  确定第五大值
         *               ①
         *
         *            10,20,30,50,80,90
         *                                      for循环中：哪个是控制轮数？
         *                                               哪个是控制次数？
         */
        //实现规则:
        // 1.   6个数 比 5 轮
        // 2.   每一轮都是第一个元素开始比
        //每一次都是和它下一个元素去比
        // 3.   每一轮比较后,已经比较出来的当前轮的最大值 不需要参与下次比较
        int[] arr = {30, 50, 80, 90, 20, 10};
        for (int i = 0; i < arr.length - 1; i++) { //控制轮数
            for (int j = 0; j < arr.length - 1 - i; j++) { //控制次数的循环
                if (arr[j] > arr[j + 1]) { //如果当前比较的元素 大于 下一个元素
                    int temp = arr[j]; //先将当前大的数据 存给 temp
                    arr[j] = arr[j + 1];//再将后面的数据内容赋值给当前元素的空间下
                    arr[j + 1] = temp;//再将当前大的数据内容 赋值给 后面的 空间
                }
            }
        }
        System.out.println(Arrays.toString(arr));//可以通过这种方式来输出数组中的内容.
​
        /**         arr.length -1 - i
         *   第一轮 i = 0  比较5次
         *   第二轮 i = 1  比较4次
         *   第三轮 i = 2  比较3次
         *   第四轮 i = 3  比较2次
         *   第五轮 i = 4  比较1次
         */
    }
}