Java(七)——集合框架---泛型Generic

1 泛型 Generic

泛型技术是JDK版本一大升级,源自于JDK1.5

泛型就是集合类<泛型>  

//无泛型写法
public static void main(String[] args) {
    /**
       *  JDK没有泛型技术,就是这样写
       *  集合可以存储任何数据类型
       *  添加元素的数据类型是Object
       */
    List list = new ArrayList();
    list.add("a");
    list.add(1);
    Iterator it = list.iterator();
    while (it.hasNext()){
        Object obj = it.next();//不能类型转换  //类型转换异常
        System.out.println(obj);
    }
}

1.1泛型的安全机制

软件升级 : 安全性提高,修复Bug错误,改善用户体验,增加功能,提升性能

JDK1.5里程碑版本

泛型 作用 : 强制了集合存储固定的数据类型

泛型的书写格式 :

集合类<存储的数据类型>  变量名 = new 集合类<存储的数据类型>();
                                       类型可以不写:钻石操作符

加入泛型后,程序的安全性提升了

    public static void main(String[] args) {
        /**
         *  JDK没有泛型技术,就是这样写
         *  集合可以存储任何数据类型
         *  添加元素的数据类型是Object
         */
        List list = new ArrayList();
        list.add("a");
        list.add(1); //编译错误,数据类型不匹配
 
        Iterator it = list.iterator();
        while (it.hasNext()){
            String obj =it.next(); //类型转换不需要
            System.out.println(obj);
        }
    }

• 使用泛型的好处 :

  • 安全性提高了

  • 程序的代码量减少

  • 避免了类型的强制转换

  • 程序的问题,由运行时期,提前到编译时期

1.2 泛型中的 E 问题

E没有什么实际价值,只是一个变量而已

特殊 : 等待接收指定的数据类型

ArrayList
//创建对象
ArrayList al = new ArrayList();
E 不在是E了,变成String
 
public boolean add(String e) {
 
}

1.3 自定义泛型类

/**
 *  定义类,类名叫工厂
 *  自定义泛型类
 *  Factory<什么都可以写> 只是变量名而已
 */
public class Factory {
    private QQ q;
 
    public void setQ(QQ q){
        this.q = q;
    }
 
    public QQ getQ(){
        return q;
    }
}

public static void main(String[] args) {
    //创建对象Factory类对象
    // Factory factory = new Factory();//没有泛型,QQ就是Object
 
    Factory factory = new Factory();
    factory.setQ("abc");
    String s = factory.getQ();
    System.out.println(s);
 
    Factory factory2 = new Factory();
    factory2.setQ(1.5);
    Double q = factory2.getQ();
    System.out.println(q);
}

1.4 泛型方法

/**
 * 泛型的方法,方法参数上
 */
public class Factory {
 
    /*
     * 静态方法
     * Q是非静态的, Q的数据类型,是new的时候指定的
     *
     * 静态方法参数中的泛型,不能和类一样
     * 静态方法的泛型,需要在方法上单独定义
     * 写在返回值类型的前面
     * 在调用时由于没有指定参数类型，所以可以随意传入任何参数。
     */
    public static  void staticMethod(T q){
        System.out.println(q);
    }
 
    public void print(Q q){
        System.out.println(q);
    }
}

1.5 泛型接口

• 实现类实现接口,不实现泛型

• 实现类实现接口,同时指定泛型

//泛型接口
public interface Inter  {
    public abstract void inter(T t);
}

/**
 * 实现接口,不理会泛型
 * 对象创建的时候,指定类型
 * Inter in = new InterImpl ();
 * in.inter("true123");//true123
 */
public class InterImpl implements Inter{
    public void inter(T t){
        System.out.println(t);
    }
}

/**
 * 实现接口,同时指定泛型
 */
public class InterImpl2 implements Inter {
 
    public void inter(String s) {
        System.out.println("s=="+s);
    }
}

public class GenericTest {
    public static void main(String[] args) {
        Inter in = new InterImpl();
        in.inter("ok");
 
        Inter in2 = new InterImpl2();
        in2.inter("kkk");
    }
}

1.6 泛型通配符“ ？”  

//泛型的通配符
public class GenericTest {
    public static void main(String[] args) {
        List stringList = new ArrayList();
        stringList.add("abc");
        stringList.add("bbc");
 
        List integerList =  new ArrayList();
        integerList.add(1);
        integerList.add(2);
 
        each(stringList);
        each(integerList);
    }
    /**
     * 定义方法,可以同时迭代器 遍历这两个集合
     * 方法的参数,是要遍历的集合,不确定是哪个集合
     * 定义参数,写接口类型,不要写实现类
     */
    public static void each(List list){
        Iterator it = list.iterator();
        while (it.hasNext()){
            Object obj = it.next();
            System.out.println(obj);
        }
    }
}

1.7 泛型限定

泛型限定 : 限制的是数据类型

•   传递类型可以是Company或者是他的子类

•   传递E类型或者是E的子类,泛型上限限定

•   传递E类型或者是E的父类,泛型下限限定

public static void main(String[] args) {
    //创建集合,存储员工对象
 
    //开发部的
    List devList = new ArrayList();
    //存储开发部员工对象
    Development d1 = new Development();
    d1.setName("张三");
    d1.setId("开发部001");
 
    Development d2 = new Development();
    d2.setName("张三2");
    d2.setId("开发部002");
    devList.add(d1);
    devList.add(d2);
 
    //财务部集合
    List finList = new ArrayList();
    Financial f1 = new Financial();
    f1.setName("李四");
    f1.setId("财务部001");
 
    Financial f2 = new Financial();
    f2.setName("李四2");
    f2.setId("财务部002");
    finList.add(f1);
    finList.add(f2);
    System.out.println(devList);
    System.out.println(finList);
 
    each(devList);
    each(finList);
 
    //        List integerList = new ArrayList<>();
    //        integerList.add(1);
    //        each(integerList);
}
/**
     * 要求 : 定义方法
     * 同时遍历2个集合
     * 遍历的同时取出集合元素,调用方法work()
     * ? 接收任何一个类型
     * 只能接收 Company和子类对象
     * 明确父类,不能明确子类
     */
public static void each(List list){
    Iteratorextends Company> it = list.iterator();
    while (it.hasNext()){
        //取出元素
        Company obj =it.next();
        obj.work();
    }
}