250/251定义和使用含有泛型的的接口和泛型通配符

定义和使用含有泛型的接口

定义格式∶

修饰符interface接口名<代表泛型的变量>{}

 

 

/*
  定义含有泛型的接口
 */
public interface GenericInterface<I> {
    public abstract void method(I i);
}

 

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

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

/*
 * 测试含有泛型的接口
 */
public class Demo04GenericInterface {
    public static void main(String[] args) {
        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl1 gi1 = new GenericInterfaceImpl1();
        gi1.method("字符串");//字符串
        
        //创建GenericInterfaceImpl1对象
        GenericInterfaceImpl2<Integer> gi2 = new GenericInterfaceImpl2<>();
        gi2.method(8);
        GenericInterfaceImpl2<Double> gi3 = new GenericInterfaceImpl2<>();
        gi3.method(8.8);
    }
}

public class GenericClass<E> {
    private E name;

    public E getName() {
        return name;
    }

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

public class Demo02Test {

    /**
     * 测试类
     *
     */
    public static void main(String[] args) {
        //不写泛型默认为Object类型
        GenericClass gc = new GenericClass();
        gc.setName("qqqq");
        Object name = gc.getName();
        System.out.println(name);

        /**
         * 创建GenericClass对象 泛型使用Integer类型
         */
        GenericClass<Integer> gc2 = new GenericClass<Integer>();
        gc2.setName(1);
        Integer name1 = gc2.getName();
        System.out.println(name1);
        /**
         * 创建GenericClass对象，泛型使用String类型
         */
        GenericClass<String> gc3 = new GenericClass<String>();
        gc3.setName("卢本伟");
        String name2 = gc3.getName();
        System.out.println(name2);
    }
}

  public static void main(String[] args) {
        //show01();
        show02();
    }
    /*
        创建集合对象，使用泛型
        好处：
            1.避免了类型转换的麻烦，存储的是什么类型，取出的就是什么类型
            2.把运行期异常（代码运行之后会抛出的异常），提升到编译期（写代码的时候就会报错)
        弊端：
            泛型是什么类型，只能存储什么类型的数据
    */
    private static void show02() {
        ArrayList<String> list = new ArrayList<>();
        list.add("abc");
        //list.add(1);//add(java.lang.String)in ArrayList cannot be applied to (int)

        //使用迭代器遍历list集合
        Iterator<String> it = list.iterator();
        while(it.hasNext()) {
            String s = it.next();
            System.out.println(s+"->"+s.length());
        }
    }
    /*
        创建集合对象，不使用泛型
        好处：
           集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
        弊端：
           不安全，会引发异常
        */
    private static void show01(){
        ArrayList list = new ArrayList();
        list.add("abc");
        list.add(1);

        //使用迭代器遍历list集合
        //获取迭代器
        Iterator it = list.iterator();
        //使用迭代器中的方法hasNext和next遍历集合
        while (it.hasNext()) {
            //取出元素也是Object类型
            Object obj = it.next();
            System.out.println(obj);

            //想要使用String类特有的方法，length获取字符串的长度;不能使用 多态 Object obj = “abc”;
            //需要向下转型
            //会抛出ClassCastException类型的转换异常，不能把Integer类型转换为String类型
            String s = (String) obj;
            System.out.println(s.length());
        }
    }
}

泛型通配符

当使用泛型类或者接口时，传递的数据中，泛型类型不确定，可以通过通配符<?>表示。但是一旦使用泛型的通配符后，只能使用Object类中的共性方法，集合中元素自身方法无法使用。

 

泛型的通配符:不知道使用什么类型来接收的时候,此时可以使用?,?表示未知通配符.

　　此时只能接受数据,不能往该集合中存储数据。

泛型的通配符:

　　?:代表任意的数据类型

使用方式:
　　不能创建对象使用

　　只能作为方法的参数使用

