泛型

Posted 2022-12-03 薰衣草

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

好处：

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

2.避免了强制转换麻烦。

 

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

 

在使用Java提供的对象时，什么时候写泛型呢？

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

 

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

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

import java.util.*;

class GenericDemo

	public static void main(String[] args)
	
		<span style="color:#33cc00;">ArrayList<String></span> al = <span style="color:#33cc00;">new ArrayList<String>()</span>;

		al.add("abc01");
		al.add("abc991");
		al.add("abc014");

		//al.add(4);	//al.add(new Integer(4));

		<span style="color:#33cc00;">Iterator<String></span> it = al.iterator();
		while(it.hasNext())
		
			String s = it.next();
			sop(s);
		
	
	public static void sop(Object obj)
	
		System.out.println(obj);
	

按字符串长度排序

import java.util.*;

class GenericDemo2

	public static void main(String[] args)
	
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());

		ts.add("cba");	
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");
		ts.add("ba");

		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 LenComparator 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;
	

若按长度由长到短排序，可改LenComparator函数为

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来完成扩展，现在定义泛型来完成扩展。

import java.util.*;

class GenericDemo3

	public static void main(String[] args)
	
		Utils<Worker> u = new Utils<Worker>();
		
		u.setObject(new Worker());
		Worker w = u.getObject();
		/*
			Tool t = new Tool();
			t.setObject(new Student());
			Worker w = (Worker)t.getObject();
		*/
	

class Worker



class Student
	



//泛型前做法
class Tool

	private Object obj;
	public void setObject(Object obj)
		
		this.obj = obj;
	
	public Object getObject()
	
		return obj;
	

//泛型类
<span style="color:#33cc00;">class Utils<QQ></span>

	private QQ q;
	public void setObject(QQ q)
		
		this.q = q;
	
	public QQ getObject()
	
		return q;
	

特殊之处：

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

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

泛型类定义的泛型，在整个类中有效，如果被方法使用，那么泛型类的对象明确要操作的具体类型后，所有要

操作的类型就已经固定了。

 

为了让不同方法可以操作不同类型，而且类型还不确定，可以将泛型定义在方法上。

class GenericDemo5

	public static void main(String[] args)
	
		Demo<String> d = new Demo<String>();
		d.show("haa");
		//d.show(new Integer(4));
		d.print(4);
		d.print("lalala");

		Demo.method("qqqqq");
	


class Demo<T>

	public  void show(T t)
	
		System.out.println("show:"+t);
	
	<span style="color:#33cc00;">public <Q> void print(Q q)</span>
	
		System.out.println("print:"+q);
	
	<span style="color:#33cc00;">public static <W> void method(W w</span>)
	
		System.out.println("method:"+w);
	

泛型定义在接口上

<span style="color:#33cc00;">interface Inter<T></span>

	void show(T t);

/*
class InterImpl implements Inter<String>

	public void show(String t)
	
		System.out.println("show:"+t);
	

*/
<span style="color:#33cc00;">class InterImpl<T> implements Inter<T></span>

	public void show(T t)
	
		System.out.println("show:"+t);
		

class GenericDemo6

	public static void main(String[] args)
	
		//InterImpl i = new InterImpl();
		//i.show("lala");
	
		InterImpl<Integer> i = new InterImpl<Integer> ();
		i.show(4);
	

?:通配符，也可以理解为占位符。

 

泛型的限定：

? extends E:可以接收E类型或其子类类型。上限定

? super E: 可以接收E类型或其父类类型。下限定

import java.util.*;

class GenericDemo7

	public static void main(String[] args)
	
		/*ArrayList<String> al = new ArrayList<String>();
		al.add("abc1");
		al.add("abc2");
		al.add("abc3");

		ArrayList<Integer> al1 = new ArrayList<Integer>();
		al1.add(3);
		al1.add(5);
		al1.add(6);

		printColl(al);
		printColl(al1);
		*/
		ArrayList<Person> al = new ArrayList<Person>();
		al.add(new Person("abc1"));
		al.add(new Person("abc2"));
		al.add(new Person("abc3"));
		//printColl(al);

		ArrayList<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("abc--1"));
		al1.add(new Student("abc--3"));
		al1.add(new Student("abc--2"));
		printColl(al1);

	
	public static void printColl(<span style="color:#33cc00;">ArrayList<? extends Person></span> al)//?表示占位符，不明确是什么类型
	
		<span style="color:#33cc00;">Iterator<? extends Person></span> it = al.iterator();
		while(it.hasNext())
		
			System.out.println(it.next().getName());	
		
	

	/*public static void printColl(ArrayList<?> al)//?表示占位符，不明确是什么类型
	
		Iterator<?> it = al.iterator();
		while(it.hasNext())
		
			System.out.println(it.next());	
		
	*/


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);