Java基础-泛型

　　　　　　　　　　　　　　　　　　　　Java基础-泛型

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

一.泛型的引入

　　由于集合可以存储任意类型的元素，导致取出时，如果出现强转就会引发运行时异常（ClassCastException）。怎么解决这个问题呢？使用集合时，必须明确集合中元素的类型。这种方式称为泛型。一旦我们给一个集合定义泛型，那就意味着这个集合只能传入指定的数据类型。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

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

public class GenericDemo {
    public static void main(String[] args) {
        Collection coll = new ArrayList();
        coll.add("yinzhengjie");
        coll.add("尹正杰");
        coll.add("Java");
        coll.add(2018);
        
        Iterator it = coll.iterator();
        while(it.hasNext()){
            Object obj = it.next();
            //在进行强转操作时，需要对数据进行判断，判断传入的数据是否为String类型，如果是则进行向下转型操作！
            if(obj instanceof String) {
                String str = (String)obj;
                System.out.println(str.toUpperCase());
            }
        }
    }
}


/*
以上代码执行结果如下：
YINZHENGJIE
尹正杰
JAVA
*/

　　JDK1.5出现新的安全机制，保证程序的安全性，就是我们今天要说明的泛型，它指明了集合中存储数据的类型。

二.泛型的定义与使用

 　　看了上面的代码，你可以明显的发现可以往一个结合里面塞各种数据类型，但是在遍历该集合的每一个元素时，你会清楚的知道，需要对不同的数据类型做相应的向下转型，这样才能使用元素本身的方法。这样就给程序员带了很多麻烦，需要对引用数据类型做断言操作，如果在定义集合时就规定好传入的数据类型就可以避免断言操作啦！我们可以对上面的代码用泛型对代码进行改进如下：

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

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

public class GenericDemo {
    public static void main(String[] args) {
        //后面的ArrayList是可以不写数据类型的，默认与前面的相同，我们称为菱形语法！
        Collection<String> coll = new ArrayList<>();
        coll.add("yinzhengjie");
        coll.add("尹正杰");
        coll.add("Java");
//        coll.add(2018);        #这里的基本数据类型会自动装箱为Integer类型，很显然和String不是一种类型，无法添加到该集合
        
        //创建迭代器的时候也会传入相应的泛型。
        Iterator<String> it = coll.iterator();
        while(it.hasNext()) {
            //此处也不需要做向下转型，直接就可以调用String的方法啦！
            System.out.println(it.next().toUpperCase());
        }
    }
}


/*
以上代码执行结果如下：
YINZHENGJIE
尹正杰
JAVA
*/

 　　综上所述，我们可以归纳泛型有两大好处：

　　　　　　1>.将运行时期的ClassCastException转移到了编译时期变成了编译失败。

　　　　　　2>.避免了类型转换的麻烦。

三.Java中的伪泛型

 　　java中的泛型是伪泛型（也就是假的泛型）。Java中的泛型只是一种编译手段。比如：“ArrayList<Integer> arr = new ArrayList<>();”很明显就是泛型，当然你调用"arr.add(Integer number)"方法往arr集合中添加元素时，若该元素不是Integer类型时就会编译失败，若该元素是Integer类型，则会编译成功。但是编译后的字节码文件（*.class）中是没有泛型的。

　　Java中泛型只是在编译时候才会体现，一旦编译成功后的字节码文件中压根就没有泛型的踪影，这就是Java的伪泛型。那么问题来了，既然Java运行时并没有泛型那还能保证数据的安全性吗？答案是肯定的，因为在编译的时候，不符合的数据类型是不会让代码编译通过的。所以Java靠编译手段完全是可以保证安全性。Java反编译字节码文件后你会发现源代码是没有泛型的哟！

四.自定义泛型类

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

import java.util.Date;

//定义泛型类
class Student<T>{
    T score;//String score;Integer score;
    //泛型方法
    public void setScore(T t){
        score = t;
    }
    public T getScore(){
        return score;
    }
}

public class GenericDemo{
    public static void main(String[] args) {
        
        Student<Integer> s1 = new Student<Integer>();　　//指定泛型为Integer类型
        s1.setScore(10);　　　　　　　　　　　　　　　　　　//传递参数的时候就必须为Integer类型
        System.out.println(s1.getScore());
            
        Student<String> s2 = new Student<>();      //指定泛型为String类
        s2.setScore("优秀");　　　　　　　　　　　　//传参数的时候就必须为String类型
        System.out.println(s2.getScore());
    }

}


