Java学习--泛型

使用泛型

		//1. ArrayList<Dog> 表示存放到 ArrayList 集合中的元素是Dog类型
        //2. 如果编译器发现添加的类型不满足要求，就会报错
        //3. 在遍历的时候，可以直接取出 Dog类型
        ArrayList<Dog> list = new ArrayList<Dog>();
        list.add(new Dog("赖皮", 10));
        list.add(new Dog("花妞", 2));
        list.add(new Dog("大黄", 5));

        for (Dog dog : list) {
            System.out.println(dog);
        }

泛型的作用是：可以在类声明时通过一个标识表示类中某个属性的类型，或者是某个方法的返回值类型，或者是参数类型

class Person<E>{
    E s; //表示 s的数据类型，该数据类型在定义Person对象的时候指定，
    //即在编译期间，就确定E是什么类型

    public Person(E s) { //E也可以是参数类型
        this.s = s;
    }

    public E f(){ //返回类型使用E
        return s;
    }
}

E具体的数据类型在定义Person对象的时候指定，即在编译期间，就确定E是什么类型

		Person<String> person = new Person<String>("dq");
        person.show(); //String
        /*
            可以这样理解
            class Person{
                String s;

                public Person(String s) {
                    this.s = s;
                }

                public String f(){
                    return s;
                }
            }
         */

一些细节

1. 给泛型指定数据类型时，要求是引用数据类型，不能是基本数据类型

ArrayList<Integer> list = new ArrayList<Integer>(); //ok
// ArrayList<int> list2 = new ArrayList<int>();  //错误

2. 在给泛型指定具体类型后，可以传入该类型或其子类类型

Pig<A> aPig = new Pig<>(new A());
Pig<A> aPig1 = new Pig<>(new B());

class A{}
class B extends A{}

3. 如果这样写，默认是Object

ArrayList arrayList = new ArrayList(); 
//等价 ArrayList<Object> arrayList = new ArrayList();

自定义泛型

自定义泛型类

//1. Tiger 后面泛型，所以把Tiger成为自定义泛型
//2. T, R, M是泛型的标识符，一般是单个大写字母
//3. 泛型标识符可以有多个
//4. 普通成员可以使用泛型（属性、方法）
//5. 使用泛型的数组不能初始化

class Tiger<T, R, M>{
    String name;
    T t; //属性使用泛型
    R r;
    M m;
    //因为数组在new时，不能确定T的类型，就无法在内存开辟空间
    // T[] ts = new T[5];
    T[] ts;

    public Tiger(String name) {
        this.name = name;
    }

    public Tiger(String name, T t, R r, M m) { //构造器使用泛型
        this.name = name;
        this.t = t;
        this.r = r;
        this.m = m;
    }

    //因为static是和类相关的，在类加载时，对象还没有创建
    //所以如果静态方法和静态属性使用了泛型，JVM就无法完成初始化
    // static R r2;
    // public static void f(M m1){}

    //方法使用泛型
    public T getT() {
        return t;
    }

    public void setT(T t) {
        this.t = t;
    }
}

自定义泛型接口

穿插接口的知识：

• 接口中的属性默认是 public static final修饰的，但一般会省略
• 方法是 public abstract 修饰的，也会省略

1.接口中的静态成员不能使用泛型
2.泛型接口的类型，在继承接口或者实现接口时确定
3.没有指定类型，默认是Object

interface IA extends IUsb<String, Double>{}

//当去实现IA接口时，因为IA继承了IUsb接口，并指定了U为String，R为Double
//在实现IUsb接口的方法时，使用String替换U，用Double替换R
class AA implements IA{

    @Override
    public void hi(Double aDouble) {

    }

    @Override
    public Double get(String s) {
        return null;
    }
}

//实现接口时，直接指定泛型接口类型
//给U指定Integer，给R指定Float
class BB implements IUsb<Integer, Float>{

    @Override
    public void hi(Float aFloat) {

    }

    @Override
    public Float get(Integer integer) {
        return null;
    }
}
// 没有指定类型，默认是Object
class CC implements IUsb{ //相等于 class CC implements IUsb<Object, Object>

    @Override
    public void hi(Object o) {

    }

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

interface IUsb<U, R>{
    int n = 10;
    // U name;  不能这么使用

    //普通方法中，可以使用泛型
    void hi(R r);
    R get(U u);
}

泛型方法

泛型方法可以定义在普通类中，也可以定义在泛型类中

class Car{ //普通类
    //<T, R>就是泛型，提供给fly使用
    public <T, R> void fly(T t, R r){ //泛型方法
        System.out.println(t.getClass()); 
        System.out.println(r.getClass()); 
    }
}

class Fish<T, R>{ //泛型类
    public <U, M> void fly(U u, M m){ //泛型方法
    }
    // hi()方法不是泛型方法  只是使用了类声明的泛型
    public void hi(T t){}
    //泛型方法可以使用类声明的泛型，也可以使用自己声明的泛型
    public<K> void hello(R r, K k){
        System.out.println(r.getClass());
        System.out.println(k.getClass());
    }
}

通配符

	//list<?>表示任意的泛型类型都可以接收
    public static void printCollection1(List<?> c) {
        for (Object object : c) { // 通配符，取出时，就是 Object
            System.out.println(object);
        }
    }
    //<? extends AA> 表示可以接收AA或者AA的子类
    public static void printCollection2(List<? extends AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }
    //<? super AA> 表示可以接收AA或AA的父类，不限于直接父类
    public static void printCollection3(List<? super AA> c) {
        for (Object object : c) {
            System.out.println(object);
        }
    }