2021.5.20笔记 泛型

---

泛型图解

---

使用泛型的优缺点

1.使用泛型
好处：避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型；把运行期异常（代码运行后会抛出的异常），提升到了编译期（写代码时候会报错）
弊端：泛型是什么类型，只能存储什么类型的数据

public class FloodType {
    public static void main(String[] args) {
        ArrayList<String> arr1 = new ArrayList<>();
        arr1.add("小新");
        arr1.add("妮妮");
        Iterator<String> iter1 = arr1.iterator();
        while (iter1.hasNext()) {
            String s1 = iter1.next();
            System.out.println(s1.length());
        }
    }
}

2.不使用泛型
好处：不使用泛型，默认类型是Object类型，可以存储任意类型的数据
弊端：不安全，会引发异常

public class FloodType {
    public static void main(String[] args) {
        ArrayList arr1 = new ArrayList();
        arr1.add("小新");
        arr1.add(1);
        Iterator iter1 = arr1.iterator();
        while (iter1.hasNext()) {
            Object next1 = iter1.next();
            System.out.println(next1);

            String s1 = (String)next1;      //抛出异常
            System.out.println(s1.length());       
        }
    }
}

---

含有泛型的类

可以模拟ArrayList集合
当我们不确定数据类型的时候，可以用泛型
创建对象时候确定泛型的数据类型

public class FloodClass<E> {
    private E name;

    public E getName() {
        return name;
    }

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

public class FloodType2 {
    public static void main(String[] args) {
        FloodClass<Integer> flood1 = new FloodClass<>();
        flood1.setName(1);
        Integer name1 = flood1.getName();
        System.out.println(name1);
        FloodClass<String> flood2 = new FloodClass<>();
        flood2.setName("小新");
        String name2 = flood2.getName();
        System.out.println(name2);
    }
}

---

含有泛型的方法

定义含有泛型的方法，泛型定义在方法的修饰符和返回值类型之间

格式：修饰符<泛型> 返回值类型 方法名（参数列表（使用泛型））{
…方法体
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型，传递什么类型的参数，泛型就是什么类型

public class GenericScr {
    public <E> void method01(E e) {
        System.out.println(e);
    }
    public static <M> void method02(M m) {
        System.out.println(m);
    }
}

public class GenericClass {
    public static void main(String[] args) {
        GenericScr src = new GenericScr();
        src.method01("小新");
        src.method01(1);
        GenericScr.method02("妮妮");
        GenericScr.method02(2);
    }
}

---

含有泛型的接口

public interface GenericInterface<I> {
    public abstract void method(I i);
}

public class InterfaceClass implements GenericInterface<String>{
    @Override
    public void method(String o) {
        System.out.println(o);
    }
}

public class InterfaceObj {
    public static void main(String[] args) {
        InterfaceClass inter = new InterfaceClass();
        inter.method("小新");
    }
}

public interface GenericInterface<I> {
    public abstract void method(I i);
}

public class InterfaceClass<I> implements GenericInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

public class InterfaceObj {
    public static void main(String[] args) {
        InterfaceClass<String> inter1 = new InterfaceClass<>();
        inter1.method("小新");

        InterfaceClass<Integer> inter2 = new InterfaceClass<>();
        inter2.method(10);
    }
}

---

泛型通配符

public class NewObj {
    public static void main(String[] args) {
        ArrayList<String> arr1 = new ArrayList<>();
        arr1.add("小新");
        arr1.add("妮妮");
        ArrayList<Integer> arr2 = new ArrayList<>();
        arr2.add(1);
        arr2.add(2);
        method(arr1);
        method(arr2);
    }
    public static void method(ArrayList<?> list) {
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
            System.out.println(next);
        }
    }
}

（可以看懂即可）