泛型

泛型(generics)
1.概述
A.泛型的本质是参数化类型：
强语言总需要明确变量的"类型"，"明确类型"的工作是必需的，一般是"立刻马上"，譬如定义一个int型数据、定义一个对象。
所谓参数化类型，是将"类型"当参数一样传递，这样就提供了一种"延迟明确类型"机制。譬如：你在定义类时，可以使用泛型，
让调用者来做"明确类型"工作，也就是传一个"类型"给你在类中的泛型。
B.泛型只能用在引用类型上
C.格式  <数据类型>（此处的数据类型只能是引用类型）
2.优点
A.把运行期问题，提前到了编译期
B.避免了强制类型转换
C.优化程序设计，去掉了黄色警告
3.什么时候使用泛型？
看API，类、接口、抽象类后面有<E>，则需要用泛型。
一般也就在使用集合时用
4.泛型应用
A.泛型类
    把泛型定义在类上
    格式:public class 类名<泛型类型1,…>
    注意:泛型类型必须是引用类型
B.泛型方法
    把泛型定义在方法上
    格式:public <泛型类型> 返回类型 方法名(泛型类型 )
C.泛型接口
   把泛型定义在接口上
   格式:public  interface 接口名<泛型类型1…>
5.泛型高级：通配符
泛型通配符<?>
任意类型，如果没有明确，那么就是Object以及任意的Java类了
? extends E
向下限定，E及其子类
? super E
向上限定，E及其父类
6.其他知识：增强for概述
简化数组和Collection集合的遍历
格式：
for(元素数据类型 变量 : 数组或者Collection集合) {
    使用变量即可，该变量就是元素
    }
好处：简化遍历
注意事项：增强for的目标要判断是否为null

package knowledge_basic_02;

import java.util.ArrayList;
import java.util.Iterator;
class Student{
    public String name;
    public int age;
    Student(String name,int age){
        this.name=name;
        this.age=age;
    }
}
//定义一个泛型类
class GenericsClass<T>{
    private T var;
    GenericsClass(T var)
    {
        this.var=var;
    }
    public T get()
    {
        return this.var;
    }
}
//定义泛型接口
interface Inter<D>{
    public abstract void show(D d);
}
//定义接口实现类，已知类型。（不常用）
class InterImpl1 implements Inter<String>{
    public void show(String s) {
        System.out.println(s);
    }   
}
//定义接口实现类，未知类型。（常用）
class InterImpl2<D> implements Inter<D>{
    public void show(D d){
        System.out.println(d);
    }      
}

public class GenericsDemo {

    //定义泛型方法
    public static <E> void show(E e)
    {
        System.out.println("泛型方法:"+e);

    }

    public static void main(String[] args) {
        //ArrayList存储并遍历字符串，带泛型
        //创建一个ArrayList，传一个String类型给泛型<E>
        //这个ArrayList里只能存储String对象
        ArrayList<String> a=new ArrayList<String>();
        a.add("Hello,");
        //a.add(10);//自动装箱
        a.add("I am");
        a.add("kang kang");
        a.add("and you!");
        //迭代器依赖于集合，泛型一样
        Iterator<String> it=a.iterator();
        while(it.hasNext())
        {
            System.out.print(it.next()+" ");
        }
        //System.out.println("\n------------------------------");
        //ArrayList存储并遍历自定义对象，带泛型
        ArrayList<Student> a2=new ArrayList<Student>();
        a2.add(new Student("小明",19));
        a2.add(new Student("小王",17));
        a2.add(new Student("小李",23));
        a2.add(new Student("小赵",21));
        Iterator<Student> i=a2.iterator();
        while(i.hasNext())
        {
            //System.out.println(i.next().name+"  "+i.next().age);
            //上面代码有误，两次next()方法不一样的，应该这样写：
            Student s=i.next();
            System.out.println(s.name+"  "+s.age);          
        }
        //使用自定义泛型类
        GenericsClass<String> g=new GenericsClass<String>("泛型类");
        System.out.println(g.get());
        //使用自定义泛型方法
        show("hello");
        show(10);
        show(true);
        //使用自定义泛型接口
        //方式1
        InterImpl1 inter=new InterImpl1();
        inter.show("泛型接口:hello");
        //方式2
        InterImpl2<Integer> inter2=new InterImpl2<Integer>();
        inter2.show(100);   
        //增强的foreach遍历集合
        //所以foreach循环能遍历数组、集合
        for(String out:a)
        {
            System.out.println(out);
        }
        for(Student out2:a2)
        {
            System.out.println(out2.name+" "+out2.age);
        }
    }
}

Hello, I am kang kang and you! 小明 19
小王 17
小李 23
小赵 21
泛型类
泛型方法:hello
泛型方法:10
泛型方法:true
泛型接口:hello
100
Hello,
I am
kang kang
and you!
小明 19
小王 17
小李 23
小赵 21