/*
以上代码执行结果如下：
10
优秀
*/

五.自定义泛型方法

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

import java.util.Date;



import java.util.Date;

//定义泛型方法.
class Generic1{
    //泛型方法
    public <T>void show(T t){//相当于Object
        System.out.println(t);
    }
}

public class GenericDemo{

    public static void main(String[] args) {

        Generic1 g1 = new Generic1();
        
        g1.show("yinzhengjie");        //存储String类型
        g1.show(2018);                //存储Integer类型
        g1.show(new Date());        //存储Date类型
        
    }
}


/*
以上代码执行结果如下：
yinzhengjie
2018
Wed Apr 25 13:25:45 GMT+08:00 2018
*/

六.自定义泛型接口

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

//定义泛型接口
interface InterA<T>{
    public abstract void show(T t);
}

//接口实现类
//实现类知道接口中的具体类型,此时实现类可以是非泛型类
class A implements InterA<String>{

    @Override
    public void show(String t) {
        System.out.println(t);
    }
    
}

//实现类在实现接口时,本身还是一个泛型类
class B<T> implements InterA<Integer>{
    @Override
    public void show(Integer t) {
        System.out.println(t);
    }
    
    public void show2(T t) {
        System.out.println(t);
    }
    
}

//实现类也不知道接口中泛型的具体类型,那么子类也是一个泛型类
class C<T> implements InterA<T>{

    @Override
    public void show(T t) {
        System.out.println(t);
    }
}

public class GenericDemo{
    public static void main(String[] args) {
        A a = new A();
        a.show("yinzhengjie");
        
        
        B<String> b = new B<>();
        b.show(2018);
        b.show2("尹正杰");
        
        C<Integer> c = new C<>();
        c.show(5200);
    }
}



/*
以上代码执行结果如下：
yinzhengjie
2018
尹正杰
5200
*/

七.泛型的通配符

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;

public class GenericDemo{
    public static void main(String[] args) {
        ArrayList<String> array = new ArrayList<String>();
        HashSet<Integer> set = new HashSet<Integer>();
        array.add("yinzhengjie");
        array.add("尹正杰");
        
        set.add(2018);
        set.add(328);
        
        iterator(array);
        iterator(set);
        
    }
    
    //定义方法，可以同时迭代2个集合，使用泛型的通配符"?"
    public static void iterator(Collection<?> coll) {
        //泛型通配符“？”可以匹配所有的数据类型。
        Iterator<?> it = coll.iterator();
        while(it.hasNext()) {
            //it.next())获取的对象应该是Object类型，此处我们最好不要强制转型，因为我们不知道传入的迭代对象是set还是array！
            System.out.println(it.next());
        }
    }
    
    
}



/*
以上代码执行结果如下：
yinzhengjie
尹正杰
2018
328
*/

八.泛型的限定

　　1>.* ? extends Animal : 上限限定,限制的是父类，即Animal和它的子类可以使用.

　　2>.* ? super Animal: 下限限定,限制的是子类，即Animal和它的父类都可以使用.

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;


import java.util.Collection;

/*
 * 泛型类是没有多态性
 * 泛型如何实现类似于多态性?
 *     通配符能实现
 *   ? 
 *   ? extends Animal : 上限限定,Animal和它的子类可以使用
 *   ? super Animal: 下限限定,Animal和它的父类都可以使用
 * 
 * 类型限定的使用
 * 
 */
class Animal {

}

class Dog extends Animal {

}

class Cat extends Animal {

}

class Demo<T> {

}

class DemoTest {
    public void test6(Collection<? extends Animal> c){//
        //由于不知道具体的类型,所以不能放东西
//        c.add(null);
        //由于元素的类型要么是Animal,要么是它的子类,都可以使用Animal去接
        for (Animal animal : c) {
        
        }
    }
    public void test7(Collection<? super Animal> c){//
        //由于不知道具体的类型,但是我知道都是Animal或者是它的父类,Animal和它的子类可以自动转成Animal
        c.add(new Animal());
        c.add(new Dog());
        c.add(new Cat());
//        c.add(new Object());
        //由于不知道类型的上限,所以不能往外拿元素,Object是所有类的鼻祖，此处我们需要忽略它。
//        for (Object object : c) {
//            
//        }
    }
    
