java基础之常量池和异常

1.字符串常量池
        a）内存位置-->    位于方法区。
       方法区：字符串常量池，类型信息（代码），静态属性

        b）作用-->  重复利用字符串对象，节约内存，因为字符串对象内容是只读的（内部存储内容的成员变量是final的）。

String创建对象的方式
     *
     * 1）字面值方式--》存储在字符串常量池中
     * Stirng str="字符串内容";
     *
     * 2)new对象--》存储在堆中
     *  a）new String() ->创建空字符串对象--》相当于 ""
     *  b)new String(字符串内容)->copy一份str的内容到新字符串对象 -》"字符串内容"
     *  
     *  
     *  对比
     *  1）字面值方式在字符串常量池，节约内存（重复内容对象存储一份）
     *  2）new对象存储在堆中，重复内容对象多次存储。
     *  3）通常选择字面值方式定义字符串--》节约内存

2.异常的概念

Throwable（异常）的概念：程序非正常执行(运行时)的情况，程序【运行】遇到了问题！！

a） Exception(例外)：业务处理代码层面的时候发生的问题，这种问题可以解决，可以通过异常机制进行处理
b） Error（错误）：业务处理jvm层面（运行环境）发生的问题，这种问题不能或不应该通过异常机制进行处理

        java是面向对象的
        -》每一个具体的程序异常（问题）都可以用对象（throwable，exception，error的对象）进行描述
        
        java程序在什么情况下会产生异常（问题）
        --》程序执行的代码不能正常表达出结果的时候-就会产生异常
        例如：被除数/除数  -》除数为0-》就会产生异常
    
        java产生异常的方式
        1）表达式产生
            a）被除数/除数  -》除数为0-》就会产生异常
        2）方法调用产生
            b）对象引用.成员方法 -》对象引用为null-》就会产生异常
            c）字符串处理-》下标超过范围
            ...
        3）手动throw产生异常，问题
            语法：
            throw exception的对象;
        作用：    如果我们自己业务代码（方法）执行的时候，不能满足要求，那么我们就可以手动抛出异常-让（方法）使用者解决
            
        java出现了可以处理问题-都可以我们去处理
        --》没有处理-》交给jvm处理    
            a）打印异常问题的详细信息到控制台
            b）停止程序（错误的线程），后面的代码不执行

3.自定义异常：自己编写异常类来描述异常-》可以更加准确的描述业务的异常。
         *
         * 语法
         * 1）类名：异常原因+exception
         * 2）继承exception或runtimeException
         * 3）保证两个构造器存在
         *   a）空构造器
         *   b）带参数String message 构造器
         *   
         *   
         *  java遇到异常的处理方式
         *  1）try catch   --》方法自己遇到问题，自己处理
         *  2）throws --》方法自己遇到问题，自己不处理，把问题报告
         *  
         *  throws-》处理-把要处理的声明到方法里
         *  语法：访问修饰符  【static】 返回值类型  方法名(参数列表)throws 可能处理的异常类,...{//方法代码}
         *   
         *  --》注意点：每一个方法都默认的【throws 了runtimeexception】如果我们处理 runtimeexception
         *  或子类，需要throws，不用添加throws 代码

4. 异常相关的操作
         *
         * throwable 常用api
         *
         * 1）异常对象.getClass().getName();-->获取异常对象所在类的完整类名
         * 2)异常对象.getMessage() --》获取异常对象的异常消息
         * 3)异常对象.printStackTrace()-->打印异常对象的详细信息（a）类名b）消息 c）错误位置）到控制台

5.java遇到异常的处理方式
         *  1）try catch   --》方法自己遇到问题，自己处理
         *  2）throws --》方法自己遇到问题，自己不处理，把问题报告
         *  
         *  throws-》处理-把要处理的声明到方法里
         *  语法：访问修饰符  【static】 返回值类型  方法名(参数列表)throws 可能处理的异常类,...{//方法代码}
         *  
         *  注意点
         *  1）throws 抛出的类可以多个
         *  2）throws 抛出异常类是【可能出现的问题】，throw 异常对象--》【马上产生一个异常问题】
         *  3） 如果方法里有多个子类异常（小问题）可以直接抛出多个子类异常的父类（大问题）
         *  原因-》大问题可以解决-小问题也就解决了
         *  ->尽量少抛出父类异常-》描述问题不准确-》增加了处理的复杂度

6.try catch finally 处理异常的结构
         *
         * a）try：监听代码可能出现的问题，不处理，遇到了问题，报告给对应的catch
         *
         * b）catch：处理try里遇到问题的代码，catch可以多个，每一个catch处理一种问题。
         *
         * c）finally：一定要执行的代码，无论是否异常都会执行
         *
         *
         * 语法：
         * try{
         *   //监听的正常逻辑的代码1
         *   //监听的正常逻辑的代码2
         *   //监听的正常逻辑的代码3
         *   ...
         * }[
         * catch(异常类   接收捕获异常的引用变量){
         *       //处理当前异常类对应的异常代码1
         *       //处理当前异常类对应的异常代码2
         *       ...
         * }
         * ...
         * ]
         * [
         * finally{
         *      // 一定要执行的代码，无论是否异常都会执行
         * }
         * ]
         *
         * a)try  catch-》try监听异常，catch处理异常
         *
         * 执行的过程
         *  1）没有异常
         *      -》执行完try里所有的代码,离开try catch结构
         *  2）有异常
         *      x）遇到的异常【处理了有对应catch】
         *      -》从try执行代码到异常的位置，找到对应的catch执行所有代码，离开try catch结构
         *      x）遇到的异常【没有处理了没有对应catch】
         *         -》从try执行代码到异常的位置，直接把对应的异常抛给方法的使用者
         *
         * b）try catch finally-》try监听异常，catch处理异常，finally处理一定执行的代码
         *
         * c）（使用少）try finally—》
         *
         * 注意点
         * 1)catch可以多个，对应处理不同的异常
         * 2）catch可以直接通过异常的父类处理子类型异常
         * 3）catch的两个异常如果有超类型和子类型的关系，先子类型，再超类型！！！

        c）finally：一定要执行的代码，无论是否异常都会执行
         *
         * ->一般执行的代码：释放资源，关闭流，关闭网络，关闭数据库...