JAVA入坑之概述及语言基础部分知识总结-CSDN博客

java的发展

1995年Java被正式发布之后，立即引起极大的轰动。
JavaJDK共推出11个版本：JDK1-JDK11。
1996年发布JDK1，走向高速发展中。
1998年发布JDK2，一个里程碑，Java的应用开始普及。
2004年发布JDK5，新增泛型、枚举、foreach、自动装箱等
2014年发布JDK8，新增访问权限、方法与构造函数引用等
2018年发布JDK11，新增Local Var、 String API新增方法

java的运行平台：

java SE（标准版）
java EE (企业版)
java ME（微型版）

java语言的特点：

特点一：面向对象

两个基本概念：类、对象

三大特性：封装、继承、多态

特点二：健壮性
特点三：跨平台性（平台无关性）
特点四：简单自动的垃圾回收机制
其他：多线程、动态性

JDK、JRE、JVM

JDK：免费的开源的java应用开发工具包；JDK编译java源码为字节码

JRE: java运行时环境，包含工具库类，核心运行文件；JRE为每个java程序创建一个独立的JVM容器运行程序

补充 JDK平台提供的Java编译器（javac.exe）和Java解释器（java.exe）位于Java安装目录的bin文件夹中
java编译器用来编译java文件。
java解释器用来解释字节码文件

JVM：java虚拟机，模拟了包括CPU指令集，寄存器，堆栈等计算机构架，通过调用真实计算机环境，解析执行java字节码

Java语言的运行原理:
在一个计算机上编译得到的字节码文件（就是.class文件），可以复制到任何一个安装了Java运行环境的计算机上直接运行。然后字节码文件由虚拟机负责解释执行，即Java虚拟机将字节码翻译成本地计算机的机器码，然后将机器码交给本地的操作系统运行。
由于在一个计算机上编译得到的字节码文件可以复制到任何一个安装了Java运行环境的计算机上直接使用，所以字节码其实是一种“中间代码”，这也就是为什么“Java语言能够一次编译，处处运行，也就是Java跨平台的原因。”所以称Java是一种“半编译，半解释的语言”，即源程序——>编译——>字节码——>字节码解释程序——>对应平台的机器语言。”

JAVA特色：

指针：在java语言中没有指针的概念。
内存分配：java是使用new运算符在内存中分配空间，使用完毕之后自动回收。
全局变量：java中只有类是全局的。不会像c#中的定义全局的int，float等等。
严格的数据类型：java无论在任何平台上进行运行的时候保证数据的长度始终保持不变，这是唯一能保证java是跨平台的途径
goto：java本身存在严格定义的异常处理机制。用户甚至可以自己定义异常之后如何处理。使得goto的存在没必要啦。
分离的头文件：java中没有头文件，但是java中的import和头文件差不多。
多重继承：java是不支持多重继承的，就是每一个子类的父类必须是唯一的不能有多个父类。

源文件的命名规则：

源文件中既可以有多个独立的类，也可以只有一个类
如果源文件中有多个类，那么只能有一个类是Public类
如果有一个类是Public类，那么源文件的名字必须与这个类的名字完全相同，扩展名是java
如果源文件没有public类，那么源文件的名字只要扩展名是java就好了
例如
个人项目建议命名：java-examples-yourname，包路径与课程教学工程相同，便于测试学习

gitee

github

JAVA常见概念

Object：事物，均具有两种特性：状态和行为。面向对象编程就是从分析/识别/抽象，事物开始

Class：类是一个蓝图，一种规范，可以用来描述形容一类特定事物的内容。就是从具体事物中，抽象出事物的状态(属性) 行为(方法)

类的实例，基于该类的一个具体的对象

Inheritance：不同类型的事物通常具有一定共同的特性，同时又拥有区别于其他事物的自有的特性，面向对象编程允许从其他类继承状态和行为

