Java Generics Summary

Introduction

I've been researching generics again for the past few days, so after giving a brief overview of generics, I decided to summarize the following two contents as a memo.

--Generics scope --Talk about type variables

Generics overview

Anyway, I would like to reorganize the merits of using Generics. It ** will notify you at compile time if you try to insert an object of the wrong type ** (quoted from Effective Java 3rd Edition Chapter 5 Generics). As a result, similar processing can be realized for various types within the range in which type safety can be guaranteed. Now, I would like to show a concrete example in code. Here, I would like to recognize the goodness of writing in generics by comparing arrays and generics. Write the definition of the list, add to the list, and retrieve it without using generics as follows.

ArrayList list = new ArrayList(); 
list.add("hoge"); 
String s = (String) list.get(0);

Since it is extracted as Object type, it is necessary to explicitly cast it, and if there is an error (such as assigning with int and extracting with String), you will not notice the error unless you move it. ← This is very painful. Write the definition of the list using generics, the addition to the list, and the retrieval as follows.

ArrayList<String> list = new ArrayList<String>(); 
list.add("hoge"); 
String s = list.get(0);

I get an error when compiling. (You can notice the mistake before executing it ← This is very nice)

About the scope of Generics

Generics has two scopes. Method scope and instance scope. An overview is given for each.

Method scope

First, the syntax is shown below.

SetInt.java

public class SetInt{
  public <E> Set<E> union(Set<E> s1,Set<E> s2){
    // (Example)Processing to add s1 and s2
 }
}

The first thing you will notice is the after the access modifier public. This is a type variable declaration. This declaration allows us to define an association that the argument and return value are of the same type within the scope of the method. Method-scoped generics declarations can be used not only in instance methods, but also in static methods and constructors. When calling, there are cases where it is called as it is and cases where it is called by explicitly specifying the type.

When calling as it is

Set<Integer> result = SetInt.union(Set<Integer>,Set<Integer>);

When calling by explicitly specifying the type

Set<Integer> result = SetInt.<Integer>union(Set<Integer>,Set<Integer>);

In addition, exception handling can be called as follows by explicitly specifying the type.

Hoge.java

public class Hoge{
	public <E extends Exception> void example() throws E {};
	public  void test() {
		try {
			this.<IOException>example();
		} catch (IOException e) {
			//Exception handling at IOException exception catch
		}
		try {
			this.<SQLException>example();
		} catch (SQLException e) {
			//Exception handling at SQLException exception catch
		}
	}	
}

Instance scope

It's more often seen than method scope, and I feel that it's usually dealt with in introductory books. An example is shown below.

Stack.java

public class Stack<E> {
  private E elements;
  public void push(E e) {
	//Process to push to elements
  }
  public E pop() {
	//Processing to extract E from elements
  }
}

You can define associations where the arguments, return values, and instance field types of multiple declared instance methods (two above) are the same.

Story around type variables

Knowledge of "covariance, contravariance, immutability" and "Liskov substitution principle" is a prerequisite. This article is easy to understand about the former (https://www.thekingsmuseum.info/entry/2016/02/07/235454) In the following memo, as an example, there are classes A, B, and C, respectively, and they are verified as having an inheritance relationship of C extends B and B extends A, respectively.

Covariant

It can be defined as follows.

List<? extends B> extendsBList = new ArrayList<C>();

The above extendsAList has the following properties.

1. B-type and C-type variables can be extracted from extendsBList.
2. Only null type can be stored in extendsBList.

Aside from property 1, property 2 remains questionable. The process by which property 2 is derived is summarized below.

Why can't I store anything other than null type in extendsBList?

For example, it can be stored in extendsBList and extendsBList.add (new B ()); holds. However, please refer to the initialization code of extendsBList once again. It is initialized with ArrayList type. If B could be added (), the B type would be added () to the ArrayList type, causing a contradiction. Therefore, in List <? Extends B>, add () can be added to List and List that can be assigned to List <? Extends B> so that the safety of the type is not broken. It is constrained so that only new things can be added (). Since it has only a null type, property 2 holds.

List<? super B> superBList = new ArrayList<A>();