day02

今日内容

  • 多态
  • final
  • Object
  • 常见类介绍

教学目标

day02-面向对象进阶（多态&final&Object&工具类）(笔记)_多态


第一章 final关键字

1.1 概述

学习了继承后，我们知道，子类可以在父类的基础上改写父类内容，比如，方法重写。

如果有一个方法我不想别人去改写里面内容，该怎么办呢？

Java提供了final 关键字，表示修饰的内容不可变。

  • final： 不可改变，最终的含义。可以用于修饰类、方法和变量。
  • 类：被修饰的类，不能被继承。
  • 方法：被修饰的方法，不能被重写。
  • 变量：被修饰的变量，有且仅能被赋值一次。

1.2 使用方式

1.2.1 修饰类

final修饰的类，不能被继承。

格式如下：

final class 类名 {
}

代码:

final class Fu {
}
// class Zi extends Fu {} // 报错,不能继承final的类

查询API发现像 public final class String 、public final class Math 、public final class Scanner 等，很多我们学习过的类，都是被final修饰的，目的就是供我们使用，而不让我们所以改变其内容。

1.2.2 修饰方法

final修饰的方法，不能被重写。
格式如下：

修饰符 final 返回值类型 方法名(参数列表){
    //方法体
}

代码:

class Fu2 {
	final public void show1() {
		System.out.println("Fu2 show1");
	}
	public void show2() {
		System.out.println("Fu2 show2");
	}
}

class Zi2 extends Fu2 {
//	@Override
//	public void show1() {
//		System.out.println("Zi2 show1");
//	}
	@Override
	public void show2() {
		System.out.println("Zi2 show2");
	}
}

1.2.3 修饰变量-局部变量

  1. 局部变量——基本类型
    基本类型的局部变量，被final修饰后，只能赋值一次，不能再更改。代码如下：
public class FinalDemo1 {
    public static void main(String[] args) {
        // 声明变量，使用final修饰
        final int a;
        // 第一次赋值 
        a = 10;
        // 第二次赋值
        a = 20; // 报错,不可重新赋值

        // 声明变量，直接赋值，使用final修饰
        final int b = 10;
        // 第二次赋值
        b = 20; // 报错,不可重新赋值
    }
}

思考，下面两种写法，哪种可以通过编译？

写法1：

final int c = 0;
for (int i = 0; i < 10; i++) {
    c = i;
    System.out.println(c);
}

写法2：

for (int i = 0; i < 10; i++) {
    final int c = i;
    System.out.println(c);
}

根据 final 的定义，写法1报错！写法2，为什么通过编译呢？因为每次循环，都是一次新的变量c。这也是大家需要注意的地方。

1.2.4 修饰变量-成员变量

成员变量涉及到初始化的问题，初始化方式有显示初始化和构造方法初始化，只能选择其中一个：

  • 显示初始化(在定义成员变量的时候立马赋值)（常用）；
public class Student {
    final int num = 10;
}
  • 构造方法初始化(在构造方法中赋值一次)（不常用，了解即可）。
    注意：每个构造方法中都要赋值一次！
public class Student {
    final int num = 10;
    final int num2;

    public Student() {
        this.num2 = 20;
//     this.num2 = 20;
    }
    
     public Student(String name) {
        this.num2 = 20;
//     this.num2 = 20;
    }
}

被final修饰的常量名称，一般都有书写规范，所有字母都大写。

第二章 多态

2.1 多态的形式

多态是继封装、继承之后，面向对象的第三大特性。

多态是出现在继承或者实现关系中的。

多态体现的格式：

父类类型 变量名 = new 子类/实现类构造器;
变量名.方法名();

多态的前提：有继承关系，子类对象是可以赋值给父类类型的变量。例如Animal是一个动物类型，而Cat是一个猫类型。Cat继承了Animal，Cat对象也是Animal类型，自然可以赋值给父类类型的变量。

2.2 多态的使用场景

如果没有多态，在下图中register方法只能传递学生对象，其他的Teacher和administrator对象是无法传递给register方法方法的，在这种情况下，只能定义三个不同的register方法分别接收学生，老师和管理员。