Package：包，项目由众多独立的文件(类/接口等源文件，配置文件等)组成；包是用来组织相关源码文件，使程序结构更加清晰的命名空间(文件夹目录)：

关键词`package`，声明包的路径名称；以`.`点分隔符分隔层次；必须声明在源文件的顶部；源文件位置必须与包声明的相同

包命名规范。倒置的开发单位域名+项目名称+功能模块名称+层次名称等，全部小写的英文单数名词

一般IDE会提供智能修改提示

Idea在错误处(光标置于错误提示红线) 按快捷键，alt+enter，给出修改提示

jar文件

本质是zip包

文档生成器

package

import

classpath和jar

二、Java语言基础部分知识总结

标识符
基本数据类型
数据的输入与输出
数组
运算符
控制语句

2.1标识符：

定义：用来标识类名、变量名、方法名、类型名、数组名等等

规定：

标识符有字母、下划线、美元符号和数字组成，长度不受限制
标识符的第一个字符不能是数字字符
标识符不能是关键字
禁止以`$`/`_`为前缀声明变量。后期框架通过反射等操作自动生成的变量可能包含`$`/`_`前缀，避免冲突。

补充代码规范

见名知意
包名：aaa.bbb.ccc 例:cn.edu.nefu.sms.io
类名:AaaBbbCcc（大驼峰式）
变量名:aaaBbbCcc （小驼峰式）多是名词
方法名:aaaBbbCcc （小驼峰式）多是动词
常量名:AAABBBCCC

必须使用有意义的/无歧义的英文单词/英文单词缩写；禁止使用中文/拼音/拼音缩写/英文拼音混合命名；区分大小写

大括号使用规范。所有`{}`大括号，左括号必须置于起始语句末，右括号独立一行或在关联语句始

补充关键字

2.2基本数据类型：

数值型
整数型（byte,short,int,long）
浮点类型（float,double）
字符型（char）
布尔型（boolean）

整数型一些注意的点：

java的整型常量默认为int型，声明long型常量须加L"

浮点型一些要注意的点：

java的浮点型常量默认是double型，声明float型常量须后加'F'

布尔型注意

与C/C++不同，无法与零/非零数替换

char型数据用来表示通常意义上字符（2字节）

除8种基本数据类型，Java通过java.lang.String类，提供了对字符串的特殊支持，使用" "双引号声明创建一个String类型对象(后面学习中单独讨论)

所有基本类型变量不与其他变量共享值，基本数据类型为值传递，而非引用传递。因此当被"引用"的值改变时，不会影响"引用"其值的变量

String类型变量虽然为对象，但依然为值传递即，8+1类型变量，均为值传递

补充：数字字面量

数字字面量，支持使用下划线字符`_`分隔，以提高代码的可读性(java7)

编译器编译时，会忽略分隔符

分隔符，适合在定义常量时使用

补充常量

不允许改变值的变量为，常量(Constant) 通过final关键词修饰变量，变量赋值后，不能再修改

Constant常量命名规范。常量所有字母大写，字母间由下划线分隔

接口内定义的变量默认是常量interface。

补充常量池

Java常量池是一种存储在class文件中的常量值的集合，包括字面量和符号引用。它主要用于存储字符串常量和基本类型常量值，例如常量1、2、3、true、false、字符串常量等等。

Java运行时常量池是方法区的一部分，它在类加载的时候，会将class文件中的常量池内容复制到内存中，以便运行时使用。运行时常量池除了包含编译期生成的字面量和符号引用外，还可以在运行期间将新的常量加入到常量池中，例如使用String类的intern()方法。

补充引用

在Java中“引用”是指向一个对象在内存中的位置，在本质上是一种带有很强的完整性和安全性的限制的指针

指针可以有++、--运算，引用不可以运算。

2.3基本数据类型的转换：

java中数据的基本类型按精度从低到高排列：
byte short char int long float double

规则：

当把容量小的的变量赋值给容量大的变量系统自动完成数据类的转换
当把容量大的变量的值赋给容量小的变量时，必须使用显示类型转换

