JavaSE复习总结(四)

朱雀 2022-09-25 06:14 176阅读 0赞

## 异常处理 ##

**异常**：  
程序在执行过程中出现的非正常情况。

异常危害，程序在执行过程中一旦出现异常，后面的语句没有机会执行，会导致程序崩溃，提前结束。

**异常是在栈中以对象的形式进行抛出。**

**异常对象是Throwable的子类对象，异常出现，当前方法不能继续执行，提前返回，并且把异常抛给调用者，对调用者产生破坏性影响。**

异常分类：
        1)受检异常：程序执行过程中必须对其进行处理的异常
            Exception及其子类(除RuntimeException及其子类)
        2)非受检异常：程序中可以对其不进行处理的异常
            Error及其子类(非常严重)
            RuntimeException及其子类(非常轻微)

异常处理：
        1)捕获 try-catch(finally)
            try {
                可能抛出异常的语句块      
            } catch(异常类型1 对象) {
                 处理异常对象;  
                }
              catch(异常类型2 对象) {
                 处理异常对象;
            } ……
            finally {
                一定会执行的语句，通常做一些释放不在GC区的资源的操作     
            }
        对于 try-catch(finally) 他们可以自行组合，但是必须有try 
                组合 : try catch
                 try catch finally 
                 try finally
        2)抛出
            在方法声明中使用throws 异常类型1, 异常类型2 ... 在方法体中使用了throw 异常对象; 
            方法中执行throw操作是真的抛出操作
        3)捕获再抛出
            在方法中先捕获一个已知异常对象, 再把这个异常对象包装成别的异常对象(一般是包装成自定义异常), 再抛出别的异常对象.
            主要是对异常进行再包装，提高可读性
    处理方式的选择：
        被调用的方法尽可能抛出异常
        处于栈底的方法尽可能捕获异常

**方法覆盖条件 :**  
1) 方法签名一致  
2) 访问控制修饰符子类大于等于父类  
3) 抛出的受检异常子类要小于等于父类

**自定义异常：**

/**
     * 自定义异常
     * 实现人工抛异常的操作：
     * 1.创建自定义异常类
     * 2.在语句块中使用throw实现抛出的动作(同时在方法签名中使用throws声明(声明可以是异常的父类，若声明多个异常可以用,分开))
     * 3.在main中对异常进行处理，try-catch(必须处理不然抛给虚拟机，很危险)
     */
    @SuppressWarnings("serial")
    public class IlleagalNumberException extends Exception{
        
    
        public IlleagalNumberException(String message) {
            super(message);
        }
        public IlleagalNumberException(Exception cause) {
            super(cause);
        }
    }

## 常用类 ##

**包装类:**  
把基本数据类型包装成对象类型.

byte        Byte
    short       Short
    char        Character
    int         Integer
    long        Long
    float       Float
    double      Double
    boolean     Boolean

**这8中基本类型对于装箱都有两个参数不同构造器，一个参数是基本数据类型，一个是字符串类型**

装箱 : 使用构造器(基本数据类型)
         构造器(字符串类型)
    两种 : 手工装箱, 使用构造器
         自动装箱, 包装类 引用 = 基本数据值;

拆箱两种方式:
        手工拆箱 : 引用.xxxValue(); 
        自动拆箱 : 基本数据类型 变量 = 引用;

字符串<----->基本数据类型
    字符串到基本数据类型转换 :
        包装类.parseXxx(String); 
    基本数据类型到字符串
        基本数据值 + ""
        String.valueOf(基本数据值)
        包装类.toString(基本数据值)

**字符串 :**  
String :  
**内容不可改变的Unicode字符序列. 任何对String内容的修改都将导致产生新的字符串对象.**

构造器 :
            String(String s) 
            String(char[] arr)  
            String(char[] arr, int offset, int count) ; 从下标offset开始,总共count个字符

