java 泛型

标签：

import java.util.*;

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

好处：
1，将运行时出现的类型准换换错误（ClassCastException）转移到编译时期，程序员刻可以及时发现错误并解决。
2，避免了强制转换的麻烦。

*/

class GenericDemo  //泛型 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al=new ArrayList<String>();
		al.add("agdjk");
		al.add("agdjk");
		al.add("agdjk");
		al.add("agdjk");
		al.add("agdjk");

		//al.add(2);//如果不做泛型处理，在编译时期不会出错，在运行时期会出现类型转换错误，所以存在很严重的安全隐患。


		Iterator<String> it=al.iterator();
		while(it.hasNext())
		{
			//String str=(String)it.next();   //使用了泛型就不用再做强制类型转换的操作。
			sop(it.next());  
		}
		System.out.println("Hello World!");
	}

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

泛型类：

/*
泛型类：
带参数的类。
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型类来完成扩展。
*/
class Worker
{
}

class Student
{
}

class Teacher
{
}

class Utils<QQ>  //QQ就是引用类型参数，QQ可以是Worker、Student、Teacher类型的
{
	private QQ q;
	public void setQQ(QQ q)
	{
		this.q=q;
	}

	public QQ getQQ()
	{
		return q;
	}
}

class GenericDemo3 
{
	public static void main(String[] args) 
	{
		Utils<Worker> w=new Utils<Worker>();
		w.setQQ(new Worker());
		Worker ww=w.getQQ();

		Utils<Teacher> t=new Utils<Teacher>();
		t.setQQ(new Teacher());
		Teacher tt=t.getQQ();
		//System.out.println("Hello World!");
	}
}

class Demo<T>   //将泛型定义在类上
{
	public void show(T t)
	{
		System.out.println("show:"+t);
	}

	public void print(T t)
	{
		System.out.println("print"+t);
	}

}


class Demo1    //泛型方法定义
{
	public <T> void show(T t)   //泛型放在返回类型的前面
	{
		System.out.println("show"+t);
	}

	public <Q> void print(Q q)
	{
		System.out.println("print"+q);
	}
}

class Demo2<T>   //泛型类和泛型方法的混合使用。在泛型类中定义泛型方法。
{
	public void show(T t)
	{
		System.out.println("show"+t);
	}

	public <Q> void print(Q q)
	{
		System.out.println("print"+q);
	}

	public static void method(T t)    //无法从静态方法上下文中应用非静态变量
	{
		System.out.println("静态方法："+t);
	}
}

class GenericDemo4 
{
	public static void main(String[] args) 
	{
		/*泛型类
		Demo<String> d=new Demo<String>();
		d.show("String...1");
		d.print("String...2");
		*/

		/*泛型方法
		Demo1 d1=new Demo1();
		d1.show("String............1");
		d1.show(3333);
		d1.print("nihao/////////////");
		d1.print(2222);
		*/

		//泛型类和泛型方法
		Demo2<String> d2=new Demo2<String>();
		d2.show("Hellllllllo");
		d2.print("hhhhhhhhhh");
		d2.print(456);
		d2.method("HEooooooo");
	}
}

/*泛型接口*/
interface Inter<T>
{
	void show(T t);
}

class InterImpl<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show"+t);
	}
}
class GenericDemo5 
{
	public static void main(String[] args) 
	{
		InterImpl<Integer> i=new InterImpl<Integer>();
		i.show(3);
		//System.out.println("Hello World!");
	}
}

泛型的限定：

import java.util.*;
/*
泛型的限定：
?通配符，也可以理解为占位符。
泛型的限定：
？ extends E:可以接收E类型或E的子类型。上限
？ super E:可以接收E类型或E的父类型。下限

*/
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 Student extends Person
{
	Student(String name,int age)
	{
		super(name,age);
	}
}


class GenericDemo6 
{
	public static void main(String[] args) 
	{
		
		//stringDemo();
		personDemo();

	}

	

	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
///////////////////////////////////////////////////////////////
	public static void stringDemo()
	{
		ArrayList<String> al1=new ArrayList<String>();
		ArrayList<Integer> al2=new ArrayList<Integer>();

		al1.add("hello1");
		al1.add("hello2");
		al1.add("hello3");

		al2.add(2);
		al2.add(3);
		al2.add(1);
		al2.add(4);

		printColl_String(al1);
		sop("______________________");

		printColl_String(al2);
	}

	public static void printColl_String(ArrayList<?> al)  //类型不明确   //T也可以用“？”来代替。
	{
		Iterator<?> it=al.iterator();
		while(it.hasNext())
		{
			sop(it.next());
		}
	}
/////////////////////////////////////////////////////////////////////////
	public static void personDemo()
	{
		ArrayList<Person> al1=new ArrayList<Person>();
		ArrayList<Student> al2=new ArrayList<Student>();

		al1.add(new Person("person1",20));
		al1.add(new Person("person2",25));
		al1.add(new Person("person3",30));

		al2.add(new Student("student1",10));
		al2.add(new Student("student2",11));
		al2.add(new Student("student3",12));

		printColl_Person(al1);
		sop("______________________");
		printColl_Person(al2);
	}

	public static void printColl_Person(ArrayList<? extends Person> al)  //
	{
		Iterator<? extends Person> it=al.iterator();
		while(it.hasNext())
		{
			Person p=it.next();
			sop(p.getName()+"..."+p.getAge());
		}
	}
//////////////////////////////////////////////////////////////////////////////////////////////


}

import java.util.*;
//泛型实现比较器的通用。但是需要注意的是比较器中用到的是父类的方法。
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);
	}
}

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

class GenericDemo7 
{
	public static void main(String[] args) 
	{
		//Student
		TreeSet<Student> ts=new TreeSet<Student>(new Comp());
		ts.add(new Student("sudent001"));		
		ts.add(new Student("sudent006"));
		ts.add(new Student("sudent003"));
		ts.add(new Student("sudent008"));

		Iterator<Student> it=ts.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
		
		System.out.println("-----------------------------");
		//Worker
		TreeSet<Worker> ts1=new TreeSet<Worker>(new Comp());
		ts1.add(new Worker("worker0028"));		
		ts1.add(new Worker("worker0033"));
		ts1.add(new Worker("worker0090"));
		ts1.add(new Worker("worker0027"));

		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(p2.getName());
	}
}

java 泛型

标签：

原文地址：http://blog.csdn.net/iemdm1110/article/details/51361923