java—泛型

泛型类：

/*
    定义一个含有泛型的类,模拟ArrayList集合
    泛型是一个未知的数据类型,当我们不确定什么什么数据类型的时候,可以使用泛型
    泛型可以接收任意的数据类型,可以使用Integer,String,Student...
    创建对象的时候确定泛型的数据类型
 */
package day2;
public class GeneratorClass<E> {
    private E name;
    public GeneratorClass() {
    }

    public E getName() {
        return name;
    }

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





另起一个类：
package day2;
public class GeneratorClasstes {
    public static void main(String[] args) {
        GeneratorClass<String> a = new GeneratorClass<>();
        a.setName("vergil");
        System.out.println(a.getName());

        GeneratorClass<Integer> b = new GeneratorClass<>();
        b.setName(1);
        System.out.println(b.getName());
    }
}

泛型方法：

/*
定义含有泛型的方法:泛型定义在方法的修饰符和返回值类型之间
    格式:
        修饰符 <泛型> 返回值类型 方法名(参数列表(使用泛型)){
            方法体;
        }
    含有泛型的方法,在调用方法的时候确定泛型的数据类型
    传递什么类型的参数,泛型就是什么类型
 */
package day2;
public class GeneratorMethod {
    public GeneratorMethod() {
    }
    public <M> void method1(M m){
        System.out.println(m);
    }
}





另起一个类：
package day2;
public class GeneratorMethodtes {
    public static void main(String[] args) {
        GeneratorMethod a = new GeneratorMethod();
        a.method1("vergil");
    }
}

泛型集合：

/*
创建集合对象,使用泛型
    好处:
        1.避免了类型转换的麻烦,存储的是什么类型,取出的就是什么类型
        2.把运行期异常(代码运行之后会抛出的异常),提升到了编译期(写代码的时候会报错)
     弊端:
        泛型是什么类型,只能存储什么类型的数据
 */
package day2;
import java.util.ArrayList;
import java.util.Iterator;
public class Generatortes {
    public static void main(String[] args) {
        demo01();
    }

    //抛出异常ClassCastException数据转换异常
    private static void demo01() {
        ArrayList a = new ArrayList();
        a.add("abc");
        a.add(1);
        a.add(1.22);
        Iterator it = a.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
            String st = (String) obj;
            System.out.println(st.length());
        }
    }
}

泛型接口：

接口：
package day2;
public interface GeneratorInterface<I> {
    public abstract void method(I i);
}




接口实现类1：
/*
    含有泛型的接口,第一种使用方式:定义接口的实现类,实现接口,指定接口的泛型
    public interface Iterator<E> {
        E next();
    }
    Scanner类实现了Iterator接口,并指定接口的泛型为String,所以重写的next方法泛型默认就是String
    public final class Scanner implements Iterator<String>{
        public String next() {}
    }
 */
package day2;
public class GeneratorInterfaceImp1 implements GeneratorInterface<String>{
    public GeneratorInterfaceImp1() {
    }

    @Override
    public void method(String s) {
        System.out.println(s);
    }
}




接口实现类2：
/*
    含有泛型的接口第二种使用方式:接口使用什么泛型,实现类就使用什么泛型,类跟着接口走
    就相当于定义了一个含有泛型的类,创建对象的时候确定泛型的类型
    public interface List<E>{
        boolean add(E e);
        E get(int index);
    }
    public class ArrayList<E> implements List<E>{
        public boolean add(E e) {}
        public E get(int index) {}
    }
 */
package day2;
public class GeneratorInterfaceImp2<I> implements GeneratorInterface<I>{
    public GeneratorInterfaceImp2() {
    }

    @Override
    public void method(I i) {
        System.out.println(i);
    }
}




另起一个类：
package day2;
public class GeneratorInterfaceImptes {
    public static void main(String[] args) {
        GeneratorInterfaceImp1 a = new GeneratorInterfaceImp1();
        GeneratorInterfaceImp2 b = new GeneratorInterfaceImp2();
        a.method("vergil");
        b.method("danti");
    }
}

泛型通用符—普通版：

/*
    泛型的上限限定: ? extends E  代表使用的泛型只能是E类型的子类/本身
    泛型的下限限定: ? super E    代表使用的泛型只能是E类型的父类/本身
 */
package day2;
import java.util.ArrayList;
import java.util.Iterator;
public class GeneratorMark {
    public static void main(String[] args) {
        ArrayList<Integer> a = new ArrayList<>();
        a.add(1);
        a.add(2);
        a.add(3);
        System.out.println(a);

        ArrayList<String> b = new ArrayList<>();
        b.add("vergil");
        b.add("danti");
        b.add("alex");

        demo01(a);
        demo01(b);
    }

    private static void demo01(ArrayList<?> list) {
        Iterator<?> it = list.iterator();
        while (it.hasNext()){
            System.out.println(it.next());
        }
    }
}

泛型通用符：

/*
    泛型的上限限定: ? extends E  代表使用的泛型只能是E类型的子类/本身
    泛型的下限限定: ? super E    代表使用的泛型只能是E类型的父类/本身
 */
package day2;
import java.util.ArrayList;
import java.util.Collection;
public class GeneratorMarkhigh {
    public static void main(String[] args) {
        Collection<Integer> list1 = new ArrayList<Integer>();
        Collection<String> list2 = new ArrayList<String>();
        Collection<Number> list3 = new ArrayList<Number>();
        Collection<Object> list4 = new ArrayList<Object>();

        getElement1(list1);
        //getElement1(list2);//报错
        getElement1(list3);
        //getElement1(list4);//报错

        //getElement2(list1);//报错
        //getElement2(list2);//报错
        getElement2(list3);
        getElement2(list4);

        /*
            类与类之间的继承关系
            Integer extends Number extends Object
            String extends Object
         */
    }
    // 泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
    public static void getElement1(Collection<? extends Number> coll){}
    // 泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
    public static void getElement2(Collection<? super Number> coll){}
}