2021-07-14

本文主要是介绍2021-07-14，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

Day18 常用API、异常机制

1. Random

1.1 使用

        //随机数从0开始
        //创建随机数生成器
        Random random = new Random();
        //从0~4中随机生成一个
        int i = random.nextInt(5);
        System.out.println(i);

1.2 案例

        //生成10~20
        //nextInt(最大减-最小值+1)+最小值
        int x = random.nextInt(11) + 10;
        System.out.println(x);
        System.out.println(random.nextInt(9 - 5 + 1) + 5);
        //生成a-z
        int c = random.nextInt(26);
        char c1 = (char) (c + 97);
        System.out.println(c1);

2. Number

2.1 DecimalFormat

        //创建数字格式化对象
        //需求:加入千分位
        DecimalFormat df = new DecimalFormat("###,###");
        System.out.println(df.format(1234567));

        //需求：加入千分位，保留两位小数
        df = new DecimalFormat(",###.##");
        //会四舍五入
        System.out.println(df.format(1234567.155));

        //需求：加入千分位，保留两位小数，不够补0
        df = new DecimalFormat(",###.0000");
        System.out.println(df.format(1234567.155));

2.2 BigInteger&BigDecimal

2.2.1 概述

java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回
值类型一般为double型。
abs 绝对值 acos,asin,atan,cos,sin,tan 三角函数 sqrt 平方根
pow(double a,doble b) a的b次幂 log 自然对数
exp e为底指数
max(double a,double b)
min(double a,double b)
random() 返回0.0到1.0的随机数
long round(double a) double型数据a转换为long型（四舍五入）
toDegrees(double angrad) 弧度—>角度
toRadians(double angdeg) 角度—>弧度

1)、BigInteger和BigDecimal类

1.1) BigInteger

(1)Integer类作为int的包装类，能存储的最大整型值为231-1，Long类也是有限的， 最大为263-1。如果要表示再大的整数，不管是基本数据类型还是他们的包装类 都无能为力，更不用说进行运算了。

(2)java.math包的BigInteger可以表示不可变的任意精度的整数。BigInteger 提供
所有 Java 的基本整数操作符的对应物，并提供 java.lang.Math 的所有相关方法。 另外，BigInteger 还提供以下运算：模算术、GCD 计算、质数测试、素数生成、 位操作以及一些其他操作。

(3)构造器
BigInteger(String val)：根据字符串构建BigInteger对象

(4)常用方法
public BigInteger abs()：返回此 BigInteger 的绝对值的 BigInteger。
BigInteger add(BigInteger val) ：返回其值为 (this + val) 的 BigInteger
BigInteger subtract(BigInteger val) ：返回其值为 (this - val) 的 BigInteger
BigInteger multiply(BigInteger val) ：返回其值为 (this * val) 的 BigInteger
BigInteger divide(BigInteger val) ：返回其值为 (this / val) 的 BigInteger。整数 相除只保留整数部分。
BigInteger remainder(BigInteger val) ：返回其值为 (this % val) 的 BigInteger。
BigInteger[] divideAndRemainder(BigInteger val)：返回包含 (this / val) 后跟(this % val) 的两个 BigInteger 的数组。
BigInteger pow(int exponent) ：返回其值为 (thisexponent) 的 BigInteger。

1.2) BigDecimal
一般的Float类和Double类可以用来做科学计算或工程计算，但在商业计算中， 要求数字精度比较高，故用到java.math.BigDecimal类。
BigDecimal类支持不可变的、任意精度的有符号十进制定点数。
构造器
public BigDecimal(double val)
public BigDecimal(String val)
常用方法
public BigDecimal add(BigDecimal augend)
public BigDecimal subtract(BigDecimal subtrahend)
public BigDecimal multiply(BigDecimal multiplicand)
public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)

2.2.2 使用

public static void main(String[] args) {
        //这个创建对象的时候 需要传递字符串的谁
        BigInteger bi = new BigInteger("22");
        BigDecimal v1 = new BigDecimal(20);
        BigDecimal v2 = new BigDecimal(20);

        //+  不能v1+v2，因为是引用类型
        BigDecimal v3 = v1.add(v2);
        //- 
        v3 = v1.subtract(v2);
        //*
        v3 = v1.multiply(v2);
        // /
        v3 = v1.divide(v2);
        //%
        v3 = v1.remainder(v2);
        System.out.println(v3);
    }

