day15 ---- 泛型

泛型、异常、lambda表达式

泛型

• 可以在类和方法预支地使用未知的类型，一般在创建对象时，将位置类型确定为具体类型，当没有指定泛型时，默认类型是Object类型

使用

• 将运行时时期的异常，转移到了编译时期变成了编译失败
• 避免类型强转的麻烦

    public static void main(String[] args) {
        Collection<String> list = new ArrayList<>();
        // 把泛型删掉后默认为Object类
        list.add("abc");
        list.add("def");
//        list.add("def");

        // 已经明确了类型，在使用迭代器的时候，迭代器也同样知道遍历元素的具体类型
        Iterator<String> iterator = list.iterator();
        while (iterator.hasNext()){
            String str = iterator.next();
            // 使用iterator控制元素后 在这里可以直接获取String类型
            System.out.println(str.length());
        }

//        System.out.println(list);

    }
    

泛型的定义与使用

• 泛型 用来灵活的将数据类型应用到不同类，方法、接口当中，将数据类型作为参数进行传递。
• 格式

修饰符 class 类名<代表泛型的变量>{
}

• 使用泛型：在创建对象的时候确定泛型
• 自定义泛型

public class MyGenericClass <MVP>{
    // 没有MVP类型，在这里代表未知的一种 数据类型
    // 未来传递什么就是什么类型
    private MVP mvp;

    public MVP getMvp() {
        return mvp;
    }

    public void setMvp(MVP mvp) {
        this.mvp = mvp;
    }
}

• 测试

public class TestGenericDemo {
    public static void main(String[] args) {
        // 创建一个泛型为String的类
        MyGenericClass<String> mine = new MyGenericClass<>();
//        不写默认为Object类
//        MyGenericClass mine1 = new MyGenericClass<>();
        mine.setMvp("哈登");
        // 传入什么类型就是什么类型
        String mvp = mine.getMvp();
        System.out.println(mvp);

        MyGenericClass<Integer> mine2 = new MyGenericClass<>();
        mine2.setMvp(13);
        Integer mine2Mvp = mine2.getMvp();
        System.out.println(mine2Mvp);
    }
}

含有泛型的方法

• 格式：

修饰符<代表泛型的变量> 返回值类型 方法名 (参数列表)}{
}

• 举个例子

public class MyGenericMethod {
    public<MVP> void show(MVP mvp){
        System.out.println(mvp.getClass());
    }
    public <MVP> MVP show2(MVP mvp){
        return mvp;
    }
}

• 测试

public class TestGenericMethod {
    public static void main(String[] args) {
        MyGenericMethod mgm = new MyGenericMethod();
        // 在调用方法时，确定泛型的类型
        mgm.show("罗斯");
        mgm.show("德里克");
        mgm.show(123);

    }
}

含有泛型的接口

• 格式：

修饰符 interface 接口名<泛型>{
}

• 定义类

package com.company.day15.myGeneric;

public interface MyGenericInterface <E>{
    public abstract void add(E e);
    public abstract E get(E e);
    
}

• 实现类在定义类的时候确定泛型的类型

public class MyGenericImpL implements MyGenericInterface<String> {


    @Override
    public void add(String s) {

    }

    @Override
    public String get(String s) {
        return null;
    }
}

• 此时类型E的值就是String类型

始终不确定泛型的类型，知道创建对象的时候，确定泛型的类型

public class MyGenericImpl2<E> implements MyGenericInterface<E> {
    @Override
    public void add(E e) {

    }

    @Override
    public E getE() {
        return null;
    }
}

public class TestGenericDemo2 {
    public static void main(String[] args) {
        MyGenericImpl2<String> impl2 = new MyGenericImpl2<>();
        ArrayList<Object> list = new ArrayList<>();
        impl2.add("hehe");

    }
}

泛型通配符

常用的通配符含义

• E Element（一般在我们集合中使用）
• T Type （Java类）
• K Key （键）
• V Value （值）
• N Number （数量类型）
• ？表示不确定的Java类型
  < ? >表示不确定的Java类型，一旦使用<?> 只能使用Object类中的共性方法

基本使用

<?> 不知道使用什么类型来接收的时候，

public class TestGenericDemo03 {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        getElement(list1);     
        getElement(list2);     
    }
    public static void getElement(Collection<?> coll){
        // <?> 可以接收任意类型
        
    }
}

