Java泛型详解_java 泛型单例

一、泛型的本质

Java 泛型（generics）是 JDK 5 中引入的一个新特性, 泛型提供了编译时类型安全检测机制，该机制允许程序员在编译时检测到非法的类型。

泛型的本质是参数化类型，即给类型指定一个参数，然后在使用时再指定此参数具体的值，那样这个类型就可以在使用时决定了。这种参数类型可以用在类、接口和方法中，分别被称为泛型类、泛型接口、泛型方法。

二、泛型的作用

泛型的好处是在编译的时候检查类型安全，并且所有的强制转换都是自动和隐式的，提高代码的重用率

1、保证类型的安全性

在没有泛型之前，从集合中读取到的每一个对象都必须进行类型转换，如果不小心插入了错误的类型对象，在运行时的转换处理就会出错。
比如：没有泛型的情况下使用集合：

public static void noGeneric() {
	ArrayList names = new ArrayList();
	names.add("mikechen的互联网架构");
	names.add(123); //编译正常
}
1
2
3
4
5

有泛型的情况下使用集合：

public static void useGeneric() {
	ArrayList<String> names = new ArrayList<>();
	names.add("mikechen的互联网架构");
	names.add(123); //编译不通过
}
1
2
3
4
5

有了泛型后，定义好的集合names在编译的时候add(123)就会编译不通过。
相当于告诉编译器每个集合接收的对象类型是什么，编译器在编译期就会做类型检查，告知是否插入了错误类型的对象，使得程序更加安全，增强了程序的健壮性。

2、消除转换

泛型的一个附带好处是，消除源代码中的许多强制类型转换，这使得代码更加可读，并且减少了出错机会。
举例说明，以下没有泛型的代码段需要强制转换：

List list = new ArrayList();
list.add("hello");
String s = (String) list.get(0);
1
2
3

当使用泛型时，代码不需要强制转换：

List<String> list = new ArrayList<String>();
list.add("hello");
String s = list.get(0); // no cast
1
2
3

3、提升性能

在非泛型编程中，将筒单类型作为Object传递时会引起Boxing（装箱）和Unboxing（拆箱）操作，这两个过程都是具有很大开销的。引入泛型后，就不必进行Boxing和Unboxing操作了，所以运行效率相对较高，特别在对集合操作非常频繁的系统中，这个特点带来的性能提升更加明显。
泛型变量固定了类型，使用的时候就已经知道是值类型还是引用类型，避免了不必要的装箱、拆箱操作。
举例说明，以下没有泛型的代码段需要强制转换，装箱拆箱：

object a=1;//由于是object类型，会自动进行装箱操作。
int b=(int)a;//强制转换，拆箱操作。这样一去一来，当次数多了以后会影响程序的运行效率。
1
2

使用泛型之后：

public static T GetValue<T>(T a){
　　return a;
}
public static void Main(){
　　int b=GetValue<int>(1);//使用这个方法的时候已经指定了类型是int，所以不会有装箱和拆箱的操作。
}
1
2
3
4
5
6

4、重用性

三、泛型的使用

1、泛型类

泛型类：把泛型定义在类上
定义格式：

public class 类名 <泛型类型1,...> {
}
1
2

注意事项：

• 泛型类型必须是引用类型（非基本数据类型）
• 定义泛型类，在类名后添加一对尖括号，并在尖括号中填写类型参数，参数可以有多个，多个参数使用逗号分隔：
  public class GenericClass<ab,a,c> {}
• 后面的参数类型的规范不能像上面一样随意，通常类型参数我们都使用大写的单个字母表示：
  • T：任意类型 type
  • E：集合中元素的类型 element
  • K：key-value形式 key
  • V： key-value形式 value

例子：

public class GenericClass<T> {
    private T value;

    public GenericClass(T value) {
        this.value = value;
    }
    public T getValue() {
        return value;
    }
    public void setValue(T value) {
        this.value = value;
    }

