Java笔记9

一、泛型Geneirc

1.前身发展

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

泛型就是集合类<泛型>

无泛型写法

public class GeneircTest {
    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);
        }
    }
}

2.泛型的安全机制

软件升级：安全性提高，修复bug错误，改善用户体验，增加功能，提升性能

泛型作用：

强制了集合存储固定的数据类型

泛型书写格式：

        集合类<存储的数据类型>   变量名 = new 集合类<存储的数据类型>();

第二个存储的数据类型可以不写

 出现报错

使用泛型的好处：

①安全性提高

②程序代码量减少

③避免了类型的强制转换

④程序的问题，由运行时期提前到编译时期

3.泛型中的<E>问题

E只是一个变量，表示等待接收指定的数据类型

例：ArrayList<E>

 E变成String

4.自定义泛型类

例：

①定义类

/**
 * 定义类，类名叫工厂
 * 自定义泛型类
 * Factory<什么都可以写>只是变量名
 */

public class Factory<QQ> {
    private QQ q;
    public void setQ (QQ q){
        this.q = q;
    }

    public QQ getQ(){
        return q;
    }

}

②使用

public class GenericTest01 {
    public static void main(String[] args){
        //创建对象Factory类对象
        //Factory factory = new Factory();//没有泛型，QQ就是Object

        Factory<String> factory = new Factory<String>();
        factory.setQ("abc");
        String s = factory.getQ();
        System.out.println(s);

        Factory<Double> factory2 = new Factory<Double>();
        factory2.setQ(1.5);
        Double q = factory2.getQ();
        System.out.println(q);
    }
}

工厂类中将数据类型自定义为“QQ”，方便使用时随时修改数据类型，可随意指定为String、Double等数据类型

5.泛型方法

静态方法参数中的泛型，需要在方法上单独定义，写在返回值类型的前边

public class Factory<Q> {

    //静态方法

    /**
     * 静态方法
     * Q是非静态的，Q的数据类型是new的时候指定的
     *
     * 静态方法参数中的泛型，需要在方法上单独定义
     * 写在返回值类型的前边
     */
    public static <T> void statucMethod(T q){
        System.out.println(q);
    }

    public void print(Q q){
        System.out.println(q);
    }
}

6.泛型接口

①实现类实现接口，不实现泛型

②实现类实现接口，同时实现泛型

例：实现接口,不理会泛型

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

例：实现接口,同时指定泛型

/**
 * 实现接口,同时指定泛型
 */
public class InterImpl2 implements Inter<String> {

    public void inter(String s) {
        System.out.println("s=="+s);
    }
}

public class GenericTest {
    public static void main(String[] args) {
        Inter<String> in = new InterImpl<String>();
        in.inter("ok");

        Inter in2 = new InterImpl2();
        in2.inter("kkk");
    }
}

7.泛型通配符

例：

//泛型的通配符
public class GenericTest {
    public static void main(String[] args) {
        List<String> stringList = new ArrayList<String>();
        stringList.add("abc");
        stringList.add("bbc");

        List<Integer> integerList =  new ArrayList<Integer>();
        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);
        }
    }
}

8.泛型限定

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

<? extends Company> 传递类型可以是Company或者是他的子类

<? extends E>传递E类型或者是E的子类,泛型上限限定

<? super E >传递E类型或者是E的父类,泛型下限限定

例：

public static void main(String[] args) {
    //创建集合,存储员工对象

    //开发部的
    List<Development> devList = new ArrayList<Development>();
    //存储开发部员工对象
    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<Financial> finList = new ArrayList<Financial>();
    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<Integer> integerList = new ArrayList<>();
    //        integerList.add(1);
    //        each(integerList);
}
/**
     * 要求 : 定义方法
     * 同时遍历2个集合
     * 遍历的同时取出集合元素,调用方法work()
     * ? 接收任何一个类型
     * 只能接收 Company和子类对象
     * 明确父类,不能明确子类
     */
public static void each(List<? extends Company> list){
    Iterator<? extends Company> it = list.iterator();
    while (it.hasNext()){
        //取出元素
        Company obj =it.next();
        obj.work();
    }
}

二、增强的for循环