Java基础知识-1

一、基本类型

1、数据类型

（1）两大数据类型

内置数据类型（原始数据类型）

8种基本类型（6种数字类型+1种字符型+1种布尔型，注意大小写敏感）。其中，6种数字类型包括（4个整数型+2个浮点型）

1. byte （1个字节）;
2. short（2个字节）
3. int（4个字节）
4. long; （8个字节）
5. float; （4个字节）
6. double; （8个字节）
7. boolean; （1个字节或4个字节；boolean用于声明一个基本类型变量时，占4个字节，声明一个数组类型时，数组中每个元素占1个字节）
8. char; （2个字节）
   而Boolean则是boolean的封装类（因此需要注意大小写，boolean是原始数据类型的一种，但Boolean不是）

引用数据类型

引用类型的变量类似于C/C++的指针。引用类型指向一个对象，指向对象的变量是引用变量，这些变量在声明时被指定为一个特定的类型。变量一旦声明后，类型就不能改变了。
对象、数组都是引用数据类型；
所有引用类型的默认值都是Null；
一个引用变量可以用来引用任何与之兼容的类型；
eg：e yvonne = new Yvonne(“Daytoy”)

（2）float和double的区别

float是单精度类型,精度是8位有效数字，取值范围是10的-38次方到10的38次方，float占用4个字节的存储空间
double是双精度类型，精度是17位有效数字，取值范围是10的-308次方到10的308次方，double占用8个字节的存储空间
当你不声明的时候，默认小数都用double来表示，所以如果要用float的话，则应该在其后加上f
例如：float a=1.3;
则会提示不能将double转化成float 这成为窄型转化
如果要用float来修饰的话，则应该使用float a=1.3f
注意float是8位有效数字，第7位数字将会产生四舍五入
所以如果一个float变量 这样定义: float a=1.32344435; 则第7位将产生四舍五入(5及5以下的都将舍去)

（3）类型转换

基本类型的赋值与转换

boolean一般不参与其他类型的转化
原则：表示范围大的数据不能向表示范围小的数据赋值，即使被赋值的对象可以装得下这个数据，但是系统仍然会报错：可能存在精度损失
因此，上面那张图之恩顺着箭头赋值，不能逆着箭头赋值

隐形转换

低范围和高范围数据进行运算的时候，会将低范围的值向高范围的类型转化，而没这种值的类型的变化并不会传递给变量。

byte a = 10;
int b = a;//编译int b = a时，a隐式转换为int型
//
int a = 2;
double b = 5.0;
System.out.println(b/a);//此时输出b/a的值将为2.5，因为编译的时候会将a提升为b类型

byte、char、short三者可以计算，但是只要开始计算，就转化为int型
eg:

byte c1 = 1;
byte c2 = 2;
c1 + c2 // int

char c3 = 3;
c1 + c3 //int

boolean不参与运算

三元运算符相关转换

三元运算符会把两个结果的数据类型进行自动的类型提升
三元运算符：一边为byte一边为char，结果为int

//即
Object o1 = true ? new Integer(1) : new Double(2.0);
//可看作->
Object o1 = true ? new Double(1.0) : new Double(2.0);

//eg:
byte b = 1;
char c = 1;
short s = 1;
int i = 1;

//三目，一边为char一边为byte，结果为int
//其他情况结果为两边中范围大的，适用于包装类型
i = true ? b : c //int
b = true ? b : b //byte
s = true ? b : s //short

// 表达式，两边为byte,short,char，结果为int型
// 其它情况结果为两边中范围大的。适用包装类型
i = b + c; // int
i = b + b; // int
i = b + s; // int

// 当 a 为基本数据类型时，a += b，相当于 a = (a) (a + b)
// 当 a 为包装类型时， a += b 就是 a = a + b
b += s; // 没问题
c += i; // 没问题
 
// 常量任君搞，long以上不能越
b = (char) 1 + (short) 1 + (int) 1; // 没问题
// i = (long) 1 // 错误

常量

常量在运行过程中不能修改，java中用final修饰常量，声明方式和变量类似：

final double PI = 3.1415927;

