제네릭 프로그래밍(Generic programming)은 데이터 형식에 의존하지 않고, 하나의 값이 여러 다른 데이터 타입들을 가질 수 있는 기술에 중점을 두어 재사용성을 높일 수 있는 프로그래밍 방식이다.

제네릭 프로그래밍 - 위키백과, 우리 모두의 백과사전

final List list1 = new ArrayList();
list1.add("Cat1!");
final String cat1 = (String) list1.get(0);

final List<String> list2 = new ArrayList<>();
list2.add("Cat2!");
final String cat2 = list2.get(0);

final List<String> list = new ArrayList<>();
list.add("Cat!");
final String cat = list.get(0);

final List list = new ArrayList();
list.add("Cat!");
final String cat = (String) list.get(0);

  public static main([Ljava/lang/String;)V
   L0
    LINENUMBER 10 L0
    NEW java/util/ArrayList
    DUP
    INVOKESPECIAL java/util/ArrayList.<init> ()V
    ASTORE 1
   L1
    LINENUMBER 11 L1
    ALOAD 1
    LDC "Cat!"
    INVOKEINTERFACE java/util/List.add (Ljava/lang/Object;)Z
    POP
   L2
    LINENUMBER 12 L2
    ALOAD 1
    ICONST_0
    INVOKEINTERFACE java/util/List.get (I)Ljava/lang/Object;
    CHECKCAST java/lang/String
    ASTORE 2

public class Animal {
    public Animal getAnimal() {
        System.out.println("Animal!");
        return new Animal();
    }
}

public class Cat extends Animal {
    @Override
    public Cat getAnimal() {
        System.out.println("Cat!");
        return new Cat();
    }
}

final Cat cat = new Cat();
cat.getAnimal(); // Cat!

final Animal animal = cat;
animal.getAnimal(); // Cat!

final Number num1 = new Integer(1);
final Number num2 = new Double(1.0);

final Number[] numbers = new Number[2];
numbers[0] = new Integer(1);
numbers[1] = new Double(1.0);

public class Animal {
    public void put(Animal animal) {
        System.out.println("Animal!");
    }
}

public class Cat extends Animal {
    public void put(Object animal) {
        System.out.println("Cat!");
    }
}

final Cat cat = new Cat();
cat.put(new Cat()); // Animal!

final Cat cat1 = new Animal(); // compile error!
final Cat cat2 = (Cat) new Animal(); // runtime error!

final Cat[] cats = new Cat[2];
cats[0] = new Animal(); // compile error!
cats[1] = (Cat) new Animal(); // runtime error!

public void printNumber(final List<Number> numbers) {
    numbers.forEach(System.out::println);
}


final List<Number> num1 = new ArrayList<Integer>(); // compile error!

final List<Number> num2 = new ArrayList<>();
num2.add(1);
printNumber(num2);

final List<Integer> num3 = new ArrayList<>();
num3.add(1);
printNumber(num3);  // compile error!

final Number[] numbers = new Number[3];
numbers[0] = new Integer(1);
numbers[1] = new Long(1);
numbers[2] = new Double(1.0);

System.out.println(numbers[0].longValue());
System.out.println(numbers[1].longValue());
System.out.println(numbers[2].longValue());

final Number[] numbers2 = new Integer[3];
numbers2[0] = new Double(1.0);
System.out.println(numbers2[0].longValue());

public <T> T newInstances(Class<T> clazz) throws Exception {
    final T instances = clazz.newInstance();
    // 적절한 초기화 코드
    return instances;
}


final String str = newInstances(String.class);
final List<String> list = newInstances(List<String>.class); // error!

public <T> List<T> newListInstances(Class<T> clazz) throws Exception {
    final ArrayList<T> list = new ArrayList<>();
    // 적절한 초기화 코드
    return list;
}

final List<String> list = newListInstances(String.class);

Map, Set ???

public class Box<T> {
    // 적절한 구현
}

public class LongBox extends Box<List<Long>> {
    // 적절한 구현
}

final Type type = LongBox.class.getGenericSuperclass();
final ParameterizedType pType = ParameterizedType.class.cast(type);
final Type[] actualTypeArguments = pType.getActualTypeArguments();

System.out.println(actualTypeArguments[0]);

public static void main(String[] args) throws Exception {
    class LongBox extends Box<List<Long>> { }
    
    final Type type = LongBox.class.getGenericSuperclass();
    final ParameterizedType pType = ParameterizedType.class.cast(type);
    final Type[] actualTypeArguments = pType.getActualTypeArguments();

    System.out.println(actualTypeArguments[0]);
}

public static void main(String[] args) throws Exception {
    Box typeBox = new Box<List<Long>>() {};

    final Type type = typeBox.getClass().getGenericSuperclass();
    final ParameterizedType pType = ParameterizedType.class.cast(type);
    final Type[] actualTypeArguments = pType.getActualTypeArguments();

    System.out.println(actualTypeArguments[0]);
}

final ParameterizedTypeReference<List<String>> typeReference =
        new ParameterizedTypeReference<List<String>>() {};
final List<String> response  = 
        restTemplate.exchange(
            url, 
            HttpMethod.GET, 
            request, 
            typeReference).getBody();

final TypeToken<List<String>> typeToken = 
    new TypeToken<List<String>>() {};

final List<String> list =
        new Gson().fromJson(jsonText, typeToken.getType());

final TypeReference type = new TypeReference<List<String>>() {};
final List<String> data = mapper.readValue(jsonData, type);