Java generics: generic classes, generic interfaces and generic methods

According to the description in "Java Programming Thoughts (4th Edition)", the motivation for the emergence of generics is:

There are many reasons that contributed to the emergence of generics, and one of the most eye-catching reasons is to create container classes.

Generic classes

Container classes should be considered one of the most reusable class libraries. Let’s first look at how to define a container class without generics:

public class Container {    
private String key;    
private String value;    
public Container(String k, String v) {
        key = k;        
        value = v;
    }    
    public String getKey() {        
        return key;
    }    
    public void setKey(String key) {        
        this.key = key;
    }    
    public String getValue() {        
        return value;
    }    
    public void setValue(String value) {        
       this.value = value;
    }
}

The Container class saves a pair of key-value pairs, but the type is fixed, that is, if I want to create a key-value pair Yes, it is of type String-Integer. The current Container cannot do this and must be customized. Then this obviously has very low reusability.

Of course, I can use Object instead of String, and before Java SE5, we could only do this. Since Object is the base class of all types, it can be transformed directly. But this flexibility is still not enough, because the type is still specified, but this time the type specified is at a higher level. Is it possible not to specify the type? Is it possible to know what the specific type is at runtime?

So, generics appeared.

public class Container<K, V> {    
private K key;    
private V value;    
public Container(K k, V v) {
        key = k;        
        value = v;
    }    
    public K getKey() {        
       return key;
    }    
    public void setKey(K key) {        
        this.key = key;
    }    
    public V getValue() {        
         return value;
    }    
    public void setValue(V value) {        
        this.value = value;
    }
}

At compile time, it is impossible to know the specific types of K and V. Only at runtime will memory be actually constructed and allocated based on the type. You can take a look at the current support of different types by the Container class:

public class Main {    
     public static void main(String[] args) {
        Container<String, String> c1 = new Container<String, String>("name", "findingsea");
        Container<String, Integer> c2 = new Container<String, Integer>("age", 24);
        Container<Double, Double> c3 = new Container<Double, Double>(1.1, 2.2);
        System.out.println(c1.getKey() + " : " + c1.getValue());
        System.out.println(c2.getKey() + " : " + c2.getValue());
        System.out.println(c3.getKey() + " : " + c3.getValue());
    }
}

Output:

name : findingsea
age : 24
1.1 : 2.2

Generic interface

In the generic interface, the generator is a good understanding. See the following generator interface definition:

public interface Generator<T> {    
   public T next();
}

Then define a generator class to implement this interface:

public class FruitGenerator implements Generator<String> {
    private String[] fruits = new String[]{"Apple", "Banana", "Pear"};
    @Override    
    public String next() {
        Random rand = new Random();        
        return fruits[rand.nextInt(3)];
    }
}

Call:

public class Main {    
      public static void main(String[] args) {
        FruitGenerator generator = new FruitGenerator();
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
        System.out.println(generator.next());
    }
}

Output:

Banana
Banana
Pear
Banana

Generic method

A basic principle is: whenever you can do it, you should Use generic methods whenever possible. That is, if using generic methods can replace generalizing the entire class, then use generic methods should be limited. Let’s look at the definition of a simple generic method:

public class Main {    
     public static <T> void out(T t) {
        System.out.println(t);
    }    
    public static void main(String[] args) {        
       out("findingsea");        
       out(123);        
       out(11.11);        
       out(true);
    }
}

You can see that the parameters of the method are completely generalized. This process involves the compiler’s type derivation and automatic packaging, which means that we originally need to perform the type derivation ourselves. Judgment and processing, now the compiler does it for us. In this way, when defining a method, you don't have to consider what types of parameters need to be processed in the future, which greatly increases the flexibility of programming.

Look at another example of generic methods and variable parameters:

public class Main {    
    public static <T> void out(T... args) {        
            for (T t : args) {
            System.out.println(t);
        }
    }    
    public static void main(String[] args) {        
         out("findingsea", 123, 11.11, true);
    }
}

The output is the same as the previous code. You can see that generics can be perfectly combined with variable parameters.