Java 面向对象三大特征之三：多态；内部类；常用API

程序员希西子

已于 2023-09-16 16:54:40 修改

阅读量76

点赞数

分类专栏： Java面向对象进阶栏文章标签： java 开发语言

于 2023-03-21 20:41:20 首次发布

本文链接：https://blog.csdn.net/wangjh11234/article/details/129647477

版权

Java面向对象进阶栏专栏收录该内容

17 篇文章 0 订阅

订阅专栏

一.面向对象三大特征之三：多态

1.多态的概述，多态的形式

父类类型 对象名称 = new 子类构造器;
接口 对象名称  = new 实现类构造器;

package coom.wjh.d1_polymorphic;

//抽象类
public abstract class Animal {
    public abstract void run();
}

package coom.wjh.d1_polymorphic;

public class Dog extends Animal{

    @Override
    public void run() {
        System.out.println("跑的好六！");
    }
}

package coom.wjh.d1_polymorphic;

public class Tortoise extends Animal{

    @Override
    public void run() {
        System.out.println("跑的很慢");
    }
}

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        //之前的创建对象的方法
        Dog a = new Dog();
        a.run();

        Tortoise t = new Tortoise();
        t.run();

        //  1.多态的形式：父类类型 对象名称 = new 子类构造器;
        Animal a1 = new Dog();
        a.run();

        Animal t1 = new Tortoise();
        t.run();
    }
}

跑的好六！
跑的很慢
跑的好六！
跑的很慢

进程已结束，退出代码为 0

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        //之前的创建对象的方法
        Dog a = new Dog();
        a.run();

        Tortoise t = new Tortoise();
        t.run();
        System.out.println("============================");

        //  1.多态的形式：父类类型 对象名称 = new 子类构造器;
        Animal a1 = new Dog();
        a1.run();    //方法调用：编译看左边，运行看右边
        System.out.println(a1.name);    //变量调用：编译看左，运行也看左（多态侧重行为多态）

        Animal t1 = new Tortoise();
        t1.run();    //方法调用：编译看左边，运行看右边
        System.out.println(t1.name);    //变量调用：编译看左，运行也看左（多态侧重行为多态）
    }
}

2.多态的好处

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        Tortoise d = new Tortoise();
        go(d);
        
        Animal t = new Dog();
        go(t);

    }

    
    /**
     * 要求：所有的动物都可以进来比赛
     */
    public static void go(Animal a){
        System.out.println("start...");
        a.run();
        System.out.println("end...");

    }
}

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        Tortoise d = new Tortoise();
        go(d);

        Animal t = new Dog();
        go(t);

        //t2.lookDoor();  //多态下不能访问子类的独有功能

    }


    /**
     * 要求：所有的动物都可以进来比赛
     */
    public static void go(Animal a){
        System.out.println("start...");
        a.run();
        System.out.println("end...");

    }
}

3.多态下引用数据类型的类型转换

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        //1.自动类型转换
        Animal a = new Dog();
        a.run();
        
        
        //2.强制类型转换
        Animal a2 = new Tortoise();
        a2.run();

        Tortoise t = (Tortoise) a2;     //强制转换，父类-->子类类型
        t.layEggs();
        
        
        
    }
}

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        //1.自动类型转换
        Animal a = new Dog();
        a.run();


        //2.强制类型转换
        Animal a2 = new Tortoise();
        a2.run();

        Tortoise t = (Tortoise) a2;     //强制转换，父类-->子类类型
        t.layEggs();

        Dog g = (Dog) a2;    //强制转换:编译阶段不报错，有继承或者实现关系编译阶段可以强制转换，没有毛病，
        //但是运行时可能出错的


    }
}

跑的好六！
跑的很慢
在下蛋
Exception in thread "main" java.lang.ClassCastException: class coom.wjh.d1_polymorphic.Tortoise cannot be cast to class coom.wjh.d1_polymorphic.Dog (coom.wjh.d1_polymorphic.Tortoise and coom.wjh.d1_polymorphic.Dog are in unnamed module of loader 'app')
at coom.wjh.d1_polymorphic.Test.main(Test.java:21)

进程已结束，退出代码为 1

package coom.wjh.d1_polymorphic;

/**
 * 目标：认识多态，理解多态的形式和概念
 */

