2020.8.6泛型

01_泛型

1. 定义：是一种把类型明确的工作
2. 作用推迟创建对象，或者调用方法的时候才去明确的特殊的类型。参数化类型，把类型当作参数一样的传递
3. 泛型的格式: <数据类型> 这里的数据类型只能是引用数据类型
4. 泛型好处：
5. 把运行时期的问题提前到了编译期间
6. 避免了强制类型转换
7. 优化了程序设计，解决了黄色警告线

案例演示：引出泛型

package GenericDemo01;
import java.util.ArrayList;
//ArrayList存储字符串并遍历泛型版
public class GenericTest01 {
    public static void main(String[] args) {
    //先用普通的创建引出泛型创建
        ArrayList arrayList = new ArrayList();
        arrayList.add("long");
        arrayList.add(8);
        arrayList.add(7);
        arrayList.add(6);
        //遍历集合
        for (int i = 0; i < arrayList.size(); i++) {
            Object o = arrayList.get(i);
            System.out.println(o);
        }
        System.out.println(arrayList.get(0));//输不出字符串长度

        Object o = arrayList.get(0);//向下转型转换为字符串
        String str= (String) o;
        System.out.println(str.length());//4
        System.out.println("----------------------");
        //如果我们用泛型就不需要向下转型了
        ArrayList<String> arrayList1 = new ArrayList<>();
        arrayList1.add("詹姆斯");
        //students.add(2);//输入的不是字符串就会报错
        String s = arrayList1.get(0);
        System.out.println(s);//詹姆斯
        System.out.println(s.length());//3

    }
}

注意：泛型只在编译期有效 但在运行期就擦除了

案例演示：泛型可以推迟创建对象、迭代器

package GenericDemo01;

import java.util.ArrayList;
import java.util.Iterator;

public class GenericTest02 {
    public static void main(String[] args) {
        //ArrayList存储字符串并遍历泛型版
        ArrayList<Student> arrayList=new ArrayList<>();
        arrayList.add(new Student("詹姆斯",35));
        arrayList.add(new Student("韦德",34));
        arrayList.add(new Student("安东尼",32));
        arrayList.add(new Student("詹姆斯",33));
        //用迭代器遍历泛型版
        Iterator<Student> iterator = arrayList.iterator();
        while (iterator.hasNext()) {
            Student stu = iterator.next();
            System.out.println(stu);
        }

    }
}

02-泛型的由来-Object

因为Object是超类，它可以接受人的对象类型，用的时候就向下转型，但是存在隐患，所以Java提供了泛型来解决这个问题。

02.1_把泛型定义在类上

定义格式: public class 类名<泛型类型1,…>

注意事项: 泛型类型必须是引用类型

案例演示：泛型类对象

package GenericDemo01;
//创建泛型类
public class MyClass<B> {
    private B b;//定义一个引用类型
    private Integer num;

    public MyClass() {
    }

    public MyClass(B b, Integer num) {
        this.b = b;
        this.num = num;
    }

    public B getB() {
        return b;
    }

    public void setB(B b) {
        this.b = b;
    }

    public Integer getNum() {
        return num;
    }

    public void setNum(Integer num) {
        this.num = num;
    }
}

测试：

package GenericDemo01;

import java.util.ArrayList;

public class GenericTest03 {
    //泛型机制:就是把数据类型明确工作，推迟到创建对象,才去明确的一种机制。
    public static void main(String[] args) {
       //创建泛型类对象
        MyClass<Integer> integerMyClass = new MyClass<>();
        //添加元素
        integerMyClass.setB(100);
        Integer b = integerMyClass.getB();
        System.out.println(b);
        System.out.println("-----------");
        MyClass<String> stringMyClass = new MyClass<>();
        stringMyClass.setB("詹姆斯");
        String b1 = stringMyClass.getB();
        System.out.println(b1);


    }
}

案例演示：创建两个引用类型

package GenericDemo01;

public class MyObject<A,C> {
    private A a;
    private C c;

    public MyObject() {
    }

    public A getA() {
        return a;
    }

    public void setA(A a) {
        this.a = a;
    }

    public C getC() {
        return c;
    }

    public void setC(C c) {
        this.c = c;
    }
}

测试

package GenericDemo01;

public class GenericTest04 {
    public static void main(String[] args) {
        //创建两个引用类型的泛型
        MyObject<String, Integer> stringIntegerMyObject = new MyObject<>();
        stringIntegerMyObject.setA("詹姆斯");
        stringIntegerMyObject.setC(35);
        String a = stringIntegerMyObject.getA();
        Integer c = stringIntegerMyObject.getC();
        System.out.println(a);
        System.out.println(c);
    }
}

02.2泛型方法的概述和使用

1. 泛型方法概述: 把泛型定义在方法上
2. 定义格式: public <泛型类型> 返回类型 方法名(泛型类型 变量名)
3. 案例演示: 泛型方法的使用

package GenericDemo01;

public class MethodDemo {
    //创建泛型方法
    public <String> void show(String string){
        System.out.println(string);
    }
}

测试

package GenericDemo01;

public class MthodTest {
    public static void main(String[] args) {
        MethodDemo methodDemo = new MethodDemo();
        methodDemo.show("詹姆斯");
    }
}

02.3_泛型接口的使用

泛型接口概述: 把泛型定义在接口上

定义格式: public interface 接口名<泛型类型>

案例演示：接口

package GenericDemo01;

public interface  MyInterfaceDemo<A> {
    public abstract void test(A a);
}

实现类A:子类实现接口是，可以明确接口上的泛型具体类型

package GenericDemo01;
//子类实现接口时，可以明确接口上的泛型具体是什么类型
public class MyA implements MyInterfaceDemo<String> {

    @Override
    public void test(String s) {

    }
}

实现类B

package GenericDemo01;

public class MyB<A>implements MyInterfaceDemo<A> {
    @Override
    public void test(A a) {

    }
}

03_泛型高级之通配符

1. 定义：泛型通配符<?>:任意类型，如果没有明确，那么就是Object以及任意的Java类了
2. ? extends E: 向下限定，E及其子类
3. ? super E: 向上限定，E及其父类

案例演示：

package GenericDemo02;

import java.security.DigestException;
import java.util.ArrayList;

//通配符
public class WildcardTest01 {
    public static void main(String[] args) {
        //？并没有明确什么类型
        ArrayList<?> dogs = new ArrayList<>();
        ArrayList<?> cats = new ArrayList<>();
        ArrayList<?> animals = new ArrayList<>();
        //向上限定，就是右边可以是自身也可以是父类，其他就会报错
        ArrayList<Dog> dogs1 = new ArrayList<>();
        ArrayList<? super Dog > sdog = new ArrayList<Dog>();
        ArrayList<?super Dog> sdog1=new ArrayList<Animal>();
        //向下限定，就是右边可以是自身也可以是子类，其他就会报错
        ArrayList<? extends Animal> list4 = new ArrayList<Animal>();
        ArrayList<? extends Animal> list5 = new ArrayList<Cat>();
        ArrayList<? extends Animal> list6 = new ArrayList<Dog>();

    }
}
class Animal{

}
class Dog extends Animal{

}
class Cat extends  Animal{

}