黑马程序员------泛型

------- <a href="http://www.itheima.com"target="blank">android培训</a>、<a href="http://www.itheima.com"target="blank">java培训</a>、期待与您交流！ ----------

泛型

Jdk1.5版本以后出现了这个新特性，它用来解决安全问题，是一个类型安全机制。

 

泛型格式<>,<>中定义要操作的引用数据类型。

好处：1.将运行时期出现问题ClassCastException转移到了编译时期。方便在编译时就能解决问题，使得运行时更安全高效。

           2.避免再进行强制转换

何时使用泛型：当类中要操作的引用数据类型不确定的时候，早期用Object来扩展，现在定义泛型来扩展。比如在集合框架中泛型定义很常见，我们也可以根据需要在自己的类中，方法中使用泛型。

代码示例：

<span style="font-size: 14px;">package com.gzj.io;
/*用到泛型示例
 * 定义一个集合，存储字符串，并按照字符串长度进行升序排序*/
import java.util.*;
class </span><span style="font-family: Arial;"><span style="font-size: 14px;"> </span><span style="font-size:12px;">Generic</span></span><span style="font-size: 14px;">
 
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());

		ts.add("abcde");
		ts.add("cc");
		ts.add("cb");
		ts.add("aaa");
		ts.add("z");
	
		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)//传入的对象也是String类型，与上面比较器保持一致
	{
		int num = new Integer(o1.length()).compareTo(new Integer(o2.length()));
		if(num==0)
		   return o1.compareTo(o2);
		return num;
	}
}</span>

如上代码可以看出，java的迭代器，比较器，集合都是泛型，我们也可以在自定义的类中定义泛型。

代码示例如下：

泛型类

class Utils<QQ>//定义一个工具类，用来操作对象，但什么对象不确定，所以可以加泛型
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}

class  GenericDemo
{
	public static void main(String[] args) 
	{
		Utils<Worker> u = new Utils<Worker>();
		u.setObject(new Worker());
		Worker w = u.getObject();;
		 
	}
}<strong style="color: rgb(0, 112, 192);">
</strong>

泛型方法：

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

代码示例如下：

class Demo
{
	Public<T> void show(T t)
	{
		System.out.println("show:"+t);
	}
	Public<Q> void print(Q q)
	{
		System.out.println("print:"+t);
	}

}
class GenericDemo 
{
	public static void main(String[] args) 
	{
		Demo d = new Demo();
		d.show(new Integer(4));
		d.print(5);
		d.print(“haha”);
}
}

注：可以既有泛型类又有泛型方法

静态方法泛型

代码示例：

class Demo<T>
{
	public  void show(T t)
	{
		System.out.println("show:"+t);
	}
	public <Q> void print(Q q)
	{
		System.out.println("print:"+q);
	}
	public  static <W> void method(W t)
	{
		System.out.println("method:"+t);
	}
}
class GenericDemo 
{
	public static void main(String[] args) 
	{
		Demo <String> d = new Demo<String>();
		d.show("haha");
		d.print(5);
		d.print("haha");

		Demo.method("hahahahha");
	}
}

接口泛型

1.泛型定义在接口上，实现时再制定类型

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

class InterImpl implements Inter<String>
{
	public void show(String t)
	{
		System.out.println("show :"+t);
	}
}
class GenericDemo
{
	public static void main(String[] args) 
	{

		InterImpl  i = new InterImpl ();
		i.show(“haha”);
	}
}    

2.泛型定义在接口上，类实现时也不明确，方法被调用时再指定

interface Inter<T>
{
	void show(T t);
}
class InterImpl<T> implements Inter<T>
{
	public void show(T t)
	{
		System.out.println("show :"+t);
	}
}
class GenericDemo
{
	public static void main(String[] args) 
	{
		InterImpl<Integer> i = new InterImpl<Integer>();
		i.show(4);
		//InterImpl i = new InterImpl();
		//i.show("haha");
	}
} 

泛型限定

当传入的对象类型不确定时，用一个通配符来表示

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

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

代码示例如下：

package com.gzj.jihe;
import java.util.*;

class  Xianding
{
	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"));
		printColl(al);

		ArrayList<Student1> al1 = new ArrayList<Student1>();
		al1.add(new Student1("abc--1"));
		al1.add(new Student1("abc--2"));
		al1.add(new Student1("abc--3"));
		printColl(al1);  //ArrayList<? extends Person> al = new ArrayList<Student>();error

	}
	public static void printColl(ArrayList<? extends Person> al)//把 从存储不同类型元素操作单独封装成一个方法，
		{                                         //这个方法接收的参数类型是接收Person类或他的子类型元素的集合，属上限
		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 Student1 extends Person  
{
	Student1(String name)
	{
		super(name);
	}
}