public class Test {
    public static void main(String[] args) {
        //1.自动类型转换
        Animal a = new Dog();
        a.run();


        //2.强制类型转换
        Animal a2 = new Tortoise();
        a2.run();

        //Dog g = (Dog) a2;    //强制转换:编译阶段不报错，有继承或者实现关系编译阶段可以强制转换，没有毛病，
        //但是运行时可能出错的
        if(a2 instanceof Tortoise){
            Tortoise t = (Tortoise)a2;
            t.layEggs();
        }else if(a2 instanceof Dog){
            Dog g = new Dog();
            g.lookBoor();
        }
        
        go(new Dog());
        go(new Tortoise());
    }
    
    public static void go(Animal a){
        //a到底是乌龟的还是狗的呢？
        if(a instanceof Tortoise){
            Tortoise t = (Tortoise)a;
            t.layEggs();
        }else if(a instanceof Dog){
            Dog g = new Dog();
            g.lookBoor();
        }
    }
}

4.多态的综合案例

USB接口

package coom.wjh.d4_polymorphic.test;

/**
 * USB接口 == 规范
 */
public interface USB {
    //接入 拔出
    void connect();
    void unConnect();
}

Mouse类

package coom.wjh.d4_polymorphic.test;

public class Mouse implements USB{

    private String name;


    @Override
    public void connect() {
        System.out.println(name + "成功连接了电脑");
    }

    /**
     * 独有功能
     */
    public void dbClick(){
        System.out.println(name + "双击了确定");
    }


    @Override
    public void unConnect() {
        System.out.println(name + "成功连接了电脑");
    }


    public Mouse() {
    }

