泛型 异常

• 泛型

 

• 在类中使用泛型

public class TestAM<T> {

}

泛型只有在调用的时候才能确定泛型的具体类型

常用的有 : K V E T U S

可以这么写

    T t;

• 在方法中使用泛型

    public T test(T t){
        System.out.println(t.toString());
        return t;
    }

• 规定泛型的继承关系

1. new E();是不被允许的
2. 在编译的时候还不能确定是什么类型的
3. 可能压根就没有他的构造方法

    public <E extends P> E test1(E e) {

        return e;
    }

 

package day08;

public class TestAM<T> {
    public T test(T t){
        System.out.println(t.toString());
        return t;
    }
    
    public <E extends P> E test1(E e) {
        return e;
    }
    
    public static void main(String[] args) {
        S s = new S();
        P p = new P();
        new TestAM().test1(s);
        new TestAM().test1(p);
        
        //Object obj = new Object();
        //new TestAM().test1(obj);
        //就不可以,因为明确规定了必须是继承自P
        
        
    }
}

 

 

 

 

 

!!!!!!!!!!!!注意!!!!!!!!!!!!!!

这里子类继承自父类

可以抛出更加精确的异常

但是不可以抛出比父类更加笼统的异常

例如这里

父类抛出了IOException

子类可以抛出FileNotFoundException,但不可以抛出Exception

 

public class TestAM1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        list.add("");
        list.add(new Object());
        Object obj = list.get(0);
        String str = (String)list.get(1);
        
        //对集合中存储的内容进行规范
        List<String> list1 = new ArrayList<String>();
        list1.add("");
        //指定泛型后,集合只能存放指定类型的对象
        String str1 = list1.get(0);
        
        Map<String , Object> map = new HashMap<String , Object>();
        
    }
}

• 异常(Exception)

 在程序编译或者运行的时候出现的异常情况

 

异常分为检查异常和运行时异常

• 检查异常

1. 在编码过程中必须处理的异常
2. Exception的子类(非RuntimeException的子类)全是检查性异常

• 运行时异常

1. 编码时可以不处理,运行时可能会抛出的异常

一旦抛出异常(未处理),程序就会中断,程序就会退出

 

 

粉红色的是受检查的异常(checked exceptions)

其必须被 try{}catch语句块所捕获,或者在方法签名里通过throws子句声明.

受检查的异常必须在编译时被捕捉处理,命名为 Checked Exception 是因为Java编译器要进行检查,Java虚拟机也要进行检查,以确保这个规则得到遵守.

绿色的异常是运行时异常(runtime exceptions),需要程序员自己分析代码决定是否捕获和处理,比如 空指针,被0除...

而声明为Error的，则属于严重错误，如系统崩溃、虚拟机错误、动态链接失败等，这些错误无法恢复或者不可能捕捉，将导致应用程序中断，Error不需要捕捉。

常见的一些异常:

除数为零的异常:

        int a = 12/0;//java.lang.ArithmeticException: / by zero
        System.out.println(a);

文件未找到的异常:

和程序之外的东西打交道基本都会抛出检查性异常

throws FileNotFoundException

 

处理异常 异常不一定会发生

尝试运行代码--避免抛出异常终断程序

    static boolean find(List list , String str) {
        for(Object o : list) {
            //尝试运行可能抛出异常的代码块,如果抛出异常
            //就会执行捕获对应的异常类型的catch
            
            try {
                if(o.equals(str)) {
                    return true;
                }
            } catch (NullPointerException e) {
                // TODO: handle exception
                continue;
            }
        }
        return false;
    }

 

可能抛出多个异常

最多执行一个catch

执行到一个程序就会中断

    static void tE() {
        //最多执行一个catch
        //执行到一个程序就会中断
        FileInputStream fis = null;//初始化
        try {
            File f = new File("d:\\maven.rar");
            fis = new FileInputStream(f);
            Class.forName("com.easy.Test");
        } catch (FileNotFoundException e) {
            // 若果发生//如果发生FileNotFoundException执行此代码执行此代码
        } catch (ClassNotFoundException e) {
            // 若果发生//如果发生ClassNotFoundException执行此代码执行此代码
        } catch (Exception e) {
            //大异常和小异常
            //Exception必须在FileNotFoundException等之后
            //否则就会爆红
        }finally {
            //任何情况下都会执行的代码块
            //此代码块用来关闭资源
            if(fis != null) {
                try {
                    fis.close();
                } catch (IOException e) {
                    // TODO: handle exception
                    e.printStackTrace();
                }
            }
        }

• 大异常和小异常

1. Exception必须在FileNotFoundException等之后
2. 否则就会爆红

 

!!!!!!!!!!!!注意!!!!!!!!!!!!!!

这里子类继承自父类

可以抛出更加精确的异常

但是不可以抛出比父类更加笼统的异常

例如这里

父类抛出了IOException

子类可以抛出FileNotFoundException,但不可以抛出Exception

 

如果try块中的代码在程序中,确实抛出了异常

FileNotFoundException类型的异常

cache块就会执行这个代码块

这个代码块需要对出现异常的程序运行进行一个补救方案

在程序调试过程中,经常会打印异常的代码

e.printStackTrace();

打印异常的信息

 

自定义异常

小例子:

向列表中添加元素,检查如果出现了同样的元素,就抛出自定义的异常

package day08;

import java.util.ArrayList;
import java.util.List;

public class Util {

    public static <T> T getElement(List<T> list,T ele) {
        int count=0;
        T result=null;
        for(T e:list) {
            if(e.equals(ele)) {
                count++;
                result=e;
            }
        }
        if(count>1) {
            throw new MoreResultException("找到多个结果");
        }
        return result;
    }
    
    public static void main(String[] args) {
        List<String> list=new ArrayList<String>();
        list.add("zhangsan");
        list.add("lisi");
        list.add("wangwu");
        list.add("zhangsan");
        try {
        String str= getElement(list, "zhangsan");
        System.out.println(str);
        }catch(Exception e) {
            e.printStackTrace();
        }
    }
}

自定义异常如下;

package day08;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class MoreResultException extends RuntimeException{

    public MoreResultException() {}
    public MoreResultException(String msg) {
        super(msg);
    }
    List list = new LinkedList();
}