常用方法：
    返回类型  方法名
    int length();   //获取字符串的长度
    char charAt(int index); //获取指定索引的字符
    int indexOf(String child); indexOf(String child, int start) 
    //Returns the index within this string of the first occurrence of the specified character.
                                            //其重载方法是从start开始    （这两个都是左--->右）
    int lastIndexOf(String child) lastIndexOf(String child, int start)  //这两个都是右--->左
    String substring(int beginIndex, int endIndex); endIndex-beginIndex个字符  //获取子串[beginIndex, endIndex)
    String substring(int beginIndex)  //获取子串[beginIndex, 最后（length）)
    boolean startsWith(String child), boolean endsWith(String child) //Tests if this string starts with the specified prefix.
                                                   //Tests if this string ends with the specified suffix.
    String trim();  //去除字符串中的空白字符
    char[] toCharArray();   //将字符串转化为字符数组
    String[] split(String child)    //切割器，以child为切割位，并返回String(字符串)数组
    String toUpperCase(), String toLowerCase()  //将字符串中的所有字符变成大写/小写
    String replace(char oldCh, char newCh); String replaceAll(String oldStr, String newStr); //对字符串中的元素进行替换
    String concat(String str);  //连接字符串
    boolean contains(String child); //是否包含子串

对于String的截取，找索引，其中的开始，结束--->遍历的字符一般都是包括开始索引，不包括结束索引
        GC区和常量区保存String字符串：new在GC，字符串常量在常量区
    
        StringBuilder : 效率高, 线程不安全
        StringBuffer : 效率低, 线程安全
            内容可以改变的Unicode字符序列
        以上两个类中的方法全部都一样
            返回值 方法名
            对象自身 append(...); 可以追加任意内容
            对象自身 insert(int index, ...)
            对象自身 delete(int beginIndex, int endIndex);

日期相关类  
Math类

## 集合 ##

**Collection : 存放无序可以重复单个对象—>解决批量对象的存储问题**

主要方法：
        boolean add(E e);   //添加元素
        boolean remove(E e);    //移除元素
        int size(); //集合的长度
        boolean contains(E e); //判断集合中是否包含元素e
        void clear();   //移除集合中的所有元素
        boolea isEmpty();   //判断集合是否为空
        Iterator iterator();    //获取迭代器

子接口：
    Set<E> : 存放无序不可重复单个对象**
    (重复的标准)：equals方法返回true，hashCode方法返回值一样(若是自定义类没有重写这两个方法，不能达到去重的目的)
        HashSet 底层是数组，使用哈希算法实现的Set集合 (数据存储依据哈希算法存储)
        优点：插入效率高，删除，检索效率高。缺点，对内存的需求大。
        TreeSet 基于树实现的Set集合(数据存储依据红黑树) --->若是自定义类，或者存储对象实现了Comparable接口中的compareTo()方法，可以实现自然排序
        (去重不在依据equals方法和hashCode方法，依据compareTo，返回0，代表重)
        linkedHashSet

List<E> : 存放有序可重复的单个对象(这里的有序和无序指的是添加顺序)
        void add(int index, E e); // index不可以越界 大于等于size也不行 //添加元素
        E set(int index, E e);  //修改元素
        E remove(int index);    //移除元素
        E get(int index);       //获取指定位置的元素
    
        ArrayList 使用数组实现的List集合 线程不安全   
        LinkedList 基于链表实现的List集合
        Vector 使用数组实现 线程安全

集合的遍历:
            增强型for循环
            迭代器
                使用 : 要在使用时才获取, 在目标集合对象上调用iterator()
                询问和迭代 : while (迭代器.hasNext()) {
                    元素 = 迭代器.next(); // 返回当前指针的下一个元素, 返回后再把指针向下移动           
                }

