Java小记——泛型

目录

泛型

泛型类

泛型接口

泛型方法

泛型通配符

---

泛型

泛型机制：是一种把数据类型明确工作，推迟到创建对象或调用方法时，才去明确的一种机制。

泛型可以使用在 类，接口，方法上。

泛型的语法 <E,Y> E Y 就是代号，一般取大写字母，当然是引用数据类型

泛型的注意事项：泛型只在编译期有效，在运行期泛型就擦除了。

泛型好处，可以把问题提前编译期，泛型有良好的扩展性。

泛型，可以避免向下转型。

        ArrayList list = new ArrayList();
        list.add(200);
        list.add("abc");
        list.add(false);
        Object obj = list.get(0);
        //向下转型
        Integer num = (Integer) obj;
        Object o = list.get(1);
        String two = (String) o;

一般来说，我们不会在容器中存储多种数据类型，一般我们只在容器中存储同一种数据类型。

        ArrayList<String> list2 = new ArrayList<String>();
        list2.add("abc");
        list2.add("abc");
        list2.add("hello");
        list2.add("world");
        //list2.add(100);    // 只能放String类型

        String s = list2.get(0);
        String s2 = list2.get(1);

想要在集合中存储多种引用数据类型。还得把泛型写上

        ArrayList<Object> list3 = new ArrayList<>();
        list3.add(200);
        list3.add("abc");

为了避免向下转型，有了泛型类

泛型类

把泛型定义在类上

格式：public class 类名<泛型类型1,…>   

泛型类型必须是引用类型

class MyObject<X, Y> {

    private X x;
    private Y name;

    public X getX() {
        return x;
    }

    public void setX(X x) {
        this.x = x;
    }

    public Y getName() {
        return name;
    }

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


public class MyTest {
    public static void main(String[] args) {
        //泛型机制：是一种把数据类型明确工作，推迟到创建对象时，才去明确的一种机制。
        MyObject<Integer, String> myObject = new MyObject<>();
        myObject.setX(200);
        Integer x = myObject.getX();

        System.out.println("===================");
        MyObject<String, String> stringMyObject = new MyObject<>();
        stringMyObject.setX("Abc");
        String x1 = stringMyObject.getX();
    }
}

泛型接口

把泛型定义在接口上

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

使用场景：

实现类去实现一个接口，可以明确泛型接口上定义的那个泛型的具体数据类型

interface MyInterface<X> {
    public abstract void show(X x);

}

class AA implements MyInterface<Integer> {
    @Override
    public void show(Integer integer) {

    }
}

public class MyTest {
    public static void main(String[] args) {
        AA aa = new AA();
        
    }
}

当一个类实现一个泛型接口时，还是不想急于去明确这个接口上的泛型的具体类型，那么这个类继续设计为泛型类

class BB<X> implements MyInterface<X> {

    @Override
    public void show(X x) {

    }
}

public class MyTest {
    public static void main(String[] args) {
       
        BB<String> stringBB = new BB<>();
        stringBB.show("abc");
    }
}

public interface Collection<E>

public interface List<E> extends Collection<E>

public class ArrayList<E> implements List<E>

泛型方法

public class MyCalc {

  /*  public void show(String s){
        System.out.println(s);
    }

    public void show(Integer num) {
        System.out.println(num);
    }

    public void show(Double num) {
        System.out.println(num);
    }*/

  /*  public void show(Object s) {
        System.out.println(s);
    }*/      //避免向下转型

    //泛型方法
    public <P> void show(P p) {
        System.out.println(p);
    }
}

泛型通配符

任意类型，如果没有明确，那么就是Object以及任意的Java类了

// ? 表示任意的数据类型

Collection<?> col5 = new ArrayList<Object>() ;

Collection<?> col6 = new ArrayList<Animal>() ;

? extends E:            向下限定，E及其子类

Collection<? extends Animal> col9 = new ArrayList<Object>() ;//报错

Collection<? extends Animal> col10 = new ArrayList<Animal>() ;

Collection<? extends Animal> col11 = new ArrayList<Dog>() ;

? super E:            向上限定，E及其父类

Collection<? super Animal> col13 = new ArrayList<Object>() ;
Collection<? super Animal> col14 = new ArrayList<Animal>() ;

Collection<? super Animal> col15 = new ArrayList<Dog>() ;//报错