当把一个int型常量赋值给一个byte和short型变量时，不可以超过这些变量的取值范围，否则必须进行类型转换运算

2.4基本类型的类封装

Java的基本数据类型包括 byte、int、short、long、float、double、char。 Java提供了基本数据类型相关的类，实现了对基本数据类型的封装。 Byte、Integer、Short、Long、Float、Double和Character类。这些类在java.lang包中。

基本类型的类封装提供了许多常用方法，下面是一些常用方法的示例：

Integer.parseInt(String s)：将字符串转换为整数。
Double.parseDouble(String s)：将字符串转换为双精度浮点数。
Integer.valueOf(String s)：返回一个表示指定字符串的 Integer 对象。
Integer.toBinaryString(int i)：将整数转换为二进制字符串。
Integer.toHexString(int i)：将整数转换为十六进制字符串。
Character.isDigit(char ch)：判断指定字符是否为数字。
Character.isLetter(char ch)：判断指定字符是否为字母。
Character.isUpperCase(char ch)：判断指定字符是否为大写字母。
Character.isLowerCase(char ch)：判断指定字符是否为小写字母。
Character.toUpperCase(char ch)：将小写字母转换为大写字母。
Character.toLowerCase(char ch)：将大写字母转换为小写字母。

补充自动装箱和拆箱

自动装箱和拆箱是Java 5中引入的一个新特性，它允许开发人员在基本数据类型和相应的包装类之间进行自动转换。

装箱是指将基本数据类型转换为相应的包装类。例如，将int类型转换为Integer类型。拆箱是指将包装类转换为相应的基本数据类型。例如，将Integer类型转换为int类型。

在Java 5之前，开发人员必须手动进行装箱和拆箱操作。例如：
int i = 10;
Integer iObj = Integer.valueOf(i); // 手动装箱
int j = iObj.intValue(); // 手动拆箱
但是，在Java 5及更高版本中，开发人员可以使用自动装箱和拆箱功能，无需手动进行转换。例如：
int i = 10;
Integer iObj = i; // 自动装箱
int j = iObj; // 自动拆箱
在上面的代码中，我们将一个int类型的值赋给了一个Integer类型的变量。编译器会自动在后台调用Integer.valueOf()方法将int类型的值转换为Integer类型的对象。同样，在将一个Integer类型的对象赋给一个int类型的变量时，编译器会自动调用intValue()方法将Integer对象转换为int值。

2.5数据的输入与输出

Scanner
可以使用Scanner类创建一个对象：
Scanner reader=new Scanner(System.in);
其中：reader对象调用下列方法，读取用户在命令行输入的各种基本类型数据：
nextBoolean()、 nextByte()、 nextShort()、 nextInt() 、
nextLong()、nextFloat()、nextDouble()。
读取字符串的方法：next(),nextLine();

注意:Scanner创建的对象没有读取一个字符的方法，可以先获取字符串,然后再分割出单个字符;
上述方法执行时都会堵塞，程序等待用户在命令行输入数据回车确认。
Scanner在java.util包中，使用时要引入import java.util.*;或者import java.util.Scanner

hasNext()

在Java中，hasNext()是一个用于Scanner类的方法。该方法用于判断输入源是否还有更多的数据可供读取。当调用该方法时，如果输入源中还有数据可供读取，则该方法返回true，否则返回false。
import java.util.Scanner;

public class ScannerDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        System.out.print("请输入一个字符串：");

        if (scanner.hasNext()) {
            String input = scanner.nextLine();
            System.out.println("您输入的是：" + input);
        } else {
            System.out.println("未输入任何内容。");
        }

        scanner.close();
    }
}
在上面的示例中，我们首先创建一个Scanner对象，并将其与System.in绑定，以便从控制台读取输入。然后，我们使用hasNext()方法检查输入源是否有更多的数据可供读取。如果有，则我们使用nextLine()方法读取输入，并输出输入结果；否则，我们输出一条消息表示未输入任何内容。

