DAY07_面向对象高级(4)&内部类&Lambda&常用Api(1)

已于 2023-05-26 15:22:01 修改
阅读量48 收藏
点赞数
分类专栏： 2.JavaSE进阶 文章标签： java
于 2023-02-25 14:54:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57075290/article/details/129209590
版权

目录

1 内部类

1.1 内部类的基本使用

  • 内部类概述：
    • 就是在一个类中定义一个类。举例：在一个A类的内部定义一个B类， B类就被称为内部类。
  • 内部类定义格式：
    在这里插入图片描述
  • 内部类的访问特点
    • 内部类可以直接访问外部类的成员，包括私有
    • 外部类要访问内部类的成员，必须创建对象
public class Test1Inner {
    public static void main(String[] args) {
        /*
            创建内部类对象的格式:
                外部类名.内部类名 对象名 = new 外部类对象().new 内部类对象();
         */
        Outer.Inner i = new Outer().new Inner();
        System.out.println(i.num);
        i.show();
    }
}

class Outer {

    private int a = 10;

    class Inner {
        int num = 10;

        public void show(){
            System.out.println("Inner..show");
            // 内部类, 访问外部类成员, 可以直接访问, 包括私有
            System.out.println(a);
        }
    }
}

1.2 内部类分类

  • 按照内部类在类中定义的位置不同，可以分为如下两种形式
    • 在类的成员位置：成员内部类
    • 在类的局部位置：局部内部类

1.2.1 成员内部类

成员内部类的定义位置
  • 在类中方法，跟成员变量是一个位置
外界创建成员内部类格式
  • 格式：外部类名.内部类名 对象名 = 外部类对象.内部类对象;
    • 范例：Outer.Inner oi = new Outer().new Inner();
修饰符修饰成员内部类

成员内部类，也属于（成员），既然是成员就可以被一些修饰符所修饰

私有成员内部类

将一个类，设计为内部类的目的，大多数都是不想让外界去访问，所以内部类的定义应该私有化，私有化之后，再提供一个可以让外界调用的方法，方法内部创建内部类对象并调用。

  • 私有成员内部类访问：在自己所在的外部类中创建对象访问。
public class Test2Innerclass {
    /*
        私有成员内部类演示
     */
    public static void main(String[] args) {
        // Outer.Inner oi = new Outer().new Inner();
        Outer o = new Outer();
        o.method();
    }
}

class Outer {
    private class Inner {
        public void show(){
            System.out.println("inner..show");
        }
    }

    public void method(){
        Inner i = new Inner();
        i.show();
    }
}
静态成员内部类
  • 静态成员内部类访问格式：外部类名.内部类名 对象名 = new 外部类名.内部类名();
  • 静态成员内部类中的静态方法：外部类名.内部类名.方法名();
public class Test3Innerclass {
    /*
        静态成员内部类演示
     */
    public static void main(String[] args) {
        // 外部类名.内部类名 对象名 = new 外部类名.内部类名();
        Outer.Inner oi = new Outer.Inner();
        oi.show();

        Outer.Inner.method();
    }
}

class Outer {
    static class Inner {
        public void show(){
            System.out.println("inner..show");
        }

        public static void method(){
            System.out.println("inner..method");
        }
    }
}

1.2.2 局部内部类

  • 局部内部类定义位置
    • 局部内部类是在方法中定义的类
  • 局部内部类方式方式
    • 局部内部类，外界是无法直接使用，需要在方法内部创建对象并使用
    • 该类可以直接访问外部类的成员，也可以访问方法内的局部变量
public class Test4Innerclass {
    /*
        局部内部类:
            编写位置: 方法中
            访问方式: 只能在方法中, 创建对象并访问
     */
    public static void main(String[] args) {
        Outer o = new Outer();
        o.method();
    }
}

class Outer {

    int a = 10;

    public void method(){
        int b = 20;
        class Inner {
            public void show(){
                System.out.println("show...");
                System.out.println(a);
                System.out.println(b);
            }
        }

        Inner i = new Inner();
        i.show();
    }
}