Map<K, V> : 存放具有映射关系的两个对象 key-value (可以存储任意具有映射关系的对象，例如：对象属性变量-值，标号-对象)
        使用set集合来保存key，保证键的不可重复性，value可以任意使用集合保存
        Map对象所属的类须重写equals和hashCode方法
        V put(K key, V value); //添加元素   若是键相同，老值会被覆盖
        int size();     //集合长度
        V get(K key);   //获取指定key对应的value
        Set<K> keySet(); //获取所有key值保存在set集合中
    
        实现类：
            HashMap底层利用hash算法实现对键值对的存储。 
            允许使用null键和null值
    
            TreeMap底层利用红黑树实现对键值对的存储
            TreeMap中key内部实现了自然排序，因此存储的对象必须实现Comparable接口中的compareTo(Object o)方法
            TreeMap中去重也是利用compareTo(Object o) 
    
            Hashtable子类--->Properties类用于处理配置文件(配置文件在当前工程中创建 (#是注释))
            Properties中的key-value都是String型
            存取数据时，建议使用setProperty(String key,String value)方法和getProperty(String key)方法
            对象.load(文件)     //加载文件
    
            LinkedHashMap是HashMap的子类
    
    Map集合遍历：
        1.获取key ----Set<K> keySet()
        2.利用key找对应的value----V get(K key)
    
    工具类：Conllections
    主要方法：
    sort(List<T> list)  排序
    shuffle(List<?> list) 打乱顺序
    reverse(List<?> list)  反转集合
    max
    min
    
    其中sort,shuffle,max,min需要实现Comparable接口中的compareTo(Object o)方法

## 泛型 ##

泛型 
    集合类中的元素使用Object类型，以允许不同的添加和获取类型。当获取集合中所需对象时，必须进行强制类型转型。
    
    泛型：属于编译时技术，以<>形式呈现，<>中约束了集合所能存储的对象类型。这样在获取集合对象时不必在进行强制类型转换。
    同时提供了编译时类型安全检查。
    
    泛型的好处，保证集合中类型安全，并且读取数据更为方便。1.5以后加入的新特性。
    
    泛型的使用：在集合中进行使用
               把一个集合中的内容限制为一个特定的数据类型，这就是generics背后的核心思想。
               自定义泛型
               泛型方法
               泛型接口

泛型类的特点：
    1.对象实例化时不指定泛型，默认为：Object。
    2.泛型不同的引用不能相互赋值。
    3.加入集合中的对象类型必须与指定的泛型类型一致。
    4.静态方法中不能使用类的泛型。(类的泛型属于对象，静态方法和类级别一致)
    5.如果泛型类是一个接口或抽象类，则不可创建泛型类的对象。(接口和抽象类不能实例化)
    6.不能在catch中使用泛型
    7.从泛型类派生子类，泛型类型需具体化

泛型方法：
    在返回值类型前面加<类型>，同时要在形参中带上类型信息
    如果泛型方法中的泛型和类中的一样，则会屏蔽类中的泛型。

泛型和继承：
    如果B是A的一个子类型（子类或者子接口），而G是具有泛型声明的类或接口，G<B>并不是G<A>的子类型！
    比如：String是Object的子类，但是List<String >并不是List<Object>的子类。
    泛型和继承体系没有关系

通配符： ?
    比如：List<?> ,Map<?,?>
    List<?>是List<String>、List<Object>等各种泛型List的父类。
    但是这种通配符只用于只读访问。
    利用通配符可以设置一个公共访问的方法，用于访问不同种类型的集合。
    
    读取List<?>的对象list中的元素时，永远是安全的，因为不管list的真实类型是什么，它包含的都是Object。
    写入list中的元素时，不行。因为我们不知道集合的元素类型，我们不能向其中添加对象。唯一的例外是null，它是所有类型的成员。

有限制的通配符：
    <?>允许所有泛型的引用调用
    有限制的通配符：
    举例：<? extends Number>     (无穷小 , Number]只允许泛型为Number及Number子类的引用调用
          <? super Number>      [Number , 无穷大)只允许泛型为Number及Number父类的引用调用
          <? extends Comparable>只允许泛型为实现Comparable接口的实现类的引用调用
    
    利用泛型可以对一个家族的类对象统一管理。