一般用大写字母表示常量

2、变量类型

• 类变量：独立于方法之外的变量，用static修饰；
• 实例变量：独立于方法之外的变量，没有static修饰；
• 局部变量：类的方法中的变量；
  eg:

public class Variable{
    static int allClicks = 0;//类变量
    String str = "hello world";//实例变量
    public void method() {
        int i = 0;//局部变量
    }
}

（1）类变量

（2）实例变量

• 实例变量声明在类中，但是在方法、构造方法和语句块之外；
• 当一个对象被实例化之后，实例变量的值就跟着被确定；
• 在对象被创建时创建，被销毁时销毁；
• 实例变量的值应该至少被一个方法、构造方法或者语句块引用，使得外部能够通过这些方法获取实例变量信息；
• 实例变量可以声明在使用前或者使用后；
• 访问修饰符可以修饰实例变量；
• 实例变量对类中的方法、构造方法或者语句块是可见的，一般情况下应该把实例变量设置为私有，通过使用访问修饰符可以使实例变量对子类可见；
• 实例变量具有默认值，变量的值可以在声明时指定，也可以在构造方法中指定；

（3）局部变量

• 访问修饰符不能用于局部变量；
• 局部变量是在栈上分配的；
• 局部变量没有默认值，所有局部变量被声明后必须经过初始化才可以使用；
• 局部变量声明在方法、构造方法或者语句块种；
• 局部变量在方法、构造方法或者语句块被执行时创建，当它们执行完毕后，局部变量将被销毁；

3、修饰符

可以使用修饰符来修饰类中的方法和属性，主要分为2类：

• 访问修饰符：default、public、protected、private；
• 非访问修饰符：final、abstract、static、synchronized；
  修饰符用来定义类、方法或者变量，通常放在语句最前端。

（1）访问控制修饰符

java中使用访问控制符来保护对类、变量、方法和构造方法的访问，java支持4种不同的访问权限：

修饰符	当前类	同包	子类	其他包
public	√	√	√	√
protected	√	√	√	×
default	√	√	×	×
private	√	×	×	×

① public

共有访问修饰符——public
如果几个相互访问的public类分布在不同的包中，则需要导入相应public类所在的包。
main()方法必须设置为public的，否则解释器不能运行该类。

② protected

受保护的访问修饰符——protected

• 子类与基类在同一个包中：被声明为protected的变量、方法和构造器能被同一个包中的任何其他类访问；
• 子类与基类不在同一包中：在子类中，子类实例可以访问其从基类继承而来的protected方法，但是不能访问基类实例的protected方法
  protected可以修饰数据成员、构成方法、方法成员，不能修饰类（内部类除外）；
  接口及接口的成员变量和成员方法不能声明为protected；
  类和接口只能是public和default；接口的方法只能是public

③ default

默认访问修饰符——不使用任何关键字
使用默认访问修饰符声明的变量和方法，对同一个包内的类是可见的。接口里的变量都隐式声明为public static final，而接口里的方法默认访问权限为public。

④ private

私有访问修饰符是最严格的访问级别，被声明为private的方法、变量和构造方法只能为所属类访问，并且接口和类不能声明为private。
声明为私有访问类型的变量只能通过类中公共的getter方法被外部类访问。

public class Logger {
    private String format;
    public String getFormat() {
        return this.format;
    }
    public void setFormat(String format) {
        this.format = format;
    }
}

如上面的例子中，Logger类中的format为私有变量，所以其他类不能直接得到和设置该变量的值。为了使其他类能够操作该变量，定义了两个public方法：getFormat()（返回format的值）和setFormat(String)（设置format的值）

（2）final

Java中，final可以用来修饰类、方法和变量（包括成员变量和局部变量）。

1. 修饰类：
   当用final修饰一个类时，表明这个类不能被继承。final类中的所有成员方法都会被隐式的指定为final方法。
   在使用final修饰类的时候，要注意慎重选择，除非这个类以后真的不会用来继承或者处于安全的考虑，尽量不要将类设计为final