输入

next()：next()方法在读取内容时，会过滤掉有效字符前面的无效字符，对输入有效字符之前遇到的空格键、Tab键或Enter键等结束符，next()方法会自动将其过滤掉；只有在读取到有效字符之后，next()方法才将其后的空格键、Tab键或Enter键等视为结束符；所以next()方法不能得到带空格的字符串。（转载自一篇博客）通俗点讲有点像C里里面的scanf()，但是不完全一样。

nextline():此方法类似于C语言里面的gets(),会读取输入一行的全部内容，他只能以enter符结束。可以读取带空格的字符串。

输出

java使用System类实现数据输出
例如：System.out.println()或System.out.print()输出串值，表达式的值。**二者的区别是前者输出数据后换行，后者不换行。**如：
System.out.println(m+“个数的和为”+sum);
System.out.println(":"+123+“大于”+122);
如果需要输出的字符串的长度较长，可以将字符串分解成几部分，然后使用并置符号：“+”将它们首尾相接，
例如：System.out.println(“你好，”+
“很高兴认识你” );
“+”两边都是数值型或者字符型时做加法运算，有字符串的时候完成字符串的连接
例如：System.out.println（12+8） ;
System.out.println（12+“”+8） ;

System.out.printf(); 格式化输出

DK1.5新增了和C语言中printf函数类似的输出数据的方法，格式如下：
System.out.printf(“格式控制部分”，表达式1，表达式2，…表达式n)
格式控制部分由格式控制符号：%d、%c、%f、%s和普通的字符组成，普通字符原样输出。格式符号用来输出表达式的值。
%d输出int类型数据值；%c输出char型数据；%f输出浮点型数据，小数部分默认保留6位；%s输出字符串数据。
输出数据时也可以控制数据在命令行的位置，例如：%md输出的int型数据占m列；%m.nf输出的浮点型数据占m列，小数点保留n位。
例如：System.out.printf("%d,%f",12, 23.78);

2.5数组：

声明数组：
数组的元素类型数组名[];
数组的元素类型 []数组名;

为数组分配空间：
flaot boy[]=new float[4];

length字段的使用：
数组名.length可以得到数组中的元素个数
多维数组：每个维度长度可以不一样
静态初始化：在声明数组的同时维数组分配空间、初始化 int a[][]={{1,2},{3,4}};
动态初始化：分配完空间后对每个元素初始化 int a[][]=new int [1][]; a[0]=new int [1]; a[0][0]=5;
注：在使用运算符new来分配内存时，对于多维数组至少要给出最高维的大小。

数组的引用

数组属于引用型变量，两个相同类型的数组如果具有相同的引用，它们就有完全相同的元素。

进行赋值a = b; 那么，a中存放的引用和b的相同，这时系统将释放最初分配给数组a的元素，使得a的元素和b的元素相同，a、b的内存模型如下。

所谓引用型变量就是将两个引用型变量赋值的时候实际上赋值的是地址，当一个做出改变的时候另一个也会做出改变，就像硬链接

数组复制

1.使用赋值运算符复制数组

class Main {
    public static void main(String[] args) {
       
        int [] numbers = {1, 2, 3, 4, 5, 6};
        int [] positiveNumbers = numbers;    //复制数组

        for (int number: positiveNumbers) {
            System.out.print(number + ", ");
        }
    }
}

2.使用循环构造复制数组

import java.util.Arrays;

class Main {
    public static void main(String[] args) {
      
        int [] source = {1, 2, 3, 4, 5, 6};
        int [] destination = new int[6];

        //迭代并将元素从源复制到目标
        for (int i = 0; i < source.length; ++i) {
            destination[i] = source[i];
        }
      
         //将数组转换为字符串
        System.out.println(Arrays.toString(destination));
    }
}

3.使用arraycopy()方法复制数组

