java中的泛型的一些常见例子

 

class Test<T, V> {
    private T name;
    private V age;
    Test() {
    }
    public T getName() {
        return name;
    }
    public void setName(T name) {
        this.name = name;
    }
    public V getAge() {
        return age;
    }
    public void setAge(V age) {
        this.age = age;
    }
    public static void main(String[] args) {
        Test<String, Integer> he = new Test<String, Integer>();
        he.setAge(10);
        he.setName("Rollen Holt");
        System.out.println(he.getName() + ":" + he.getAge());
    }
}

/**
 *
 * @author Rollen-Holt 泛型类的构造方法定义
 */
class Test<T, V> {
    private T name;
    private V age;
    Test(T name, V age) {
        this.age = age;
        this.name = name;
    }
    public T getName() {
        return name;
    }
    public V getAge() {
        return age;
    }
    public static void main(String[] args) {
        Test<String, Integer> he = new Test<String, Integer>("Rollen", 12);
        System.out.println(he.getName() + "  " + he.getAge());
    }
}

/**
 * @author Rollen-Holt 使用通配符
 */
class info<T> {
    private T name;
    info(T name) {
        this.name = name;
    }
}
class Test {
    public static void function(info> temp) {
        System.out.println("内容： " + temp);
    }
    public static void main(String[] args) {
        info<String> demo = new info<String>("Rollen");
        function(demo);
    }
}

/**
 * @author Rollen-Holt 泛型上限
 */
class info<T> {
    info(T age) {
        this.age = age;
    }
    private T age;
}
class Test {
    public static void function(info extends Number> temp) {
        System.out.println("内容" + temp);
    }
    public static void main(String[] args) {
        info<Integer> demo = new info<Integer>(1);
        function(demo);
    }
}

/**
 * @author Rollen-Holt 泛型下限
 */
class info<T>{
    info(T age){
        this.age=age;
    }
    private T age;
}
class hello{
    public static void function(info super String> temp){
        System.out.println("内容"+ temp);
    }
    public static void main(String[] args){
     // 此处只能使用String 或者Object
      info<String> demo=new info<String>("Rollen");
      function(demo);
    }
}

 * @author Rollen-Holt 泛型和子类继承的限制
 */
class info<T>{
}
class hello{
    public static void main(String[] args){
    info<String> demo1=new info<String>();
    info<Object> demo2=new info<Object>();
    //demo2=demo1;   此处错误
    }
}
/**
 * 上面的例子说明，一个类的子类可以通过多态性被其父类实例化
 * 但是在泛型操作中，子类的泛型类型是无法被其父类的泛型类型实例化的。
 */
如果允许上面的条语句的话，会出现：
Exception in thread "main" java.lang.Error: Unresolved compilation problem:
    Type mismatch: cannot convert from info<String> to info<Object>
    at hello.main(hello.java:12)

/**
 * @author Rollen-Holt 泛型接口的实现1
 */
interface info<T> {
    public void say();
}
// 直接在子类之后声明泛型

class hello<T> implements info<T>{
    public static void main(String[] args){
        info<String> demo = new hello<String>();
        demo.say();
    }
    public void say(){
        System.out.println("hello");
    }
}

/**
 * @author Rollen-Holt 泛型接口的实现2
 */
interface info<T> {
    public void say();
}
// 在子类实现的接口中明确给出泛型类型
class hello implements info<String>{
    public static void main(String[] args){
        info<String> demo = new hello();
        demo.say();
    }
    public void say(){
        System.out.println("hello");
    }
}

/**
 * @author Rollen-Holt 使用泛型统一传入参数的类型
 */
class info<T> {
    private T var;
    public T getVar(){
        return var;
    }
    public void setVar(T var){
        this.var = var;
    }
    public String toString(){
        return this.var.toString();
    }
}
class hello{
    public static void main(String[] args){
        info<String> demo1=new info<String>();
        info<String> demo2=new info<String>();
        demo1.setVar("Rollen");
        demo2.setVar("Holt");
        printAdd(demo1, demo2);
    }
    // 此处传递的都是同一个String类型的
    public static <T> void printAdd(info<T> demo1, info<T> demo2){
        System.out.println(demo1.getVar()+" "+demo2.getVar());
    }
}