    public Mouse(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

KeyBoard

package coom.wjh.d4_polymorphic.test;

/*
实现类：
 */
public class KeyBoard implements USB{

    private String name;

    @Override
    public void connect() {
        System.out.println(name + "成功连接了电脑");

    }

    /**
     * 独有功能
     */
    public void KeyDown(){
        System.out.println(name + "输入了：666");
    }

    @Override
    public void unConnect() {
        System.out.println(name + "从键盘中拔出了");
    }

    public KeyBoard() {
    }

    public KeyBoard(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

Coputer类

package coom.wjh.d4_polymorphic.test;

public class Computer {
    private String name;

    /**
     * 提供安装USB设备的入口
     */
    public void installUSB(USB usb){
        //多态： usb == 可能是键盘 也可能是鼠标
        usb.connect();

        //独有功能，先判断再强转
        if(usb instanceof KeyBoard){
            KeyBoard k = (KeyBoard) usb;
            k.KeyDown();
        }else if(usb instanceof Mouse){
            Mouse m = (Mouse) usb;
            m.dbClick();
        }
        usb.unConnect();
    }

    public void start(){
        System.out.println(name + "电脑开机了");
    }


    public Computer() {
    }

    public Computer(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

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

Test类

package coom.wjh.d4_polymorphic.test;

/**
 * 目标: USB设备模拟
 * 1、定义USB接口:接入拔出
 * 2、定义2个USB的实现类:鼠标、键盘。
 * 3、创建一个电脑对象，创建USB设备对象，安装启动。
 */

public class Test {
    public static void main(String[] args) {
        //a.创建电脑对象
        Computer c = new Computer("外星人");
        c.start();

        //b.创建键盘对象，鼠标对象
        //KeyBoard k = new KeyBoard();      //常用
        USB u = new KeyBoard("雷蛇键盘");     //多态
        c.installUSB(u);

        System.out.println("1s后...");

        USB u2 = new Mouse("罗技鼠标");     //多态
        c.installUSB(u2);
    }
}

外星人电脑开机了
雷蛇键盘成功连接了电脑
雷蛇键盘输入了：666
雷蛇键盘从键盘中拔出了
1s后...
罗技鼠标成功连接了电脑
罗技鼠标双击了确定
罗技鼠标成功连接了电脑

进程已结束，退出代码为 0

二.内部类

1.内部类概述

内部类的分类：

2.内部类之一:静态内部类[了解]

package coom.wjh.d5_innerclass_static;

/**
 * 外部类
 */

public class Outer {

    public static int a = 100;
    /**
     * 学习静态成员内部类
     */
    public static class Inner{
        private String name;
        private int age;
        public static String schoolName;

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void show(){
            System.out.println(name);
            System.out.println(a);
        }



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

        public static String getSchoolName() {
            return schoolName;
        }

        public static void setSchoolName(String schoolName) {
            Inner.schoolName = schoolName;
        }
    }
}

package coom.wjh.d5_innerclass_static;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer.Inner();
        in.setName("周扒皮");
        in.show();
    }
}

周扒皮
100

进程已结束，退出代码为 0

3.成员内部类（非静态内部类）[了解]

package coom.wjh.d6_innerclass;

/**
 * 外部类
 */

public class Outer {


    /**
     * 成员内部类：不能加static修饰 属于外部类对象的
     */
    class Inner{
        private String name;
        private int age;
        public static int a = 100;    //JDK 16开始支持静态成员了

        public static void test(){
            System.out.println(a);
        }

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void show(){
            System.out.println(name);
        }

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

        public static int getA() {
            return a;
        }

        public static void setA(int a) {
            Inner.a = a;
        }
    }
}

package coom.wjh.d6_innerclass;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();
        in.setName("小明");
        in.show();

        Outer.Inner.test();
    }
}

小明
100

进程已结束，退出代码为 0

package coom.wjh.d6_innerclass;

/**
 * 外部类
 */

public class Outer {
    public static int name = 111;
    private String hobby = "睡觉";



    /**
     * 成员内部类：不能加static修饰 属于外部类对象的
     */
    class Inner{
        private String name;
        private int age;
        public static int a = 100;    //JDK 16开始支持静态成员了

        public static void test(){
            System.out.println(a);
        }

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void show(){
            System.out.println(name);
            System.out.println(Outer.name);
            System.out.println(hobby);
        }

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

        public static int getA() {
            return a;
        }

        public static void setA(int a) {
            Inner.a = a;
        }
    }
}

package coom.wjh.d6_innerclass;

/**
 * 外部类
 */

public class Outer {
    public static int name = 111;
    private String hobby = "睡觉";

    public Outer() {
    }

    public Outer(String hobby) {
        this.hobby = hobby;
    }



    /**
     * 成员内部类：不能加static修饰 属于外部类对象的
     */
    class Inner{
        private String name;
        private int age;
        public static int a = 100;    //JDK 16开始支持静态成员了

        public static void test(){
            System.out.println(a);
        }

        public Inner() {
        }

        public Inner(String name, int age) {
            this.name = name;
            this.age = age;
        }

        public void show(){
            System.out.println(name);
            System.out.println(age);
            System.out.println(Outer.name);
            System.out.println(hobby);
        }

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

        public static int getA() {
            return a;
        }

        public static void setA(int a) {
            Inner.a = a;
        }
    }
}

package coom.wjh.d6_innerclass;

public class Test {
    public static void main(String[] args) {
        Outer.Inner in = new Outer().new Inner();
        in.setName("小明");
        in.show();

        Outer.Inner.test();

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

        Outer.Inner in1 = new Outer("吃饭").new Inner("小亮",9);
        in1.show();
    }
}

小明
0
111
睡觉
100
-----------------
小亮
9
111
吃饭

进程已结束，退出代码为 0

            System.out.println(age);    //78
            System.out.println(this.age);    //110
            System.out.println(Outer.this.age);    //150

4.局部内部类[了解]

package coom.wjh.d7_innerclass;

/**
 * 目标：了解局部内部类的语法
 */

public class Test {
    
    static {
        class Dog{
            
        }
        
        abstract class Animal{
            
        }
        
        interface Sport{
            
        }
    }
    
    
    public static void main(String[] args) {
        class Cat{
            private String name;
            public static int onlineNumber = 100;
            

            public String getName() {
                return name;
            }

            public void setName(String name) {
                this.name = name;
            }
        }
        
        Cat c = new Cat();
        c.setName("小红");
        
    }
}

5.匿名内部类[重点]

匿名内部类：

本质上是一个没有名字的内部类，定义在方法中、代码块中，等

作用：方便创建子类对象，最终目的为了简化代码编写

格式：

new 类|抽象类名|或者接口名(){
    重写方法;
};

Employee a = new Employee(){
    public void work(){
    
    }
}
a.work;

package coom.wjh.d8_innerclass_anonymous;

/**
 * 目标：学习匿名内部类的形式和特点
 */

public class Test {
    public static void main(String[] args) {
        Animal a = new Animal(){
            @Override
            public void run() {
                System.out.println("老虎跑得快！！！");
            }
        };
        a.run();
    }
}

//  class Tiger extends Animal{
//
//    @Override
//    public void run() {
//        System.out.println("老虎跑得快！！！");
//    }
//}

abstract class Animal{        //abstract抽象的，所以Animal不能创建对象
    public abstract void run();
}

老虎跑得快！！！

进程已结束，退出代码为 0

特点总结：
1.匿名内部类是一个没有名字的内部类

2.匿名内部类写出来就会产生一个内部类的对象

3.匿名内部类的对象类型是相当于当前new的那个的类型的子类类型

6.匿名内部类常见使用形式

package coom.wjh.d8_innerclass_anonymous;

/**
 * 目标：掌握匿名内部类的使用形式（语法）
 */

public class Test2 {
    public static void main(String[] args) {
        Swimming s = new Swimming() {       //匿名内部类的对象，不是接口的对象，接口不能创建对象
            @Override
            public void swim() {
                System.out.println("学生游泳...");
            }
        };
        go(s);

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

        Swimming s1 = new Swimming() {       //匿名内部类的对象，不是接口的对象，接口不能创建对象
            @Override
            public void swim() {
                System.out.println("老师游泳...");
            }
        };
        go(s1);

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

        //简化代码
        go(new Swimming() {
            @Override
            public void swim() {
                System.out.println("老师游泳...");
            }
        });


    }
    /**
     * 学生，老师，运动员可以一起参加比赛
     */

    public static void go(Swimming s){
        System.out.println("开始...");
        s.swim();
        System.out.println("结束...");

    }
}

//    //子类
//class Student implements Swimming{
//
//    @Override
//    public void swim() {
//        System.out.println("游泳...");
//    }
//}

interface Swimming{
    void swim();
}

开始...
学生游泳...
结束...
-----------------
开始...
老师游泳...
结束...
----------------
开始...
老师游泳...
结束...

进程已结束，退出代码为 0

7.匿名内部类真实使用场景演示

package coom.wjh.d8_innerclass_anonymous;

import javax.swing.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;

/**
 * 目标：通过GUI编程 理解匿名内部类的真实使用场景
 */

public class Test3 {
    public static void main(String[] args) {
        //1.创建接口
        JFrame win = new JFrame("登录界面");
        JPanel panel = new JPanel();
        win.add(panel);

        //2.创建一个按钮对象
        JButton btn = new JButton("登入");

        while(true) {

            //注意：讲解匿名内部类的使用     //监听器
            btn.addActionListener(new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    JOptionPane.showMessageDialog(win, "点我一下，说明爱我");
                }
            });
            panel.add(btn);

            //简化代码
            btn.addActionListener(e -> JOptionPane.showMessageDialog(win, "再点一下"));

        //3.把按钮对象添加到桌布上显示

        //4.展示窗口
        win.setSize(400,300);   //宽度和高度
        win.setLocationRelativeTo(null);    //居中显示
        win.setVisible(true);
        }

    }

}

