异常处理和泛型

异常

• 处理异常的格式

public static void main(String[] args) {
    // 可能会出异常的代码，需要使用try来处理，try不能单独使用，必须配合finally或catch使用
    try {
        int i = 10 / 0;
        System.out.println(i);
    } catch(Exception e) {  // 捕获异常
        // 获取异常信息
        String message = e.getMessage();
        System.out.println("异常信息：" + message);
        // 一定要打印e.printStackTrace()
        e.printStackTrace();
    } finally {  //最终都会执行的（当有必须程序需要处理时）
        System.out.println(111);
    }
    System.out.println(222);
}
 
# 运行结果
异常信息：/ by zero
111
222
 

• 抛出异常

static void f1() throws Exception {
    try {
        int i = 10/0;
        System.out.println(i);
    } catch (Exception e) {
        // 捕获到异常后抛出异常，丢到方法名的后面
        throw new Exception();
    }
}
 
// f1()方法抛出了1个异常，main方法中调用时就需要main方法处理异常
public static void main(String[] args) throws Exception {
    // 将异常抛给他的父级处理
    f1();
}
 

• 捕获多个异常时，因为程序是从上往下运行，所以小的异常类型必须放在前面

static Integer f(String str) {
    try {
        return Integer.parseInt(str);
    } catch (ArrayIndexOutOfBoundsException e) {
        System.out.println("捕获到异常");
    } catch(NumberFormatException e) {
        e.printStackTrace();
    } catch (ClassCastException e) {
        System.out.println("类型转换");
    } catch (Exception e) {
        System.out.println("最大的异常");
    }
    return 0;
}
 
// 测试
public static void main(String[] args){
    try {
        int f;
        f = f("111a");
        System.out.println(f);
    } catch (Exception e) {
        e.printStackTrace();
    }
}
 

• 自定义异常

// 自定义的异常类需继承Throwable、Exception、RuntimeException
public class MyException extends RuntimeException {
    // 实现序列化id
    private static final long serialVersionUID = 1L;
 
    MyException() {
        super();
    }
 
    MyException(String msg) {
        super(msg);
    }
}
 
public class Test {
    static void f(String str) throws MyException{
        try {
            int i = Integer.parseInt(str);
        } catch (MyException e) {
            System.out.println("111");
            throw new MyException("类型转换错误");
        }
    }
 
    public static void main(String[] args) {
        f("a");
    }
}

• throw和throws的区别：
  throw在方法体内，表示抛出异常的动作
  throws表示可能会抛出的异常类型

• 异常处理的方式：try-catch或throws
  try放可能出现异常的代码，catch捕获后处理；throws在方法头部抛出异常，交给方法的调用者处理

泛型

• 集合中使用泛型

// 给集合指定泛型，那么该集合中只能存入该类型的数据
public static void main(String[] args) {
    List<String> list = new ArrayList<String>();
    list.add("adc");
}
 

• 方法中使用泛型

// 格式：访问修饰符 [static] <T> void  方法名(T  t){  方法体}    //可传多个参数
public class Test {
    // 泛型方法
    public static < E > void printArray( E[] inputArray ) {
        // 输出数组元素
        for ( E element : inputArray ){
            System.out.printf( "%s ", element );
        }
        System.out.println();
    }
}
 

• 判断是否是泛型方法

# 格式：访问修饰符 [static] <T> void 方法名(T t){方法体}
public void f(){      # 普通方法
}
public T f() {     # 类泛型化后的方法
}
public void f(T t) {       # 普通方法，传入的参数可以是泛型
}
public <T> void f(T t){        # 泛型方法
}
 

• 类中使用泛型

public class Box<T> {
    private T t;
 
    public void add(T t) {
        this.t = t;
    }
 
    public T get() {
        return t;
    }
 
    // 测试：main方法中new一个泛型类的对象，调用其中的方法
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();
 
        integerBox.add(new Integer(10));
        stringBox.add(new String("菜鸟教程"));
 
        System.out.printf("整型值为 :%d\n\n", integerBox.get());
        System.out.printf("字符串为 :%s\n", stringBox.get());
    }
}
 

• 接口中使用泛型，参考

public  interface Interface01 <M>{
    public  abstract void f1(M m);
}
 
public class Interface01impl<M> implements Interface01<M>{
    @Override
    public void f1(M m) {
        System.out.println(m);
    }
}
 
public class Interface02impl implements Interface01<String> {
    @Override
    public void f1(String s) {
        System.out.println(s);
    }
}
 

• 类型通配符 ？

public class Test {
    // 为List集合指定类型统配符号
    public static void getData(List<?> data) {
        System.out.println("data :" + data.get(0));
    }
 
    // 若是使用泛型，则集合只能存入一种类型
    // 若是使用通配符，则可以接受任意不确定类型
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
 
        name.add("icon");
        age.add(18);
        number.add(314);
 
        getData(name);
        getData(age);
        getData(number);
    }
}
 

• 泛型边界

// 格式：<? extends ClassName>
// 为通配符指定一个类型，则该集合只能接受这种类型
public class Test {
    public static void getUperNumber(List<? extends Number> data) {
        System.out.println("data :" + data.get(0));
    }
 
    public static void main(String[] args) {
        List<String> name = new ArrayList<String>();
        List<Integer> age = new ArrayList<Integer>();
        List<Number> number = new ArrayList<Number>();
 
        name.add("icon");
        age.add(18);
        number.add(314);
 
        //getUperNumber(name);//1
        getUperNumber(age);//2
        getUperNumber(number);//3
    }
 
}
 

• 超类型通配符

// 父类
public class Fruit {
}
 
// 子类
public class Apple extends Fruit {
}
 
// 使用超类型通配符
// Apple、Orange类继承了Fruit类，使用超类型通配符可存入父类和子类的类型
// 格式：<? super 父类>
public class Test {
    // 1. 声明泛型方法
    static <T extends Apple> void f(T t) {
    }
 
    public static void main(String[] args) {
        // 2. 调用泛型方法；
        f(new Apple());
	f(new Orange());
 
	// 报错：<? extends ClassName> 不能往里存，只能取数据
        List<? extends Apple> l = new ArrayList<Apple>();
        // l.add(new Apple());
        l.add(null);
        System.out.println(l.get(0));
 
        // **超类型通配符使用方式：集合中添加当前类及其子类**
        List<? super Fruit> l2 = new ArrayList<Fruit>();
        l2.add(new Orange());
        l2.add(new Fruit());
        l2.add(new Apple());
    }
}
 

• 总结

# 泛型边界：T的类型只能是当前ClassName或ClassName的子类        
<T extends ClassName>
 
# 通配符? 不能存数据，只能取数据，具有任何从ClassName继承的类型的列表
<? extends ClassName>
# 超类型通配符，声明通配符是有某个特定类的任何基类来界定的
<? super ClassName>
# 无界通配符
<?>
# 表示类型的上界，表示参数化类型的可能是T 或是 T的子类；即类型只能是T或T的子类
<? extends T> 
# 表示类型下界，表示参数化类型是此类型的超类型（父类型），直至Object；即类型只能是T或T的父类
<? super T>