Question

一个关于Java的泛型问题，举个例子？

什么是泛型啊，能不能举个例子，详细解释一下？

Answer 1

import java.util.ArrayList;
import java.util.List;

public class $ {

    public static void main(String[] args) {

        List<String> data = new ArrayList<String>();
        data.add("a");
        data.add("b");

        for (String str : data) {
            System.out.println(str);
        }
    }
}

简单说，就是说data里面只能放String，放别的都会报错，

而且下面可以自动拆箱，遍历data，用String接受

Answer 2

java中的泛型实际让使用者生产类时就指定存储这个集合或者类存储什么格式的数据。
如：List<String> list= new ArrayList<String>();//说明这个集合中只能存储String对象
List<User> uList= new ArrayList<User>();//只能存储User对象。

Answer 3

以下是我们泛型所遇到的所有实例简化，

package Test17;
import java.util.Hashtable;
import java.util.Vector;
import Test18.eightEmpress;

public class genericsClassExample {
/**
* @java中的泛型编程
*/
public static void main(String[] args) {
/*
//集合类的泛型
// Vector v=new Vector();
Vector<Integer> v=new Vector<Integer>();
v.add(15);
v.add(new Integer(10));
v.add(new Integer('a'));
// v.add(new Integer("a")); 数据类型错误
for(int i=0;i<v.size();i++){
Integer value=(Integer)v.get(i);
System.out.println(value);
}
*/

/*
//泛型参数集合示例
Hashtable<Integer, Student> ht=new Hashtable<Integer, Student>();
ht.put(1,new Student(14,"张三","11五班"));
ht.put(2,new Student(16,"李四","11五班"));
ht.put(3,new Student(15,"马六","11五班"));
Student s=ht.get(2);
System.out.println(s.name);
}
}
class Student {
public int age;
public String name;
public String className;
public Student(int age,String name,String className){
this.age=age;
this.name=name;
this.className=className;
*/

/*
//自定义泛型
Student<String>stu1=new Student<String>("名字", "代号");
Student<Double>stu2=new Student<Double>("价钱", 1569.0);
String name=stu1.getT();
double price=stu2.getT();
System.out.println(name);
System.out.println(price);
}
}
class Student<T>{
private String name;
private T t;
public Student(String name,T t){
this.name=name;
this.t=t;
}
public T getT(){
return t;
*/

/*
//类型通配符使用
Vector <String> c=new Vector<String>();
c.add("aaa");
printC(c);
}
static void printC(Vector<?> c) {
for(Object e:c){
System.out.println(e );
}
*/

/*
//受限类型参数
TestGeneric<Person> tg1=new TestGeneric<Person>();
tg1.setT(new Person());
tg1.testp();
TestGeneric<Student> tg2=new TestGeneric<Student>();
tg2.setT(new Student());
tg2.testp();
TestGeneric<Teacher> tg3=new TestGeneric<Teacher>();
tg3.setT(new Teacher());
tg3.testp();
//通配符受类型参数的使用
TestGeneric<? extends Person> tg4=tg3;
tg4.testp();
}
}
class Person{
public void p(){
System.out.println("person");
}
}
class Student extends Person{
public void p(){
System.out.println("student");
}
}
class Teacher extends Person{
public void p(){
System.out.println("teacher");
}
}
class TestGeneric<T extends Person>{
private T t;
public void setT(T t){
this.t=t;
}
public void testp(){
t.p();
*/

genericsClassExample g=new genericsClassExample();
g.gtest("");
g.gtest('a');
g.gtest(15);
g.gtest(15.0);
g.gtest(new eightEmpress());
g.gtest(false);
g.gtest(g);
}
public <T> void gtest(T t){
System.out.println(t.getClass().getName());

}
}

Answer 4

关于这个问题，百度百科有详细的解释和代码，楼上说的也是正确的，泛型可以是任意类型