arraycopy(Object src, int srcPos,Object dest, int destPos, int length)

这里，

src -您要复制的源数组
srcPos -源数组中的起始位置（索引）
dest -目标数组，将从源中复制元素
destPos -目标数组中的起始位置（索引）
length -要复制的元素数

//使用Arrays.toString()方法
import java.util.Arrays;

class Main {
    public static void main(String[] args) {
        int[] n1 = {2, 3, 12, 4, 12, -2};
      
        int[] n3 = new int[5];

        //创建长度为n1的n2数组
        int[] n2 = new int[n1.length];
      
        //将整个n1数组复制到n2
        System.arraycopy(n1, 0, n2, 0, n1.length);
        System.out.println("n2 = " + Arrays.toString(n2));  
      
         //从n1数组的索引2复制元素
         //将元素复制到n3数组的索引1
        //将复制2个元素
        System.arraycopy(n1, 2, n3, 1, 2);
        System.out.println("n3 = " + Arrays.toString(n3));  
    }
}

2.5补充稀疏数组

稀疏数组是一种特殊的数组，它的大部分元素都是0。当一个数组中大部分元素为0或者为同一个值的数组时，可以使用稀疏数组来保存该数组。稀疏数组的处理方式是：记录数组一共有几行几列，有多少个不同值；把具有不同值的元素和行列及值记录在一个小规模的数组中，从而缩小程序的规模

2.6运算符：

算术运算符关系运算符逻辑运算符赋值运算符位运算符 instanceof

算数运算符：

java计算算术表达式时，使用下列计算精度规则：

如果表达式中有双精度浮点数（double），则按双精度进行计算
如果表达式中最高精度是（float）,则按单精度进行计算
如果表达式中最高精度是long型整数，则按long精度进行运算
char型数据和整形数据运算结果的精度是int

注意：i++与++i，仅在表达式内部有区别，单独一行时结果相同

比较运算符：

在关系运算符中，当操作数是引用类型时，比较的是引用对象的引用值，判断是否是同一对象，而没有比较对象的内容。

逻辑运算符：

当前面的表达式op1的值为false时，&&运算符在运算时就不再去计算op2表达式的值；当op1为true时，||运算符就不再计算op2的值。（op1&&op2；op1||op2）。

位运算符

位运算符：是指对两个整型数据按照对应的位进行运算，结果为新的整型数据。
“按位与”运算
“&”是双目运算符。运算法则是：如果a，b两个数据对应位都是1，则c的该位是1，否则是0。
“按位或”运算
“|”是双目运算符。运算法则是：如果a，b两个数据对应位都是0，则c的该位是0，否则是1。
“按位非”运算
“~”是单目运算符。运算法则是：如果a对应位是0，则c的该位是1，否则是0。
“按位异或”运算
“^”是双目运算符。运算法则是：如果a，b两个数据对应位相同，则c的该位是0，否则是1。

instanceof 运算符

在Java中，instanceof是一个二元运算符，用于检查一个对象是否是某个类或其子类的实例。instanceof运算符返回一个布尔值，如果对象是该类或其子类的实例，则返回true，否则返回false。
public class Example {
    public static void main(String[] args) {
        Object obj1 = "Hello";
        Object obj2 = new Integer(10);

        boolean b1 = obj1 instanceof String; // true
        boolean b2 = obj2 instanceof Integer; // true
        boolean b3 = obj1 instanceof Integer; // false
        boolean b4 = obj2 instanceof String; // false

        System.out.println(b1);
        System.out.println(b2);
        System.out.println(b3);
        System.out.println(b4);
    }
}

补充运算符的优先次序

2.7控制语句：

（挑几个我觉得重要的写下吧，其他都在C++里面学过了）

