泛型的使用和上下限

• 约束数据类型，在集合;JDK5 之后出现的

• E-element K-key V-value T-type

• 泛型符号，只是一个占位符，给引用类型占个位置

• 名称无要求，个数无要求，

• 泛型符号 在本类中作为已知的类型来使用

• 可以出现在类的声明处，接口的声明处，方法的声明处

1.2.1.泛型类

• 泛型符号出现在类的声明处

泛型类的定义

public class GenericCustom<A, B, C> {
    private A a;
    private B b;
    private C c;

    public void method1(A a) {
    }

    /**
     * 静态方法中不能使用类的 泛型符号
     *
     * @param b
     */
    /*public static void method2(B b) {

    }*/
}

 

---

测试

/**
     * 1，泛型类
     */
    private static void method1() {
        //泛型符号对应的类型是在 创建对象的时候确定的；
        GenericCustom<Integer, String, Double> genericCustom = new GenericCustom<>();
        // 泛型符号只要不指定 统统当成Object来看
        GenericCustom genericCustom2 = new GenericCustom();
        //ArrayList是个泛型类
        ArrayList<String> strings = new ArrayList<>();
        strings.add("");
    }

 

 泛型接口

public interface GenericInter<T, K, V> {
    T method1(T t);

    K method2(K k);

    V method3(V v);
}


    //a，实现类直接确定泛型接口中的泛型符号类型

/**
 * 1, 实现类中直接确定类型
 */
public class GenericInterImpl1 implements GenericInter<String, Integer, Float> {
    @Override
    public String method1(String s) {
        return null;
    }

    @Override
    public Integer method2(Integer integer) {
        return null;
    }

    @Override
    public Float method3(Float aFloat) {
        return null;
    }
}


//b，实现类继续带上泛型符号



/**
 * 2，实现类继续带上泛型符号
 *
 * @param <T>
 * @param <K>
 * @param <V>
 */
public class GenericInterImpl2<T, K, V> implements GenericInter<T, K, V> {
    @Override
    public T method1(T t) {
        return null;
    }

    @Override
    public K method2(K k) {
        return null;
    }

    @Override
    public V method3(V v) {
        return null;
    }
}

//c，如果不指定 都当成Object来看

public class GenericInterImpl3 implements GenericInter {
    @Override
    public Object method1(Object o) {
        return null;
    }

    @Override
    public Object method2(Object o) {
        return null;
    }

    @Override
    public Object method3(Object o) {
        return null;
    }
}



//测试

   /**
     * 2，泛型接口
     */
    private static void method2() {
        GenericInterImpl1 genericInterImpl1 = new GenericInterImpl1();
        GenericInterImpl2<String, Integer, Float> genericInterImpl2 = new GenericInterImpl2<>();
        HashMap<Integer, String> hashMap = new HashMap<>();
    }

---

1.2.3.泛型方法

         

public class GenericMethod {

    /**
     * 在进行方法调用的时候 确定泛型方法中的类型
     * 在返回值前面 声明符号
     *
     * @param a
     * @param <A>
     */
    public <A, B> A method1(A a) {
        return a;
    }
    //静态方法中使用泛型
    public static <T, K, V> void method2(T t, K k, V v) {
    }
}

//测试
 /**
     * 3，泛型方法
     */
    private static void method3() {
        GenericMethod genericMethod = new GenericMethod();
        genericMethod.method1("abc");
        genericMethod.method1(123);
        genericMethod.method1(3.6);

        List<Integer> list = Arrays.asList(1, 2, 3, 34, 66, 88);
        System.out.println(list);
        List<String> strings = Arrays.asList("abc", "str", "java");
    }

---

可变长参数

 public static void main(String[] args) {
        List<Integer> list = Arrays.asList(1, 2, 3, 34, 66, 88);
        List<String> strings = Arrays.asList("a", "b", "c");
        method4(1, 2, 3, 4, 5);
    }
    /**
     * 可变长的参数,
     * 任意数据类型...
     * 传 0 或多个实际参数
     * 如果有可变长参数 必须出现在最后
     *
     * @param a 数组
     */
    public static void method4(double b, int... a) {
        System.out.println(a.length);
        System.out.println(": " + Arrays.toString(a));
    }

 

 

---

泛型上下限

public class Feeder {
    /**
     * 泛型的上限
     * ?通配符 表示任意类型
     * ? extends Animal表示只要是Animal或者Animal的子类型
     *
     * @param animals
     */
    public void feed(List<? extends Animal> animals) {
        for (Animal animal : animals) {
            animal.eat();
        }
    }
    /**
     * 泛型的下限
     * ? super Animal；表示是 Animal 或者Animal的父类型
     *
     * @param animals
     */
    public void getAnimal(List<? super Animal> animals) {
        for (Object animal : animals) {

        }
    }
}
//测试

 public static void main(String[] args) {
        Feeder feeder = new Feeder();
        List<Animal> animals = new ArrayList<>();
        animals.add(new Dog());
        animals.add(new Cat());

        List<Dog> dogs = new ArrayList<>();
        dogs.add(new Dog());
        dogs.add(new Dog());

        feeder.feed(dogs);
    }