    public static void main(String[] args) {
        GenericClass<String> name = new GenericClass<>("这个是String类型");
        System.out.println(name.getValue());

        GenericClass<Integer> number = new GenericClass<>(123);
        System.out.println(number.getValue());
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

输出结果：

这个是String类型
123
1
2

2、泛型接口

泛型接口概述：把泛型定义在接口上
定义格式：

public interface 接口名 <泛型类型> （泛型类型 变量名） {
}

1
2
3

例子：

public interface GenericInterface<T> {
    T show(T value);
}

class StringShowImpl implements GenericInterface<String> {
    @Override
    public String show(String value) {
        System.out.println(value);
        return value;
    }}

class NumberShowImpl implements GenericInterface<Integer> {
    @Override
    public Integer show(Integer value) {
        System.out.println(value);
        return value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

注意：

• 方法声明中定义的形参只能在该方法里使用，而接口、类声明中定义的类型形参则可以在整个接口、类中使用。当调用show()方法时，根据传入的实际对象，编译器就会判断出类型形参T所代表的实际类型。
• 使用泛型的时候，前后定义的泛型类型必须保持一致，否则会出现编译异常

3、泛型方法

泛型方法，是在调用方法的时候指明泛型的具体类型
定义格式：

修饰符 <泛型类型> 返回类型 方法名（泛型类型 变量名） {
}
1
2

例子

/**
     *
     * @param t 传入泛型的参数
     * @param <T> 泛型的类型
     * @return T 返回值为T类型
     * 说明：
     *   1）public 与 返回值中间<T>非常重要，可以理解为声明此方法为泛型方法。
     *   2）只有声明了<T>的方法才是泛型方法，泛型类中的使用了泛型的成员方法并不是泛型方法。
     *   3）<T>表明该方法将使用泛型类型T，此时才可以在方法中使用泛型类型T。
     *   4）与泛型类的定义一样，此处T可以随便写为任意标识，常见的如T、E等形式的参数常用于表示泛型。
     */
    public <T> T genercMethod(T t){
        System.out.println(t.getClass());
        System.out.println(t);
        return t;
    }
 
	public static void main(String[] args) {
	    GenericsClassDemo<String> genericString  = new GenericsClassDemo("helloGeneric"); //这里的泛型跟下面调用的泛型方法可以不一样。
	    String str = genericString.genercMethod("hello");//传入的是String类型,返回的也是String类型
	    Integer i = genericString.genercMethod(123);//传入的是Integer类型,返回的也是Integer类型
	}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

输出结果：

class java.lang.String
hello
class java.lang.Integer
123
1
2
3
4

这里可以看出，泛型方法随着我们的传入参数类型不同，他得到的类型也不同。泛型方法能使方法独立于类而产生变化。

四、泛型通配符

Java泛型的通配符是用于解决泛型之间引用传递问题的特殊语法, 主要有以下三类:

//表示类型参数可以是任何类型
public class Apple<?>{}
 
//表示类型参数必须是A或者是A的子类
public class Apple<T extends A>{}
 
//表示类型参数必须是A或者是A的超类型
public class Apple<T supers A>{}

1
2
3
4
5
6
7
8
9

1. <?>

无边界的通配符(Unbounded Wildcards), 就是<?>, 比如List<?>
无边界的通配符的主要作用就是让泛型能够接受未知类型的数据.

2、<? extends E>

固定上边界的通配符(Upper Bounded Wildcards)，采用<? extends E>的形式
使用固定上边界的通配符的泛型, 就能够接受指定类及其子类类型的数据。
要声明使用该类通配符, 采用<? extends E>的形式, 这里的E就是该泛型的上边界。
注意: 这里虽然用的是extends关键字, 却不仅限于继承了父类E的子类, 也可以代指显现了接口E的类

3. <? super E>

固定下边界的通配符(Lower Bounded Wildcards)，采用<? super E>的形式
使用固定下边界的通配符的泛型, 就能够接受指定类及其父类类型的数据.。
要声明使用该类通配符, 采用<? super E>的形式, 这里的E就是该泛型的下边界.。
注意: 你可以为一个泛型指定上边界或下边界, 但是不能同时指定上下边界。

五、泛型中KTVE的含义

E： Element (在集合中使用，因为集合中存放的是元素)
T：Type（Java 类）
K： Key（键）
V： Value（值）
N： Number（数值类型）
？： 表示不确定的java类型

六、使用案例

1、单例工具类

使用泛型之前，我们的单例模式写法如下：

public class Singleton {
    private static Singleton singleton;
    private Singleton(){}
    public static Singleton getInstance(){
        if(singleton == null){
            synchronized (Singleton.class){
                if(singleton == null){
                    singleton = new Singleton();
                    return singleton;
                }
            }
        }
        return singleton;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用泛型编写单例模式工具类如下：

public class SingletonParent {
    private static final Map<Class<? extends SingletonParent>, SingletonParent> instancesMap = new HashMap<>();

    public synchronized static <E extends SingletonParent> SingletonParent getInstance(Class<E> instanceClass) throws Exception {
        if(instancesMap.containsKey(instanceClass)){
            return instancesMap.get(instanceClass);
        } else {
            E instance = instanceClass.newInstance();
            instancesMap.put(instanceClass, instance);
            return instance;
        }
    }
    protected SingletonParent(){
    }
    
    public static void main(String[] args) throws Exception {
        Test test = (Test)SingletonParent.getInstance(Test.class);
    }
}

class Test extends SingletonParent{

}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23