黑马程序员--泛型

                                    ------------android培训、java培训、期待与您交流！ --------------

大纲：

           一、泛型概念

           二、泛型的基本应用

           三、泛型的限定

           四：泛型的扩展

一：泛型概念

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

好处：

1.将运行时期出现问题ClassCastException，转移到了编译时期。，

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

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

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

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

示例代码1（不使用泛型）：

public class GenericTest {

       public static void main(String[] args) {

             ArrayList collection = new ArrayList();

             collection.add(1);
             collection.add(1L);
             collection.add("abc");

             int i = (Integer)collection.get(1);

      }

}

结果会报类型转换异常的错误，集合元素提取之后不但要进行强制类型转换，并且运行时还可能会出错。

在编译时发现不了错误，就需要程序员主观判断要存那种类型的数据，很容易出错。因此需要使用泛型，

把错误的发现定在编译时。

示例代码2（使用泛型）：

class GenericTest 
{
	public static void main(String[] args) 
	{
		ArrayList<String> al = new ArrayList<String>();
		al.add("abc01");
		al.add("abc0991");
		//al.add(1);//虚拟机会报错		

		//往迭代器里装的是String类型
		Iterator<String> it = al.iterator();
		while(it.hasNext())
		{
			String s = it.next();//不用再进行类型转换
			System.out.println(s+":"+s.length());
		}
	}
}

没有使用泛型时，只要是对象，不管是什么类型的对象，都可以存储进同一个集合中。使用泛型集合，

可以将一个集合中的元素限定为一个特定类型，集合中只能存储同一个类型的对象，这样更安全；并且

当从集合获取一个对象时，编译器也可以知道这个对象的类型，不需要对对象进行强制类型转换，更方便。

二：泛型的基本应用

示例代码3（比较器接口运用泛型）

//根据字符串的长度进行排序
import java.util.*;
class GenericTest
{
	public static void main(String[] args) 
	{
		TreeSet<String> ts = new TreeSet<String>(new LenComparator());

		ts.add("abcd");
		ts.add("cc");
		ts.add("cba");
		ts.add("aaa");
		ts.add("z");
		ts.add("hahaha");

		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)
	{
		int num = new Integer(o2.length()).compareTo(new Integer(o1.length()));

		if(num==0)
			return o2.compareTo(o1);
		return num;
	}
}

示例代码4（灵活地添加和取出对象）

/*
class Tool
{
	private Worker w;
	public void setWorker(Worker w)
	{
		this.w = w;
	}
	public Worker getWorker()
	{
		return w;
	}
}
*/

class Worker
{

}
class Student
{
}
//泛型前做法。
class Tool
{
	private Object obj;
	public void setObject(Object obj)
	{
		this.obj = obj;
	}
	public Object getObject()
	{
		return obj;
	}
}

//泛型类。
/*
什么时候定义泛型类？
当类中要操作的引用数据类型不确定的时候，
早期定义Object来完成扩展。
现在定义泛型来完成扩展。
*/
class Utils<QQ>
{
	private QQ q;
	public void setObject(QQ q)
	{
		this.q = q;
	}
	public QQ getObject()
	{
		return q;
	}
}

class  GenericDemo3
{
	public static void main(String[] args) 
	{

		Utils<Worker> u = new Utils<Worker>();

		u.setObject(new Student());
		Worker w = u.getObject();;
		/*
		Tool t = new Tool();
		t.setObject(new Student());
		Worker w = (Worker)t.getObject();
		*/
	}
}

示例代码5（灵活定义方法的接收类型）

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

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

}

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 GenericDemo4 
{
	public static void main(String[] args) 
	{
		Demo <String> d = new Demo<String>();
		d.show("haha");
		//d.show(4);
		d.print(5);
		d.print("hehe");

		Demo.method("hahahahha");

		/*
		Demo d = new Demo();
		d.show("haha");
		d.show(new Integer(4));
		d.print("heihei");
		*/
		/*
		Demo<Integer> d = new Demo<Integer>();

		d.show(new Integer(4));
		d.print("hah");

		Demo<String> d1 = new Demo<String>();
		d1.print("haha");
		d1.show(5);
		*/
	}
}

三、泛型的限定；

? 通配符。也可以理解为占位符。
？ extends E: 可以接收E类型或者E的子类型。上限。
？ super E: 可以接收E类型或者E的父类型。下限

限定通配符的上边界：
 正确：Vector<? extends Number> x = new Vector<Integer>();
 错误：Vector<? extends Number> x = new Vector<String>();
限定通配符的下边界：
 正确：Vector<? super Integer> x = new Vector<Number>();
 错误：Vector<? super Integer> x = new Vector<Byte>();

示例代码6：

class  GenericDemo6
{
	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<Student> al1 = new ArrayList<Student>();
		al1.add(new Student("abc--1"));
		al1.add(new Student("abc--2"));
		al1.add(new Student("abc--3"));
		printColl(al1);  //ArrayList<? extends Person> al = new ArrayList<Student>();error

	}
	public static void printColl(Collection<? extends Person> al)
	{
		Iterator<? extends Person> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().getName());
		}
	}
	/*
	public static void printColl(ArrayList<?> al)//ArrayList al = new ArrayList<Integer>();error
	{
		Iterator<?> it = al.iterator();
		while(it.hasNext())
		{
			System.out.println(it.next().toString());
		}
	}
	*/
}

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

}

四、泛型的扩展；

泛型是提供给javac编译器使用的，可以限定集合中的输入类型，让编译器挡住源程序中的非法输入。

但是，编译器编译带类型说明的集合时会去除掉“类型”信息，目的就是使程序运行效率不受影响。

因此，对于参数化的泛型类型，getClass()方法的返回值和原始类型完全一样。

import java.util.ArrayList;
public class GenericTest {
       public static void main(String[] args) {

            ArrayList<String> collection1 = new ArrayList<String>();
            ArrayList collection2 = new ArrayList();
            System. out.println(collection1.getClass() == collection2.getClass());
             //结果：true

      }

}

      ------------android培训、java培训、期待与您交流！ --------------