java generics

1. Introduction to Generics

## Generics are a new feature of Java SE 1.5. The essence of generics is

parameterized types , that is to say, the data type being operated on is specified as a parameter.  Before Java SE 1.5, without generics, the "arbitrary" parameters were implemented by referencing the type Object. The disadvantage of "arbitrary" was that explicit
mandatory Type conversion, and this conversion requires the developer to know the actual parameter type beforehand. In the case of forced type conversion errors, the compiler may not prompt an error , and the exception will only occur when runs . This is a security risk.  The advantage of generics is that type safety is checked at compile time, and all casts are automatic and implicit to improve code reuse.

2. Why are generics needed?

2.1. Detecting data types during compilation

First we look at a case where a string is added to an ArrayList. "Accidentally "Added an integer, such as the following code,

There is no error:

But when executed, an error will be reported:

"java.lang.classCastException"

Because ArrayList maintains an Object array,

private transient Object[] elementData; , using get() returns An Object object needs
forced conversion, but an Integer value is mixed in the middle, causing the forced conversion to fail. This error is caused by the arbitrary of Object. If you can find that the data type is wrong during the compilation stage, it will be very convenient.
Generics meets this requirement: I will modify this program. ArrayList uses generics: you will find that during the compilation stage An error was reported.

2.2 Forced conversion is automatic

Do not use generics:

package com.chb.fanxing;public class NoGen {    
private Object ob;    
public NoGen(Object ob) {        
this.ob = ob;
    }
    getter setter...    
    private void showType() {
        System.out.println("数据的实际类型是：" + ob.getClass().getName());
    }    public static void main(String[] args) {
        NoGen ngInt = new NoGen(88);
        ngInt.showType();        int i = (int)ngInt.getOb();
        System.out.println("value = " + i);
        System.out.println("---------------");

        NoGen ngStr = new NoGen("88");
        ngStr.showType();
        String str = (String)ngStr.getOb();
        System.out.println("value = " + str);   
    }
}

Use Generics:

package com.chb.fanxing;public class Gen {    
private T ob;    
public Gen(T ob) {        
this.ob = ob;
    }
    getter setter...    
    private void showType() {
        System.out.println("T的实际类型:"+ob.getClass().getName());
    }    public static void main(String[] args) {        //定义一个Integer版本
        Gen genInt = new Gen(88);
        genInt.showType();        int i = genInt.getOb();//此处不用强制转换
        System.out.println("value = " + i);
        System.out.println("----------------------");

        Gen genStr = new Gen("88");
        genStr.showType();
        String str = genStr.getOb();
        System.out.println("value = "+str); 
    }
}

Running results:

The running results of the two examples

are consistent

数据的实际类型是：java.lang.Integervalue = 88
---------------数据的实际类型是：java.lang.String
value = 88

Comparing the two examples, you will find :

• Use generics, forced conversion is performed automatically:

int i = genInt.getOb();//此处不用强制转换

• Without using generics, you must To perform manual forced conversion

int i = (int)ngInt.getOb();

3. In-depth generics

3.1. There are two classes, and we need to print their member variables

class StringDemo {    
private String s;    
public StringDemo (String s) {        
this.s = s;
    }
    setter geter....
}
class DoubleDemo{    
private Double d;    
public DoubleDemo(Double d) {        
this.d = d;
    }
    setter getter...
}

3.2. Refactoring

Carefully observe that the functions of the two classes are basically the same, but the data types are different. Considering the refactoring, because Object is the base class of all classes, you can use Object as a member variable, so that the code It can be

generally used. The refactored code is as follows:

class ObjectDemo{
    private Object ob;    
    public ObjectDemo(Object ob){        
    this.ob = ob;
    }
    setter getter...
}

ObjectDemo test:

public static void ObjectDemoTest(){
        ObjectDemo strOD = new ObjectDemo("123");
        ObjectDemo dOD = new ObjectDemo(new Double(23));
        ObjectDemo od = new ObjectDemo(new Object());
        System.out.println((String)strOD.getOb());
        System.out.println((Double)dOD.getOb());
        System.out.println(od.getOb());
    }

Running results:

3.3 Using generic refactoring

Discover

Force conversion must be used in the above ObjectDemoTest(), which is more troublesome. We must also know the data type to be converted in advance in order to perform the correct conversion , otherwise, an error will occur. There will be no problem when the business is compiled, but once it is run, a "classCastException" will appear. So we don't need to do the cast ourselves, which is especially important for generics.

class GenDemo{    
private T t;    
public GenDemo(T t) {        
this.t = t;
    } 
    public void setT(T t) {        
    this.t = t;
    }    
    public T getT() {        
    return t;
    }
}

Test:

Eliminates manual cast

public static void GenTest() {
        GenDemo strOD = new GenDemo("123");
        GenDemo dOD = new GenDemo(new Double(23));
        GenDemo