泛型 定义在类上 、方法上、静态方法上 <？> 泛型限定 上限限定 下限限定

泛型

举例子：由于java中，编译和运行是分开的，有时候我门在集合中存储数据时，没有定义存储数据类型是什么，这时在编译过程中是看不见的，但是在运行过程中才会报异常。所以我们需要将异常在编译时就体现出异常。这时候就产生泛型。我们在创建集合对象时，通过泛型定义集合要存储的数据对象类型。这样，如果我们在编写代码时，传入泛型定义意外的对象类型，那么就会在编译过程中报出异常！

JDK1.5版本后出现的新特性，用于解决安全问题，是一个类型安全机制。

好处

1，类将异常转移到了编译时期。

将运行时期出现的ClassCastException，转移到了编译时期。

放便与程序员解决问题，让运行事情问题减少，安全。

2，避免了强制转换的麻烦。

缺点

不能使用一些类的特有方法。

泛型格式

通过<>来定义要操作的引用数据类型。

什么时候写泛型呢？

通常在集合框架中很常见，只要见到<>就要定义泛型。

其实<>就是用来接收类型的，

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

注意

compareTo  可以使用泛型。

但是equals切记不能使用泛型

使用泛型类，在ArrayList中打印出集合元素的长度

import java.util.*;
class  Test
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();

		al.add("abc01");
		al.add("abc0991");
		al.add("abc013");
		al.add("abc014");
		
		Iterator<String> it = al.iterator();
		while (it.hasNext())
		{
			String s= it.next();
			sop(s+"="+s.length());
		}
	}
	public static void sop (Object obj)
	{
		System.out.println(obj);
	}
}

通过泛型类，将TreeSet中的元素按长度排序

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

		ts.add("abcde");
		ts.add("aabd");
		ts.add("cc");
		ts.add("dea");
	
		Iterator<String> it =ts.iterator();
			while (it.hasNext())
			{
				String s = it.next();
				sop(s);
			}
	}

	public static void sop (Object obj)
	{
		System.out.println(obj);
	}
}
class Length implements Comparator<String>
{
	public int compare(String o1,String o2)
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if (num==0)
			return o1.compareTo(o2);
		return num;
	}
}

泛型类（泛型定义在类上）

什么时候定义泛型类

当类中要操作的引用数据类型不确定的时候

现在定义泛型来定义扩展

import java.util.*;
class Utils<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}

class Worker
{
}

class  Test
{
	public static void main(String[] args)
	{
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject();
	}
	public static void sop (Object obj)
	{
		System.out.println(obj);
	}
}

泛型 定义在方法上

泛型类定义的泛型，在整个类中有效

如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要操作的类型就已经固定了。

为了让不同方法可以操作不同类型，而且类型还不确定

那么可以将泛型定义在法方上。

泛型方法写在返回值前面   <T > void

import java.util.*;

class Demo
{
	public <T> void show(T t)
	{
		System.out.println("show :"+t);
	}
	public <W> void print(W w)
	{
		System.out.println("print:" +w);
	}
}
class  Test
{
	public static void main(String[] args)
	{
		Demo d = new Demo();
		d.show("abzc");
		d.print("wokao");
		d.print(3);
	}
	public static void sop (Object obj)
	{
		System.out.println(obj);
	}
}

特殊之处----泛型与静态

因为静态方法随着类的产生而加载

泛型类随着对象的创建才能确定

静态方法不可以访问定义在类上的泛型。

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

import java.util.*;

class Demo <T> 
{
	public void show(T t)
	{
		System.out.println("show :"+t);
	}
	public <W> void print(W w)
	{
		System.out.println("print:" +w);
	}
	public static <Z> void sop (Z z)
	{
		System.out.println("sop:"+z);
	}
}
class  Test
{
	public static void main(String[] args)
	{
		Demo<String> d = new Demo<String>();
		d.show("abzc");
		d.print("wokao");
		d.print(3);
		d.sop("gsdf");
	}
	public static void sop (Object obj)
	{
		System.out.println(obj);
	}
}

泛型定义在接口上

interface Demo <T>
{
	void show (T t);
}

class DemoImpl implements Demo<String>
{
	public void show(String s)
	{
		System.out.println(s);
	}
}

class  Test
{
	public static void main(String[] args) 
	{
		DemoImpl d = new DemoImpl();
		d.show("hello world");
	}
}

泛型定义在接口上

interface Demo <T>
{
	void show (T t);
}

class DemoImpl<T> implements Demo<String>
{
	public void show(String s)
	{
		System.out.println(s);
	}
}

class  Test
{
	public static void main(String[] args) 
	{
		DemoImpl<Integer> d = new DemoImpl<Integer>();
		d.show(36);
	}
}

占位符

<？>通配符，也可以理解为占位符

import java.util.*;

class Test
{
	public static void main(String[] args) 
	{
		ArrayList<String> al= new ArrayList<String>();			
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");
	
		ArrayList<Integer> al2=new ArrayList<Integer>();
		al2.add(123);
		al2.add(33);
		al2.add(131);

		printit(al);
		printit(al2);
	}

	public static void printit(ArrayList<?> al)
	{
		Iterator<?> it = al.iterator();
		
		while(it.hasNext())
		{
			System.out.println(it.next());
		}
	
	}
}

泛型限定

？ extends E ：可以接受E类型或者E的子类型，上限限定

？ super    E : 可以接收E类型或者E的服类型，下限限定

下线限定

import java.util.*;

class Test
{
	public static void main(String[] args) 
	{
		ArrayList<Person> al= new ArrayList<Person>();			
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));
	
		ArrayList<Student> al2=new ArrayList<Student>();
		al.add(new Student("abc--1"));
		al.add(new Student("abc--2"));
		al.add(new Student("abc--3"));

		printit(al);
		printit(al2);
	}
	public static void printit(ArrayList<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();
		
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
}
class Person
{
	private String name;
	Person(String name)
	{
		this.name=name;
	}
	public String getName()
	{
		return name;
	}
}
class Student extends Person
{
	Student (String name)
	{
		super (name);	
	}
}

import java.util.*;

class Test
{
	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("abc01"));
		ts.add(new Student("abc04"));
		
		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("wabc03"));
		ts1.add(new Worker("wabc02"));
		ts1.add(new Worker("wabc01"));
		ts1.add(new Worker("wabc04"));
		
		Iterator<Worker> it1 = ts1.iterator();
		while (it1.hasNext())
		{
			System.out.println(it1.next().getName());
		}
	}
}

class comp implements Comparator <Person>
{
	public int compare(Person p1,Person p2)
	{
		return p1.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);	
	}
}