1.3 匿名内部类

  • 匿名内部类概述：
    • 匿名内部类本质上是一个特殊的局部内部类（定义在方法内部）
    • 是一个继承了该类或者实现了该接口的子类匿名对象
  • 匿名内部类前提：
    • 存在一个类或者接口，这里的类可以是具体类也可以是抽象类
  • 匿名内部类的格式：

    • 格式：在这里插入图片描述

    • 范例：在这里插入图片描述

  • 匿名内部类理解：
    • 匿名内部类是将（继承 \ 实现）（方法重写）（创建对象）三个步骤，放在了一步进行
public class Test5Innerclass {
    /*
        1. 创建实现类, 通过implements关键字去实现接口
        2. 重写方法
        3. 创建实现类对象
        4. 调用重写后的方法.
        匿名内部类:
            前提: 需要存在类\接口
            格式:
                    new 类名 \ 接口名 (){
                        重写方法
                    }
     */
    public static void main(String[] args) {
        InterImpl ii = new InterImpl();
        ii.show();

        // 匿名内部类的理解: 将继承\实现, 方法重写, 创建对象, 放在了一步进行.
        // 解释: 实现了Inter接口的, 一个实现类对象.
        new Inter() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类中的show方法");
            }
        }.show();

        // 情况: 接口中存在多个方法
        Inter2 i = new Inter2() {
            @Override
            public void show1() {
                System.out.println("show1...");
            }

            @Override
            public void show2() {
                System.out.println("show2...");
            }
        };

        i.show1();
        i.show2();
    }
}

interface Inter {
    void show();
}

interface Inter2 {
    void show1();
    void show2();
}

class InterImpl implements Inter {
    @Override
    public void show() {
        System.out.println("InterImpl  重写的show方法");
    }
}

1.4 匿名内部类在开发中的使用场景

  • 匿名内部类的本质是一个继承了该类或者实现了该接口的【子类匿名对象】
  • 既然是对象，那就可以作为参数传递
  • 所以，当发现某个方法需要，接口或抽象类的子类对象，我们就可以传递一个匿名内部类过去
public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming){
        /*
            Swimming swimming = new Swimming() {
                @Override
                public void swim() {
                    System.out.println("铁汁, 我们去游泳吧");
                }
            }
         */
        swimming.swim();
    }
}

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

2 Lambda表达式

2.0 函数式编程思想概述

  • 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”
  • 面向对象思想强调“必须通过对象的形式来做事情”
  • 函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么形式去做”
  • 而我们要学习的Lambda表达式就是函数式思想的体现

2.1体验Lambda表达式

public class TestSwimming {
    public static void main(String[] args) {
        goSwimming(new Swimming() {
            @Override
            public void swim() {
                System.out.println("铁汁, 我们去游泳吧");
            }
        });

        /*
            理解: 对于Lambda表达式, 对匿名内部类进行了优化
         */
        goSwimming(() -> {
            System.out.println("铁汁, 我们去游泳吧");
        });
    }

    /**
     * 使用接口的方法
     */
    public static void goSwimming(Swimming swimming) {
        swimming.swim();
    }
}

/*
    游泳接口
 */
interface Swimming {
    void swim();
}

2.2 Lambda表达式的标准格式

  • Lambda表达式的使用前提
    • 有一个接口
    • 接口中有且仅有一个抽象方法
  • 组成Lambda表达式的三要素：
    • 形式参数，箭头，代码块
  • 格式： (形式参数) -> {代码块}
  • 形式参数：如果有多个参数，参数之间用逗号隔开；如果没有参数，留空即可
  • ->：由英文中画线和大于符号组成，固定写法。代表指向动作
  • 代码块：是我们具体要做的事情，也就是以前我们写的方法体内容

2.3 Lambda表达式练习1——无参数无返回值

  • 编写一个接口（ShowHandler）
  • 在该接口中存在一个抽象方法（show），该方法是无参数无返回值
  • 在测试类（ShowHandlerDemo）中存在一个方法（useShowHandler）
    • 方法的的参数是ShowHandler类型的
    • 在方法内部调用了ShowHandler的show方法
