11.泛型与异常

Dasher jensen

于 2022-08-02 14:44:00 发布

阅读量247

点赞数

分类专栏： JAVA学习笔记文章标签： servlet java

本文链接：https://blog.csdn.net/unstoppableyi/article/details/126121365

版权

JAVA学习笔记专栏收录该内容

23 篇文章 0 订阅

订阅专栏

泛型的使用

如果在使用集合时没有限定集合所保存的数据类型，则在代码运行期间容易会出现ClassCastException类转换的异常，通过设置泛型，可以在编译期间发生问题。

可以在类和方法中预支地使用某个未知的类型【在使用类或者使用方法的时候确定类型】；泛型可以在类、接口、方法中进行定义

泛型的作用

1.将运行时期的ClassCastException，转移到了编译时期发现

2.避免类型转换的异常

3. 作为模块化编程，提高代码的复用性，用来编写框架，工具类相当适当；如hibernate，spring；

		// 在使用集合存放数据时没有限定类型，则容易在运行时出现类转换异常ClassCastException
		List<String> list = new ArrayList<String>();
		// 添加//在末尾

例子

厨师类：处理食材的行为；做菜的行为

在类和接口中定义泛型的道理是一样的；

//在接口中使用泛型   <C,F>菱形语法
public interface CookerFace<C,F> {
	public void deal(C c);

	public void cooking(F f);
}

//泛型变量也是一个标识符 
//在运行时没有泛型的概念、在编译的时候已经确定类型【在编程的时候，使用泛型】
public class Cooker<C> {// C是泛指某个类型，不确定   Cooker<C,F>  <C extends SeaFood>可以

	C mainFood;
	
	//在方法中定义泛型  吃饭方法【独立的泛型】<F extends SeaFood>可以
	public <F> void eat(F f) {
		System.out.println("吃" + f.getClass() + "类型的食材");
	}

	// 处理食材的行为
	public void deal(C c) {
		System.out.println("处理" + c.getClass() + "类型的食材");
	}

	// 做菜的行为
	public void cooking(C c) {
		System.out.println("烹饪" + c.getClass() + "类型的食材");
	}

	// 测试代码
	public static void main(String[] args) {
		Cooker<SeaFood> sCooker = new Cooker<>();//泛型为海里游的
		sCooker.cooking(new SeaFood());
		sCooker.eat(new SeaFood());
	}

}

// 海里游的
class SeaFood {

}

// 天上飞的
class skyFood {

}

泛型的通配符

1、?代表是所有泛型的父类，也就是一个通配符

2、可以实现遍历、但是不能添加明确的数据类型、除了null可以

3.？通配符不能在接口和类的泛型定义中使用；

	public static void main(String[] args) {
		// 泛型通配符的使用
		//
		List<Object> list = new ArrayList<>();
		getData(list);
	}

	// 匹配存放任意数据类型的集合
	// public static void getData(Collection<?> coll) {

		System.out.println(coll);
		// 注意：由于使用泛型的通配符，在这里是不能添加数据【类型不确定、没有办法通过编译】
		// coll.add(null);
		// coll.add(1);
	}

泛型通配符的上边界

泛型继承了某个类型？ extends Class

