8.6笔记

复习{
 异常体系:
   为什么 java中要有 异常机制? 
    因为程序在运行时 ，有可能会出现一些 未予期 的问题，我们可以通过 java中提供的处理异常的
    方式来 捕获 或 抛出异常; 从而达到 解决的目的
    它本质是不能 解决问题， 只是给我们提供解决问题的信息,根据提供的信息，能快速锁定，找到问题所在
    
   如果没有java的异常，那么程序出现错误 就会由 jvm虚拟机 解决, 有了异常机制 就可以提前捕获异常信息;
   
java异常体系: 
    Throwable: 类
      |-- Error:      程序崩溃 ，程序员解决不掉
               |-- VirtualMachineError 虚拟机错误
                     |-- StackOverflowError: 栈溢出错误    方法的相互调用 
                     |-- OutOfMemoryError: 内存泄露了错误    执行的代码 没有 可用的资源的时候
                     
      |-- Exception:  程序员能解决掉的问题
               |-- IOException:  I/O流 异常     
               |-- RuntimeException:  运行时 异常
                        |-- ArthmeticException 数学异常
                        |-- NullPointerException 空指针异常
                        |-- IndexOutofBoundsException 下标越界异常
                                ArrayIndexOutofBoundsExcpetion 数组下标越界
                                StringIndexOutofBoundsException 字符串下标越界
                        |-- NumberFormatException 数字格式化异常
                        |-- IllegalArgumentException 非法参数异常
                        |-- ClassCastException 类型转换异常

    CheckedException: 受检查异常   javaAPI是 没有类          
               
 java中处理异常的方式:
   1. 捕获异常 
              try{  
              
                   有可能出现异常的代码
              
              }catch(异常类型 e){  可以是 多个 ， 用| 分开， 变量名公用 1 个  e ， 异常类型必须同级 
                   打印输出信息
              }catch(异常类型 e){  可以是 多个 ， 用| 分开， 变量名公用 1 个  e ， 异常类型必须同级 
                   打印输出信息
              }      必须是从小到大的排列            
         
   2.抛出异常
           用到了  throw 关键字  抛出异常 throw new 异常类型
               throws  声明异常     throws 异常名;
                     
    public void eat()throws Exception,NullPointerException{  声明异常
    
        throw new Exception();  抛出异常
    }
-----------------------------------------------------------------------------------------
1.try...catch块儿 拓展: 
     
     普通 语法结构: 
           try{
                
                有可能出现异常的代码
                
           }catch(异常类型 e){
                 e.printStackTrace();
           }
           
    拓展结构:
          try{
               
               有可能出现异常的代码 
               
          }catch(异常类型 e){
              e.printStackTrace();
          }finally{
               最终的  , finally块儿 ， 这里的代码 正常情况下 无论如何都会执行
          }            
     
     特殊情况: 
      1.在进入到 try...catch 块儿 之前 就出现异常了 ， 那么finally 块儿 就不会执行
      2.在try块儿中 ，执行System.exit(0); 强制推出 ， 这样你的finally块儿也不会执行
      
      try{
               就是用来关闭资源的 ,没有任何处理异常的能力, 可以写普通代码
      }finally{    
           一般用于关闭资源 , 连接数据库后， 或使用 IO流 读取 文件后
           ips.close();
      }
      
 return关键字有两个功能: 
  1.代表方法的返回值
           public int a(){
               return 10;
           }
           
  2.终止程序     
        if(true){
            return;
        }
     
注意事项: 
  finally 块儿中 不要加 return 关键字，加了返回值会出现什么情况? 
            1. 会覆盖返回值
         2. 会出现异常丢失问题   
---------------------------------------------------------------------------------
自定义异常: 
    什么情况下 会有自定义 异常?
      java本身的 异常体系 不能满足我们的 需求的时候 ，需要我们拓展自己的异常
      
   如何做的自定义异常? 
     掌握Exception, 这个类 没有final修饰 ，所以我们可以定义一个类 继承Exception这个类
====================================================================================
集合框架: 
  1.变量:  是用来存储单个元素的  ， 会在栈中开辟多个 空间存储
  2.数组:  是用来存储多个元素的  ,          
           特点: 数组的长度一旦确定，不能改变
                   数组必须存储相同数据类型
                   数组必须通过下标来获取元素
                   数组可以存储重复元素
                   
      byte[] , int[], short[] ,long[] , char[] , boolean[] , float[] , double[];             
                   
  3.集合框架: 是相当于动态的容器  
            优点: 自动扩容
                     可以存出任何数据类型
                   有的容器是通过下标来获取， 有的不是通过下标来获取元素
                   有的容器可以存储重复元素， 有的不可以存储重复元素  

是java提供给我们的一套集合框架体系:   包括 接口 和 类 ， 接口的作用是 用来设计程序功能的
   Iterable: 接口 --->  可迭代的   ,在循环处 我们了解过
             方法: iterator();  迭代
   
       |-- Collection: 接口     ---> 集合框架的顶级接口      ,  特点： 单值存储，
                      Collection 下的子接口 ，有的可以存储重复数据，有的不可以存储重复数据
                                    有的是 有序的， 有的是 无序的， 顺序只的是 输入顺序 和输出顺序 不一致
                 |-- List: 接口   有序的， 可以重复的 ， 允许存储为null  ， 多个
               |-- Set: 接口    无序的 ， 不可重复的 ， 允许存储为null ，只能 是一个
               |-- Queue: 接口   
                       |-- Deque 接口:
   独立接口: 
   Map: 接口      双值存储
        map.put(1,"张三");
   
    
 Collection的常用方法: 
      方法: 
           1.add();  向集合中添加一个元素
           2.clear(); 删除所有元素
         3.contains(Object o); 判断次容器中 是否包含指定元素， 如果包含返回true ，否则 返回false
        4.equals(Object o);
        5.isEmpty(); 判断当前容器 是否是空的
        6.iterator();
        7.remove(Object o); 删除指定 对象
        8.size() 返回当前容器中的大小
        9.Object[]  toArray(); 将一个集合编程 对象数组
        
      List接口的 底层实现方式就是 对象数组， 它的实现类 就是把 数组进行了封装，保证 动态效果
      
              add(int index, E element); 在指定 位置上 添加元素
              get(int index); 获取指定下标位置上的元素
              indexOf(Object o); 返回此对象在容器中的位置
              lastIndexOf(Object o); 返回此对象在容器中最后出现的位置
              remove(int index); 根据索引删除元素
              remove(Object obj);  根据对象删除
              set(int index, E element); 替换，将指定位置上的元素，替换为新的
              size(); 返回集合中有效的元素个数
              subList(int fromIndex, int toIndex); 截取集合中的元素
              
    ArrayList是List接口的实现类: 
           底层代码 是 用Object[] 数组做的 ，封装了数组
           
          new ArrayList();      
          

    
    
 
 
   
 

}