public class TestLambda {
    /*
        Lambda表达式的使用前提
            1. 一个接口
            2. 接口中有且仅有一个抽象方法

        练习1：
            1. 编写一个接口（ShowHandler）
            2. 在该接口中存在一个抽象方法（show），该方法是无参数无返回值
            3. 在测试类（ShowHandlerDemo）中存在一个方法（useShowHandler）
                        方法的的参数是ShowHandler类型的
                        在方法内部调用了ShowHandler的show方法
     */
    public static void main(String[] args) {
        useShowHandler(new ShowHandler() {
            @Override
            public void show() {
                System.out.println("我是匿名内部类中的show方法");
            }
        });

        // Lambda实现
        useShowHandler(() -> {
            System.out.println("我是Lambda中的show方法");
        });
    }

    public static void useShowHandler(ShowHandler showHandler) {
        showHandler.show();
    }
}

interface ShowHandler {
    void show();
}

2.4 Lambda表达式练习2——有参数无返回值

  • 首先存在一个接口（StringHandler）
  • 在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
  • 在测试类（StringHandlerDemo）中存在一个方法（useStringHandler）
    • 方法的的参数是StringHandler类型的
    • 在方法内部调用了StringHandler的printMessage方法
public class StringHandlerDemo {
    /*
        1.首先存在一个接口（StringHandler）
        2.在该接口中存在一个抽象方法（printMessage），该方法是有参数无返回值
        3.在测试类（StringHandlerDemo）中存在一个方法（useStringHandler）
                方法的的参数是StringHandler类型的
                在方法内部调用了StringHandler的printMessage方法
     */
    public static void main(String[] args) {
        useStringHandler(new StringHandler() {
            @Override
            public void printMessage(String msg) {
                System.out.println("我是匿名内部类" + msg);
            }
        });

        // Lambda实现
        useStringHandler((String msg) -> {
            System.out.println("我是Lambda表达式" + msg);
        });
    }

    public static void useStringHandler(StringHandler stringHandler) {
        stringHandler.printMessage("itheima");
    }
}

interface StringHandler {
    void printMessage(String msg);
}

2.5 Lambda表达式练习3——无参数有返回值

  • 首先存在一个接口（RandomNumHandler）
  • 在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
  • 在测试类（RandomNumHandlerDemo）中存在一个方法（useRandomNumHandler）
    • 方法的的参数是RandomNumHandler类型的
    • 在方法内部调用了RandomNumHandler的getNumber方法
import java.util.Random;

public class RandomNumHandlerDemo {
    /*
        1. 首先存在一个接口（RandomNumHandler）
        2. 在该接口中存在一个抽象方法（getNumber），该方法是无参数但是有返回值
        3. 在测试类（RandomNumHandlerDemo）中存在一个方法（useRandomNumHandler）
                方法的的参数是RandomNumHandler类型的
                在方法内部调用了RandomNumHandler的getNumber方法
     */
    public static void main(String[] args) {
        useRandomNumHandler(new RandomNumHandler() {
            @Override
            public int getNumber() {
                Random r = new Random();
                int num = r.nextInt(10) + 1;
                return num;
            }
        });

        useRandomNumHandler(() -> {
            Random r = new Random();
            int num = r.nextInt(10) + 1;
            return num;
            // 注意: 如果lambda所操作的接口中的方法, 有返回值, 一定要通过return语句, 将结果返回
            // 否则会出现编译错误
        });
    }

    public static void useRandomNumHandler(RandomNumHandler randomNumHandler) {
        int result = randomNumHandler.getNumber();
        System.out.println(result);
    }
}

interface RandomNumHandler {
    int getNumber();
}

2.6 Lambda表达式练习4——有参数有返回值

  • 首先存在一个接口（Calculator）
  • 在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
  • 在测试类（CalculatorDemo）中存在一个方法（useCalculator）
    • 方法的的参数是Calculator类型的
    • 在方法内部调用了Calculator的calc方法