// ? extends Number 匹配 Number本身和Number的子类
 public static void getData(Collection<? extends Number> coll) {// 设定上边界

泛型通配符的下边界

泛型被某个类型所继承（某个类型的父类）？ super Class

	// ? super Number 匹配 Number本身和Number的父类
	public static void getData(Collection<? super Number> coll) {// 设定下边界

总结：泛型无非就是用限定类型、上限（是某个类的子类）和下限（是某个类的父类）

泛型的擦除

//list存放的是Integer的数据
List<Integer> list = new ArrayList<>();
list.add( 12);
list.add(32);
//定义一个没有设置泛型的集合list1中有没有指定泛型?没有
List list1 = list;//丢失了泛型，称为泛型的擦除
//定义一个String类型的集合
List<string> list2 = list1;//List<string> list2表示list2中的数据都是String类型
//由于泛型的擦除，导致原来的泛型丢失，在编译期间没有办法发现类型限定或者类型转换的问题，有可能在运行时出现ClassCastException异常
system.out.println( list2.get(0));

由于泛型的擦除，导致原来的泛型丢失，在编译期间没有办法发现类型限定或者类型转换的问题，有可能在运行时出现ClassCastException异常。

//测试类
public class Test1 {
	public static void main(String[] args) {
		// 
		List<Integer> list = new ArrayList<>();
		//
		list.add(12);
		list.add(132);
		//丢失了泛型，把类型擦除掉了
		List list1 = list;
		System.out.println(list1.get(0));
		// 把擦除了泛型集合赋值给了List<String>
		List<String> list2= list1;
		// get()方法  是返回String类型，但是list中的数据为Integer
		System.out.println(list2.get(0));//ClassCastException
	}

}

泛型的应用

举例：JDBC中的模块设计

//数据库操作的模板工具类
public abstract class DaoUtil<Entity> i
//添加
public abstract boolean insert(Entity en) ;//删除
public abstract boolean delete(int id);//修改
public abstract boolean update(Entity en);//查询所有
public abstract List<Entity> queryAl1();//根据id查询
public abstract Entity queryById(int id);
}

异常机制的使用

一般来说,高级一点的编程语言,如Java, Php,javascript, c#它们都具备一套用来处理, 在程序的运作过程中监视与捕获突发的各种异常的机制,可允许在相应的代码当中编写相应的补救措施/处理办法

使用try...catch捕抓异常

// 如果程序出现异常，没有处理的话，则默认交给虚拟机抛出异常；如果处理了异常，则程序可以继续往下执行
		try {
		System.out.println(arr[0].length());
		} catch (Exception e) {// e保存了出现的异常的对象 比如出现的NullPointerException对象
		// // 处理操作
		 System.out.println("出现了异常！");
		 }

		// 运行时异常
		// 异常的出现 数组索引越界异常、空指针异常、类转换异常
		String[] arr = null;// {"s","sd"};
		try {
			//System.out.println(arr[3].length());
			//
			System.out.println(5/0);
		} catch (Exception e) {
			e.printStackTrace();
			System.out.println(e.getMessage());
			StackTraceElement[] elements = e.getStackTrace();
			//遍历获取每一个 stackTrace的信息
			for (StackTraceElement stackTraceElement : elements) {
				System.out.println(stackTraceElement.getClassName());//出现在哪个类
				System.out.println(stackTraceElement.getMethodName());//出现在哪个方法
				System.out.println(stackTraceElement.getLineNumber());//出现在哪一行代码
			}
		}

异常的体系架构

错误

Error错误，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致应用程序中断。通常应用程序无法处理这些错误，因此应用程序不应该试图使用catch块来捕获 Error对象。在定义该方法时，也无须在其throws子句中声明该方法可能抛出 Error及其任何子类。下面看几个简单的异常捕获例子。

误差错误，一般是指与虚拟机相关的问题，如系统崩溃、虚拟机错误、动态链接失败等，这种错误无法恢复或不可能捕获，将导致应用程序中断。通常应用程序无法处理这些错误，因此应用程序不应该试图使用捕获块来捕获错误对象。在定义该方法时，也无须在其抛出子句中声明该方法可能抛出错误及其任何子类。

异常

可以通过trycatch进行捕抓，或者使用throw进行异常的抛出

try{

}catch(异常类型 e){

}

Checked异常和RumTime异常

举例：

Checked异常为检查时异常，需要在编译期间进行异常的处理，比如SQLException\IOException

RumTime异常为运行时异常，在运行期间会出现，程序员可以在程序中预先进行异常的捕抓和处理、比如：NullPointerException

访问异常类的信息

1.打印异常栈踪迹

e.printStackTrace();

2.打印异常的信息message

System.out.println(e.getMessage());

3.返回异常跟踪栈的对象数组【异常链、异常来源线索】

e.getStackTrace();

多异常的捕抓

try{

}catch(异常类型1 e){

}

catch(异常类型2 e){

}

	public static void main(String[] args) {
		// 多异常的捕抓操作：
		String item = null;
		int[] arr = {1,2,3};
		try {
			// 空指针、算术异常
			//item.lastIndexOf("a");
			//System.out.println(5/0);
			// 
			arr[4] = 5;
		} catch (NullPointerException | IndexOutOfBoundsException e) {
			// TODO Auto-generated catch block
			System.out.println("捕抓到空指针异常");
		} catch (ArithmeticException e) {
			// TODO Auto-generated catch block
			System.out.println("捕抓到算术异常");
		} catch (Exception e) {
			// TODO Auto-generated catch block
			System.out.println("捕抓到异常");
		} 
	}

}

finally语句块

1.finally和trycatch一起使用的

2.不管trycatch中是否有出现异常都会执行finally中的代码

