Java知识点复习与总结(三) —— 泛型和异常

2018-07-30 15:48:44 Java 阅读: 273

泛型

Java泛型类似C++里面的模板,表示的是一种通用类型,这种技术可以减少因为类型导致的代码重复。
Java系统类库中的有些容器类也是使用泛型进行定义的,如ListMap

泛型方法

对方法可以使用泛型返回值和泛型参数,泛型方法的调用同普通方法,系统会根据传入参数自动填入泛型参数。

泛型参数格式: <T1, T2, ...>,位置放在方法的返回值之前。

例子:

public class Test {
    //泛型方法printArray
    public static <E> void printArray(E[] inputArray) {
        //输出数组元素
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }

    public static void main(String args[]) {
        // 创建不同类型数组: Integer, Double 和 Character
        Integer[] intArray = {1, 2, 3, 4, 5};
        Double[] doubleArray = {1.1, 2.2, 3.3, 4.4};
        Character[] charArray = {'H', 'E', 'L', 'L', 'O'};

        System.out.println("整型数组元素为:");
        printArray(intArray); // 传递一个整型数组

        System.out.println("双精度型数组元素为:");
        printArray(doubleArray); // 传递一个双精度型数组

        System.out.println("字符型数组元素为:");
        printArray(charArray); // 传递一个字符型数组
    }
}

输出结果:

整型数组元素为:
1 2 3 4 5 
双精度型数组元素为:
1.1 2.2 3.3 4.4 
字符型数组元素为:
H E L L O 

注意:泛型参数必须是引用类型,所以在上面例子上没有使用基本类型int、double和char,而使用了对应的包装类。这也是包装类的一个重要应用。

泛型类

对类使用泛型参数,该参数在全类都有效,声明格式同泛型方法,位置放置于类名称之后。如class List<T>

泛型类的实例化和普通类不同,需要手动指定泛型参数,格式:

Class<Type> class = new Class(Arguments);

其中Type填入具体类型,注意只能是引用类型,如Integer,不能只用基本类型。

例子:

public class Test<T> {
  private T t;

  public void set(T t) {
    this.t = t;
  }

  public T get() {
    return t;
  }

  public static void main(String[] args) {
    Test<Integer> i = new Test<Integer>();
    Test<String> s = new Test<String>();

    i.set(new Integer(10));
    s.set(new String("luoluolzb"));

    System.out.println(i.get());
    System.out.println(s.get());
  }
}

输出:

10
luoluolzb

有界的类型参数

可能有时候,你会想限制传入参数只能使用某个类及其子类类型,如: <T extends Number>,只接受Number或者Number子类类型。

例子:

class A {}
class B extends A {}
class D<T extends B>{}

public class Test {
  public static void main(String[] args) {
      //D<Integer> d1 = new D<Integer>();  //错误
      //D<A> d2 = new D<A>();  //错误
      D<B> d3 = new D<B>();    //正确
  }
}

类型通配符

类型通配符是指在泛型参数中是使用?代替具体的类型参数。

结合extends和super可以指定上下界:

  1. 限定上界:<? extends T> , 表示该通配符所代表的类型是T类及其子类。
  2. 限定下界:<? super T> , 表示该通配符所代表的类型是T类及其父类。

注意:泛型类型通配符只能在方法的参数列表中使用。

例子:

class A {}
class B extends A {}
class C extends B {}
class D<T> {}

public class Test {
    static void f1(D<? extends B> b) {}  //只能传入B及其子类
    static void f2(D<? super B> b) {}    //只能传入B及其父类

    public static void main(String[] args) {
        //f1(new D<A>());  //错误
        f1(new D<B>());
        f1(new D<C>());

        f2(new D<A>());
        f2(new D<B>());
        //f2(new D<C>());  //错误
    }
}

异常

异常也是面对对象编程的重要技术之一。在Java中也毫无例外的提供了异常处理机制。

语法:

    try {
            throw ExceptObj;
        } catch(ExceptionType1 e) {
            //异常处理代码
        } catch(ExceptionType2 e) {
            //异常处理代码
        } finally {
            //总会被调用的代码
        }

使用 throw 抛出一个异常对象(实际上throw可以抛出任何类型),随后的多个 catch 可以捕获类型相同的异常(父类也可以捕获到子类的异常对象)。
最后的 finally 的代码块总会被执行,无论有没有抛出异常。

try 语句块不可以独立存在,必须与 catch 或者 finally 块同存。cath可以有一个或多个,finally可以有也可以没有。

定义异常类

Java类库内置了很多异常类,具体可以查看API,如果开发中找不到合适的,也可以自己写一个异常类,自己写的异常类一般要继承Exception或它子类。

Java内置异常类:
异常类关系图

thows声明

thows 看起来和 throw 很像,这个多余的 s 指的 statement —— 声明,用来在修饰函数可能会抛出一个异常。

如果一个方法没有捕获异常,那么该方法必须使用 throws 关键字来声明。throws 关键字放在方法的尾部。

例如:

public class Test {
    public static void main(String[] args) throws Exception {
        throw new Exception();
    }
}

版权声明:本文为博主原创文章,转载需注明来自: 洛洛の空间


功能
最新评论