public class CalculatorDemo {
    /*
        1. 首先存在一个接口（Calculator）
        2. 在该接口中存在一个抽象方法（calc），该方法是有参数也有返回值
        3. 在测试类（CalculatorDemo）中存在一个方法（useCalculator）
            方法的的参数是Calculator类型的
            在方法内部调用了Calculator的calc方法

     */
    public static void main(String[] args) {
        useCalculator(new Calculator() {
            @Override
            public int calc(int a, int b) {
                return a + b;
            }
        });

        useCalculator((int a, int b) -> {
            return a + b;
        });
    }

    public static void useCalculator(Calculator calculator) {
        int result = calculator.calc(10, 20);
        System.out.println(result);
    }
}

interface Calculator {
    int calc(int a, int b);
}

2.7 Lambda表达式的省略模式

  • 省略的规则
    • 参数类型可以省略。但是有多个参数的情况下，不能只省略一个
    • 如果参数有且仅有一个，那么小括号可以省略
    • 如果代码块的语句只有一条，可以省略大括号和分号，和return关键字
public class Test6 {
    public static void main(String[] args) {

        useInter(new Inter() {
            @Override
            public double method(double a, double b) {
                return a + b;
            }
        });

        /*useInter( (double a, double b) -> {
            return a + b;
        });*/

        useInter((a, b) -> a + b);
    }

    public static void useInter(Inter inter) {
        double result = inter.method(12.3, 22.3);
        System.out.println(result);
    }
}

interface Inter {
    // 用于计算 a + b 的结果并返回
    double method(double a, double b);
}

2.8 Lambda表达式和匿名内部类的区别

  • Lambda在特定情况下可以代替匿名内部类
  • 所需类型不同
    • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类
    • Lambda表达式：只能是接口
  • 使用限制不同
    • 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
    • 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
  • 实现原理不同
    • 匿名内部类：编译之后，产生一个单独的.class字节码文件
    • Lambda表达式：编译之后，没有一个单独的.class字节码文件。对应的字节码会在运行的时候动态生成

3 API

3.1 API概述

  • 什么是API
    • API (Application Programming Interface) ：应用程序编程接口
  • java中的API
    • 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。

3.2 如何使用API帮助文档

  • 打开帮助文档
    在这里插入图片描述

  • 找到索引选项卡中的输入框
    在这里插入图片描述

  • 在输入框中输入
    在这里插入图片描述

  • 看类在哪个包下
    在这里插入图片描述

  • 看类的描述
    在这里插入图片描述

  • 看构造方法
    在这里插入图片描述

  • 看构造方法
    在这里插入图片描述

4 常用API

4.1 Math

  • Math类概述
    • Math 包含执行基本数字运算的方法
  • Math中方法的调用方式
    • Math类中无构造方法，但内部的方法都是静态的，可以通过 类名.进行调用
  • Math类的常用方法
方法名 方法名说明
public static int abs(int a)返回参数的绝对值
public static double ceil(double a)返回大于或等于参数的最小double值，等于一个整数
public static double floor(double a)返回小于或等于参数的最大double值，等于一个整数
public static int round(float a)按照四舍五入返回最接近参数的int
public static int max(int a,int b)返回两个int值中的较大值
public static int min(int a,int b)返回两个int值中的较小值
public static double pow (double a,double b)返回a的b次幂的值
public static double random()返回值为double的正值，[0.0,1.0)
public class MathDemo {
    public static void main(String[] args) {
//        public static int abs(int a)		返回参数的绝对值
        int abs = Math.abs(10);
        System.out.println(abs);

//        public static double ceil(double a)	向上取整
        double ceil = Math.ceil(10.1);
        System.out.println(ceil);

//        public static double floor(double a)	向下取整
        double floor = Math.floor(10.9);
        System.out.println(floor);

//        public static int round(float a)	四舍五入
        long round = Math.round(10.1);
        System.out.println(round);
//
        long round1 = Math.round(1.9);
        System.out.println(round1);

//        public static int max(int a,int b)	返回两个int值中的较大值
        int max = Math.max(10, 20);
        System.out.println(max);

//        public static int min(int a,int b)	返回两个int值中的较小值
        int min = Math.min(10, 20);
        System.out.println(min);

//        public static double pow(double a,double b)返回a的b次幂的值
        double pow = Math.pow(2, 3);
        System.out.println(pow);

//        public static double random()		返回值为double的正值，[0.0,1.0)
        for (int i = 0; i < 10 ; i++) {
            double random = Math.random();
            System.out.println(random);
        }
    }
}

