泛型第一发 #类泛型#

泛型

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



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


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

主类：

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