有了多态之后，方法的形参就可以定义为共同的父类Person。

要注意的是：

  • 当一个方法的形参是一个类，我们可以传递这个类所有的子类对象。
  • 当一个方法的形参是一个接口，我们可以传递这个接口所有的实现类对象（后面会学）。
  • 而且多态还可以根据传递的不同对象来调用不同类中的方法。

代码示例：

父类：
public class Person {
    private String name;
    private int age;

    空参构造
    带全部参数的构造
    get和set方法

    public void show(){
        System.out.println(name + ", " + age);
    }
}

子类1：
public class Administrator extends Person {
    @Override
    public void show() {
        System.out.println("管理员的信息为：" + getName() + ", " + getAge());
    }
}

子类2：
public class Student extends Person{

    @Override
    public void show() {
        System.out.println("学生的信息为：" + getName() + ", " + getAge());
    }
}

子类3：
public class Teacher extends Person{

    @Override
    public void show() {
        System.out.println("老师的信息为：" + getName() + ", " + getAge());
    }
}

测试类：
public class Test {
    public static void main(String[] args) {
        //创建三个对象，并调用register方法

        Student s = new Student();
        s.setName("张三");
        s.setAge(18);


        Teacher t = new Teacher();
        t.setName("王建国");
        t.setAge(30);

        Administrator admin = new Administrator();
        admin.setName("管理员");
        admin.setAge(35);



        register(s);
        register(t);
        register(admin);


    }



    //这个方法既能接收老师，又能接收学生，还能接收管理员
    //只能把参数写成这三个类型的父类
    public static void register(Person p){
        p.show();
    }
}

2.3 多态的定义和前提

多态： 是指同一行为，具有多个不同表现形式。

从上面案例可以看出，Cat和Dog都是动物，都是吃这一行为，但是出现的效果（表现形式）是不一样的。

前提【重点】

  1. 有继承或者实现关系
  2. 方法的重写【意义体现：不重写，无意义】
  3. 父类引用指向子类对象【格式体现】

父类类型：指子类对象继承的父类类型，或者实现的父接口类型。

  1. 演示多态的使用:
// 创建父类动物类型
public class Animal {

    public void load(){
        System.out.println("动物叫.....");
    }
}

创建子类 驴

package com.itheima.duotai01;

public class Lv extends Animal {

    // 因为驴的叫声 别致 所以重写 叫的方法

    @Override
    public void load() {
        System.out.println("a~o~哦！~啊~额~~哦~~~");
    }
}

测试类测试

package com.itheima.duotai01;

public class Demo {

    /*
      研究多态
        什么是多态
           简单理解 就是一种事物多种形态，代码中体现是 对象的多种形态。
        特征
            父类引用 指向 子类对象  (子类以父类的形态示人)
        前提:
          1:有继承(实现)关系
          2:父类引用 指向 子类对象
          3:一般有方法重写
     */
    public static void main(String[] args) {
       // 多态写法
        Animal a = new Lv();//远看是个动物
        // 多态的本质 还是new 哪个对象。。。
        a.load();//执行重写的方法
        // 执行的 时候 真正的调用的还是 儿子的功能
    }
}

2.4 多态的运行特点–扩展看一下即可(因为属性将来是私有的)

调用成员变量时：编译看左边，运行看左边

调用成员方法时：编译看左边，运行看右边

代码示例：

Fu f = new Zi()；
//编译看左边的父类中有没有name这个属性，没有就报错
//在实际运行的时候，把父类name属性的值打印出来
System.out.println(f.name);
//编译看左边的父类中有没有show这个方法，没有就报错
//在实际运行的时候，运行的是子类中的show方法
f.show();

多态好处

package com.itheima.duotai02;

public class Animal {

    public void load(){
        System.out.println("动物叫.....");
    }

    public void sleep(){
        System.out.println("静静睡觉....");
    }
}
package com.itheima.duotai02;

public class Cat extends Animal{

    @Override
    public void load() {
        System.out.println("喵~~喵~~喵~~喵~~");
    }

