// 必须传入字符串
BigInteger v1 = new BigInteger("123123");
BigDecimal v2 = new BigDecimal(20);
BigDecimal v3 = new BigDecimal(20);
// +
BigDecimal result = v2.add(v3);
System.out.println(result);
// -
result = v2.subtract(v3);
System.out.println(result);
// *
result = v2.multiply(v3);
System.out.println(result);
// /
result = v2.divide(v3);
System.out.println(result);
// %
result = v2.remainder(v3);
System.out.println(result);
public static void main(String[] args) {
System.out.println(test(120));
System.out.println(test1(120));
System.out.println(Long.MAX_VALUE);
}
public static long test(long n){
long result = 1;
for (int i = 1; i <= n; i++) {
result *= i;
}
return result;
}
public static BigInteger test1(long n){
BigInteger result = new BigInteger("1");
for (int i = 1; i <= n; i++) {
result= result.multiply(new BigInteger(i+""));
}
return result;
}
// 绝对值
System.out.println(Math.abs(-3));
// 向上取整 , 有小数 就进位
System.out.println(Math.ceil(2.000000001));
// 向下取整 , 舍弃小数
System.out.println(Math.floor(2.999999999999));
// 返回最大的值
System.out.println(Math.max(2.3, 4.1));
// 返回最小的值
System.out.println(Math.min(2.3, 4.1));
// 开平方
System.out.println(Math.sqrt(16));
// 开立方
System.out.println(Math.cbrt(8));
// 返回一个 大于等于0 且小于 1 的随机数
// 本质就是Random的nextDouble方法
System.out.println(Math.random());
// 四舍六入五取偶 , 当小数大于0.5 就进1 , 小于 0.5 就舍弃,当小数为0.5整的时候,取偶数
// 2.5 = 2 , 3.5 = 4 , 2.50001 = 3
System.out.println(Math.rint(2.50001));
System.out.println(Math.rint(9.5));
// N的M次幂 , 2的3次幂
System.out.println(Math.pow(2, 3));
public static void main(String[] args) {
// 1 > x >= 0
// 123 > x >= 97
System.out.println(Math.random());
// Math.random() * (最大-最小+1) + 最小
char result = (char) (Math.random() * (122 - 97 + 1) + 97);
System.out.println(result);
}
* 异常 其实就是错误的一种说法,在java中 有一个专门模拟所有异常和错误的类 Throwable ,是所有异常类的父类
*
* try...catch... : 处理异常,一般用于客户端
*
* throws : 抛出异常,一般用于服务端
*
* throw : 异常源点
*
* finally : 必须执行的语句
public static void main(String[] args) {
System.out.println("------------");
// 除数不能为0
int a = 10;
int b = 0;
if (b != 0) {
int c = a / b;
} else {
System.out.println("除数不能为0");
}
System.out.println("===========");
}
* try{
* 高风险代码
* 只要出错,就执行catch,try中剩余代码不再执行
* 如果没出错,try就可以顺利执行完成,并且catch不再执行
* }catch(异常类型 变量){
* 处理方案;
* }
public static void main(String[] args) {
try {
// 加载对应的文件
FileInputStream fis = new FileInputStream("123.txt");
System.out.println("=========");
} catch (Exception e) {
// 打印错误栈帧和信息,一般用于程序员排错
e.printStackTrace();
// 获取错误信息,一般用于反馈给客户端
String msg = e.getMessage();
System.out.println(msg);
System.out.println("xxxxxxxxxx");
}
// 不再终止生命周期执行
System.out.println(1111);
}
* throws 抛出异常,该方式并不会处理理解,一种提醒机制,告诉调用人员,这里可能会有错误
*
* 如果 知道如何解决 则使用try 解决问题, 否则就要通过 throws 抛出问题
*
* 只要你的下家提醒了你,要么你解决,要么抛给上家
public static void main(String[] args) {
try {
m1();
} catch (Exception e) {
// e.printStackTrace();
// TODO 解决错误的措施
}
System.out.println("====");
}
// throws 可以同时抛出多个异常,多个用逗号隔开
public static void m1() throws FileNotFoundException,Exception {
m2();
}
public static void m2() throws FileNotFoundException {
m3();
}
public static void m3() throws FileNotFoundException {
new FileInputStream("123");
}
* try{
* 高风险代码;
* }catch(异常类型 变量){
* 处理措施;
* }catch(异常类型 变量){
* 处理措施;
* }catch(异常类型 变量){
* 处理措施;
* }.....
*
* 可以写多个catch , 但是 从上往下 必须是从子类到父类,或者没有继承关系
*
public static void main(String[] args) {
// 当try下面 可能会出现多个异常的时候,并且每个异常对应的解决方案不同的时候
// 需要写多个catch进行不同的处理
// 如果解决方案一致,则只写一个 exception 即可
try {
new FileInputStream("123");
String stre = null;
System.out.println(stre.trim());
} catch (FileNotFoundException e) {
System.out.println("找不到指定文件");
} catch (IOException e) {
} catch (NullPointerException e) {
System.out.println("不能为空");
} catch (Exception e) {
System.out.println("其他异常");
}
}
* try{
*
* }catch(异常类型1 | 异常类型2 | 异常类型3 ...){
*
* }
*
* 同时捕捉多个异常,并且多个异常类型直接用 | 隔开,并且 不能有继承关系
* 如果有继承关系 则直接写父类即可
public static void main(String[] args) {
try {
new FileInputStream("123");
} catch ( FileNotFoundException | NullPointerException e) {
// TODO: handle exception
}
}
* finally : 必须执行的语句块,不能单独使用,必须和try 或者try..catch..一起使用
*
* finally 只有一种不执行的情况,那就是 System.exit(0);
public static void main(String[] args) {
try {
FileInputStream fis = new FileInputStream("123");
System.out.println(fis);
} catch (IOException e) {
e.printStackTrace();
}finally{
System.out.println("必须执行");
}
}
public static void main(String[] args) {
int result = m1();
// 11
System.out.println(result);
}
public static int m1() {
int i = 10;
try {
// 因为finally中有return,所以这里的return 不执行,但是 i++执行,编译之后 会把return去掉
return i++;
} catch (Exception e) {
} finally {
System.out.println(i + "-------");
return i;
}
}
public static void main(String[] args) {
// 提升作用域,否则访问不到
// 添加默认值,否则因为局部变量没有默认值而报错
FileInputStream fis = null;
try {
fis = new FileInputStream("D://123.txt");
System.out.println("执行成功");
} catch (FileNotFoundException e) {
e.printStackTrace();
} finally {
try {
// 判断是否打开该资源
if (fis != null) {
System.out.println("关闭成功");
fis.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
* java7新特征,自动关闭资源
*
* try(开启资源语句;){
* 高风险代码;
* }catch(异常类型 变量){
* 处理方案;
* }
*
public static void main(String[] args) {
try(
FileInputStream fis = new FileInputStream("123");
) {
// 操作
} catch (Exception e) {
e.printStackTrace();
}
}
* 方法覆写,不能比原方法有更宽泛的异常
*
* 子类方法抛出的异常,不能大于父类异常,也就是 小于等于 父类异常均可
* 要么和父类抛出的异常一public class Exception_10 {
public static void main(String[] args) {
}
}
class A {
public void m1() throws IOException {
}
}
class B extends A {
public void m1() throws IOException {
}
}致,要么是父类抛出异常类的子类,或者 直接不抛出异常