Java泛型类（11）

GenricClass类：

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

    public E getName() {
        return name;
    }

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

GenericClassTest类：

package demo23泛型类;

public class GenericClassTest {
    public static void main(String[] args) {
        //不写默认Object类型
        GenricClass gc=new GenricClass();
        gc.setName("只能是字符串");
        Object name=gc.getName();
        System.out.println(name);

        //创建GenericClass对象，泛型使用Integer
        GenricClass<Integer> gc2=new GenricClass<>();
        gc2.setName(1);
        Integer name2=gc2.getName();
        System.out.println(name2);

        创建GenericClass对象，泛型使用String
            GenricClass<String> gc3=new GenricClass<>();
        gc3.setName("小明");
        String name1=gc3.getName();
        System.out.println(name1);
    }
}

 Generic类：

package demo23泛型类;

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


public class Generic {
    public static void main(String[] args) {
      show01();//运行会报异常ClassCastException类型转换异常，1不能转换字符串类型
      //  show02();
    }

    private static void show02() {
        /*
        创建集合对象，使用泛型
        好处：
  集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
  把运行期的异常，（代码运行之后出现的异常），提升到编译器（写代码的时候会报错）
  弊端：
  泛型是什么类型，只能存储什么类型
         */
        ArrayList<String> list=new ArrayList();
        list.add("abc");

        Iterator<String> it=list.iterator();
        //使用迭代器遍历list集合
        while(it.hasNext()){
            String s=it.next();
            System.out.println(s+"--->"+s.length());
        }


    }

    private static void show01() {
        /*
创建集合对象，不使用泛型
好处：
  集合不使用泛型，默认的类型就是Object类型，可以存储任意类型的数据
弊端：
  不安全，会引发异常
 */
        ArrayList list=new ArrayList();
        list.add("abc");
        list.add(1);//下面因为要转换为字符串，运行会报异常ClassCastException类型转换异常，1不能强制转换字符串类型
        //使用迭代器遍历集合list
        //获取迭代器
        Iterator it=list.iterator();
        while(it.hasNext()){
            //取元素也是Object类型
            Object obj= it.next();
            System.out.println(obj);

            //想要String类特有的方法 length获取字符串的长度；不能使用 需要向下转型 多态 Object obj="abc"; 多态的弊端不能使用子类的方法
            //需要向下转型 Object--String
            String s=(String)obj;
            System.out.println(s.length());
        }
    }

}

 

 GenericMethod类：

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

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

 GenericMethodTest类：

package demo24泛型的方法;
/*
测试泛型方法
 */
public class GenericMethodTest {
    public static void main(String[] args) {
        //创建泛型对象
        GenericMethod gm=new GenericMethod();
        //调用含有泛型的方法method01 传递什么类型，泛型就是什么类型
        gm.method01("10");
        gm.method01("abc");
        gm.method01(8.8);
        gm.method01(true);

        gm.method02("静态方法，不建议创建对象使用");
        //静态方法，通过类名.方法名直接使用
        GenericMethod.method02(1);

    }
}

 GenericInterface接口：

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

GenericInterfaceImpl1类：

package demo25泛型接口;
/*
含有泛型的接口，第一种使用方式：定义接口的实现类，实现接口,指定接口的类型

Scanner类实现了Iterator接口，并指定接口的泛型为String，所以重写的next方法泛型就是string
public final class Scanner impments Iterator<String>{
  public String next(){};
}
 */
public class GenericInterfaceImp1 implements GenericInterface<String> {
    @Override
    public void method(String s) {
        System.out.println(s);
    }
}

GenericInterfaceImpl2类：

package demo25泛型接口;
/*
含有泛型接口的第二种使用方法：接口使用什么类型，实现类就使用什么类型，类跟着接口走
就相当于定一个一个含有泛型的类，创建对象的时候确定泛型的类型
public interface List<E>{
   boolean add(E e);
   E get(int index);
}
public calss ArrayList<E> inplements List<E>{
   public boolean add(E e){}
   public E get(int index){}
}
 */