    public void catchMouse(){
        System.out.println("猫抓老鼠.....");
    }
}
package com.itheima.duotai02;

public class Lv extends Animal {

    // 因为驴的叫声 别致 所以重写 叫的方法
    @Override
    public void load() {
        System.out.println("a~o~哦！~啊~额~~哦~~~");
    }

    public void laMo(){
        System.out.println("懒驴拉磨...屎尿多....");
    }
}
package com.itheima.duotai02;

public class Demo {

    public static void main(String[] args) {


        //子健 要睡觉了  靖轩管家---拉过来一只动物  让它叫
       Animal a = new Lv();//多态形式
       listenAnimalLoad(a);
       System.out.println("=================");
       listenAnimalLoad(new Cat()); //
    }

    /*
      子健---听动物的叫声 才能睡着
       要求设计一个方法
      方法 不调用不执行！！
     */                              //          = new Cat()
    public static void listenAnimalLoad(Animal a){//参数 是父类类型
        a.load();
    }
}

2.5 多态的弊端

我们已经知道多态编译阶段是看左边父类类型的，如果子类有些独有的功能，此时多态的写法就无法访问子类独有功能了。

接着上面的案例

package com.itheima.duotai02;

public class Demo02 {

    public static void main(String[] args) {
        Animal a = new Lv();//向上转型

        a.load();
        a.sleep();
        //拉磨
       // a.laMo();//编译期报错 --检查语法问题
        // 现在是动物的形态  动物不会拉磨的
        // 编译只看 多态式子的左边 检查左边的这个类型里面是不是有 该方法
        // 多态的弊端  在父类形态下 只能使用父类的功能  无法使用子类特有功能
       
    }
}

2.6 引用类型转换

2.6.1 为什么要转型

多态的写法就无法访问子类独有功能了。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

回顾基本数据类型转换

  • 自动转换: 范围小的赋值给范围大的.自动完成:double d = 5;
  • 强制转换: 范围大的赋值给范围小的,强制转换:int i = (int)3.14

多态的转型分为向上转型（自动转换）与向下转型（强制转换）两种。

2.6.2 向上转型（自动转换）

  • 向上转型：多态本身是子类类型向父类类型向上转换（自动转换）的过程，这个过程是默认的。
    当父类引用指向一个子类对象时，便是向上转型。
    使用格式：
父类类型  变量名 = new 子类类型();
如：Animal a = new Cat();

**原因是：父类类型相对与子类来说是大范围的类型，Animal是动物类，是父类类型。Cat是猫类，是子类类型。Animal类型的范围当然很大，包含一切动物。**所以子类范围小可以直接自动转型给父类类型的变量。

2.6.3 向下转型（强制转换）

  • 向下转型：父类类型向子类类型向下转换的过程，这个过程是强制的。
    一个已经向上转型的子类对象，将父类引用转为子类引用，可以使用强制类型转换的格式，便是向下转型。

使用格式：

子类类型 变量名 = (子类类型) 父类变量名;
如:Aniaml a = new Cat();
   Cat c =(Cat) a;

2.6.4 案例演示

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误。也就是说，不能调用子类拥有，而父类没有的方法。编译都错误，更别说运行了。这也是多态给我们带来的一点"小麻烦"。所以，想要调用子类特有的方法，必须做向下转型。

转型演示，代码如下：

定义类：

package com.itheima.duotai02;

public class Demo02 {

    public static void main(String[] args) {
        Animal a = new Lv();//向上转型

        a.load();
        a.sleep();
        //拉磨
       // a.laMo();//编译期报错 --检查语法问题
        // 现在是动物的形态  动物不会拉磨的
        // 编译只看 多态式子的左边 检查左边的这个类型里面是不是有 该方法
        // 多态的弊端  在父类形态下 只能使用父类的功能  无法使用子类特有功能
        /*
        向上转型 -- 自动转型--多态形式
          父类类型 变量名 = 子类对象。
        向下转型 -- 强制转换 -- 还原回去
          子类类型 变量名 = (子类类型)父类变量;
         */
        Lv lv = (Lv)a;
        lv.laMo();
        //类型转换 作用  还原会子类类型  调用子类特有功能
    }
}

