`
dyy_gusi
  • 浏览: 209430 次
  • 性别: Icon_minigender_1
  • 来自: 武汉
社区版块
存档分类
最新评论

Java中泛型的各种使用

    博客分类:
  • Java
阅读更多

Java中的泛型的使用:
1.普通的泛型使用

在使用类的时候后面的<>中的类型就是我们确定的类型。

public class MyClass1<T> {//此处定义的泛型是T
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }
}
/**
 * 最普通的泛型使用,只有一个泛型类型
 */
@Test
public void testMyClass1() {
    MyClass1<String> clazz = new MyClass1<String>();//此事确定对象对应的泛型T是String
    clazz.setVar("stringType");
    String str = clazz.getVar();
    System.out.println(str);
}

   
2.带有两个泛型类型

 

和普通的泛型使用基本一样,只是我们可以在使用类的时候定义两个不同的泛型类型,当然我们也可以定义多个,只要我们业务需要。

public class MyClass2<K, V> {//此处定义两个泛型类型
    private K var1;//第一个变量的类型是K对应的具体类型
    private V var2;//第二个变量的类型是V对应的具体类型

    public K getVar1() {
        return var1;
    }

    public void setVar1(K var1) {
        this.var1 = var1;
    }

    public V getVar2() {
        return var2;
    }

    public void setVar2(V var2) {
        this.var2 = var2;
    }

}

/**
 * 含有两个泛型类型的使用
 */
@Test
public void testMyClass2() {
    //此处确定定义的clazz对象的第一个泛型类型是Integer,第二个泛型类型是String
    MyClass2<Integer, String> clazz = new MyClass2<Integer, String>();
    clazz.setVar1(1); //此处只能用int类型的参数
    clazz.setVar2("string");//此处只能用String类型的参数

    System.out.println(clazz.getVar1() + "," + clazz.getVar2());
}

   
3.含有通配符的泛型

 

这里面又包含3种:没限制的通配符、使用extends限制、使用super限制

public class MyClass3<T> {
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    @Override
    public String toString() {
        return var.toString();
    }

}
/**
 * 通配符?的使用 包括<?>、<?extends 类型>和<? super 类型>
 */
@Test
public void testMyClass3() {
    MyClass3<Boolean> clazz = new MyClass3<Boolean>();
    clazz.setVar(false);
    fun(clazz);//调运该方法的时候,对泛型没有限制,任何类型的泛型都可以使用

    MyClass3<Integer> clazzInt = new MyClass3<Integer>();
    clazzInt.setVar(1);
    funExtends(clazzInt);//调运该方法的时候,只能使用Number类型或者其子类型

    MyClass3<Double> clazzDouble = new MyClass3<Double>();
    clazzDouble.setVar(2.2);
    funExtends(clazzDouble);//调运该方法的时候,只能使用Number类型或者其子类型


    MyClass3<String> clazzString = new MyClass3<String>();
    clazzString.setVar("string");
    funSuper(clazzString);//调运该方法的时候,只能使用String类型或者其父类型


    MyClass3<Object> clazzObject = new MyClass3<Object>();
    clazzObject.setVar(new Object());
    funSuper(clazzObject);//调运该方法的时候,只能使用String类型或者其父类型

}

public void fun(MyClass3<?> clazz) {//没有限制的泛型使用
    System.out.println(clazz);
}

public void funExtends(MyClass3<? extends Number> clazz) {//只能使用Number及其子类的泛型
    System.out.println(clazz);
}

public void funSuper(MyClass3<? super String> clazz) {//只能使用String及其父类的泛型
    System.out.println(clazz);
}

4.定义类的时候就对泛型进行限制

public class MyClass4<T extends Number> {//定义类的泛型的时候进行泛型的限制
    private T var;

    public T getVar() {
        return var;
    }

    public void setVar(T var) {
        this.var = var;
    }

    @Override
    public String toString() {
        return this.var.toString();
    }

}

/**
 * 定义类的泛型的时候都给定泛型的限制
 */
@Test
public void testMyClass4() {
    //同样只能定义Number及其子类的泛型
    // MyClass4<String> clazzString = new MyClass4<String>();
    MyClass4<Integer> clazzInt = new MyClass4<Integer>();
    MyClass4<Double> clazzDouble = new MyClass4<Double>();

    MyClass4<Float> clazzFClass4 = fun(1.1f);
    //此处调运的参数是float类型,这就确定了返回类型必须是float
}

public <T extends Number> MyClass4<T> fun(T arg) {
    return new MyClass4<T>();

}

5.泛型接口的使用

public interface MyInterface<T> {
    public T getVar();
}

//两种实现方式。1,在实现的时候还是使用泛型,到具体定义对象的时候再确定
public class MyInterface1Impl<T> implements MyInterface<T> {
    private T var;

    public MyInterface1Impl() {
    }

    public MyInterface1Impl(T var) {
        this.var = var;
    }

    @Override
    public T getVar() {
        return this.var;
    }

}
//第二种实现方式,在实现的时候就确定泛型的类型
public class MyInterface2Impl implements MyInterface<String> {
    private String varStr;

    public MyInterface2Impl() {
    }

    public MyInterface2Impl(String varStr) {
        this.varStr = varStr;
    }

    @Override
    public String getVar() {
        return this.varStr;
    }
}

/**
 * 泛型接口的使用
 */
@Test
public void testMyInterface() {
    //实现类可以定义为任意类型的泛型
    MyInterface1Impl<String> varStr = new MyInterface1Impl<String>("abc");
    System.out.println(varStr.getVar());
    MyInterface1Impl<Integer> varInt = new MyInterface1Impl<Integer>(123);
    System.out.println(varInt.getVar());

    //之前已经在类实现的时候已经确定了只能是String
    MyInterface2Impl var = new MyInterface2Impl("cba");
    String str = var.getVar();
    System.out.println(str);
}

6.泛型方法的使用

public class MyFunction {
    public <T> T fun1(T arg) {//传入参数和返回参数都是同样的泛型类型
        return arg;
    }

    public <T> void fun2(T arg) {//传入参数是泛型,不需要返回
        if (arg instanceof String) {
            System.out.println("T is StringType");
        } else if (arg instanceof Integer) {
            System.out.println("T is IntegerType");
        } else {
            System.out.println("T is OtherType");
        }
    }

    public <T> String fun3(T arg) {//传入的参数是泛型,返回的确定类型
        return arg.toString();
    }
}

/**
 * 泛型方法的使用
 */
@Test
public void MyFunction() {
    MyFunction clazz = new MyFunction();
    
    //传入什么类型,返回什么类型
    String var1 = clazz.fun1("abc");
    int var2 = clazz.fun1(12);
    System.out.println(var1);
    System.out.println(var2);

    //无论传入的是什么类型,都没关系
    clazz.fun2(1);
    clazz.fun2(false);
    clazz.fun2("string");

    //无论传入什么,都返回的是String
    String var3 = clazz.fun3(123);
    String var4 = clazz.fun3("string");
    System.out.println(var3);
    System.out.println(var4);

}

 7.泛型数组

/**
 * 泛型数组的使用
 */
@Test
public void testArray(){
    Integer[] arr = fun(1,2,3);
   
}

public <T> T[] fun(T... args){//传入什么类型,T就是什么类型,并且可以使用泛型遍历
    for(T t:args){
        System.out.println(t.toString());
    }
    return args;
}

 8.嵌套泛型

/**
 * 嵌套泛型
 */
@Test
public void testNest(){
    //外层泛型的类型其实就是内层泛型,当内层泛型确定了,那外层泛型也就确定了
    MyClass1<MyClass2<Integer, String>> nestOut = new MyClass1<MyClass2<Integer,String>>();
    MyClass2<Integer, String> nestIn = new MyClass2<Integer,String>();
    nestIn.setVar1(1);
    nestIn.setVar2("a");
    nestOut.setVar(nestIn);
    System.out.println(nestOut.getVar().getVar1());
    System.out.println(nestOut.getVar().getVar2());
}

 

 

 

2
0
分享到:
评论
3 楼 freerambo 2013-12-18  
很受用,谢谢 楼主
2 楼 wlxlz 2013-12-13  
很全面,谢谢 楼主
1 楼 coolbamboo2008 2013-12-13  
不错,感谢楼主总结

相关推荐

    Java 实现泛型List

    Java 实现泛型List的源码,基本实现了List接口的全部所有方法。欢迎大家发表自己的观点和建议。

    Java中的泛型简析实战.zip

    Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战Java中的泛型简析实战...

    java 泛型方法使用示例

    下面我们将深入探讨Java泛型方法的概念、语法以及使用示例。 **一、泛型方法概念** 泛型方法是一种具有类型参数的方法,这些类型参数可以在方法声明时指定,并在方法体内部使用。与类的泛型类似,它们提供了编译时...

    2.java定义泛型类.zip

    2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip2.java定义泛型类.zip...

    关于C#、java泛型的看法

    在Java中,泛型同样使用尖括号表示,但它的类型擦除特性使得编译后的字节码并不包含类型参数信息,而是使用Object或其他基础类型作为替代。这意味着Java的泛型不支持协变和逆变,但可以通过通配符(如?)来放宽类型...

    Java1.5泛型指南中文版

    感谢所有为Java泛型做出贡献的人们,包括设计者、实现者以及提供反馈和支持的社区成员。泛型是Java语言的一个重要特性,极大地提高了代码的质量和可维护性。 以上就是基于给定文件信息对Java 1.5泛型指南的主要知识...

    java5泛型新特性 pdf

    2. **通配符**:泛型中使用通配符可以增加类型参数的灵活性。例如,`?`表示任何类型,`? extends Number`则限制为Number或其子类。这在处理多种类型的集合时非常有用,如方法参数的定义。 3. **类型擦除**:由于...

    java 泛型类的类型识别示例

    4. **利用`Class&lt;T&gt;`作为泛型约束**:有时候,我们可以在泛型类中使用`Class&lt;T&gt;`作为参数或字段,这样可以在运行时获取类型信息。例如: ```java public class MyClass&lt;T&gt; { private final Class&lt;T&gt; clazz; ...

    JAVA-泛型课件-泛型课件

    泛型接口允许在接口声明中使用类型参数,实现此接口的类或接口必须提供具体的类型。 ### 泛型的优势 引入泛型的主要目的是在编译时提供更严格的类型检查,并且减少强制类型转换的需要。使用泛型后,在集合操作中...

    JAVA泛型加减乘除

    这是一个使用JAVA实现的泛型编程,分为两部分,第一部分创建泛型类,并实例化泛型对象,得出相加结果。 第二部分用户自行输入0--4,选择要进行的加减乘除运算或退出,再输入要进行运算的两个数,并返回运算结果及...

    Java泛型的用法及T.class的获取过程解析

    Java泛型是Java编程语言中的一种重要特性,它允许开发者在编写代码时指定类型参数,从而提高代码的灵活性和可读性。本文将详细介绍Java泛型的用法 及T.class的获取过程解析。 一、泛型的基本概念 泛型是Java 5中...

    Java泛型_Java中的泛型结构_

    }`,这里的 `T` 是类型参数,可以在类的方法和成员变量中使用。 - 实例化:`MyClass&lt;String&gt; myObj = new MyClass();` - 类型擦除:Java编译器会进行类型擦除,将泛型类的实例转换为无参数类型,但会在编译时进行...

    java 一个关于泛型的简单例子

    泛型允许我们在类、接口和方法中使用类型参数,这样我们可以在编译时检查类型,避免了运行时类型转换的麻烦和潜在的ClassCastException风险。 在Java中,泛型的主要目的是为了实现参数化类型,这意味着我们可以创建...

    java泛型的内部原理及更深应用

    Java泛型是Java编程语言中的一个强大特性,它允许在定义类、接口和方法时使用类型参数,从而实现参数化类型。这使得代码更加安全、可读性更强,并且能够减少类型转换的必要。在“java泛型的内部原理及更深应用”这个...

    Java反射泛型,实现数据库的动态增删改查等功能

    Java反射和泛型是两种强大的编程特性,它们在开发中有着广泛的应用,特别是在数据库操作的动态化场景下。本文将详细介绍如何结合这两种技术实现在Java中对MySQL、SQL Server或Oracle数据库进行动态的增删改查操作。 ...

Global site tag (gtag.js) - Google Analytics