2. 修饰方法：
   被final修饰的方法，任何继承类不允许修改它的涵义
   类的private方法会被隐式的指定为final方法
3. 修饰变量：
   修饰变量是final用的最多的地方。对于一个final变量，如果是基本数据类型的变量，则其数值一旦初始化后便不能更改；如果是引用类型的变量，则在对其初始化之后便不再指向另一个对象。

final与static：
static作用于成员变量，用来标识只保存一份副本，而final的作用是用来保证变量不可变，可以把它类似于C语言中的宏变量

4、标识符命名规则

标识符：Java对各种变量、方法和类等要素命名时使用的字符序列称为标识符
凡是自己可以起名字的都叫标识符。

命名规则：

• 由26各英文字母大小写、0-9、_或$组成；
• 数字不可以开头
• 不可以使用关键字和保留字
• Java中严格区分大小写，长度无限制
• 标识符不能包含空格

5、关键字保留字

关键字和保留字均不能用作变量名、方法名、类名、包名和参数

（1）关键字

关键字中所有字母都为小写

• 用于定义数据类型的关键字：class interface enum byte short int long float double char boolean void
• 用于定义数据类型值的关键字：true false null
• 用于定义流程控制的关键字：if else switch case default while do for break continue return
• 用于定义访问权限修饰符的关键字：private protected public
• 用于定义类、函数、变量修饰符的关键字：abstract final static synchronized
• 用于定义类与类之间关系的关键字：extends implements
• 用于定义建立实例及引用实例、判断实例的关键字：new this super instanceof
• 用于异常处理的关键字：try catch finally throw throws
• 用于包的关键字：package import
• 其他修饰符关键字：native strictfp transient volatile assert

（2）保留字

即它们在Java现有版本中没有特殊含义，以后版本可能会作为有特殊含义的词，或者该词虽然在Java中没有特殊含义，以后版本也不打算使用，但在其他语言中有特殊含义，不宜在Java中定义为变量名称等，因为容易混淆。
eg:const goto

6、运算符

（1）位/逻辑运算

首先名称是不同的
＆＆逻辑与　　｜｜逻辑或　　它们都是逻辑运算符
＆　按位与　　｜　按位或　　它们都是位运算符
ｉｆ（ａ＝＝１＆＆ｂ＝＝２）　这是说既要满足ａ＝１也要满足ｂ＝２
ｉｆ（ａ＝＝１｜｜ｂ＝＝２）　这是说或者满足ａ＝１或者要满足ｂ＝２

而ａ＆ｂ或者ａ｜ｂ则是二进制的与或运算
＆同为１时为１，否则为０
｜同为０时为０，否则为１

（2）优先级

（3）移位运算符

<<,>>,>>>为java中的移位运算符。

1. <<表示左移运算符：
   例如8<<2,表示将8向左移2位，结果为32。低位补0。
   二进制演算：
   8的二进制：1 0 0 0
   向左移动两位结果为1 0 0 0 0 0，换算成十进制即为32，
   也可以简单的理解为，左移就是将数变大，相当8*2^2=32。
   左移运算符的运算规律：将左边的数按照右边的数往左移动几位。
2. ”>>”表示右移运算符：
   例如 8>>2,表示将8向右移动2位，结果为2。高位补0。
   二进制演算：
   8的二进制：1 0 0 0
   向右移动两位：0 0 1 0即为2，也可以简单的理解为将数向右移位就是将数变小，相当于8除以2^2=2。
   右移运算符运算规律：将左边的数按照右边的数右移几位。（算术右移）
3. ”>>>”表示无符号右移运算符：
   高位补0例如8>>>2表示将8向右移位2位，结果为2。这个也可以和右移运算符一起理解。(逻辑右移)

（4）== 及 equals

① ==

比较的是值，对于基本数据类型的比较易懂，而对于引用类型，比如String等，则是比较二者地址是否一样
示例：

public static void main(String[] args) {
    int n = 3;
    int m = 3;
    System.out.println(n == m);
    String str = new String("hello");
    String str1 = new String("hello");
    String str2 = new String("hello");
    System.out.println(str1 == str2);
    str1 = str;
    str2 = str;
    System.out.println(str1 == str2);
}