三.常用API

1.Object

什么是API(application Programming interface)应用程序编程接口。

简单来说：就是Java帮我们写好的一些语法，我们直接拿过来用就可以了。

toString方法

package coom.wjh.d9_api_Object;

public class Student {  //extends Object{
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

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

//    @Override
//    public String toString(){
//        return "Student {name="+ name + ",age="+ age + ",sex="+ sex + "}";
//    }
    
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

package coom.wjh.d9_api_Object;

/**
 * 目标：掌握object类中toString方法的使用
 */
public class Test {
    public static void main(String[] args) {
        Student s = new Student("小明",18,'男');
        String rs = s.toString();
        System.out.println(rs);     //输出当前内存对象的地址
        //coom.wjh.d9_api_Object.Student@3b07d329

        System.out.println(s.toString());

        //直接输出对象变量，默认可以省略toString不写
        System.out.println(s);
    }
}

Student{name='小明', sex=男, age=18}
Student{name='小明', sex=男, age=18}
Student{name='小明', sex=男, age=18}

进程已结束，退出代码为 0

equals方法

package coom.wjh.d9_api_Object;

import java.util.Objects;

public class Student {  //extends Object{
    private String name;
    private char sex;
    private int age;

    public Student() {
    }

    public Student(String name, int age, char sex) {
        this.name = name;
        this.age = age;
        this.sex = sex;
    }

    public char getSex() {
        return sex;
    }

    public void setSex(char sex) {
        this.sex = sex;
    }

    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;
    }
    //自动生成
    @Override
    public boolean equals(Object o) {
        //1.判断是否是同一个对象比较，如果是返回true
        if (this == o) return true;
        //2.如果o是null返回false Student != Pig
        if (o == null || getClass() != o.getClass()) return false;
        Student student = (Student) o;
        return sex == student.sex && age == student.age && Objects.equals(name, student.name);
    }