4.2 System

  • System 不能被实例化
  • System类的常用方法
方法名说明
public static void exit(int status)终止当前运行的 Java虚拟机，非零表示异常终止
public static long currentTimeMillis()返回当前时间(以毫秒为单位)
arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)数组copy
public class SystemDemo {
    public static void main(String[] args) {
//        public static void exit(int status)	终止当前运行的 Java 虚拟机，非零表示异常终止
        System.out.println(111);
        System.exit(0);  //当代码执行到这个方法的时候,就表示虚拟机已经停止了
        System.out.println(222);

//        public static long currentTimeMillis()  返回当前时间(以毫秒为单位)
        long start = System.currentTimeMillis();//获取当前时间
        for (int i = 0; i < 10000; i++) {
            System.out.println(i);
        }
        long end = System.currentTimeMillis();//获取当前时间
        System.out.println(end - start);//472 --- 得到的就是这个for循环运行的时间.

//      arraycopy(数据源数组, 起始索引, 目的地数组, 起始索引, 拷贝个数)	数组copy
        int[] arr1 = {1, 2, 3, 4, 5};
        int[] arr2 = new int[10];
        //需求:我要把arr1中的数据拷贝到arr2中.
        System.arraycopy(arr1,0,arr2,0,arr1.length);

        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }

        //我要把arr1最后两个元素,拷贝到arr2的最后两个索引上
        System.arraycopy(arr1, 3, arr2, 8, 2);
        for (int i = 0; i < arr2.length; i++) {
            System.out.println(arr2[i]);
        }
    }
}

4.3 Object

  • Object 类的概述
    • Object是类层次结构的根，每个类都可以将 Object 作为父类（超类）
    • 所有类都直接或者间接的继承自该类
  • 构造方法：
    • public Object()
  • Object 类的常用方法
方法名说明
public String toString()返回对象的字符串表示形式。建议所有子类重写该方法，自动生成
public boolean equals(另一个对象)比较对象是否相等。默认比较地址，重写可以比较内容，自动生成

4.3.1 Object类的toString方法

  • toString方法的作用：
    • 以良好的格式，更方便的展示对象中的属性值
  • 重写toString方法的方式
    • Alt + Insert 选择toString
    • 在类的空白区域，右键 -> Generate -> 选择toString
public class Student /*extends Object*/{
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

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

public class Demo {
    public static void main(String[] args) {
        Student s = new Student("张三",23);
        System.out.println(s);//com.itheima.demo1.Student@1b6d3586
        System.out.println(s.toString());
        //重写toString之后两次输出都是Student{name='张三', age=23}
    }
}
  • 总结：
    • Object类是所有类的直接或者间接父类
    • 直接打印一个对象就是打印这个对象的toString方法的返回值
    • Object类的toString方法得到的是对象的地址值
    • 我们一般会对toString方法进行重写

4.3.2 Object类的equals方法

  • equals方法的作用
    • 用于对象之间的比较，返回true和false的结果
    • 举例：s1.equals(s2); s1和s2是两个对象
  • 重写equals方法的场景
    • 不希望比较对象的地址值，想要结合对象属性进行比较的时候。
  • 重写equals方法的方式
    • alt + insert 选择equals() and hashCode()，IntelliJ Default，一路next，finish即可
    • 在类的空白区域，右键 -> Generate -> 选择equals() and hashCode()，后面的同上。
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

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

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (o == null || getClass() != o.getClass()) return false;