输出结果如下：

如图中，
第一次比较，为int基本类型的比较，结果为true；
第二次比较，为String类型，为引用类型，String存储的是指向对象的地址，二者存储地址不同，因此结果为false
第三次比较，都让str1和str2指向了str指向的对象，因此结果为true

② equals()

equals方法是基类Object中的方法，因此对于所有的继承于Object的类都会有该方法。即不能用equals()比较基本类型。

总结

1）对于==，比较的是值是否相等
如果作用于基本数据类型的变量，则直接比较其存储的 “值”是否相等；
　　如果作用于引用类型的变量，则比较的是所指向的对象的地址
2）对于equals方法，注意：equals方法不能作用于基本数据类型的变量，equals继承Object类，比较的是是否是同一个对象
　　如果没有对equals方法进行重写，则比较的是引用类型的变量所指向的对象的地址；
　　诸如String、Date等类对equals方法进行了重写的话，比较的是所指向的对象的内容。

二、String相关

1、StringBuffer、StringBuilder、String比较

运行速度：StringBuilder > StringBuffer > String

① String

String是字符串常量
java中字符串属于对象，java提供了String类来创建和操作字符串。
String是只读字符串
String类是不可改变的，所以一旦创建了String对象，那么它的值就无法改变了，如果需要对字符串进行修改，那么应该选择使用StringBuffer & StringBuilder类。

② StringBuilder

字符串变量
与String不同，StringBuffer和StringBuilder类的对象能够被多次修改，并且不产生新的未使用对象。

③ StringBuffer

字符串变量
与String不同，StringBuffer和StringBuilder类的对象能够被多次修改，并且不产生新的未使用对象。

总结

当对字符串进行修改的时候需要使用StringBuffer/StringBuilder类。
StringBuilder与StringBuffer最大的不同在于StringBuilder的方法不是线程安全的（不能同步访问）。
由于StringBuilder相较于StringBuffer有速度优势，因此多数情况下建议使用StringBuilder类。然而在应用程序要求线程安全的情况下则必须使用StringBuffer类。

public class Test {
    public static void main(String args[]) {
        StringBuffer sBuffer = new StringBuffer('菜鸟官网：');
        sBuffer.append('www');
        sBuffer.append('.baidu');
        sBuffer.append('.com');
        System.out.println(sBuffer);//菜鸟官网：www.baidu.com
    }
}

2、 subString

subString是否始终返回一个新串？ ——否。
subString只有在截取的子串是真子串（真子串指子串与原串不相同）时才返回一个新声明的子串。当截取的是整个字符串时，则返回自身。
语法：
String subString(int begin)
String subString(int begin, int end)

3、replace

replace方法是否始终返回一个新串？
一般是这样。但如果要替代的字符与新字符一样，则返回自身.

4、toCharArray

toCharArray方法返回String对象内置的字符数组？——否。
方法返回的是一个崭新的字符数组，且空间分配在堆空间。所以对该方法返回的字符数组进行修改，不会对String对象产生任何影响。

5、toString

toString方法返回的是一个新的String对象吗？——否。
该方法返回的就是自身。

6、trim

trim方法始终返回一个新的String对象吗？——否。
并不总是这样。首先trim返回String对象的一个副本，该副本去除了原来字符串中的首部和尾部空白。但如果String对象首部和尾部没有空白的话，则返回自身。否则调用subString方法返回一个崭新的String对象（真子串，subString中有所提到）

三、数组

1、创建数组

arrayRefVar = new dataType[arraySize];
//使用dataType[arraySize]创建了一个数组；把新建的数组引用赋值给arrayRefvar;

//数组变量的声明和创建数组可以用一条语句完成：
dataType[] arrayRefVar = new dataType[arraySize]
//除此之外，还有以下方法：
dataType[] arrayRefVar = {1,2,3,...,100};

2、二维数组

二维数组定义，一维长度必须定义，二维可以后续定义

