Java异常类和常用类、容器、泛型

一、异常类

异常就是在运行时产生的问题，在java中，把异常封装成了一个类，当出现问题时，就会创建异常类对象并抛出异常相关的信息（如详细信息，名称以及异常所处的位置）。

Throwable类    所有错误跟异常类的父类。（在 java.lang包中）

        Error类     与Exception的平级的类，用来表示Java中存在的严重错误，只能通过修改代码来解决问题。

        Exception类      异常类及其子类都是继承自Throwable类，用来表示java中可能出现的异常，并且合理的处理这些异常。

               RuntimeException类  是运行异常类，继承自Exception类，它以及它的子类只能在运行过程中存在，当出现时，只能修改源代码，此异常无法处理。

异常产生过程

1. 运行或编译时产生异常
2. 创建异常类的对象
3. 声明异常类
4. 将异常类对象传给调用者（main()方法）处理
5. 调用者无法处理，再将异常类对象传给jvm虚拟机
6. jvm虚拟机将异常类的信息（名称、详细信息、异常所处的位置）打印在屏幕上，并且停止程序的运行

处理机制

• throw   用来抛出一个指定的异常                

        声明异常格式：修饰符 返回值类型 方法名称 （参数）throws 异常1名称，异常2名称{}             

        使用格式：throw new 异常类名（参数）

• try：该代码块中编写可能产生异常的代码。

• catch：用来进行某种异常的捕获，实现对捕获到的异常进行处理。
• finally：有一些特定的代码无论异常是否发生，都需要执行。另外，因为异常会引发程序跳转，导致有些语句执行不到。而finally就是解决这个问题的，在finally代码块中存放的代码都是一定会被执行的。

​public static int a(int j,int i) throws Exception
//声明异常格式：修饰符 返回值类型 方法名称 （参数）throws 异常1名称，异常2名称{}     
    {
        return i/j;
}

try {
    //需要被检测的语句。
}
catch(异常类 变量) { //参数。
    throw new a();//使用格式：throw new 异常类名（参数）
 //异常的处理语句。
}
finally {
     //一定会被执行的语句。
}

​

常见异常

运行时异常RuntimeException

1.Exception in thread “main” java.lang.NullPointerException 空指针异常
原因: 获得到对象本身是一个null 我们继续使用空对象调用其他方法 就会导致空指针异常

2.Exception in thread “main” java.lang.ArrayIndexOutOfBoundsException： 数组下标越界             原因: 数组下标超过了界限

3.Exception in thread “main” java.lang.ArithmeticException: / by zero 算数异常
原因: 分母为0报出异常

4.Exception in thread “main” java.lang.ClassCastException 类型转换错误
原因: 把某一个类强制转换成其他类 这个时候就会出现类型转换错误
​5.Exception in thread “main” java.lang.NumberFormatException 数字格式错误
原因：一般在字符串和数字类型进行转换的时候 格式错误导致的异常

检查时异常

InterruptedException /IOException

二、常用类

1.Object类

是所有类的父类，所有类都默认继承了Objet类。

• hashcode（）    返回该对象的哈希码值   格式：public int hashCode()
• toString（）       返回该对象的字符串表示 格式：public String toString()
• getClass（）     返回引用中存储的实际对象类型 格式：public final Class<?> getClass()
• equals()             比较两个对象是否相等   格式：public boolean equals(Object obj)

2、包装类

包装类(Wrapper Class),8种基本数据类型分别对应一个包装类,包装类均位于java.lang包

基本数据类型	包装类
byte	Byte
boolean	Boolean
short	Short
char	Char
int	Integer
long	Long
float	Float
double	Double

3.String类和StringBuffer类和Stringbuilder类

• String类

        String 类代表字符串。Java 程序中的所有字符串字面值都作为此类的实例实现。字符串是常量；它们的值在创建之后不能更改。

• StringBuffer和Stringbuilder类

        线程安全的可变字符序列。之前String是不可变的序列，那么StringBuffer即是可变的序列         StringBuilder类和StringBuffer类用法差不多。

4.Arrays类

        该类包含用于操作数组的各种方法（例如排序和搜索）。
常用方法：
遍历：public static String toString(int[] a)
排序：public static void sort(int[] a)
查找：public static int binarySearch(int[] a,int key) 二分查找，查找前必须排序

三、容器

数据容器主要分为了两类：

Collection: 存放独立元素的序列。

                ArrayList,LinkedLsit,Vector,Stack

　　　　  TreeSet,HashSet,LinkedHashSet

Map：存放key-value型的元素对。

　　  HashMap,LinkedHashMap,WeakHashMap, TreeMap,                 HashTable, IdentityHashTable

容器接口（Collection，Map，Iterator）

（1）collection接口

