黑马程序员——泛型的用法

黑马程序员——泛型的用法

———–android培训、java培训、期待与您交流！————

泛型是JDK1.5以后出现的新特新，主要是用于解决安全问题，它是一个安全机制。

将运行时期出现的安全问题转移到了编译时期，方便了程序员解决问题，让运行时问题减少。

还有就是避免了强制转换的麻烦

[code]//用一段代码来演示一下泛型用在集合上
import java.util.*;
class demo01 
{
    public static void main(String[] args) 
    {
//泛型写在尖括号中，这里的泛型是Stirng，意思就是只能往arr中传String类型的对象
        ArrayList <String>arr = new ArrayList<String>();
        arr.add("java1");//添加元素
        arr.add("java2");
        arr.add("java3");
        arr.add("java4");
//获取一个迭代器，也加了泛型，迭代器迭代就可以直接获得String类型的对象
        Iterator <String> it = arr.iterator();
        while(it.hasNext()) //判断容器是否为空 返回boolean
        {
            sop(it.next());//打印元素
        }
      }
    //一个打印的小方法
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}

[code]在没有泛型之前，往集合中添加元素都是靠程序员的主观判断去添加，很容易引发安
全问题，引进泛型之后，通过泛型判断添加元素的类型，减少了程序员的主观判断，也大大增加了程序的安全性。

泛型不仅可以定义在集合上，还可以定义在类，函数和接口上！

那什么时候定义泛型类呢？

当类中要操作的引用数据类型不确定的时候，就可以定义泛型类；早期没有泛型的时候，都是通过Object来完成拓展，现在可以用泛型。

[code]//用一段代码演示泛型定义在类上，接口上和函数上
class demo02 
{
    public static void main(String[] args) 
    {
        demo<String> t1 = New demo<String>();
        t1.noe(“abc”);//泛型在类上
        t1.show(123);//把泛型定义在方法上
    }
}

interface Inter<T>//定义在接口上
{
    void show(T t);

}
class Interg<T> implements Inter<T> //类实现接口
{
    public void show(T t)
    {
        System.out.println("show"+t);
    }
}

class demo<Q>//泛型定义在类上
{

    public <B> void one(B b)//方法上定义自己的泛型
    {
        System.out.println("one:"+b);
    }
    public void show(Q q)//直接用类上的泛型
    {
        System.out.println("method:"+q);
    }
//**静态只能用定义在自己方法上的泛型，不能用定义在类上的泛型
    public static <Z> void method(Z z)// 定义在静态方法上的泛型
    {
        System.out.println("method:"+z);
    }
}

注意：静态方法不能引用类上定义的泛型，但是可以定义在自己的方法上。

泛型限定

什么是泛型限定呢，就是把泛型限定在一个范围之类，比起单个的泛型，其拓展性又大大增强。这里我们会用到一个特殊字符：？ 就是这个问号，叫做通配符，也叫做占位符，就是不知道泛型的具体类型时可以用这个通配符去表示。

在泛型限定有两种限定一种上限，一种下限。

这是限定上限

[code]//用一个例子来说一下
/*
定义一个person类
定义一个学生类继承person
定义一个工人类继承person
写一个排序方法接收Person可以同时给学生对象和工人对象进行排序使用
*/
class demo04 
{
    public static void main(String[] args) 
    {
        //创建一个存储学生类型的集合，加载一个父类的比较器 去比较
        TreeSet<students> st = new TreeSet<students>(new sortList());
        st.add(new students("marry",12));
        st.add(new students("narry",18));
        st.add(new students("karry",16));
        st.add(new students("zarry",15));
        st.add(new students("barry",13));
        st.add(new students("garry",16));
        st.add(new students("yarry",15));
        st.add(new students("rarry",13));

        Iterator<students> it = st.iterator();
        while(it.hasNext())
        {
            students s = it.next();
            sop(s.getName()+"---"+s.getAge());  
        }
    }
    //打印方法
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }
}
//定义一个人的类
class Person
{
    private String name;
    private int age;

    Person(String name,int age)
    {
        this.name = name;
        this.age = age;
    }
    public String getName()
    {
        return name;
    }
    public int getAge()
    {
        return age;
    }
}
class students extends Person
{
//学生类继承了人的类
    students(String name,int age)
    {
        super(name,age);
    }
}
class worker extends Person
{
//工人类继承了人的类
    worker(String name,int age)
    {
        super(name,age);

    }
}
//这是一个比较器，可以接收Person类的和他的子类
class sortList implements Comparator<Person>
{
    public int compare(Person p1,Person p2)
    {
        int num = new Integer(p1.getAge()).compareTo(new Integer(p2.getAge()));
        if(num == 0)
        {
            return p1.getName().compareTo(p2.getName());
        }
        return num;
    }
}