定义测试类：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat(); 				// 调用的是 Cat 的 eat

        // 向下转型  
        Cat c = (Cat)a;       
        c.catchMouse(); 		// 调用的是 Cat 的 catchMouse
    }  
}

2.6.5 转型的异常

转型的过程中，一不小心就会遇到这样的问题，请看如下代码：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        Dog d = (Dog)a;       
        d.watchHouse();        // 调用的是 Dog 的 watchHouse 【运行报错】
    }  
}

这段代码可以通过编译，但是运行时，却报出了 ClassCastException ，类型转换异常！这是因为，明明创建了Cat类型对象，运行时，当然不能转换成Dog对象的。

2.6.6 instanceof关键字

为了避免ClassCastException的发生，Java提供了 instanceof 关键字，给引用变量做类型的校验，格式如下：

变量名 instanceof 数据类型 
如果变量属于该数据类型或者其子类类型，返回true。
如果变量不属于该数据类型或者其子类类型，返回false。

所以，转换前，我们最好先做一个判断，代码如下：

public class Test {
    public static void main(String[] args) {
        // 向上转型  
        Animal a = new Cat();  
        a.eat();               // 调用的是 Cat 的 eat

        // 向下转型  
        if (a instanceof Cat){
            Cat c = (Cat)a;       
            c.catchMouse();        // 调用的是 Cat 的 catchMouse
        } else if (a instanceof Dog){
            Dog d = (Dog)a;       
            d.watchHouse();       // 调用的是 Dog 的 watchHouse
        }
    }  
}

2.6.7 instanceof新特性

JDK14的时候提出了新特性，把判断和强转合并成了一行

//新特性
//先判断a是否为Dog类型，如果是，则强转成Dog类型，转换之后变量名为d
//如果不是，则不强转，结果直接是false
if(a instanceof Dog d){
    d.lookHome();
}else if(a instanceof Cat c){
    c.catchMouse();
}else{
    System.out.println("没有这个类型，无法转换");
}
梳理案例 – Ga子装爹

父类

package com.itheima.duotai03;

public class GaZiDie {
    //父年龄
    int age = 50;

    public void teach(){
        System.out.println("教Java基础,名声显赫.....");
    }

}

子类

package com.itheima.duotai03;

public class GaZi extends GaZiDie{
    //子年龄
    int age = 18;
    //存在重写
    public void teach(){
        System.out.println("教....喝酒.....");
    }

    public void play(){
        System.out.println("玩..LOL...");
    }
}

测试类

package com.itheima.duotai03;
/*
   多态形式下
     编译  看左边  检查语法错误
     运行
        成员变量 看左边 因为堆空间中是有这份数据的
        成员方法 看右边 因为方法形成了覆盖
 */
public class Demo {
    public static void main(String[] args) {
        //潘子...想挣钱---做程序员
        // 找 教java好的人 ...拨通了 gazidie 家里电话
        // ga子正在lol 没有钱买皮肤 很郁闷  1W
        // ga子 装爹  用爹的形态  粘上胡子 带上眼镜 格子衫
        // 向上转型
        GaZiDie gzd = new GaZi();//多态
        //到潘子家了
        System.out.println("潘子见到的老师:"+gzd.age+"岁");
        // 教课
        System.out.println("想写出更好的代码,先喝点酒");
        gzd.teach();
        // 潘子喝蒙了 嘎子 就准备走人 钱到手...
        // 回到家了 想玩游戏
//        gzd.play();
       // 向下转型 还原回去
        GaZi gz = (GaZi)gzd;

        gz.play();
    }
}

2.7 综合练习