break和continue
再循环体中可以使用break语句和continue语句
如果在某次循环中执行了break语句，那么整个循环语句就结束；
如果在某次循环中执行了continue语句那么本次循环就结束，转而进行下一次循环
增强的for循环
switch语句
在Java的switch语句中，加上“->”符号表示使用Lambda表达式的形式。
使用Lambda表达式形式的switch语句与传统的switch语句的主要区别在于，它允许在每个case标签后面直接指定执行的代码，而不需要使用break语句。此外，它还可以使用类似于Lambda表达式的形式来定义代码块。
int result = switch (expression) {
    case value1 -> {
        // 当表达式等于value1时执行的代码
        yield result1; // 返回result1的值
    }
    case value2 -> {
        // 当表达式等于value2时执行的代码
        yield result2; // 返回result2的值
    }
    ...
    case valueN -> {
        // 当表达式等于valueN时执行的代码
        yield resultN; // 返回resultN的值
    }
    default -> {
        // 当表达式的值与所有case标签的值都不匹配时执行的代码
        yield defaultResult; // 返回defaultResult的值
    }
};

2.8JAVA注释

在Java中，注释是用于在代码中添加说明性文字的一种方式，它不会被编译器编译为字节码，因此不会影响程序的执行。Java中有三种不同类型的注释：

单行注释：使用//符号表示，注释的内容从//到行末
// 这是一个单行注释
多行注释：使用/和/符号表示，注释的内容位于这两个符号之间。
/*
 * 这是一个多行注释
 * 它可以跨多行
 */
