Java基础-泛型

泛型

• 集合中的使用，规范化数据，作用在编译期间
• 泛型可以作用在类的声明，接口的声明，方法的声明
• 在本类中当成已知类型的存在，是一个占位符
• 反射可以越过泛型检查，其实都是Object

1.1.泛型类

• 在定义类的时候使用泛型<T,E,K,V> 泛型符号名字和个数无要求，在本来中作为已知存在
• 在实例化的时候如果不指定类型，都当成Object来看
• 静态方法不能使用类的泛型占位符

/**
 * @author Anne
 * @date 2021/1/6 9:56
 * T type K key V value E element
 */
public class CustomGeneric<T, A, B> {
    private T name;
    private A a;
    private B b;

    public T method1() {
        return name;
    }

    public void method2(A a){
    }

/*    public static void method3(B b){
    }*/
}

1.2.泛型接口

1.接口定义

public interface CustomInter<A, B, C> {
    void methodA(A a);

    void methodB(B a);

    void methodC(C a);
}

2.实现类实现接口分2种情况

a.实现类指定泛型类型，在实现的时候接口泛型确定下来了

public class CustomInterImpl implements CustomInter<String,Integer,Double> {
    @Override
    public void methodA(String s) {

    }

    @Override
    public void methodB(Integer a) {

    }

    @Override
    public void methodC(Double a) {

    }
}

测试类

 @Test
    public void methodA() {
        CustomInterImpl customInter = new CustomInterImpl();
    }

b.实现类不指定接口中泛型类型，继续把泛型占位符带上

public class CustomImpl2<A,B,C,D,E> implements CustomInter<A,B,C> {
    @Override
    public void methodA(A a) {
    }
    @Override
    public void methodB(B a) {
    }

    @Override
    public void methodC(C a) {
    }
}

测试类

    @Test
    public void methodA() {
        CustomImpl2<String, Integer, Double,String,String> im2 = new CustomImpl2<>();
    }

总结：

​ 使用的时候，如果不指定泛型类型，统统都当成Object来看

1.3.泛型方法

• 泛型是在进行方法调用时 根据传入的值来确定类型的

public class GenericMethod {

    public <T> T methodA(T t) {
        return t;
    }

    /**
     * 静态方法不能使用类的泛型占位符
     * @param b
     * @param <B>
     */
    public static <B> void methodB(B b) {
    }
}

1.4. 泛型上下限

Animal类

public abstract class Animal {
    public abstract void eat();
}

子类

public class Monkey extends Animal {
    @Override
    public void eat() {
        System.out.println("猴子喜欢吃香蕉");
    }
}

饲养员类

public class Feeder {
    /**
     *  ? extends T  泛型上限，只能时T类型或者T的子类型 ? 通配符
     * @param animal
     */
    public void feed(List<? extends Animal> animal) {
        for (Animal animal1 : animal) {
            animal1.eat();
        }
    }

    /**
     * ? extends T  泛型下限，只能是T类型或者T的父类型
     * @param animal
     */
    public void feed2(List<? super Animal> animal) {
        for (Object o : animal) {
        }
    }
}

测试类

 @Test
    public void feed() {
        Feeder feeder = new Feeder();
        List<Animal> lists = new ArrayList();
        lists.add(new Monkey());
        lists.add(new Cat());

        List<Monkey> monkeys = new ArrayList<>();
        monkeys.add(new Monkey());
        monkeys.add(new Monkey());
        //使用泛型上限，monkeys才可以传入
        feeder.feed(monkeys);
    }

泛型擦除

		List<Monkey> monkeys = new ArrayList<>();
        monkeys.add(new Monkey());
        monkeys.add(new Monkey());
        // 泛型擦除,失去泛型了
        List list = monkeys;
        list.add(1);