fload f[][] = new float[6][6]  // 正确
float []f[] = new float[6][6]  // 正确
fload [][]f = new float[6][6]  // 正确
fload [][]f = new float[6][]   // 正确
fload f[][] = new float[][6]   // 错误

3、new与string赋值的区别

String a = "hello";
String b = a.substring(2,3);
String c = a.toString();
String d = new StringBuffer(a).toString();

System.out.println(a == c);//true
System.out.println(a.equals(c));//true
System.out.println(a == d);//false
System.out.println(a.equals(d));//true

——
问：下述语句创建了几个String Object？

String s = new String("xyz");

答：创建了2个
因为每new一次就会创建一次

4、Arrays工具类

Arrays 是JDK提供的操作数组的工具类，array类提供了动态创建和访问 Java 数组的方法。
arrays此类包含用来操作数组（比如排序和搜索）的各种方法。此类还包含一个允许将数组作为列表来查看的静态工厂。最常用的就是asList,sort,toString,equals,copyOf了

（1）转字符串 Arrays.toString(arr)

System.out.println("转换前："+a);
//数组转换字符串
String str=Arrays.toString(a);       
System.out.println("转换为字符串："+str);

运行结果如下：

（2）排序 Arrays.sort(arr)

关于sort()的用法参考：
link
该文章中，不仅包含数组排序，还包括集合排序，这里暂时仅介绍数组排序sort方法。
数组排序：

int a[] ={20,3,32,1,72,26,35};
System.out.println("原数组："+Arrays.toString(a));
Arrays.sort(a);
System.out.println("排序后数组："+Arrays.toString(a));

运行结果如下：

（3）填充 Arrays.fill(arr,10)

所有元素赋特定值fill（基于目标元素填充数组）

int a[] ={20,3,32,1,72,26,35};
System.out.println("赋值前："+Arrays.toString(a));
Arrays.fill(a,10);
System.out.println("赋值后："+Arrays.toString(a));

运行结果如下：

（3）判等 Arrays.equals(arr1,arr2)

int a[] ={20,3,32,1,72,26,35};
int b[]={3,5,7,8,54,23,9};
int c[]={3,5,7,8,54,23,9};
boolean boo1 = Arrays.equals(a,b);
boolean boo2 = Arrays.equals(b,c);
System.out.println("a:"+Arrays.toString(a));
System.out.println("b:"+Arrays.toString(b));
System.out.println("c:"+Arrays.toString(c));
System.out.println("a与b是否相等："+boo1);
System.out.println("b与c是否相等："+boo2);

运行结果如下：

（5）赋值 Arrays.copyOf(arr,arr.length)

int b[]={3,5,7,8,54,23,9};
int d[] = Arrays.copyOf(b,b.length);
System.out.println("d:"+Arrays.toString(d));
System.out.println("b:"+Arrays.toString(b));

运行结果如下：

（6）查下标 Arrays.binarySearch(arr,1)

int b[]={3,5,7,8,54,23,9};
int i = Arrays.binarySearch(b,5);
System.out.println("数组b数字5所在的下标是:"+i);

运行结果如下：

（7）转集合 Arrays.asList(arr)

int a[] ={20,3,32,1,72,26,35};
//数组转换成字符串
String str = Arrays.toString(a);
//字符串转换成集合
List<String> list = Arrays.asList(str);
for(int i=0;i<list.size();i++) {
    System.out.println("转换后的List集合:"+list.get(i));
}

运行结果如下：

5、数组拷贝

（1）arraycopy

link
arraycopy()方法用于将一个数组的元素快速拷贝到另一个数组。其中的参数如下：

System.arraycopy(src, srcPos, dest, destPos, length);

src：表示源数组
srcPos：表示源数组中拷贝元素的起始位置。
dest：表示目标数组
destPos：表示拷贝到目标数组的起始位置
length：表示拷贝元素的个数

需要注意的问题：

1. 在进行数组拷贝时，目标数组必须有足够的空间来存放拷贝的元素，否则就会发生角标越界异常。
2. 目标数组相对应位置上的元素会被覆盖掉；

四、类

1、继承

Java中 ，子类不能继承父类的私有属性

（1）继承类型