        Student student = (Student) o;

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

public class Demo {
    public static void main(String[] args) {
        Student s1 = new Student("zhangsan",23);
        Student s2 = new Student("zhangsan",23);

        System.out.println(s1 == s2);//地址值不相同，所以是false
        //Object类中的equals方法,底层也是用==号比较地址值.
        //重写equals方法之后，底层比较的是属性值
        System.out.println(s1.equals(s2));//重写equals之前是false，重写之后为true
    }
}

4.3.3 Object类的面试题

public class InterviewTest {
    public static void main(String[] args) {
        String s1 = "abc";
        StringBuilder sb = new StringBuilder("abc");
        //1.此时调用的是String类中的equals方法.
        //保证参数也是字符串,否则不会比较属性值而直接返回false
        System.out.println(s1.equals(sb));//false

        //StringBuilder类中是没有重写equals方法,用的就是Object类中的.
        System.out.println(sb.equals(s1));//false
    }
}

4.4 Objects

  • 常用方法
方法名说明
public static String toString(对象)返回参数中对象的字符串表示形式。
public static String toString(对象, 默认字符串)返回对象的字符串表示形式。
public static Boolean isNull(对象)判断对象是否为空
public static Boolean nonNull(对象)判断对象是否不为空
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(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;
    }

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

import java.util.Objects;

public class MyObjectsDemo {
    public static void main(String[] args) {
//      public static String toString(对象)  		 返回参数中对象的字符串表示形式。
        Student s1 = new Student("小罗同学", 50);
        String result1 = Objects.toString(s1);
        System.out.println(result1);//Student{name='小罗同学', age=50}
        System.out.println(s1);//Student{name='小罗同学', age=50}
        System.out.println("--------------------");

//      public static String toString(对象, 默认字符串)  返回对象的字符串表示形式。如果对象为空,那么返回第二个参数.
        Student s2 = new Student("小花同学", 23);
        String result2 = Objects.toString(s2, "随便写一个");
        System.out.println(result2);//Student{name='小花同学', age=23}
        Student s3 = null;
        String result3 = Objects.toString(s3, "随便写一个");
        System.out.println(result3);//随便写一个
        System.out.println("--------------------");

//        public static Boolean isNull(对象)		 判断对象是否为空
        Student s4 = null;
        boolean result4 = Objects.isNull(s4);
        System.out.println(result4);//true
        Student s5 = new Student();
        boolean result5 = Objects.isNull(s5);
        System.out.println(result5);//false
        System.out.println("--------------------");

//        public static Boolean nonNull(对象)		 判断对象是否不为空
        Student s6 = new Student();
        boolean result6 = Objects.nonNull(s6);
        System.out.println(result6);//true
        Student s7 = null;
        boolean result7 = Objects.nonNull(s7);
        System.out.println(result7);//false
        System.out.println("--------------------");
    }
}

4.5 BigDecimal

  • 作用
    • 可以用来进行精确计算
  • 构造方法
方法名说明
BigDecimal(double val)参数为double
BigDecimal(String val)参数为String
import java.math.BigDecimal;

public class MyBigDecimalDemo2 {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal(10.0);
        BigDecimal bd2 = new BigDecimal("0.3");

        System.out.println(bd1);//10
        System.out.println(bd2);//0.3
    }
}
  • 常用方法——四则运算
方法名说明
public BigDecimal add(另一个BigDecimal对象)加法
public BigDecimal subtract (另一个BigDecimal对象)减法
public BigDecimal multiply (另一个BigDecimal对象)乘法
public BigDecimal divide (另一个BigDecimal对象)除法
import java.math.BigDecimal;