需求：根据需求完成代码:
    1.定义狗类
            属性：
                年龄，颜色
            行为:
                eat(String something)(something表示吃的东西)
                看家lookHome方法(无参数)
    2.定义猫类
        属性：
            年龄，颜色
        行为:
            eat(String something)方法(something表示吃的东西)
            逮老鼠catchMouse方法(无参数)
    3.定义Person类//饲养员
        属性：
            姓名，年龄
        行为：
            keepPet(Dog dog,String something)方法
                功能：喂养宠物狗，something表示喂养的东西
        行为：
            keepPet(Cat cat,String something)方法
                功能：喂养宠物猫，something表示喂养的东西
        生成空参有参构造，set和get方法  
    4.定义测试类(完成以下打印效果):
        keepPet(Dog dog,String somethind)方法打印内容如下：
            年龄为30岁的老王养了一只黑颜色的2岁的狗
            2岁的黑颜色的狗两只前腿死死的抱住骨头猛吃
        keepPet(Cat cat,String somethind)方法打印内容如下：
            年龄为25岁的老李养了一只灰颜色的3岁的猫
            3岁的灰颜色的猫眯着眼睛侧着头吃鱼
    5.思考：		
        1.Dog和Cat都是Animal的子类，以上案例中针对不同的动物，定义了不同的keepPet方法，过于繁琐，能否简化，并体会简化后的好处？
	2.Dog和Cat虽然都是Animal的子类，但是都有其特有方法，能否想办法在keepPet中调用特有方法？

画图分析：

前四问代码示例:

第一问 第二问 结合分析 设计出三个类

动物类

package com.itheima.test;

public class Animal {
    //成员变量
    private int age;
    private String color;

    public Animal() {
    }

    public Animal(int age, String color) {
        this.age = age;
        this.color = color;
    }

    public int getAge() {
        return age;
    }

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

    public String getColor() {
        return color;
    }

    public void setColor(String color) {
        this.color = color;
    }

    public void eat(String something){
        System.out.println("正在吃:"+something);
    }
}

猫类

package com.itheima.test;

public class Cat extends Animal{
    public Cat() {
    }

    public Cat(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"色的猫眯着眼侧着头吃:"+something);
    }

   public void catchMouse(){
       System.out.println("小猫会抓老鼠...");
   }
}

狗类

package com.itheima.test;

public class Dog extends Animal{
    public Dog() {
    }

    public Dog(int age, String color) {
        super(age, color);
    }

    @Override
    public void eat(String something) {
        System.out.println(getAge()+"岁的"+getColor()+"色的狗两只前腿实时的抱住"+something+"正在猛吃...");
    }

   public void lookHome(){
       System.out.println("狗狗会看家....");
   }
}

第三问设计 饲养员类 Person

package com.itheima.test;

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

    public Person() {
    }

    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;
    }

    /**
     *
     * @param dog 饲养的狗
     * @param something  喂得食物
     */
    public void keepPet(Dog dog ,String something){
        System.out.println("年龄为"+age+"岁的"+name+"养了一只"+dog.getColor()+"颜色的"+dog.getAge()+"岁的狗");
       dog.eat(something);
   }

 
}

第四问测试

步骤
    1 创建 Person对象  老王 30
      老王养狗
    2 创建 狗对象
    3 老王对象调用keepPet方法 
    同理 老李

测试代码

package com.itheima.test;

public class Demo {

    public static void main(String[] args) {
        //想调用 keepPet方法 方法属于 饲养员对象
        //创建 饲养员对象
        Person p = new Person("隔壁老王",30);
        //调用方法 方法重载
        //  方法需要什么参数 我就给什么类型数据
//        p.keepPet(狗对象,食物);
        Dog dog = new Dog(2, "黑色");
        String gouShi = "蓝翔";
        p.keepPet(dog,gouShi);

        System.out.println("=============");
        Person p2 = new Person("隔壁翠花",28);
//        p.keepPet(猫对象,食物);
        Cat cat = new Cat(3,"黑白花");
        String maoShi = "小鱼";
        p2.keepPet(cat,maoShi);
    }
}
// 5.1 优化
    public void keepPet(Animal a ,String something){
        System.out.println("年龄为"+age+"岁的"+name+"养了一只"+a.getColor()+"颜色的"+a.getAge()+"岁的小动物");
        a.eat(something);
        
        //5.2 优化
        // 是猫 就去 抓老鼠
        if(a instanceof Cat cat){//判断同时完成转换 jdk14的新特性
//            Cat cat = (Cat)a;
            cat.catchMouse();
        }
        // 是狗 就去 看门
        if(a instanceof Dog dog){
            dog.lookHome();
        }
    }