public static void main(String[] args) {
        ArrayList<Integer> integers = new ArrayList<>();
        integers.add(1);
        integers.add(2);

        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");

        printArray(integers);
        printArray(list);

        /*
              错误写法
              ArrayList<?> objects = new ArrayList<?>();
         */
    }
    /*
          定义一个方法，能遍历所有类型的ArrayList集合
          这时候我们不知道ArrayList集合使用什么数据类型，可以泛型的通配符 ？ 来接受数据类型
          注意：
              泛型没有继承概念的
       */
    public static void printArray(ArrayList<?> list){
        //使用迭代器遍历集合
        Iterator<?> iterator = list.iterator();
        while (iterator.hasNext()){
            //iterator.next()方法，取出的元素是Object，可以接受任意的数据类型
            Object next = iterator.next();
            System.out.println(next);
        }

    }

public static void main(String[] args){
    //可以存储整数的集合
    Collection<Integer> list01 = new ArrayList<Integer>();
    //此时list01可以存储整数的数据
    //展示list01集合当中的数据
    getElement(list01);
    //可以存储String字符串集合
    Collection<String> list02 = new ArrayList<String>();
    //此时list02可以存储字符串的数据
    //getElement(list02);//如果方法的接受的行参类型的集合的泛型是Object，那么这么写是错误的  Collection<Object>    x    不可以的
    //此时如果换成泛型通配符?就可以接收
    getElement(list02);//可以
}
/*public static void getElement(Collection<Object> coll){
    
}*/
public static void getElement(Collection<?> coll){
    //只能接收Integer类型的数据
    //此时？可以代表任意类型
}

 

 

通配符高级使用----受限泛型

之前设置泛型的时候，实际上是可以任意设置的，只要是类就可以设置。但是在JAVA的泛型中可以指定一个泛型的上限和下限。

泛型的上限:

　　格式:类型名称<extends类〉对象名称

　　意义︰只能接收该类型及其子类

泛型的下限:

　　格式︰类型名称〈?super类〉对象名称

　　意义︰只能接收该类型及其父类型

泛型的上限限定:? extends E代表使用的泛型只能是E类型的子类/本身

泛型的下限限定:? super E代表使用的泛型只能是E类型的父类/本身

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){}

上限通配符

//现已知Object类、String类、Number类、Integer类，其中Number是Integer的父类。
public static void main(String[] args){
 
    //通配符"?"在创建泛型类对象时限制泛型类的类型
    Collection<? extends Number> list1 = null; 
    list1 = new ArrayList<Integer>(); //Integer类是Number类型的子类
    //list1 = new ArrayList<String>(); //报错,String类不是Number类型或Number类型的子类
 
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
    Collection<Object> list4 = new ArrayList<Object>();
 
    //可以将由通配符限制的泛型类对象用在方法的参数中以防传入不允许接收的类型对象
    getElement(list1); //Integer类是Number类型的子类
    getElement(list2); //报错,String类不是Number类型或Number类型的子类
    getElement(list3); //是Number类型
    getElement(list4); //报错,Object类是所有类的默认父类
}
 
//泛型的上限：此时的泛型?，必须是Number类型或者Number类型的子类
public static void getElement(Collection<? extends Number> coll){}

下限通配符

​//现已知Object类、String类、Number类、Integer类，其中Number是Integer的父类。
public static void main(String[] args){
 
    //通配符"?"在创建泛型类对象时限制泛型类的类型
    Collection<? super Number> list1 = null; 
    //list1 = new ArrayList<Integer>(); //报错,Integer类不是Number类型的父类
    //list1 = new ArrayList<String>(); //报错,String类不是Number类型或Number类型的父类
    list1 = new ArrayList<Object>();
 
    Collection<String> list2 = new ArrayList<String>();
    Collection<Number> list3 = new ArrayList<Number>();
 
    //可以将由通配符限制的泛型类对象用在方法的参数中以防传入不允许接收的类型对象
    getElement(list1); //Object类是所有类的默认父类
    getElement(list2); //报错,String类不是Number类型或Number类型的父类
    getElement(list3); //是Number类型
}
 
//泛型的下限：此时的泛型?，必须是Number类型或者Number类型的父类
public static void getElement(Collection<? super Number> coll){}​