public class MyBigDecimalDemo3 {
    public static void main(String[] args) {
        //BigDecimal bd1 = new BigDecimal(0.1);
        //BigDecimal bd2 = new BigDecimal(0.2);
        //如果想要进行精确运算,那么请使用字符串的构造
        BigDecimal bd1 = new BigDecimal("0.1");
        BigDecimal bd2 = new BigDecimal("0.2");
        //public BigDecimal add(另一个BigDecimal对象) 	加法
        BigDecimal add = bd1.add(bd2);
        System.out.println("和为" + add);
        //System.out.println(0.1 + 0.2);

        //public BigDecimal subtract (另一个BigDecimal对象)  减法
        BigDecimal subtract = bd1.subtract(bd2);
        System.out.println("差为" + subtract);

        //public BigDecimal multiply (另一个BigDecimal对象)  乘法
        BigDecimal multiply = bd1.multiply(bd2);
        System.out.println("积为" + multiply);

        //public BigDecimal divide (另一个BigDecimal对象)    除法
        BigDecimal divide = bd1.divide(bd2);
        System.out.println("商为"+divide);
    }
}
  • 常用方法——除法的特殊方法
方法名说明
public BigDecimal divide (另一个BigDecimal对象，精确几位，舍入模式)除法
  • 示例：
  • BigDecimal divide = bd1.divide(参与运算的对象, 小数点后精确到多少位，舍入模式);
    • 参数1： 表示参与运算的BigDecimal 对象。
    • 参数2： 表示小数点后面精确到多少位
    • 参数3： 舍入模式
      • BigDecimal.ROUND_UP 进一法
      • BigDecimal.ROUND_FLOOR 去尾法
      • BigDecimal.ROUND_HALF_UP 四舍五入法
import java.math.BigDecimal;

public class MyBigDecimalDemo4 {
    public static void main(String[] args) {
        BigDecimal bd1 = new BigDecimal("0.3");
        BigDecimal bd2 = new BigDecimal("4"); 

        BigDecimal divide = bd1.divide(bd2);
        System.out.println(divide);//0.075

        //参数一:表示参数运算的另一个对象
        //参数二:表示小数点后精确到多少位
        //参数三:舍入模式
        //进一法  BigDecimal.ROUND_UP
        //去尾法  BigDecimal.ROUND_FLOOR
        //四舍五入 BigDecimal.ROUND_HALF_UP
        BigDecimal divide2 = bd1.divide(bd2, 2, BigDecimal.ROUND_HALF_UP);
        System.out.println(divide2);//0.08
    }
}
  • 总结
    • BigDecimal是用来进行精确计算的
    • 创建BigDecimal的对象，构造方法使用参数类型为字符串的。
    • 四则运算中的除法，如果除不尽请使用divide的三个参数的方法。