public class GenericInterfaceImp2<I> implements GenericInterface<I>{
    @Override
    public void method(I i) {
        System.out.println(i);
    }
}

Test类：

package demo25泛型接口;

public class Test {
    public static void main(String[] args) {
        //创建GenericInterfaceImp1对象
        GenericInterfaceImp1 gi1=new GenericInterfaceImp1();
        gi1.method("字符串");

        //创建GenericIterfaceImp2对象
        GenericInterfaceImp2<Integer> gi2=new GenericInterfaceImp2<>();
        gi2.method(10);

        GenericInterfaceImp2<Double> gi3=new GenericInterfaceImp2<>();
        gi3.method(8.8);
    }
}

 DemoGeneric类：

package demo26泛型的通配符;

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");

        printArray(list01);
        printArray(list02);

       // ArrayList<?> list03=new ArrayList<?>();错误的，不能创建对象使用，但是参数传递的时候使用

    }
    /*
    定义一个方法，能遍历所有的类型的ArrayList集合
    这时候我们不知道Arraylist集合使用什么数据类型，可以使用泛型的通配符？来接收数据
    注意：
       泛型没有继承概念的
     */
    public static void printArray(ArrayList<?> list){//<>中如果写String，上面调用的时候printArray(list01)会报错，也不能写Object，所以使用？代表位置的类型
        //使用迭代器遍历集合
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            //it.next()方法，取出的元素时Object，可以接收任意的数据类型
            Object o=it.next();
            System.out.println(o);
        }
    }
}

DemoGeneric类：

package demo26泛型的通配符;

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");

        printArray(list01);
        printArray(list02);

       // ArrayList<?> list03=new ArrayList<?>();错误的，不能创建对象使用，但是参数传递的时候使用

    }
    /*
    定义一个方法，能遍历所有的类型的ArrayList集合
    这时候我们不知道Arraylist集合使用什么数据类型，可以使用泛型的通配符？来接收数据
    注意：
       泛型没有继承概念的
     */
    public static void printArray(ArrayList<?> list){//<>中如果写String，上面调用的时候printArray(list01)会报错，也不能写Object，所以使用？代表位置的类型
        //使用迭代器遍历集合
        Iterator<?> it=list.iterator();
        while(it.hasNext()){
            //it.next()方法，取出的元素时Object，可以接收任意的数据类型
            Object o=it.next();
            System.out.println(o);
        }
    }
}

 Demo01Generic类：

package demo26泛型的通配符;

import java.util.ArrayList;
import java.util.Collection;

/*
泛型的上限限定：？ extends E 代表使用的泛型只能是E类型的子类/本身
泛型的下限限定：？ super E 代表使用泛型只能是E类型的父类/本身

 */
public class Demo01Generic {
    public static void main(String[] args) {
        Collection<Integer> list1=new ArrayList<>();
        Collection<String> list2=new ArrayList<>();
        Collection<Number> list3=new ArrayList<>();
        Collection<Object> list4=new ArrayList<>();

        getElement1(list1);
        //getElement1(list2);//不是它的子类或本身会报错
        getElement1(list3);
       // getElement1(list4);//不是它的子类或本身会报错

        //getElement2(list1);//不是它的父类或本身 会报错
        //getElement2(list2);//不是它的父类或本身 会报错
        getElement2(list3);
        getElement2(list4);
    }

    /*
    上面类之间的继承关系
      Integer extends Number extends Object
      String extends Object
     */

    //泛型的上限限定：？ extends E 代表使用的泛型只能是E类型的子类/本身
    public static void getElement1(Collection<? extends Number> coll) {

    }
    //泛型的下限限定：？ super E 代表使用泛型只能是E类型的父类/本身
    public static void getElement2(Collection<? super Number> coll) {

    }
}