2.2.3 阶乘

    //传统递归long类型值有限
    public static long m1(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * m1(n - 1);
    }

    public static BigDecimal m2(int n) {
        if (n <= 1) {
            return new BigDecimal(1);
        }
        return new BigDecimal(n).multiply(m2(n - 1));
    }

3. Math

3.1 概述

Math 提供了科学技算和基本的数字操作方法
全是静态方法，类名调用即可，并且Math在java.long下，不需要导包

3.2 常用方法

public static void main(String[] args) {
        //abs 绝对值
        System.out.println(Math.abs(-23));
        //ceil 向上取整  小数大于0 就进位
        System.out.println(Math.ceil(1.000001));
        //floor 向下取整 舍小数
        System.out.println(Math.floor(1.99999));

        //sqrt 平方根
        System.out.println(Math.sqrt(4));
        //cbrt 立方根
        System.out.println(Math.cbrt(8));

        //random 随机数 生成大于等于0.0 且小于1.0
        //greater than or equal to {@code 0.0} and less than {@code 1.0}
        System.out.println(Math.random());

        //rint 四舍五入
        //银行算法，四舍六入 五取偶数
        System.out.println(Math.rint(2.4));
        System.out.println(Math.rint(2.5));
        System.out.println(Math.rint(3.5));

        //pow N次方
        System.out.println(Math.pow(2, 3));
    }
 

4. 异常机制

4.1 之前见过的异常

1 下标越界(数组)
2 空指针异常(数组,面向对象)
3 栈内存移出(递归)
4 类型转换异常(面向对象)
5 数字格式化异常(常用API)

4.2 概述

异常：

 是java提供的识别错误的响应机制，可以使程序更加见状 易于调试
1
 异常是错误的另一种说法
1
 java中 有个专门模拟所有异常的类,Throwable,是异常类的祖类，所有的异常类 都是它的子类
1
 如果程序出现了异常 会终止程序生命周期执行，所以需要进行处理
1
异常处理形式：

 try...catch... :解决 异常，一般用在客户端(调用处)
1
 throws :抛 异常，一般用在类库端(服务段，被调用的地方)
1
 throw :异常源，制作异常，创建异常对象
1
4.3 继承体系

4.4 Error

4.5 Exception

4.5.1 概述
Exception是所有异常类的父类。分为非RuntimeException和RuntimeException 。
非RuntimeException
指程序编译时需要捕获或处理的异常，如IOException、自定义异常等。属于checked异常。
RuntimeException
指程序编译时不需要捕获或处理的异常，如：NullPointerException等。属于unchecked异常。一般是由程序员粗心导致的。如空指针异常、数组越界、类型转换异常等。

4.5.2 常用方法

4.5.3 Try…catch…

4.5.3.1 第一种

 * 语法：
 * try{
 *         高风险代码；
 * }catch{
 *         出错后的操作
 * }

public static void main(String[] args) {
        try {
            //高风险代码，可能出错的代码
            //可能找不到这个文件，所以我们要处理一下
            FileInputStream fis = new FileInputStream("a");
            //try中 出错语句之后不执行，直接执行catch
            System.out.println("xxx");
        } catch (FileNotFoundException e) {//出错后的处理措施
            //            catch (Exception e)  越精确越好
            //打印追踪栈帧
            //            e.printStackTrace();

            //获取错误信息，响应用户方便
            String mag = e.getMessage();
            System.out.println(mag);

        }
        //代码可以正常执行
        System.out.println("=======");
    }

4.5.3.2 第二种

 * try{
 *         高风险代码
 * }catch(异常类型 变量){
 * 
 * }catch(异常类型 变量){
 * 
 * }

public static void main(String[] args) {
        try {
            new FileInputStream("");
            String s = null;
            s.equals("");
            //可以写多个catch 捕捉多个异常，进行不同的处理
            //多个异常类型之间不能有继承关系，否则就必须是从子类到父类
        } catch (FileNotFoundException e) {
            System.out.println("找不到文件");
        } catch (NullPointerException e) {
            System.out.println("空指针");
        }
    }