    //    @Override
//    public String toString(){
//        return "Student {name="+ name + ",age="+ age + ",sex="+ sex + "}";
//    }

    /**
     * 自己重写equals，自己定制重写规则
     * 两个对象内容一样就认为他们是相等的
     * s1.equals(s2)
     * 比较者：s1   == this
     * 被比较者：s2
     * @return
     */



//    @Override
//    public boolean equals(Object o){
//        //1.判断o是不是学生类型
//        if(o instanceof Student){
//            Student s2 = (Student) o;
//            //2.判断两个对象的内容是否一样
            if(this.name.equals(s2.name) && this.age == s2.age && this.sex == s2.sex){
                return true;
            }else {
                return false;
            }
//
//            //简化代码
//            return this.name.equals(s2.name) && this.age == s2.age && this.sex == s2.sex;
//
//        }else{
//            //学生只能和学生比较，否则结果一定是false
//            return false;
//        }
//    }

    //自动生成


    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", sex=" + sex +
                ", age=" + age +
                '}';
    }
}

package coom.wjh.d9_api_Object;

public class Test1 {
    public static void main(String[] args) {
        Student s1 = new Student("小明",18,'男');
        Student s2 = new Student("小明",18,'男');

        //equals默认是比较2个对象的地址是否相同
        System.out.println(s1.equals(s2));
        System.out.println(s1 == s2);

    }
}

true
false

进程已结束，退出代码为 0

2.objects

package coom.wjh.d10_api_objects;

import java.util.Objects;

/**
 * 目标：掌握Object类的常用方法：equals
 */
public class Test {
    public static void main(String[] args) {
        String s1 = null;
        String s2 = new String("wjh");
        //System.out.println(s1.equals(s2));      //留下了隐患，可能出现空值的异常
        System.out.println(Objects.equals(s1, s2)); //更安全更准确
        
    }
}

false

进程已结束，退出代码为 0

3.StringBuilder

package coom.wjh.d11_api_Stringbulider;

/**
 * 学会使用StringBuilder操作字符串，最终还需要它性能好的原因
 */
public class Test {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(); //""
        sb.append("a");
        sb.append("b");
        sb.append("c");
        sb.append(1);
        sb.append(3.3);
        sb.append(false);
        sb.append(true);
        System.out.println(sb);

        StringBuilder sb1 = new StringBuilder();
        //支持链式编程
        sb1.append("a").append("b").append("我爱你中国!");
        System.out.println(sb1);

        //反转内容
        sb1.reverse();
        System.out.println(sb1);

        System.out.println(sb1.length());

        //注意：StringBuilder只是拼接字符串的手段，效率好。
        //最终的结果还是要恢复成String类型。

        StringBuilder sb2 = new StringBuilder();
        sb2.append("123").append("456");
        //check(sb2);   报错
        String rs = sb2.toString();
        check(rs);
    }

    public static void check(String date){
        System.out.println(date);
    }
}

abc13.3falsetrue
ab我爱你中国!
!国中你爱我ba
8
123456

进程已结束，退出代码为 0

package coom.wjh.d11_api_Stringbulider;

public class test1 {
    public static void main(String[] args) {
    int[] arr1 = null;
        System.out.println(toString(arr1));

        int[] arr2 = {11,22,33,44,55};
        System.out.println(toString(arr2));


    }

/**
 * 定义方法，接受任意整型数组，返回数组内容格式
 */
    public static String toString(int[] arr){
        //2.开始拼接内容。
        if(arr != null){
            StringBuilder sb = new StringBuilder("[");
            for (int i = 0; i < arr.length; i++) {
                sb.append(arr[i]).append(i == arr.length - 1 ? "" : ",");
            }
            sb.append("]");
            return sb.toString();
        }else{
            return null;
        }
    }
}

null
[11,22,33,44,55]

进程已结束，退出代码为 0

4.Math

package coom.wjh.d12_api_Math;

/**
 *
 */