高级应用 – 受限类型

在Java中 泛型可以指定一个泛型的上限和下限

• 泛型的上限

格式：
	类型名称 <? extends 类> 对象名称 
意义：
	只能接收该类型及其子类

格式：
	类型名称 <? super 类> 对象名称 
意义：
	只能接收该类型及其父类

• 例子：已知object类、String类、Number类、Integer类、其中Number类是Integer的父类

public class TestGenericDemo04 {
    public static void main(String[] args) {
        // 已知object类、String类、Number类、Integer类、其中Number类是Integer的父类
        Collection<Integer> list1 = new ArrayList<>();
        Collection<String> list2 = new ArrayList<>();
        Collection<Number> list3 = new ArrayList<>();
        Collection<Object> list4 = new ArrayList<>();
        
        getElement01(list1); // Integer是Number的子类 所以可以使用
//        getElement01(list2);  String不是Number的子类 报错
        getElement01(list3); 
//        getElement01(list4);  Object是Number父类 报错
//        getElement02(list1);  下限以下
        getElement02(list3); // 本类 可以使用
    }
    public static void getElement01(Collection<? extends Number> coll){
        // 泛型的上限 此时必须是Number类型或者子类
    }
    public static void getElement02(Collection<? super Number> coll){
        // 泛型的下限 此时必须是Number类型或者父类
    }
}

异常

• 异常

指的是程序在执行过程中，出现的非正常的情况，最终会导致JVM的非正常停止 在Java中异常本身是一个类，产生异常就是创建异常对象并且抛出一个异常对象。Java处理异常的方式是中断处理。
异常不是语法错误，语法错误是无法通过编译

异常体系

• 异常的根类

异常的根类是java.lang.Throwable,有两个子类 Java.lang.Error 和 Java.lang.Exception 平时说的异常是java.lang.Exception

Throwable体系：

• Error严重错误，无法通过处理的错误，好比绝症
• Exception 表示异常 异常产生后程序员可以通过代码纠正的方式，使程序正常运行，好比感冒发烧

常用方法：

1. printStackTrace() 打印异常的常用信息

public void printStackTrace() {
        printStackTrace(System.err);
    }

2. getMessage() 获取发生异常的原因

 public String getMessage() {
        return detailMessage;
    }

3. 例子

public class Demo01 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        System.out.println(arr[3]);
    }
}

异常的分类

• 编译时期异常：如果没有处理，编译失败（比如日期格式化异常）
• 运行时期异常：在运行时期检查异常（如数字异常）

异常处理

Java中异常处理关键字

1. try
2. catch
3. finally
4. throw
5. throws

抛出异常throw

• 创建一个异常对象，封装一些提示信息（信息可以自己编写）
• 通过throw这个异常对象告知调用者，throw用在方法内，用来抛出一个异常对象，将这个异常对象传递给调用者处，并结束当前方法的执行
• 格式：

throw new 异常类名（参数）;

• 例子

public class Demo02 {
    public static void main(String[] args) {
        int[] arr = {1,2,3};
        int index = 4;
        int element = getElement(arr, index);
        System.out.println(element);

    }
    public static int getElement(int[]arr,int index){
        // 判断
        if (index < 0 || index > arr.length - 1){
            throw new ArrayIndexOutOfBoundsException("数组越界了,兄弟");
        }
        return arr[index];
    }
}

throws 声明异常

• 声明异常：将问题标识出来，报告给调用者，如果方法内通过throw，跑出来编译时异常，而没有捕获处理，那么必须通过throws进行声明，让调用者去处理

修饰符 <代表泛型的变量> 返回值类型 方法名（参数列表）throws 异常类

public class Demo3 {
    public static void main(String[] args) throws ParseException {
        String s = "1994-01-1";
        timeFormat(s);

    }
    public static void timeFormat(String str) throws ParseException {
        SimpleDateFormat sdf = new SimpleDateFormat("YYYY-MM");
        Date date = sdf.parse(str);
        System.out.println(date);
    }
}

捕获异常try catch

如果异常出现会立刻终止程序，所以我们得处理异常

1. 声明抛出 由调用者来处理（throws）
2. try catch语句块来处理异常

try catch的方式就是捕获异常
try 编写可能会出现异常的代码
catch异常的捕获处理
try catch不能单独使用 必须连用

格式：

