泛型的几个使用

泛型：jdk1.5版本以后出现的特性，用于解决安全问题，是一个安全机制

好处：

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

• 避免了强制转换的麻烦

class GenericDemo
{
    public static void main(String[] args)
    {
        ArrayList<String> a1 = new ArrayList<String>();//初始化时定义了数组存储的类型
        
        a1.add("abc01");
        a1.add("dwd12");
    }
    Iterator<String> it = a1.iterator();//迭代时定义数组的存储类型
    while(it.hasNext())
    {
        String s = it.next();
        System.out.println("dwdw");
             
    }
}

泛型使用

格式：通过<>定义要操作的引用类型，什么时候使用？

通常在集合框架下很常见，只要见到< >就要使用泛型，其实<>就是用来接收类型的

当使用集合时，将集合中要存储的数据类型作为参数查传递到<>中即可

注意：arraylist中复写equals方法不能使用泛型（因为object类中没有泛型）

import java.util.*;
class GenericDemo2 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());//泛型的使用

		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");


		Iterator<String> it = ts.iterator();

		while(it.hasNext())
		{
			String s = it.next();
			System.out.println(s);
		}
	}
}


class LenComparator implements Comparator<String>//泛型记得写上类型
{
	public int compare(String o1,String o2)//类型与申明的时候相同
	{
		int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));
 
		if(num==0)
			return o2.compareTo(o1);
		return num;
	}
}

泛型类

什么时候定义泛型类
当类中要操作的引用数据类型不确定的时候
早期定义Object来完成扩展
现在定义泛型类来扩展

class Utils<QQ>//定义一个类型的参数
{
    private QQ q;
    public void setObject(QQ q)
    {
        this.q = q;
    }
    public QQ getObject()
    {
        return q;
    }
}
class GenericDemo3
{
    public static void mian(String[] args)
    {
        Utils<Worker> u = new Utils<Worker>();//将类型参数传入，生成
        u.setObject(new Worker());
        Worker w = u.getObject();
    }
}

泛型方法（相比泛型类更细化了）

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了，为了让不同的方法可以操作不同的类型，而且类型还不确定–>那么就可以将泛型定义在方法上

静态方法不可以访问类上定义的泛型,如果静态方法操作的应用数据类型不确定，可以将泛型定义在方法上

class Demo 
{
    public <T> void show(T t)//泛型定义在方法上，注意在修饰符后面加上泛型的修饰(返回值前面)
    {
        System.out.println(t);
    }
    public <Q> void println(Q q)
    {
        System.out.println(q);
    }
    public static <w> void method(W w)
    {
        System.out.println(w);
    }
}
class GenericDemo4
{
    public static void main(String[] args)
    {
        Demo d = new Demo();
        d.show("haha");
        d.show(new Interger(4));
        d.println("heihei");
        
        Demo.method("啊哈哈哈哈");
        
    }
}

泛型接口

interface Inter<T>
{
    void show(T t);
}
/*在定义实现的时候已经确定传入的类型
class InterImpl implements Inter<String>//定义了泛型的类型
{
    public void show(String t)
    {
        System.out.println(t);
    }
}
class GenericDemo
{
    public static void main(String[] args)
    {
        InterImpl i = new InterImpl();
        i.show("hahaha");
    }
}
*/
class InterImpl<T> implements Inter<T>//在实现的时候不明确参数的类型
{
   public void show(T t);
   {
       System.out.println(t);
   }
    public static void main(String[] args)
    {
        InterImpl<Interger> i = new InterImpl<Interger>();
        i.show(4);
    }
}

泛型限定

？通配符。也可以理解为占位符
泛型的限定：（优点：拓展性增加，缺点：不能用具体类型的方法）
<？ extends E>：可以接受E类型或者E的子类型。上限
：可以接受E类型或者E的父类型。下限

class GenericDemo
{
    public static void main(String[] args)
    {
        ArrayList<String> al  = new ArrayList<String>();
        
        al.add("abc01");
        al.add("abc02");
        al.add("abc03");
        ArrayList<Interger> al1 = new ArrayList<Integer>();
        al1.add(1);
        al1.add(3);
        
    }
    /*
    public static <T> void printColl(ArrayList<T> al)
    {
        Iterator<T> it = al.iterator();
        while(it.hasNext())
        {
            T t = it.next();
            System.out.println(it.next());
        }
    }
    */
    /*//泛型
    public static  void printColl(ArrayList<? extends Person> al)
    {
        Iterator<? extends Person> it = al.iterator();
        while(it.hasNext())
        {
            T t = it.next();
            System.out.println(it.next());
        }
    }
    */
    public static void printColl(ArrayList<?> al)
    {
        Iterator<?> it = al.iterator();
        while(it.hasNext())
        {
            System.out.println(it.next());
        }
    }
}

比较器复用

import java.util.*;
class GenericDemo7 
{
	public static void main(String[] args) 
	{
		
		TreeSet<Student> ts = new TreeSet<Student>(new Comp());

		ts.add(new Student("abc03"));
		ts.add(new Student("abc02"));
		ts.add(new Student("abc06"));
		ts.add(new Student("abc01"));
		
		Iterator<Student> it = ts.iterator();

		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
		/**/



		TreeSet<Worker> ts1 = new TreeSet<Worker>(new Comp());

		ts1.add(new Worker("wabc--03"));
		ts1.add(new Worker("wabc--02"));
		ts1.add(new Worker("wabc--06"));
		ts1.add(new Worker("wabc--01"));


		Iterator<Worker> it1 = ts1.iterator();

		while(it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
	}
}

/*
class StuComp implements Comparator<Student>
{
	public int compare(Student s1,Student s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}

class WorkerComp implements Comparator<Worker>
{
	public int compare(Worker s1,Worker s2)
	{
		return s1.getName().compareTo(s2.getName());
	}
}
*/

class Comp implements Comparator<Person>//接口文档写的是<? super E>提高了扩展性，但是只能用父类的方法
{
	public int compare(Person p1,Person p2)
	{
		return p2.getName().compareTo(p1.getName());
	}
}


class Person
{
	private String name;
	Person(String name)
	{
		this.name = name;
	}
	public String getName()
	{
		return name;
	}
	public String toString()
	{
		return "person :"+name;
	}
}

class Student extends Person
{
	Student(String name)
	{
		super(name);
	}

}

class Worker extends Person
{
	Worker(String name)
	{
		super(name);
	}
}