【无标题】day

【无标题】day

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

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

        2.常用方法
            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

        3.使用
            //必须传入字符串
            BigInteger v1 = new BigInteger("123456");
            //不需要字符串，普通数就行
            BigDecimal v2 = new BigDecimal(20);
            BigDecimal v3 = new BigDecimal(20);
            //+    其他以此类推
            BigDecimal result = v2.add(v3);

        4.阶乘
            public static BigInteger_02{
                System.out.println(test(120));
                System.out.println(test1(120));
            }
            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;
            }

    2.Math 
        1.概述
            java.lang.Math提供了一系列静态方法用于科学计算。其方法的参数和返回
            值类型一般为double型

        2.常用方法
            abs 绝对值 sin asin 三角函数  sqrt  平方根
            pow(double a,double 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) 角度->弧度

        3.使用方式
            //绝对值
            System.out.println(Math.abs(-3));
            //向上取整，有小数就进位（向下取整，舍弃小数，ps：如果小数位太多（二十来个9）也可能+1）
            
            //返回一个大于等于0且小于1的随机数
            //本质就是Random的nextDouble方法

            //四舍六入五取偶，小数大于0.5进1，小于0.5舍弃，等于0.5整数位偶时舍去

2.异常机制
    1.概述
        异常时Java中提供的一种识别及响应错误情况的一致性机制。有效地异常处理能使
        程序更加健壮，易于调试。

        其实就是错误的一种说法，在java中有一个专门模拟所有异常和错误的类
        
        Throwable是所有异常类的父类

        try…catch… ：处理异常，一般用于客户端
        throws ：抛出异常，一般用于服务器
        throw ： 异常源点
        finally ：必须执行的语句

        异常的原因有很多，比如：
            1.用户输入了非法数据
            2.要打开的文件不存在
            3.网络通信时连接中断
            4.JVM内存溢出  等等

    2.继承体系： 见图

    3.Error
        系统内部错误，这类错误由系统内部处理，程序本身无需捕获处理

    4.Exception
        1.概述
            所有非系统错误的父类，分为RuntimeException和非RuntimeException
            非RuntimeException:指程序编译时需要捕获或处理的异常，如IOException，属于checked异常
            RuntimeException:指程序编译时不需要捕获或处理的异常，属于unchecked异常，
                一般由程序员粗心导致
            
        2.常用方法
            Exception类和其他类一样，有自己的属性和方法
            
            public String getMeaasge():返回关于发生的异常的详细信息，
                这个消息在Throwable类的构造函数中初始化了（用于给客户反馈）              
            public void printStackTrace():打印toString()结果和栈层次到System.err，即错误输出流

        3.try…catch…
            不再终止生命周期的执行

            try{
                高风险代码
                只要出错，就执行catch，try中剩余代码不再执行
                如果没出错，try就可以顺利执行完成，并且catch不再执行
            }catch（异常类型 变量）{
                处理方法;
            }

**************举例****************：
            try{
                //加载对应的文件
                FilelnputStream fis = new FilelnputStream("123.txt");
                System.out.println("=======");
            }catch(Exception e){
                //打印错误栈帧和信息，一般用于程序员排错
                e.printStackTrace();
                //获取错误信息，一般用于反馈给客户端
                String msg = e.getMeaasge();
                String.out.println(msg);
                System.out.println("xxxxxxxxx");
            }

            //当try下面可能会出现多个异常并且每个一场对应的解决方案不同的时候
            //需要写多个catch进行不同的处理，从上往下必须时从子类到父类，或者没有继承关系
            //如果解决方案一致，则只写一个exception即可

            try{
                高风险代码；
            }catch（异常类型 变量）{
                处理措施；
            }catch（异常类型 变量）{
                处理措施；
            }catch（异常类型 变量）{
                处理措施；
            }

            同时捕捉多个异常，并且 不能有继承关系，如果有直接写父类即可
            try{
            }catch(异常类型1 | 异常类型2 | 异常类型3…){                
            }

        4.Throws 
            抛出异常，该方法并不会处理问题，一种提醒机制，告诉调用人员这里可能有错误
            如果直到如何解决则用try解决问题，否则就要通过throws抛出问题
            只要你的下家提醒了你，你要么解决，要么抛给上家
            抛到main方法，还解决不了抛给JVM，再解决不了就掩盖过去

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

            //throws可以同时抛出多个异常，用逗号隔开

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

            public static int m1(){
                int i = 10;
                try{
                    return i++;             //因为finally中有return，所以这里的return不执行，但是i++执行，编译之后会把return去掉（详见课堂笔记12页）
                }catch(Exception e){
                }finally{
                    System.out.println(i + "----------");
                    return i;
                }
            }

            //代码要求：确保文件关闭
            FileInputStream fis = null;
            try{
                fis = new FileInputStream("123.txt");
            }catch(FileNotFoundException e){
                e.printStackTrace();
            }finally{
                try{
                    //判断是否打开该资源
                    if(fis != null){
                        System.out.println("关闭成功");
                        fis.close();
                    }
                }catch(IOException e){
                    e.printStackTrace();
                }
            }

            //java7新特征 自动关闭资源 
            try(开启资源语句;){
                高风险代码;
            }catch（异常类型 变量）{
                处理方案;
            }

            不能有更宽泛的异常
                方法覆写，不能比原方法有更宽泛的异常
                子类方法抛出的异常不能大于父类异常，要么和父类抛出异常一致，
                要么是父类抛出异常类的子类，或者不抛出异常

        6.自定义异常类
            1.需求
                完成用户登陆功能
                传入用户信息,校验用户名和密码是否正确,
                如果正确则返回该用户所有信息,反之则提示错误信息

                软件构成：如图

            2.实体类：用户模块（User）
            
            3.异常类
                自定义异常类
                    1.继承一个已有的异常类
                        如果是运行时异常，则继承RuntimeException，反之继承Exception即可
                        一般情况下，我们写的 一定是编译时异常
                    2.公共的无参构造
                    3.公共的有参构造，参数是错误信息，然后通过super 把错误信息传递到父类

                    public class UserException extends Exception{
                        public UserException(){
                        }
                        public UserException(String msg){
                            super(msg);
                        }
                    }

            4.Controller    控制台输入用户名密码并验证

            5.Date          模拟数据库，填写用户信息

            6.Dao           根据用户名查询用户信息 查找是否存在

            7.service       同上

           

多个catch父类在下   
finally优先级极高，
覆写的异常要是父类异常的子类   子类方法的异常不能大于父类异常