try{
	// 编写可能会出现异常的地方
}catch(异常类型){
	// 处理异常的代码
	// 记录日志，打印异常信息，继续抛出异常
}

public class Demo04 {
    public static void main(String[] args) {
        try {
            read("xiaomiMi.txt");
        }catch (Exception e) {
            // try中抛出什么异常,在括号里就捕获什么异常
            e.printStackTrace();
            System.out.println("---------------------------");
            System.out.println(e);
            // 打印异常详细信息
        }
        System.out.println("end");
    }
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("xiaomimi.txt")){
            throw new FileNotFoundException("你的文件怎么消失了呢");
        }
    }
}

finally 代码块

finally 有一些特定的代码，无论是否发生异常都会执行，另外异常会引发程序跳转，导致有些语句执行不到，而finally就解决了这个问题
finally不能单独使用

public class Demo04 {
    public static void main(String[] args) {
        try {
            read("xiaomiMi.txt");
        }catch (Exception e) {
            // try中抛出什么异常,在括号里就捕获什么异常
            e.printStackTrace();
            System.out.println("---------------------------");
            System.out.println(e);
            // 打印异常详细信息
        }finally {
            System.out.println("不管try和catch执行什么了,我这里都会执行");
            System.out.println("我是接盘侠");
        }
        System.out.println("end");
    }
    public static void read(String path) throws FileNotFoundException {
        if (!path.equals("xiaomimi.txt")){
            throw new FileNotFoundException("你的文件怎么消失了呢");
        }
    }
}

lambda表达式

使JDK1.8 版本的新特性 lambda省去面向对象的条条框框，格式由三部分组成

• 一些参数
• 一个箭头
• 一段代码

标准格式：

(参数类型 参数名)->{
 //代码语句    System.out.println("lambda的饭好了");
        }

说明

• 小括号就是传统的参数列表，多个用括号分隔
• -> 代表指向动作
• 大括号和原来一样写方法体

无参无返回

public class Demo02 {
    public static void main(String[] args) {
        // 格式: (参数类型 参数名称)-> {代码语句}
        invoke(()->{
            System.out.println("lambda的饭好了");
        });
    }
    public static void invoke(Cook cook){
        cook.makeFood();
    }
}

小括号代表Cook接口的makeFood方法 参数为空，大括号代表方法体

有参有返回值

需求 使用数组存储多个Person对象，对数组中的Person对象使用Arrays的sort方法通过年龄排序

代码分析

• 为了排序 ArrayList.sort需要排序规则，Comparator接口的实例。
• 实现compare方法，不得不写一个Comparator的实现类
• 为了省略Comparator的实现类ComparatorImpl，不得不使用匿名内部类
• 必须覆盖compare方法 所有的声明都需要重写一遍
• 实际上 只有参数和方法体是关键部分

lambda写法

public class Demo06 {
    public static void main(String[] args) {
        Person[] array = {
                new Person("貂蝉",23),
                new Person("妲己",26),
                new Person("西施",25),
                new Person("杨玉环",29),
        };
        Arrays.sort(array,(Person a,Person b)->{
            return a.getAge()-b.getAge();
        });

        for (Person person:array
             ) {
            System.out.println(person);
        }
    }
}

需求：定义一个计算器接口Caculator 内涵抽象方法可以将 int类型的数组相加得到的和的值

public interface Caculator {
    int cacu(int a,int b);
}

省略格式

• Lambda强调做什么，而不是怎么做，凡是可以根据上下文推到得知的消息，都可以省略

public class Demo08 {
    public static void main(String[] args) {
        // 使用lambda表达式调用测试
        invokeCacu(5,6,(a,b) -> a + b);

    }
    public static void invokeCacu(int a,int b,Caculator caculator){
        int result = caculator.cacu(a,b);
        System.out.println("结果是" + result);
    }
 }

省略规则

• 小括号参数可以省略
• 如果小括号内有且仅有一个参数，小括号可以省略
• 如果大括号内且仅有一个语句，则无论是否有返回值 都可以省略大括号、return及分号

lambda使用前提

• 必须具有接口，且要求接口中有且仅有一个抽象方法（无论是Runable、Comparator还是自己定义的接口，都得是抽象方法唯一）
• 使用lambda必须具有上下文推断：也就是方法的参数或者局部变量类型必须lambda对应的接口类型，才能使用，Lambda作为该接口的实例
• 有且只有一个抽象方法的接口叫做函数式接口