第三章 API

API（Application Programming interface）意思是应用程序编程接口，说人话就是Java帮我们写好的一些程序，如：类、方法等，我们直接拿过来用就可以解决一些问题。

很多初学者给我反应的问题是，这些API一听就会，但是就是记住不！送同学们一句话**，**

“千里之行始于足下，多记、多查、多些代码、孰能生巧！”

一、Object类

各位小伙伴，我们要学习的第一个API就是Object类。Object类是Java中所有类的祖宗类，因此，Java中所有类的对象都可以直接使用Object类中提供的一些方法。

按照下图的提示，可以搜索到你想要找的类

我们找到Object类的下面两个方法

toString()方法

我们先来学习toString()方法。

public String toString()
    调用toString()方法可以返回对象的字符串表示形式。
    默认的格式是：“包名.类名@哈希值16进制”

假设有一个学生类如下

public class Student{
    private String name;
    private int age;
    
    public Student(String name, int age){
        this.name=name;
        this.age=age;
    }
}

再定义一个测试类

public class Test{
    public static void main(String[] args){
        Student s1 = new Student("赵敏",23);
        System.out.println(s1.toString()); 
    }
}

打印结果如下

如果，在Student类重写toString()方法，那么我们可以返回对象的属性值，代码如下

public class Student{
    private String name;
    private int age;
    
    public Student(String name, int age){
        this.name=name;
        this.age=age;
    }
    
    @Override
    public String toString(){
        return "Student{name=‘"+name+"’, age="+age+"}";
    }
}

运行测试类，结果如下

equals(Object o)方法

接下来，我们学习一下Object类的equals方法

public boolean equals(Object o)
    判断此对象与参数对象是否"相等"

我们写一个测试类，测试一下

public class Test{
	public static void main(String[] args){
        Student s1 = new Student("赵薇",23);
        Student s2 = new Student("赵薇",23);
        
        //equals本身也是比较对象的地址，和"=="没有区别
        System.out.println(s1.equals(s2)); //false
         //"=="比较对象的地址
        System.out.println(s1==s2); //false
    }
}

但是如果我们在Student类中，把equals方法重写了，就按照对象的属性值进行比较

public class Student{
    private String name;
    private int age;
    
    public Student(String name, int age){
        this.name=name;
        this.age=age;
    }
    
    @Override
    public String toString(){
        return "Student{name=‘"+name+"’, age="+age+"}";
    }
    