    public void test(Demo<Animal> d) {// 多态?Demo<Dog>

    }
    public void test2(Demo<?> d) {// 相当于Object，但是如果你写Object的话，那么传入的对象就只能是Object啦！

    }
    public void test3(Demo<Object> d) {// 相当于Object，调用者此处传入的必须是Object类，不能是其子类。
        
    }
    
    public void test4(Demo<? extends Animal> d){//Animal或者它的子类
        
    }
    public void test5(Demo<? super Animal> d){//Animal或者它的父类都可以使用
        
    }
}

public class GenericDemo1 {

    public static void main(String[] args) {
        DemoTest dt = new DemoTest();
        
        
        dt.test5(new Demo<Animal>());
        dt.test5(new Demo<Object>());
//        dt.test5(new Demo<Dog>());//NG

//        dt.test4(new Demo<Animal>());
//        dt.test4(new Demo<Dog>());
//        dt.test4(new Demo<Cat>());
//        dt.test4(new Demo<Object>());//NG
        
        
        
//        dt.test2(new Demo<Integer>());

        // Demo<Dog> d = new Demo<Dog>();
        // Demo<Animal> d2 = new Demo<>();

        // dt.test(d2);//Demo<Animal> Demo<Dog>

    }

}

案例展示：

　将酒店员工，厨师，服务员，经理，分别存储到3个集合中，定义方法可以同时遍历这3个集合，遍历三个集合的同时，可以调用工作方法。

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

public abstract class Employee {
    public  abstract  void Work();
}

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

public class Waiter extends Employee {
    private String name;
    private String department;
    public Waiter() {
        super();
    }
    public Waiter(String name, String department) {
        super();
        this.name = name;
        this.department = department;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDepartment() {
        return department;
    }
    public void setDepartment(String department) {
        this.department = department;
    }
    @Override
    public void Work() {
        System.out.println(this.getName()+" 正在工作中......");
    }
    
    
    
}

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

public class Cook extends Employee {
    private String name;
    private String department;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDepartment() {
        return department;
    }
    public void setDepartment(String department) {
        this.department = department;
    }
    public Cook() {
        super();
    }
    public Cook(String name, String department) {
        super();
        this.name = name;
        this.department = department;
    }
    @Override
    public void Work() {
        System.out.println(this.getName()+" 正在工作中......");
        
    }
    
}

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

public class LobbyManager extends Employee {
    private String name;
    private String department;
    private double bonus;
    public LobbyManager() {
        super();
    }
    public LobbyManager(String name, String department, double bonus) {
        super();
        this.name = name;
        this.department = department;
        this.bonus = bonus;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getDepartment() {
        return department;
    }
    public void setDepartment(String department) {
        this.department = department;
    }
    public double getBonus() {
        return bonus;
    }
    public void setBonus(double bonus) {
        this.bonus = bonus;
    }
    @Override
    public void Work() {
        System.out.println(this.getName()+" 正在工作中......");
    }

}

/*
@author :yinzhengjie
Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
EMAIL:y1053419035@qq.com
*/

package cn.org.yinzhengjie.note;

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

public class GenericDemo {
    public static void main(String[] args) {
        //创建三个集合对象
        ArrayList<Cook> cook = new ArrayList<>();
        ArrayList<Waiter> waiter = new ArrayList<>();
        ArrayList<LobbyManager> manager = new ArrayList<>();
        
        //每个集合都存储自己的元素
        cook.add(new Cook("邓西西","主厨001"));
        cook.add(new Cook("方合意","主厨002"));
        
        waiter.add(new Waiter("陶涛","服务部门001"));
        waiter.add(new Waiter("邓西","服务部门002"));
        
        manager.add(new LobbyManager("桂阳","董事会",12463125247.28));
        manager.add(new LobbyManager("李洋","董事会",12463125247.28));
        iterator(cook);
        iterator(waiter);
        iterator(manager);
        
    }
    //上限限定,可以传递Employee以及传递他的子类对象。
    public static void iterator(ArrayList<? extends Employee> array) {
        Iterator<? extends Employee> it = array.iterator();
        while(it.hasNext()) {
            //获取出来的it.next()的数据类型是Employee，因为我们并不知道它传入的是什么类型的子类。
            Employee e = it.next();
            e.Work();
        }
    }
}



/*
以上代码执行结果如下：
邓西西 正在工作中......
方合意 正在工作中......
陶涛 正在工作中......
邓西 正在工作中......
桂阳 正在工作中......
李洋 正在工作中......
*/