4.5.3.3 第三种

 * java 1.7新改进
 * 
 * 自动关闭资源
 * 
 * try(开启资源){
 *         高风险代码
 * }catch(异常类型 变量){
 * }

try (FileInputStream fis = new FileInputStream("E://WorkSpace//eclipse//JavaSE_06_Exception//src//a.txt");
        //资源2
        //资源3
        ) {
            //操作，自动关闭，不用finally
            fis1 = fis;
            System.out.println(fis.read());
        } catch (Exception e) {
            e.printStackTrace();
        }


4.5.4 Throws

 * throws 把异常抛出，是一种提醒，跟调用处，这里可能有异常
 * 
 * 可以抛出多个异常，多个之间 逗号隔开

public static void main(String[] args) {
        try {
            m1();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (NullPointerException e) {
            e.printStackTrace();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("=====");
    }

    public static void m1() throws FileNotFoundException, Exception, NullPointerException {
        m2();
    }

    public static void m2() throws FileNotFoundException {
        new FileInputStream("");
    }

4.5.5 Finally

 * finally :是必须执行的语句，只有一种情况不执行
 *         System.exit(0);
 * 1 finally 不能单独使用
 * 2 必须和try或者try..catch一起使用

public static void main(String[] args) {
        try {
            String string = null;
            string.equals("");
            //空指针异常，终止程序生命周期
        } finally {
            //必须执行
            System.out.println("=====");
        }
        //因为没有catch，所以没有办法捕捉异常，依旧会终止生命周期，所以下面代码不会执行
        System.out.println("-----");
    }
1
2
3
4
5
6
7
8
9
10
11
12
public static void main(String[] args) {
        FileInputStream fis = null; //不初始化 18行报错
        try {
            //打开资源
            fis = new FileInputStream("a");
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            //关闭资源
            try {
                if (fis != null) {
                    fis.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

4.5.6 不能有更宽泛的异常

class A {
    public void m1() throws FileNotFoundException {

    }
}

class B extends A {
    //要么不抛出异常
    //要么就是父类抛出的异常类的子类
//    public void m1() throws IOException { 抛出的异常类只能范围一样或者更少

//    }
}

4.6 自定义异常

4.6.1 语法

 *      自定义异常类：
 *         1 继承一个已有的异常类
 *                 一般我们继承Exception即可
 *                 如果是运行时异常，则继承RuntimeException
 *         2 公共的无参构造
 *         3 有参构造，传入String，是错误信息
 

4.6.2 应用场景

 * 需求 : 
 *         完成用户登陆
 *             1 用户拥有 username,password,nickname 三个属性
 *             2 业务逻辑类，提供登录方法，校验是否登录成功
 *                     准备用户数组，保存用户信息(相当于是数据库)
 *             3 入参是 用户对象，出参也是用户对象，登陆成功之后，返回用户的所有信息
 *             4 客户端类，接收用户输入，进行登陆校验

4.6.2.1 用户类

public class User {
    private String username;
    private String password;
    private String nickname;

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(String username, String password, String nickname) {
        super();
        this.username = username;
        this.password = password;
        this.nickname = nickname;
    }

    public User() {
        super();
    }

    public String toString() {
        return "User [username=" + username + ",password=" + password + ",nickname=" + nickname + "]";
    }
}

4.6.2.2 用数组模拟的数据库类 -DataBase- (负责存储用户信息)

 * 模拟数据库存储
 * 
 * 默认初始化容量为10，自动扩容为1.5倍
 * 
 * 默认内置用户为admin root 管理员
 * 
 * 需要提供获取数据的方法 和 添加数据的方法

public final class DataBase {
    //用户信息
    private static User[] database;
    //已有用户个数
    private static int size = 0;
    static {
        if (database == null) {
            database = new User[10];
            database[size++] = new User("admin", "root", "管理员");
        }
    }

    /**
     * 用户注册
     */
    public static void add(User user) {
        //1 判断数组中是否还有空间
        if (size >= database.length) {
            //2 数组如果满了， 扩容
            User[] newDatebase = new User[database.length + database.length * 2];
            //3 把源数组中内容赋值到新数组中
            System.arraycopy(database, 0, newDatebase, 0, database.length);
            //4 把新数组地址 赋值给database
            database = newDatebase;
        }
        //5 如果还有空间 就添加进去
        database[size++] = user;
    }

    /**
     * 获取所有用户的方法
     * @return
     */
    public static User[] getDatabase() {
        User[] newDatabase = new User[size];
        System.arraycopy(database, 0, newDatabase, 0, size);
        return newDatabase;
    }
}

4.6.2.3 操作数据库的类 -UserDao- (负责执行注册 登陆)

public class UserDao {
    public User loadByUserName(String username) {
        User[] database = DataBase.getDatabase();
        for (User user : database) {
            if (user.getUsername().equals(username)) {
                return user;
            }
        }
        return null;
    }

    public void add(User user) {
        DataBase.add(user);
    }
}

4.6.2.4 逻辑判断类 -UserService- (判断 注册 登陆 是否会出现异常)

public class UserService {
    private static UserDao userDao = new UserDao();

    /**
     * 用户注册
     * @param user
     * @throws UserException
     */
    public static void add(User user) throws UserException {
        //1 判断用户名是否重复(根据用户名查询，能找到就是重复)
        User oleUser = userDao.loadByUserName(user.getUsername());
        //2 重复就抛异常：用户名已重复
        if (oleUser != null) {
            //创建一个异常对象并抛出
            throw new UserException("用户名已存在");
        }
        //3 不重复就添加
        userDao.add(user);
    }

    /**
     * 登陆
     */
    public static User login(String username, String password) throws UserException {
        //1 根据用户名查询用户
        User oldUser = userDao.loadByUserName(username);
        //2 如果用户不存在，说明用户名不正确
        if (oldUser == null) {
            throw new UserException("用户名不存在");
        }
        //3 如果查询到了用户，就比较密码
        //4 密码不对，返回密码不正确
        if (!oldUser.getPassword().equals(password)) {
            throw new UserException("密码不正确");
        }
        //5 密码正确，登陆成功
        return oldUser;
    }
}

4.6.2.5 客户端类 -Client- (负责 输入 注册 登陆)

public class Client {
    public static void main(String[] args) {
        UserService userService = new UserService();
        //1 接收用户输入
        Scanner scanner = new Scanner(System.in);
        //循环接收
        while (true) {
            System.out.println("1 是注册 2 是登陆");
            int value = scanner.nextInt();
            //2 判断是登陆还是注册
            if (value == 1) {
                System.out.println("请输入：用户名");
                String username = scanner.next();
                System.out.println("请输入：昵称");
                String nickname = scanner.next();
                System.out.println("请输入：密码");
                String password = scanner.next();
                System.out.println("请输入：确认密码");
                String password2 = scanner.next();
                while (!password.equals(password2)) {
                    System.err.println("两次密码不一致，请重新输入");
                    System.out.println("请输入：密码");
                    password = scanner.next();
                    System.out.println("请输入：确认密码");
                    password2 = scanner.next();
                }
                try {
                    userService.add(new User(username, password, nickname));
                    System.out.println("注册成功");
                } catch (UserException e) {
                    System.out.println(e.getMessage());
                }
            } else if (value == 2) {
                System.out.println("请输入：用户名");
                String username = scanner.next();
                System.out.println("请输入：密码");
                String password = scanner.next();
                try {
                    User loginUser = UserService.login(username, password);
                    //欢迎登陆信息
                    System.out.println("登陆成功,欢迎" + loginUser.getNickname() + "回来");
                    //打印所有信息
                    System.out.println(loginUser);
                } catch (UserException e) {
                    System.err.println(e.getMessage());
                }
            }
        }
    }
}

4.6.2.6 自定义异常类 -UserException- (负责返给用户错误信息)

public class UserException extends Exception {
    public UserException() {

    }

    public UserException(String msg) {
        super(msg);
    }
}
 

这篇关于2021-07-14的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！