泛型的使用
如果在使用集合时没有限定集合所保存的数据类型,则在代码运行期间容易会出现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 的区别
一个表示声明,在方法中声明异常类型
一个表示动作,在方法中抛出异常类型