文档注释：使用/*和/符号表示，位于类、方法或字段的声明前面。文档注释是一种特殊的注释类型，可以用于生成程序的API文档。
文档注释：使用/*和/符号表示，位于类、方法或字段的声明前面。文档注释是一种特殊的注释类型，可以用于生成程序的API文档。

三、进阶专场

3.1大数类

BigInteger和BigDecimal

BigInteger和BigDecimal是Java中提供的两个用于高精度计算的类，它们的主要作用是可以处理比原始数据类型范围更大的数字和浮点数

BigInteger类：用于处理整数类型的高精度计算，它可以处理任意长度的整数，而不受原始数据类型的范围限制。BigInteger类提供了一组方法来支持基本的整数运算，例如加、减、乘、除、求余等。
import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("1234567890");
        BigInteger big2 = new BigInteger("9876543210");
        
        // 加法
        BigInteger result1 = big1.add(big2);
        System.out.println("加法结果：" + result1);
        
        // 减法
        BigInteger result2 = big2.subtract(big1);
        System.out.println("减法结果：" + result2);
        
        // 乘法
        BigInteger result3 = big1.multiply(big2);
        System.out.println("乘法结果：" + result3);
        
        // 除法
        BigInteger result4 = big2.divide(big1);
        System.out.println("除法结果：" + result4);
        
        // 求余
        BigInteger result5 = big2.mod(big1);
        System.out.println("求余结果：" + result5);
    }
}
BigDecimal类：用于处理浮点数类型的高精度计算，它可以处理任意精度的小数，而不受原始数据类型的范围和精度限制。BigDecimal类提供了一组方法来支持基本的浮点数运算，例如加、减、乘、除、取模等。
import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal big1 = new BigDecimal("123456.789");
        BigDecimal big2 = new BigDecimal("9876.54321");
        
        // 加法
        BigDecimal result1 = big1.add(big2);
        System.out.println("加法结果：" + result1);
        
        // 减法
        BigDecimal result2 = big1.subtract(big2);
        System.out.println("减法结果：" + result2);
        
        // 乘法
        BigDecimal result3 = big1.multiply(big2);
        System.out.println("乘法结果：" + result3);
        
        // 除法
        BigDecimal result4 = big1.divide(big2, BigDecimal.ROUND_HALF_UP);
        System.out.println("除法结果：" + result4);
        
        // 取模
        BigDecimal result5 = big1.remainder(big2);
        System.out.println("取模结果：" + result5);
    }
}
需要注意的是，由于BigInteger和BigDecimal类的计算需要耗费更多的时间和空间，因此在处理大型计算时，应该慎重使用。同时，在使用这两个类时，也需要注意避免出现除数为0的情况，以及使用适当的舍入模式来保证计算结果的准确

除了上面提到的方法外，BigInteger和BigDecimal还提供了许多其他常用的方法

BigInteger的常用方法：

pow()：返回该BigInteger对象的指定次幂。
equals()：比较两个BigInteger对象是否相等。
gcd()：返回该BigInteger对象和参数之间的最大公约数。
abs()：返回该BigInteger对象的绝对值。
negate()：返回该BigInteger对象的负数。
compareTo()：将该BigInteger对象与指定的对象进行比较，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数
import java.math.BigInteger;

public class BigIntegerDemo {
    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("1234567890");
        BigInteger big2 = new BigInteger("9876543210");
        
        // 求幂
        BigInteger result1 = big1.pow(2);
        System.out.println("幂运算结果：" + result1);
        
        // 判断是否相等
        boolean result2 = big1.equals(big2);
        System.out.println("是否相等：" + result2);
        
        // 求最大公约数
        BigInteger result3 = big1.gcd(big2);
        System.out.println("最大公约数：" + result3);
        
        // 求绝对值
        BigInteger result4 = big1.abs();
        System.out.println("绝对值：" + result4);
        
        // 取反数
        BigInteger result5 = big1.negate();
        System.out.println("取反数：" + result5);
        
        // 比较大小
        int result6 = big1.compareTo(big2);
        System.out.println("比较大小：" + result6);
    }
}
BigDecimal的常用方法：
pow()：返回该BigDecimal对象的指定次幂。
equals()：比较两个BigDecimal对象是否相等。
abs()：返回该BigDecimal对象的绝对值。
negate()：返回该BigDecimal对象的负数。
scale()：返回该BigDecimal对象的小数位数。
setScale()：将该BigDecimal对象的小数位数设置为指定值，并返回新的BigDecimal对象。
compareTo()：将该BigDecimal对象与指定的对象进行比较，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。
import java.math.BigDecimal;

public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal big1 = new BigDecimal("1234.5678");
        BigDecimal big2 = new BigDecimal("9876.54321");
        
        // 求幂
        BigDecimal result1 = big1.pow(2);
        System.out.println("幂运算结果：" + result1);
        
        // 判断是否相等
        boolean result2 = big1.equals(big2);
        System.out.println("是否相等：" + result2);
        
        // 求绝对值
        BigDecimal result3 = big1.abs();
        System.out.println("绝对值：" + result3);
        
        // 取反数
        BigDecimal result4 = big1.negate();
        System.out.println("取反数：" + result4);
        
        // 获取小数位数
        int result5 = big1.scale();
        System.out.println("小数位数：" + result5);
        
        // 设置小数位数
        BigDecimal result6 = big1.setScale(3);
        System.out.println("设置小数位数：" + result6);
    }
}

定义变量

BigInteger a = BigInteger.ONE;
BigDecimal b = BigDecimal.TEN;

声明赋值

BigInteger a = new BigInteger("100");
BigDecimal b = new BigDecimal(100);

JAVA入坑之概述及语言基础部分知识总结

一、java的概述

java的发展

java的运行平台：

java语言的特点：

JDK、JRE、JVM

JAVA特色：

源文件的命名规则：

JAVA常见概念

package

import

classpath和jar

二、Java语言基础部分知识总结

2.1标识符：

补充代码规范

补充关键字

2.2基本数据类型：

补充：数字字面量

补充常量

补充常量池

补充引用

2.3基本数据类型的转换：

2.4基本类型的类封装

补充自动装箱和拆箱

2.5数据的输入与输出

2.5数组 ：

数组复制

2.5补充稀疏数组

2.6运算符：

补充运算符的优先次序

2.7控制语句：

2.8JAVA注释

三、进阶专场

3.1大数类

2.5数组：