Java（泛式）

package com.day19.generic;

import com.day19.HomeWork.Teacher;
import org.junit.Test;

import java.util.ArrayList;
import java.util.List;

/*
   泛型要解决类型安全问题
 */

class Person<T> {//T表示某种类型，T在这里称为泛型的类型参数（是一个形参）
    //T类型的真实类型会在创建对象时确定下来,隶属于对象的存在而存在
    private String name;
    private T info;

    public Person() {
    }

    public Person(String name, T info) {
        this.name = name;
        this.info = info;
    }

    public String getName() {
        return name;
    }

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

    public T getInfo() {
        return info;
    }

    public void setInfo(T info) {
        this.info = info;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", info=" + info +
                '}';
    }
}

class A<Y> {//泛型和继承之间的关系
    private Y y;

    public Y getY() {
        return y;
    }
}

class B1 extends A {//子类中没有处理父类的泛型，泛型类型就是最模糊的Object,这种不好
}

class B2 extends A<Integer> {//子类在继承时把父类的泛型写死了，最简单的。
}
class B3 extends A<Teacher> {//在创建子类对象后，其泛型是固定的。
}
class B4<Y> extends A<Y> {//子类在继承时仍然泛型，最灵活的
}
class GenericMethod<T>{
    public void test(T t){
    }
 //   public Object get(Object obj){}
    //泛型方法中必须传入泛型类型的参数，如果不传泛型永远无法确定。
    //这个泛型类型有实参的类型来确定，所以它是和方法某次调用相关。
    public static <E> E get(E e){//E表示只可以在此方法中使用的某种类型
        return null;
    }

}
public class GenericTest {
    @Test
    public void test5() {
        //Object o = GenericMethod.get();
        String abc = GenericMethod.get("abc");//泛型方法必须通过实参来告诉方法，泛型的具体类型是什么

        Integer integer = GenericMethod.get(200);

        Object o = GenericMethod.get(null);//如果实参是null，将会导致泛型类型无法感知

        Boolean aBoolean = GenericMethod.get(true);
    }
    @Test
    public void test4() {
        B1 b1 = new B1();//子类中没有处理父类的泛型，泛型类型就是最模糊的Object。
        Object y = b1.getY();

        B2 b2 = new B2();//子类在继承时把父类的泛型写死了。
        Integer y1 = b2.getY();

        B3 b3 = new B3();//在创建子类对象后，其泛型是固定的。
        Teacher y2 = b3.getY();

        B4<Object> objectB4 = new B4<>();//子类在继承时仍然泛型
        Object y3 = objectB4.getY();

        B4<Double> doubleB4 = new B4<>();
        Double y4 = doubleB4.getY();
    }

    @Test
    public void test3() {
        Person<Integer> p1 = new Person<>("张三", 30);//使用了泛型后，类型就安全了
        Integer info = p1.getInfo();//获取到的属性安全了，清晰了

        Person<String> p2 = new Person<>("李四", "男");
        String info1 = p2.getInfo();

        Person<Double> p3 = new Person<>("王五", 3.14);
        Double info2 = p3.getInfo();
    }

    @Test
    public void test2() {
        Person p1 = new Person("张三", 30);
        Object info = p1.getInfo();
        Person p2 = new Person("李四", "女");
        Object info1 = p2.getInfo();
    }

    @Test
    public void test1() {
        List<Object> list = new ArrayList<>();
        list.add(1);
        list.add("abc");

        Object o = list.get(0);

        ArrayList<Integer> list1 = new ArrayList<>();
        list1.add(0);
        list1.add(2);

        Integer integer = list1.get(1);

        ArrayList<Object> list2 = new ArrayList<>();

    }
}