java不支持多继承，但支持多重继承

（图源自link）

（2）关键字

继承可以使用extends和implements这两个关键字来实现继承，而且所有的类都是继承于java.lang.Object，当一个类没有继承的两个关键字，则默认继承object祖先类。

① extends

在java中，类的继承是单一继承，也就是说，一个子类只能拥有一个父类，所以extends只能继承一个类。

public class Animal { 
    private String name;   
    private int id; 
    public Animal(String myName, String myid) { 
        //初始化属性值
    } 
    public void eat() {  //吃东西方法的具体实现  } 
    public void sleep() { //睡觉方法的具体实现  } 
} 
 
public class Penguin  extends  Animal{ 
}

② implements

使用implements关键字可以变相的使java具有多继承的特性，适用范围为类继承接口的情况，同时可以继承多个接口（接口和接口之间用逗号分开）

public interface A {
    public void eat();
    public void sleep();
}
 
public interface B {
    public void show();
}
 
public class C implements A,B {
}

五、接口

接口在Java中是一个抽象类型，是抽象方法的集合，通常以interface来声明，一个类通过继承接口的方式从而来继承接口的抽象方法。
**接口无法被实例化，但是可以被实现。**一个实现接口的类，必须实现接口内描述的所有方法，否则就必须声明为抽象类。另外，接口类型可以用来声明一个变量，他们可以成为一个空指针，或者是被绑定在一个以此接口实现的对象。

1、实现

接口的实现
当类实现接口的时候，类要实现接口中所有的方法。否则，类必须声明为抽象的类。
**类使用implements关键字实现接口。**在类声明中，Implements关键字放在class声明后面。
实现一个接口的语法，可以使用这个公式：

...implements 接口名称[, 其他接口名称, 其他接口名称..., ...] ...

• 一个类可以同时实现多个接口。
• 一个类只能继承一个类，但是能实现多个接口。
• 一个接口能继承另一个接口，这和类之间的继承比较相似。

类不允许多继承，但是接口运行多继承

public interface Hockey extends Sports, Event

2、接口与类

接口不是类。编写接口的方式和类很相似。类描述对象的属性和方法，接口则包含类要实现的方法。除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。
接口与类的区别：

• 接口不能用于实例化对象。
• 接口没有构造方法。
• 接口中所有的方法必须是抽象方法。
• 接口不能包含成员变量，除了 static 和 final 变量。
• 接口不是被类继承了，而是要被类实现。
• 接口支持多继承。

3、接口与抽象类

1. 接口中所有的方法隐含的都是抽象的，而抽象类则可以同时包含抽象和非抽象的方法
2. 类可以实现很多接口，但只能继承一个抽象类；
3. 类可以实现抽象类和接口声明的所有方法，当然，这种情况下，类也必须声明成抽象的
4. 抽象类可以在不提供接口实现方法的情况下实现接口
5. Java接口中声明的变量默认为final，抽象类可以包含非final的变量
6. Java接口中的成员函数默认是public，抽象类的成员函数也可以是private、protected或者public
7. 接口是绝对抽象的，不可以被实例化，抽象类也不可以被实例化
8. 一个类实现接口的话要实现接口的所有方法，而抽象类不一定。

从设计层面上来说，抽象是对类的抽象，是一种模板设计，接口是行为的抽象，是一种行为规范。

工具类

1、Number类

一般当需要使用数字的时候，我们通常用内置数据类型，如：byte、

int、long、double等
int a = 5000;
float b = 13.65f;
byte c = 0x4a;

但是实际开发中我们经常会遇到需要使用对象，而不是内置数据类型的情况，为了解决这个问题，java为每个内置数据类型提供了对应的包装类。
所有的包装类（Integer、Long、Byte、Double、Float、Short）都是抽象类Number的子类

（图源自link）

这种由编译器特别支持的包装称为装箱，所以当内置数据类型被当作对象使用的时候，编译器会把内置类型装箱为包装类，相似的，编译器也可以把一个对象拆箱为内置类型。Number类属于java.lang包。

public class Test{
    public static void main(String args[]) {
        Integer x = 5;
        x = x+10;
        System.out.println(x);//15
    }
}

2、Math类

Math的方法都被定义为static的形式，通过Math类可以在主函数中直接调用。

public class Test {
    public static void main(String []args) {
        System.out.println(Math.sin(Math.PI/2));
        //90度的正切值，输出1.0
    }
}

（1）BigDecimal

link
Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数。在实际应用中，需要对更大或者更小的数进行运算和处理。float和double只能用来做科学计算或者是工程计算，在商业计算中要用java.math.BigDecimal。BigDecimal所创建的是对象，我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

**构造器描述 **

• BigDecimal(int) 创建一个具有参数所指定整数值的对象。
• BigDecimal(double) 创建一个具有参数所指定双精度值的对象。 //不推荐使用
• BigDecimal(long) 创建一个具有参数所指定长整数值的对象。
• BigDecimal(String) 创建一个具有参数所指定以字符串表示的数值的对象。//推荐使用

**方法描述 **

• add(BigDecimal) BigDecimal对象中的值相加，然后返回这个对象。
• subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。
• multiply(BigDecimal) BigDecimal对象中的值相乘，然后返回这个对象。
• divide(BigDecimal) BigDecimal对象中的值相除，然后返回这个对象。
• toString() 将BigDecimal对象的数值转换成字符串，有必要时使用科学计数法。
• toPlainString() 将BigDecimal对象的数值转换成字符串，不使用任何指数
• toEngineeringString() 将BigDecimal对象的数值转换成字符串， 有必要时使用工程计数法。工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数
• doubleValue() 将BigDecimal对象中的值以双精度数返回。
• floatValue() 将BigDecimal对象中的值以单精度数返回。
• longValue() 将BigDecimal对象中的值以长整数返回。
• intValue() 将BigDecimal对象中的值以整数返回。
• signum() 如果此BigDecimal<0, 则为-1;如果 = 0，则为0;如果> 0, 则为1

java.math.BigDecimal.subtract()方法实例
link

BigDecimal的3个toString方法

• toEngineeringString：有必要时使用工程计数法。工程记数法是一种工程计算中经常使用的记录数字的方法，与科学技术法类似，但要求10的幂必须是3的倍数
• toPlainString：不使用任何指数
• toString：有必要时使用科学计数法
  
  示例：

import java.math.BigDecimal;
public class BigDecimalDemo {
    public static void main(String[] args) {
        BigDecimal bg = new BigDecimal("1E11");
        System.out.println(bg.toEngineeringString());//100E+9
        System.out.println(bg.toPlainString());//100000000000
        System.out.println(bg.toString());//1E+11
    }
}

（2）round

Math.round()：

System.out.println(Math.round(11.3));//11
System.out.println(Math.round(-11.3));//-11
System.out.println(Math.round(11.5));//12
System.out.println(Math.round(-11.5));//-11
System.out.println(Math.round(11.7));//12
System.out.println(Math.round(-11.7));//-12

返回值为long或者int类型，即类似与四舍五入取整数
正数四舍五入
负数绝对值，小于等于5，直接舍去小数部分，大于5，则返回一个绝对值大于的最小整数（实际应该是小于）

（3）floor

Math.floor()：

System.out.println(Math.floor(11.3));//11.0
System.out.println(Math.floor(-11.3));//-12.0
System.out.println(Math.floor(11.5));//11.0
System.out.println(Math.floor(-11.5));//-12.0
System.out.println(Math.floor(11.7));//11.0
System.out.println(Math.floor(-11.7));//-12.0

返回值为double类型，返回一个小于或等于参数的最大整数，即舍去

（4）ceil

Math.ceil()：

System.out.println(Math.ceil(11.3));//12.0
System.out.println(Math.ceil(-11.3));//-11.0
System.out.println(Math.ceil(11.5));//12.0
System.out.println(Math.ceil(-11.5));//-11.0
System.out.println(Math.ceil(11.7));//12.0
System.out.println(Math.ceil(-11.7));//-11.0

返回值为double类型，返回一个大于或等于参数的最小整数，即进一