java学习之泛型

电玩女神 2022-08-05 01:29 209阅读 0赞

泛型：jdk1.5后出现的安全机制。  
  
  
好处：  
   1、将运行时期的问题ClassCastException转到了编译时期。  
   2、避免了强制转换的麻烦。  
     
<>什么时候使用？  
           当操作的引用数据类型不确定的时候，就使用<>，将要操作的引用数据类型传入即可。  
           其实<>就是一个用于接收具体引用数据类型的参数范围。

在程序中，只要用到了带有<>的类或者接口，就要明确传入的具体引用数据类型。

泛型技术是给编译器使用的技术，用于编译时期，确保了类型的安全。  
运行时，会将泛型去掉，生成的Class文件中是不带泛型的，这个成为泛型的擦除。  
为什么擦除？ 因为为了兼容运行时的加载器。jdk1.5之前用的类加载器和jdk1.5后用的类加载器是一样的，而jdk1.5之前没有泛型。  
泛型的补偿：在运行时，通过获取元素的类型进行转换动作，不用使用者再强制转换了。

集合存储自定义类型：

public class Person implements Comparable<Person>
    {
    	private String name;
    	private int age;
    	
    	public Person() 
    	{
    		super();
    	}
    	
    	public Person(String name, int age) 
    	{
    		super();
    		this.name = name;
    		this.age = age;
    	}
    
    	public String getName() 
    	{
    		return name;
    	}
    	public void setName(String name) 
    	{
    		this.name = name;
    	}
    	public int getAge()
    	{
    		return age;
    	}
    	public void setAge(int age)
    	{
    		this.age = age;
    	}
    
    	public int compareTo(Person p) 
    	{
    		int temp = this.age - p.age;
    		return temp==0?this.name.compareTo(p.name):temp;
    	}
    }

使用TreeSet集合时，需要实现Comparable接口中的compareTo方法，

或者自己定义比较器，实现Comparator里面的compare方法，如下图：

public static void main(String[] args)
    	{
    		TreeSet<Person> ts = new TreeSet<Person>(new ComparatorByName());
    		ts.add(new Person("zhangsan", 21));
    		ts.add(new Person("wangwu", 23));
    		ts.add(new Person("zhangsan", 21));
    		ts.add(new Person("xiaohong", 20));
    		Iterator<Person> it = ts.iterator();
    		while(it.hasNext())
    		{
    			Person p = (Person)it.next();
    			System.out.println(p.getName() + " " + p.getAge());
    		}
    	}

public class ComparatorByName implements Comparator<Person> 
    {
    	public int compare(Person o1, Person o2) 
    	{
    		int temp = o1.getName().compareTo(o2.getName());
    		return temp == 0 ? o1.getAge() - o2.getAge() : temp;
    	}
    
    }

将泛型定义在接口上就得到泛型接口，在实现接口的同时，可以指定引用类型，如第16行中的形式。

如果在实现接口时还不确定具体的类型，可以再次定义泛型来代替引用类型，如第23行，这种方式

在定义对象的时候必须指定引用类型，如第7行。

public class GenericDemo1 
    {
    	public static void main(String[] args) 
    	{
    		InterImpl1 in1 = new InterImpl1();
    		in1.show("123");//str = 123
    		InterImpl2<Integer> in2 = new InterImpl2<Integer>();
    		in2.show(8);//show : 8
    	}
    }
    //泛型接口，将泛型定义在接口上。
    interface Inter<T>
    {
    	public void show(T t);
    }
    class InterImpl1 implements Inter<String>
    {
    	public void show(String str)
    	{
    		System.out.println("str = " + str);
    	}
    }
    class InterImpl2<Q> implements Inter<Q>
    {
    	public void show(Q q)
    	{
    		System.out.println("show : " + q);
    	}
    }

泛型的通配符:?代表未知类型，这样可以复用集合的迭代器，根据建立对象时指定的引用类型，

对不同的引用类型进行迭代。

public static void main(String[] args)
    	{
    		ArrayList<String> a1 = new ArrayList<String>();
    		a1.add("abc");
    		a1.add("efg");
    		printCollection(a1);
    		ArrayList<Integer> a2 = new ArrayList<Integer>();
    		a2.add(5);
    		a2.add(9);
    		printCollection(a2);
    		/*输出
    		 * abc
    		 * efg
    		 * 5
    		 * 9
    		 */
    	}
    	//用?来代替未知类型
    	private static void printCollection(Collection<?> a1) {
    		Iterator<?> it = a1.iterator();
    		while(it.hasNext())
    		{
    			System.out.println(it.next());
    		}
    	}

泛型的限定，可以指定接收类型的范围。<? extends Person>表示只能接收Person或者Person子类的类型。

通用形式：? extends E  表示接收E类型，或者E的子类型对象，这是上限。

通用形式：? super E 表示接收E类型，或者E的父类型，这是下限。

private static void printCollection(Collection<? extends Person> a1)
    	{
    		Iterator<? extends Person> it = a1.iterator();
    		while(it.hasNext())
    		{
    			Person p = it.next();
    			System.out.println(p.getName() + " : " + p.getAge());
    		}
    	}

什么时候使用上限？  
一般在存储元素的时候都是用上限，因为这样取出都是按照上限类型来运算的，不会出现类型隐患。  
什么时候使用下限？

通常对集合中的元素进行取出操作时用下限。