public class Test {
    public static void main(String[] args) {
        //1.取绝对；返回正数
        System.out.println(Math.abs(10));   //10
        System.out.println(Math.abs(-10.3));    //10.3

        //2.向上取整：5
        System.out.println(Math.ceil(4.0000001));   //5.0

        //3.向下取整：4
        System.out.println(Math.floor(4.99999999));     //4.0

        //4.求指数次方
        System.out.println(Math.pow(2,3)); //2^3=8.0

        //5.四舍五入：10
        System.out.println(Math.round(4.499999));   //4
        System.out.println(Math.round(4.500001));   //5

        System.out.println(Math.random());  //0.0 - 1.0（包0不包1；包前不包后）
   
        int date = (int)(Math.random() * 7) + 3;
        System.out.println(date);
        //拓展：3-9之间的随机数： (0-6)+3
        //(0-1) * 6 +3
 }
}

10
10.3
5.0
4.0
8.0
4
5
0.8256819484828756

进程已结束，退出代码为 0

5.system

package coom.wjh.d13_api_System;

import java.lang.reflect.Array;
import java.util.Arrays;

/**
 *
 */

public class Test {
    public static void main(String[] args) {
        System.out.println("程序开始.....");

        //System.exit(0); //JVM终止！

        //  1s = 1000ms
        long time = System.currentTimeMillis();
        System.out.println(time);
        //2.计算认为时间有起源：返回1970-1-1 00:00:00 走到此刻的总的毫秒值；时间毫秒值。
        //进行时间的计算：性能分析
        long start = System.currentTimeMillis();
        for (int i = 0; i < 10; i++) {
            System.out.println("输出：" + i);
        }
        long end = System.currentTimeMillis();
        double times = (end - start);
        System.out.println(times / 1000 + "s");        //单位：ms


        /**
         * arraycopy(Object src, int srcPos, Object dest, int destPos, int length)
         */
        //参数一：被拷贝的数组
        //参数二：从那个索引开始拷贝
        //参数三：复制的目标数组
        //参数四：粘贴位置
        //参数五：拷贝元素的个数

        //3.做数组拷贝
        int[] arr1 = {10,20,30,40,50,60,70};
        int[] arr2 = new int[6];    //[0, 0, 0, 0, 0, 0] => [0, 0, 40, 50, 60, 0]
        System.arraycopy(arr1, 3, arr2,2,3);
        System.out.println(Arrays.toString(arr2));

        System.out.println("程序结束....");
    }
}

程序开始.....
1679400890522
输出：0
输出：1
输出：2
输出：3
输出：4
输出：5
输出：6
输出：7
输出：8
输出：9
0.012s
[0, 0, 40, 50, 60, 0]
程序结束....

进程已结束，退出代码为 0

6.BigDecimal

package coom.wjh.d14_api_BigDecimalDemo;

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

public class BigDecimalDemo {
    public static void main(String[] args) {
        //浮点数运算的时候直接+ - * / 可能会出现数据失真的（精度问题）。
        System.out.println(0.09 + 0.01);
        System.out.println(1.0 - 0.32);
        System.out.println(1.015 * 100);
        System.out.println(1.301 / 100);

        System.out.println("---------------");
        double a = 0.1;
        double b = 0.2;
        double c = a + b;
        System.out.println(c);
        System.out.println("---------------");

        //包装浮点型数据成为大数据对象    BigDecimal
        BigDecimal a1 = BigDecimal.valueOf(a);
        BigDecimal b1 = BigDecimal.valueOf(b);
        BigDecimal c1 = a1.add(b1);         //  +
        BigDecimal c2 = a1.subtract(b1);    //  -
        BigDecimal c3 = a1.multiply(b1);    //  *
        BigDecimal c4 = a1.divide(b1);      //  /
        System.out.println(c1);     //0.3
        System.out.println(c2);     //-0.1
        System.out.println(c3);     //0.02
        System.out.println(c4);     //0.5

        //目的：转成double类型
        double rs = c1.doubleValue();
        System.out.println(rs);

        //注意事项：BigDecimal是一定要精度运算的
        BigDecimal a11 = BigDecimal.valueOf(10.0);
        BigDecimal b11 = BigDecimal.valueOf(3.0);
        /**
         * 参数一：除数
         * 参数二：保留小数位
         * 参数三：舍入模式
         */
        //BigDecimal c11 = a11.divide(b11);
        //System.out.println(c11);    //错误
        BigDecimal c12 = a11.divide(b11,2, RoundingMode.HALF_UP);       //3.33
        System.out.println(c12);
        
        

        System.out.println("---------------");
    }
}

0.09999999999999999
0.6799999999999999
101.49999999999999
0.013009999999999999
---------------
0.30000000000000004
---------------
0.3
-0.1
0.02
0.5
0.3
3.33
---------------

进程已结束，退出代码为 0