泛型第一发 #类泛型#

泛型

泛型是一个安全机制。好处：一、从集合读取的数据不需要强转，能自动识别。二、把运行期的错误提前到编译期。

注意：当一个变量被声明为泛型时，只能被实例变量和方法调用，而不能被静态变量和方法调用。原因很简单，参数化的泛型是一些实例。静态成员是被类的实例和参数化的类所共享的，所以静态成员不应该有类型参数和他们关联。

下面是泛型类的代码实现：

主类：

package cn.hncu.generic.one;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;

import cn.hncu.collection.Person;

public class Demo1 {

	public static void main(String[] args) {
		//t1();
		
		//t2();
		
		t3();
	}
	
	//演示泛型的好处之一：没采用泛弄，对元素的处理不安全。泛型可以把运行期的错误提前到编译期
	public static void t1(){
		//List list = new ArrayList();//无泛型
		List<String> list = new ArrayList<String>();//无泛型
		list.add("aaaqqqq");
		list.add("abaqqqq");
		list.add("cccqqqq");
		//list.add(100); //无泛型时，此处不会报错，但有泛型时会报错。
		Iterator it = list.iterator();
		while(it.hasNext()){
			Object obj = it.next();
			String str = (String)obj;
			str = str.substring(1, 4);
			System.out.println(str);
		}
	}
	
	//演示泛型的好处之二：从集合中读取的数据不需要强转，能够自动识别
	public static void t2(){
		//List list = new ArrayList();//无泛型
				List<String> list = new ArrayList<String>();
				list.add("aaaqqqq");
				list.add("abaqqqq");
				list.add("cccqqqq");
				Iterator<String> it = list.iterator();
				while(it.hasNext()){
					//String str =(String) it.next();//无泛型，必须强转
					String str = it.next();//List有泛型，并且Iterator也加泛型，那么这里就不用强转.
					str = str.substring(2);
					System.out.println(str);
				}
				System.out.println("------------");
				
				for(Object obj:list){
					System.out.println(obj);
				}
				
				//※泛型的好处之二：从集合中读取的数据不需要强转，能够自动识别
				for(String str:list){
					System.out.println(str);
				}
	}

	/**
	 * 我们自己在MySet中定义泛型，然后在此处进行调用测试
	 */
	public static void t3(){
		//List<String> list = new ArrayList<String>();
		//MySet set = new MySet();
		MySet<String> set = new MySet<String>();
		set.add("abc");
		//set.add(100);//泛型的好处1： 有泛型，这里出报编译错误
		//泛型的好处2：不用类型强转
		String str = set.popLast();
		System.out.println(str);
		
		
		MySet<Integer> set2 = new MySet<Integer>();
		set2.add(100);
		//set2.add("abc");//编译错误
		int i = set2.popLast();
		System.out.println(i);
		
		Collection<Person> col = new HashSet<Person>();
		col.add(new Person("Jack",20));
		
	}
	
}

集合类：

package cn.hncu.generic.one;

public class MySet<E> {
    private Object[] objs= new Object[0];
    public boolean contains(Object obj){
    	for(Object tmp: objs){
    		if(tmp.equals(obj)){
    			return true;
    		}
    	}
    	return false;
    }
    
    public boolean add(E obj){
    	if(contains(obj)){
    		return false;
    	}
    	Object[] tempObjs = new Object[objs.length+1];
    	System.arraycopy(objs, 0, tempObjs, 0, objs.length);
    	tempObjs[objs.length] = obj;
    	objs = tempObjs;
    	return true;
    }
    
    public E popLast(){
    	if(size()==0){
    		return null;
    	}
    	return (E) objs[size()-1];
    }
    
    public Object[] getAll(){
    	return objs;
    }
    public int size(){
    	return objs.length;
    }
}