3.不管trycatch中是否有出现异常return语句都会执行

4.finally会影响方法的返回值、finally中如果有return语句，则trycatch中的return就不起作用，最终还是返回finally中的数据

finally的作用 JDBC数据库操作或者 IO流等操作中进行资源关闭

使用throws声明异常

--在方法中声明方法所有抛出的异常，用于声明异常类型（将异常往上抛，不处理异常）

使用throw抛出异常

抛出异常的关键字，用于抛出异常

关键点

--trycatch是捕抓并处理异常

--throws只是声明异常和将异常往上抛，不处理异常

--throw是抛出异常

异常链

异常出现的跟踪栈信息，里面包含了方法的调用关系和原始抛出异常的位置

//异常信息跟踪链分析
public class ExceptionTraceMain {

	public static void main(String[] args) throws Exception {
		Controller.request();
	}

}

//  Controller-- >Service   -->  Dao
// 控制层--展现层
class Controller {
	public static void request() throws Exception {
		Service.service();
	}
}

// 中间层-业务层
class Service {

	public static void service() throws Exception {
		Dao.test();
	}

}

// 持久层--数据层
class Dao {
	public static void test() throws Exception {
		for (int i = -1; i <= 5; i++) {
			//
			if (i == 0) {
				throw new Exception("分母不能为0");
			}
			//
			System.out.println(2 / i);
		}
	}
}

自定义异常类

自定义一个类，继承Exception，然后提供构造器初始化异常信息

练习

举例：

Person【name\sex\age】

当给age进行赋值时，不能超过一定的数值范围，否则就抛出一个自定义的AgeOutOfRangeException

//1、定义Person类

//2、定义setAge方法，声明异常

//年龄超出范围的异常类AgeOutOfRangeException
public class AgeOutOfRangeException extends Exception {

	// 定义一个错误信息提醒
	public AgeOutOfRangeException(String message) {
		super(message);// 调用父类的构造器
	}

	public AgeOutOfRangeException() {

	}

}

//人类
public class Person {

	//
	private String name;
	private String sex;
	private int age;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public String getSex() {
		return sex;
	}

	public void setSex(String sex) {
		this.sex = sex;
	}

	public int getAge() {
		return age;
	}

	// 正确值：0~150
	public void setAge(int age) throws AgeOutOfRangeException {
		//年龄超出范围的异常类AgeOutOfRangeException
		if(age<0||age>150) {
			throw new AgeOutOfRangeException(age+"不在0~150的正确值范围内！");
		}else
		this.age = age;
	}

	public Person(String name, String sex, int age) throws AgeOutOfRangeException {
		super();
		//年龄超出范围的异常类AgeOutOfRangeException
		if(age<0||age>150) {
			throw new AgeOutOfRangeException(age+"不在0~150的正确值范围内！");
		}else {
			this.age = age;
		}
		this.name = name;
		this.sex = sex;
	}

	public Person() {
		super();
	}

	@Override
	public String toString() {
		return "Person [name=" + name + ", sex=" + sex + ", age=" + age + "]";
	}

}

public class PersonTest {

	//思考：什么时候使用try catch  什么时候使用throws  ？区别？
	// 	  throw 和 throws 的区别是什么？
	public static void main(String[] args) throws AgeOutOfRangeException {
		// 
		Person p = new Person();
		//
		try {
			p.setAge(155);
		} catch (AgeOutOfRangeException e) {
			System.out.println(e.getMessage());
			p.setAge(15);
		}
		//
		System.out.println(p);
	}
}

异常处理规则

1.不要过度使用异常（要正确使用），在需要进行异常捕抓或者定义时使用

2.不要使用trycatch捕抓过大的代码块

public void test(){
    try {
        功能1；
        功能2；
        功能3；
        功能n；
    }
    catch(e){
    }
}

3.避免使用捕抓所有异常的操作【Exception】,即要精确到哪个错误！！

4.不要忽略捕抓到的异常，一定有具体的处理操作

5.使用trycatch时一定要有输出或者打印跟踪栈的操作【不能空操作】

throws和try catch区别

1.【根据功能需求决定使用哪一种】

--throws将异常往上抛出，没有处理异常的【由上层调用者来处理】

--try catch在当前代码中立刻处理

2.一般在代码中出现异常，会try catch处理

3.在方法声明异常的使用,使用throws

throw 和 throws 的区别

一个表示声明，在方法中声明异常类型

一个表示动作，在方法中抛出异常类型