异常
- 处理异常的格式
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>