    //重写equals方法，按照对象的属性值进行比较
    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() 

总结一下Object的toString方法和equals方法

```java
public String toString()
   	返回对象的字符串表示形式。默认的格式是：“包名.类名@哈希值16进制”
   	【子类重写后，返回对象的属性值】
   	
public boolean equals(Object o)
    判断此对象与参数对象是否"相等"。默认比较对象的地址值，和"=="没有区别
    【子类重写后，比较对象的属性值】

二、Objects类

Objects是一个工具类，提供了一些方法可以对任意对象进行操作。主要方法如下

下面写代码演示一下这几个方法

public class Test{
    public static void main(String[] args){
        String s1 = null;
        String s2 = "itheima";
        
        //这里会出现NullPointerException异常，调用者不能为null
        System.out.println(s1.equals(s2));
        //此时不会有NullPointerException异常，底层会自动先判断空
        System.out.println(Objects.equals(s1,s2));
        
        //判断对象是否为null，等价于==
        System.out.println(Objects.isNull(s1)); //true
        System.out.println(s1==null); //true
        
        //判断对象是否不为null，等价于

```java
/**
 * 目标：学会使用Arrays类的常用方法。
 */
public class ArraysTest1 {
    public static void main(String[] args) {
        // 目标 掌握Arrays的使用
        // 是 数组工具类 解决 数组的操作问题

        int[] arr = {6,5,7,24,8,3,1,0,2,15};
        System.out.println(arr);// [I@4eec7777
        // 1:将数组中内容 按照字符串形式展示
        // static String toString(数组)
        System.out.println(Arrays.toString(arr));
        //2:copy数组一部分 产生新的数组
        System.out.println(arr.length);
        // static 类型[]  copyOfRange(类型[] 源数组,int start ,int end)
                                //java的特性  包前不包后
        int[] newArr1 = Arrays.copyOfRange(arr, 1, 5);
        System.out.println("新数组长度:"+newArr1.length);
        System.out.println("新数组内容:"+Arrays.toString(newArr1));
        //3:copy数组   static 类型[] copyOf(类型[] 源数组,新数组的长度)
        //            特点 根据长度复制数组内容 长了补充默认值0
        int[] newArr2 = Arrays.copyOf(arr, 12);
        System.out.println("新数组2:"+Arrays.toString(newArr2));
        int[] newArr3 = Arrays.copyOf(arr, 8);
        System.out.println("新数组2:"+Arrays.toString(newArr3));

        // 4: 数组元素的排序
        // static void sort(类型[] arr) 对指定数组进行排序
        Arrays.sort(arr);
        System.out.println("排好顺序的:"+Arrays.toString(arr));
        //  [0, 1, 2, 3, 5, 6, 7, 8, 15, 24] 默认是升序排序

    }
}

六、BigDecimal类

各位同学，接下来我们学习的这个类叫BigDecimal，至于它是干什么用的，我们先不说。我们先看一段代码，看这个代码有什么问题？再说BigDeimal这个类是干什么用的，这样会更好理解一些。

public class Test {
    public static void main(String[] args) {
        System.out.println(0.1 + 0.2);
        System.out.println(1.0 - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);
    }
}

运行以上代码，我们会发现，结果并和我们想看到的不太一样。如下图所示

为了解决计算精度损失的问题，Java给我们提供了BigDecimal类，它提供了一些方法可以对数据进行四则运算，而且不丢失精度，同时还可以保留指定的小数位。下面看代码，演示一下

package com.itheima.api02;

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

public class BigDecimalDemo {

    public static void main(String[] args) {

        System.out.println(0.1 + 0.2);// 0.3
        System.out.println(1.0 - 0.32);//0.68
        System.out.println(1.015 * 100);//101.5
        System.out.println(1.301 / 100);//0.01301
        System.out.println("=====================");

        // 目标：掌握BigDecimal进行精确运算的方案。
        double a = 0.1;
        double b = 0.2;

        // 1、把浮点型数据封装成BigDecimal对象，再来参与运算。
        // a、public BigDecimal(double val) 得到的BigDecimal对象是无法精确计算浮点型数据的。 注意：不推荐使用这个，
        // b、public BigDecimal(String val)  得到的BigDecimal对象是可以精确计算浮点型数据的。 可以使用。
        // c、public static BigDecimal valueOf(double val): 通过这个静态方法得到的BigDecimal对象是可以精确运算的。是最好的方案。
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);


        // 2、public BigDecimal add(BigDecimal augend): 加法
          // a1+b1
        BigDecimal c1 = a1.add(b1);
        System.out.println(c1);

        // 3、public BigDecimal subtract(BigDecimal augend): 减法
        BigDecimal c2 = a1.subtract(b1);
        System.out.println(c2);

        // 4、public BigDecimal multiply(BigDecimal augend): 乘法
        BigDecimal c3 = a1.multiply(b1);
        System.out.println(c3);

        // 5、public BigDecimal divide(BigDecimal b): 除法
        BigDecimal c4 = a1.divide(b1);
        System.out.println(c4);

        System.out.println("================================");

        // 6、public BigDecimal divide(另一个BigDecimal对象，精确几位，舍入模式) : 除法，可以设置精确几位。
        BigDecimal d1 = BigDecimal.valueOf(1.0);
        BigDecimal d2 = BigDecimal.valueOf(3.0);
        BigDecimal f = d1.divide(d2,2, RoundingMode.HALF_UP);
        System.out.println(f);


        // 7、public double doubleValue() : 把BigDecimal对象又转换成double类型的数据。
        double v = f.doubleValue();
        System.out.println(v);
    }
}