黑马程序员_泛型

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------

泛型概述

泛型 也叫广泛类型 可以泛指各种类型，但是是除了基本数据类型之外的所有类型

 

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

 

好处：

       将运行时期出现的问题（ClassCastException），转移到了编译时期，

       方便于程序员解决问题，让运行时期问题减少，安全

       格式：

       ArrayList<String> al = new ArrayList<String>();

 

       同时也避免了类型转换时，因为类型不符合而产生的麻烦 

 

泛型使用

 

class LenCompara implements Comparator<String>

{

       	public int compare(String s1, String s2)

	{
		//直接使用省去了判断类型和类型转换
       		int num = new Integer(s1.length()).compareTo(new Integer(s2.length()));

       		if(num == 0)

              		return s1.compareTo(s2);

       		return s2;

	}

}

class Demo

{

       	public static void main(String[] args)

	{

       		TreeSet<String> tree = new TreeSet<String>(new LenCompara());

       		tree.add("sadfsadf");

       		tree.add("fsadf");

		tree.add("sadadf");

		Iterator<String> ite = tree.iterator();

		while(ite.hasNext)

		{

			String s = ite.next();

       			System.out.println(s);

		}

	}

}

 

泛型类

泛型类（class Util<QQ>）定义的泛型（QQ），在整个类中有效，

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

  

class Student

{

       

}

class Util<QQ>

{

       	private QQ q;

       	public void setObject(QQ q)

	{

       		this.q = q;

	}

	public QQ getObject()

	{

       		return this.q;

	}

}

class Test

{

       	public static void main(String[] args)

	{

       		Util<Student> util = new Util<Student>();

       		util.setObject(new Student());

       		System.out.println(util.getObject());

	}

}

 

 

泛型方法

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

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

 

class Demo

{

       	public <T> void show(T t)

	{

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

	}

	public <Q> void print(Q q)

	{

       		System.out.println("print : "+q);

	}

}

class Test

{

       	public static void main(String[] args)

	{

       		Demo d = new Demo();

       		d.show("haa");

       		d.show(new Integer(4));

	}

}

 

静态方法与泛型

特殊之处：

静态方法不可以访问类上定义的泛型（class Demo<T>）

如果静态方法要操作的引用类型不确定，可以将泛型定义在方法上

 

class Demo<T>

{

	public static <W> void show(W w)
	{

       		System.out.println("static show : "+w);

	}

}

 

泛型接口

 

interface Inter<T>

{

       void show(T t);

}

class InterImpl implements Inter<String>

{

       	public void show(String str)

	{

       		System.out.println("show <String>");

	}

}

class InterImpl2<T> implements Inter<T>

{

       	public void show(T t)

	{

		System.out.println("show <T>");       		

	}

}

 

泛型限定

 

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

< ? extends E > ：可以接收E类型或者E的子类型，上限

< ? super E >：可以接收E类型或者E的父类型，下限

 

public void show(放在这里的话其实就是在这里规定了传入的范围)

{

       

}

 

public void show(TreeSet<? extends Person> tree)//说明传入的范围是Person及其所有子类

{

       

}

public void show(TreeSet<? super Person> tree)//说明传入的范围是Person及其所有父类

{

       

}

 

 

加个例子说明：

 

class Person

{

       	private String name;

       	Person(String name)

	{

       		this.name = name;

	}

	public String getName()

	{

       		return this.name;

	}

}

class Student extends Person

{

       	Student(String name)

	{

       		super(name);

	}

}

class Student implements Comparable<Person>

{

       	public int compareTo(Person p)

	{

       		return this.getName().compareTo(p.getName());

	}

}

class Cmp implements Comparator<Person>

{

       	public int compare(Person p1, Person p2)

	{

       		return p1.getName().compareTo(p2.getName());

	}

}

Comparator<Person>有扩展就有局限，只能调用父类的方法

---------------------- ASP.Net+Unity开发、.Net培训、期待与您交流！ ----------------------详细请查看：www.itheima.com