_-Mr-sun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java基础进阶-day28（内部类&Lambda&API）
d5_fengzi的博客
01-02 461
内部类
atguigu_Day_01随堂笔记1.pdf
10-04
在JavaSE课程大纲中，学习者将深入掌握Java的基础语法、面向对象编程思想，以及常用API的使用，例如集合框架、输入/输出（IO）操作、多线程编程和网络编程。此外，课程还会涵盖Java 8的新特性，如Lambda表达式、方法...
面向对象高级技术
阿豪
06-07 46
原文链接: 面向对象高级技术 上一篇: ...
包 权限修饰符 final 常量 枚举 抽象类 接口 多态 内部类 常用API 正则表达式 Lambda
qq_52749760的博客
05-04 231
包 什么是包？ 包是用来分门别类的管理各种不同类的，类似于文件夹、建包利于程序的管理和维护。 建包的语法格式：package 公司域名倒写.技术名称。报名建议全部英文小写，且具备意义。 package com.itheima.javabean; public class Student { } ​ 建包语句必须在第一行，一般IDEA工具会帮助创建 导包 相同包下的类可以直接访问，不同包下的类必须导包,才可以使用！导包格式：import 包名...
day19 面向对象高级和应用
mannixiang的博客
04-01 115
day19 面向对象高级和应用 版权声明：本博客转载自路飞学城Python全栈开发培训课件，仅用于学习之用，严禁用于商业用途。 欢迎访问路飞学城官网：https://www.luffycity.com/ 课程目标：掌握面向对象高级知识和相关应用。 今日概要 继承【补充】 内置函数【补充】 异常处理 反射 1. 继承【补充】 对于Python面向对象中的继承，我们已学过： 继承存在意义：将公共的方法提取到父类中，有利于增加代码重用性。 继承的编写方式： # 继承 class Base(objec
面向对象高级（内部类）
Superzhaoy的博客
07-05 258
20200705赵阳来软帝的第一周 面向对象高级（内部类） 内部类 内部类，也称之为嵌套类，内属类，在一个java中还包含其他java类的定义。 public class Button { private String title; private int width; private int height; /** * 内部类 * @author mrchai */ public class Click{ public void click() { System
day04-内部类&Lambda&API
lanziDemo blog
11-01 49
什么是API​ API (Application Programming Interface) ：应用程序编程接口java中的API​ 指的就是 JDK 中提供的各种功能的 Java类，这些类将底层的实现封装了起来，我们不需要关心这些类是如何实现的，只需要学习这些类如何使用即可，我们可以通过帮助文档来学习这些API如何使用。
Day18_1009_java_常用API和异常&&集合
yczzzqwe123的博客
10-09 24
什么是异常？在编写或运行时程序的异常情况，统称为异常。异常的体系结构？【重点】如何处理异常？【重点】/*** @author 桐叔*///可变参数：实际参数的个数可以改变info("a");//可变参数语法：类型... 变量// strs 可变参数的变量，相当于数组/*// 可变参数底层会转换成数组，所以与数组不能共存*/
Python_Day8_面向对象编程进阶
weixin_34378767的博客
12-03 130
本节内容： 面向对象高级语法部分异常处理 经典类vs新式类　　 静态方法、类方法、属性方法 类的特殊方法 反射 Socket开发基础 经典类vs新式类 classical vs new style： 经典类：深度优先 新式类：广度优先 super()用法 抽象接口 import abc clas...
python之路day9_Python之路，Day7 - 面向对象编程进阶
weixin_39888268的博客
12-10 112
本节内容面向对象高级语法部分静态方法、类方法、属性方法类的特殊方法反射异常处理Socket开发基础作业开发一个支持多用户在线的FTP程序面向对象高级语法部分静态方法通过@staticmethod装饰器即可把其装饰的方法变为一个静态方法什么是静态方法呢其实不难理解普通的方法可以在实例化后直接调用并且在方法里可以通过self.调用实例变量或类变量但静态方法是不可以访问实例变量或类变量的一个不能访问实例...
day13_Stream流_每日作业卷-答案2
08-08
在给定的代码中，我们看到了如何使用lambda表达式创建`Predicate`对象： - `Predicate<Integer> p1 = (s) -> s >= 0;` 这个`Predicate`用于检查一个整数是否是非负的（自然数）。 - `Predicate<Integer> p2 = (s)...
F2019_Day2
02-22
2. **面向对象编程**：深入讲解如何利用Java进行面向对象设计，包括接口、抽象类、访问修饰符以及构造器等。 3. **集合框架**：Java集合框架是编程中的重要部分，可能探讨了List、Set、Map接口，以及ArrayList、...
Java_day10上课资料.zip
04-01
7. 内部类与匿名类：内部类是定义在其他类内部的类，它可以访问外部类的所有成员。匿名类是没有名字的类，通常用于创建一次性使用的对象，简化代码。 8. 文件与流：Java提供了丰富的I/O流API来处理文件操作。学习者...
Java_day13上课资料.zip
04-01
2. **类与对象**：Java是面向对象的语言，因此理解和创建类以及实例化对象至关重要。这涉及到类的定义、构造函数、封装、继承和多态等面向对象特性。 3. **数组**：在Java中，数组是一种存储固定数量同类型元素的...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 523
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 647
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 337
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 222
maven配置使用nexus仓库
java面向对象高级Lambda表达式,头哥
05-31
Lambda表达式是Java 8中引入的新特性，它可以使代码更加简洁、易读，同时也提高了代码的可维护性。Lambda表达式可以看作是一种匿名函数，它没有方法名、返回值类型和访问修饰符，但是它可以像普通方法一样被传递和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值