* boolean add(Object obj): 添加对象，集合发生变化则返回true
　　　　* Iterator iterator()：返回Iterator接口的对象
　　　　* int size()
　　　　* boolean isEmpty()
　　　　* boolean contains(Object obj)
　　　　* void clear() 　　　 
       * <T> T[] toArray(T[] a)

 （2）Map接口

* Object get（Object key）
　　　　* Object put（Object key, Object value）
　　　　* Set keySet() : returns the keys set      Set<K> keySet()
　　　　* Set entrySet(): returns mappings set    Set<Map.Entry<K,V>> entrySet()
　　　　* containsKey()
　　　　* containsValue()

（3）Iterator接口

　* Object next()
　　　　* boolean hasNext()
　　　　* void remove()

子接口

（1）List（有顺序可以重复，有顺序所以操作时可以在方法中加入索引参数，如下：）

* boolean add(E element)
　　* void add(int index, E element) 
　　* E set（int index, E element）
　　* E get(int index);

(2）Set（无顺序不可以重复，无序因而不能通过索引操作对象）

(3）ListIterator（Iterator for List，List是双向表，因而在Iterator上增加了一些新的方法，允许traverse the List in either direction）

　　* boolean hasPrevious();
　　* E previous();
　　* int previousIndex()

(4) SortedMap

public interface SortedMap<K,V>extends Map<K,V>
　　* Comparator comparator()
　　*　Object firstKey()
　　*　Object lastKey()

(5)SortedSet　 

　　主要用于排序操作，实现此接口的子类都是排序的子类

public interface SortedSet<E>extends Set<E>
　　* Comparator comparator()
　　*　E first() ：返回第一个元素
　　*　E last() 
   *  SortedSet<E> headSet(E toElement): 返回less than toElement
　　*  SortedSet<E> tailSet(E fromElement)
　　*  SortedSet<E> subSet(E fromElement) 

抽象容器类

使用抽象容器类可以方便的定义类，而不用在每个类中都实现容器接口container 中的所有的方法

 * AbstractCollection  　　　 public abstract class AbstractCollection<E>extends Objectimplements Collection<E>
 * AbstractList              public abstract class AbstractList<E>extends AbstractCollection<E>implements List<E>
 * AbstractSet   　　　　　　  public abstract class AbstractSet<E>extends AbstractCollection<E>implements Set<E>
 * AbstactMap                public abstract class AbstractMap<K,V>extends Object implements Map<K,V>
 * AbstractSequentialList    public abstract class AbstractSequentialList<E> extends AbstractList<E>

 四、泛型

Java 泛型是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数。

泛型标记符：

• E - Element (在集合中使用，因为集合中存放的是元素)
• T - Type（Java 类）
• K - Key（键）
• V - Value（值）
• N - Number（数值类型）
• ？ - 表示不确定的 java 类型

泛型有三种使用方式，分别为：泛型类、泛型接口、泛型方法

泛型类

泛型类型用于类的定义中，被称为泛型类。通过泛型可以完成对一组类的操作对外开放相同的接口。最典型的就是各种容器类，如：List、Set、Map。

泛型类的最基本写法

lass 类名称 <泛型标识：可以随便写任意标识号，标识指定的泛型的类型>{
  private 泛型标识 /*（成员变量类型）*/ var; 
  .....

  }
}
 

定义泛型方法的规则：

• 所有泛型方法声明都有一个类型参数声明部分（由尖括号分隔），该类型参数声明部分在方法返回类型之前（在下面例子中的 <E>）。
• 每一个类型参数声明部分包含一个或多个类型参数，参数间用逗号隔开。一个泛型参数，也被称为一个类型变量，是用于指定一个泛型类型名称的标识符。
• 类型参数能被用来声明返回值类型，并且能作为泛型方法得到的实际参数类型的占位符。
• 泛型方法体的声明和其他方法一样。注意类型参数只能代表引用型类型，不能是原始类型（像 int、double、char 等）。

泛型接口

泛型接口与泛型类的定义及使用基本相同。泛型接口常被用在各种类的生产器中

//定义一个泛型接口
public interface Generator<T> {
    public T next();
}

泛型方法

泛型类，是在实例化类的时候指明泛型的具体类型；

泛型方法，是在调用方法的时候指明泛型的具体类型 。

/**
 * 泛型方法的基本介绍
 * @param tClass 传入的泛型实参
 * @return T 返回值为T类型
 * 说明：
 *     1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
 *     2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
 *     3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
 *     4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型。
 */
public <T> T genericMethod(Class<T> tClass)throws InstantiationException ,
  IllegalAccessException{
        T instance = tClass.newInstance();
        return instance;
}

泛型上下边界

在使用泛型的时候，我们还可以为传入的泛型类型实参进行上下边界的限制，如：类型实参只准传入某种类型的父类或某种类型的子类。

为泛型添加上边界，即传入的类型实参必须是指定类型的子类型