泛型

关于泛型

定义一个含有泛型的类，模拟ArrayList集合
泛型是一个未知数据类型，当我们不确定什么数据类型的时候可以使用泛型
泛型可以接收任何数据类型，可以使用Integer，String，student。。。
创建对象的时候确定泛型类型

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

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

public class demoGenericClass {
    public static void main(String[] args) {
        GenericClass gc=new GenericClass();
        gc.setName("可以是任意类型，object");
        Object obj=gc.getName();
        System.out.println(obj);
        GenericClass<String> gc1=new GenericClass();
        gc1.setName("xiaoming");
        String name= gc1.getName();
        System.out.println(name);
        GenericClass<Integer> gc2=new GenericClass();
        gc2.setName(1);
        Integer i= gc2.getName();
        System.out.println(i);
    }
}

含有泛型的静态方法

定义含有泛型的方法：泛型定义在方法的修饰符和返回值之间
格式：修饰符<泛型>返回值类型 方法名（参数列表（使用泛型））{
方法体；
}
含有泛型的方法，在调用方法的时候确定泛型的数据类型
传递什么类型的参数，泛型就是什么类型

public class GenericMethod {
    public <M> void method01(M m){//定义一个含有泛型的方法
        System.out.println(m);
    }
    public static <S> void method02(S s){
        System.out.println(s);
    }
}

创建一个测试类

/*调用含有泛型的方法，传递什么泛型就是什么泛型*/
public class demo01GenericMethod {
    public static void main(String[] args) {
        GenericMethod gn=new GenericMethod();
        gn.method01(10);
        gn.method01("abc");
        gn.method01(8.8);
        GenericMethod.method02("静态方法不建议创建对象使用");//静态方法也可以传递任意类型
        GenericMethod.method02(111);
    }
}

含有泛型的接口

义一个含有泛型的接口

public interface GenericInterface<I> {
    public abstract void method(I i);
}

泛型接口第二种使用方法：接口使用的是什么泛型，实现类就使用什么泛型，类跟着接口走
就相当于定义了一个含有泛型的类，创建对象的时候确定泛型的类型
public interface List{
boolean add(E e){};
public E get(int index){}
}

public class GenericInterfaceImpl<I> implements GenericInterface<I> {
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

/*含有泛型的接口第一种使用方式：定义接口的实现类，实现接口，指定接口的泛型*/
public class GenericInterfaceImpl1 implements GenericInterface <String>{
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

定义一个测试类测试

public class demo {
    public static void main(String[] args) {
        GenericInterfaceImpl1 ge1 =new GenericInterfaceImpl1();
        ge1.method("第一种泛型接口使用方法");
        GenericInterfaceImpl<Integer> ge02=new GenericInterfaceImpl();
        ge02.method(80);
        GenericInterfaceImpl<Double>ge03=new GenericInterfaceImpl<>();
        ge03.method(0.2);
    }
}

关于泛型通配符

泛型的通配符：
？：代表任意的数据类型
使用方法：不能创建对象使用，只能作为参数使用

import java.util.ArrayList;
import java.util.Iterator;

/*泛型的通配符：
？：代表任意的数据类型
使用方法：不能创建对象使用，只能作为参数使用*/
public class demoGeneric {
    public static void main(String[] args) {
        ArrayList<Integer> list01=new ArrayList<>();
        list01.add(1);
        list01.add(2);
        ArrayList<String> list02=new ArrayList<>();
        list02.add("a");
        list02.add("b");
        list02.add("c");
        demo01(list01);
        demo01(list02);
    }
    /*定义一个方法，能遍历所有的类型的ArrayList集合
    这时候我们不知道ArrayList集合是什么类型，可以使用泛型的通配符？来接收数据类型
    注意：泛型没有继承，所以不能用Object来代替，在定义是不能使用泛型通配符来定义，只有传递参数时才可以*/
    public static void demo01(ArrayList<?> list){
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            Object o=it.next();
            System.out.println(o);
        }
    }
}