jupyter/chapter20-generics.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# Generics\n", "Generics are way to propagate types from when a value is created to when the value is used.\n", "Historically, Java did not have a way to specify generics, by backward compatibility,\n", "you can still create a code without generics\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## The problem\n", "Let suppose we have a code somewhere to extract credentials from a config file\n", "Note: this code generates two warnings, that we will discuss later.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Pair(Object first, Object second) { }\n", "List getCredentials() {\n", "  List list = new ArrayList();\n", "  list.add(new Pair(\"login\", \"admin\"));\n", "  list.add(new Pair(\"password\", \"password\"));\n", "  return list; \n", "}\n", "System.out.println(getCredentials());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["And in another code, we want to use the method `getCredential()`, we may write\n", "a code like this\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["List list = getCredentials();\n", "String value = (String) list.get(0);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["This code will compile but fail at runtime, it throws a `ClassCastException`\n", "because in `getCredential()`, we are creating a list of pairs but in the code\n", "above, we try to extract the first value from the list as a String\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Here, we have lost the fact that the list returned by `getCredential()`\n", "is a list of pairs.\n", "Generics allows to propagate the type of values stored inside a class or\n", "more generally, allows to declare relations between types\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["We have said above that the code generate warnings, it's because java.util.List\n", "is declared as a generics class in the JDK API. So the compiler let you use\n", "List as type if you interact with a code written before generics were introduced\n", "to Java (2004) but emits a warning saying you should not declare it that way.  \n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Generics\n", "There are two kinds of generics\n", "- parameterized class\n", "- parameterized method\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Parameterized class\n", "A parameterized class is a class that declares type variables\n", "(variable that contains a type) and use them whenever we can use a type.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Declaration\n", "The type variables are declared after the name of the class.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Pair<F, S>(F first, S second) { }\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["When used, as a user of the generics you have to specify the type\n", "of each type variable (here F is String and S is Integer)\n", "so pair.first() which is typed as F will return a String and\n", "pair.second() which is typed as S will return an int.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var pair = new Pair<String, Integer>(\"port\", 8080);\n", "String first = pair.first();\n", "int second = pair.second();\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["If you don't understand why in between the '<' and '>',\n", "there is a Integer here and not an int\n", "Don't worry, it's explained in next chapter\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["So the idea of a generics class is to specify the type arguments `<String, Integer>`\n", "when you use it and the compiler will propagate the types.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### static context\n", "You may have notice that two different instances may have different type arguments\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var pair1 = new Pair<String, Integer>(\"port\", 8080);\n", "var pair2 = new Pair<String, String>(\"captain amarica\", \"shield\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["So the type variable (F and S) are not available inside a static method of Pair.\n", "A static method is called on the class `Pair.hello()`, not on an instance.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["record Pair<F, S>(F first, S second) {\n", "  static void hello() {\n", "    // can not access F and S here !\n", "  }\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Parameterized methods\n", "Like a class, a method can be parameterized, by declaring the type variables\n", "in between `<` and `>` before the return type\n", "So instead of\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Object chooseOne(Object o1, Object o2) {\n", "  var random = ThreadLocalRandom.current();\n", "  return random.nextBoolean()? o1: o2;\n", "}\n", "/*\n", "  String s = chooseOne(\"day\", \"night\");\n", "*/\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["We can write\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["<T> T chooseOne(T o1, T o2) {\n", "  var random = ThreadLocalRandom.current();\n", "  return random.nextBoolean()? o1: o2;\n", "}\n", "String s = chooseOne(\"day\", \"night\");\n", "System.out.println(s);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Inference\n", "So, we can now rewrite `getCredentials()`, to correctly type it\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["List<Pair<String, String>> getCredentials() {\n", "  List<Pair<String, String>> list = new ArrayList<Pair<String, String>>();\n", "  list.add(new Pair<String, String>(\"login\", \"admin\"));\n", "  list.add(new Pair<String, String>(\"password\", \"password\"));\n", "  return list; \n", "}\n", "System.out.println(getCredentials());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["but it's quite verbose, so in Java, we have a mechanism called __inference__\n", "to let the compiler try to guess itself the type arguments instead of\n", "having to specify them by hand\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### inference of variable local type\n", "The keyword `var` ask the compiler to find the type of the left of `=`\n", "from the type of the right of `=`.\n", "So instead of\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["List<Pair<String, String>> list = new ArrayList<Pair<String, String>>();\n", "System.out.println(list);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["using `var` we get\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var list = new ArrayList<Pair<String, String>>();\n", "System.out.println(list);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### inference when using `new`\n", "You can ask the compiler to find the type using the left type and the arguments\n", "using the diamond syntax `<>`.\n", "So instead of\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Pair<String, String> pair = new Pair<String, String>(\"login\", \"admin\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["using the diamond syntax `<>`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Pair<String, String> pair = new Pair<>(\"login\", \"admin\");\n", "System.out.println(pair);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The left type can be also found when you do a `return` \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["Pair<String, String> getOnePair() {\n", "  return new Pair<>(\"login\", \"admin\");\n", "}\n", "System.out.println(getOnePair());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["or using the type of the parameter of the method\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var list = new ArrayList<Pair<String, String>>();\n", "list.add(new Pair<>(\"login\", \"admin\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["You may wonder what if we are using `var` and the diamond `<>` at the same time\n", "When the inference doesn't known, it using `Object`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["var objectList = new ArrayList<>();   // this is a list of Object\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### inference of parameterized method\n", "Type arguments of a parameterized method are inferred by default and we have\n", "to use a special syntax if we want to specify the type arguments\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["That's why when we have\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Utils {\n", "  static <T> T chooseOne(T o1, T o2) {\n", "    var random = ThreadLocalRandom.current();\n", "    return random.nextBoolean()? o1: o2;\n", "  }\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["we can write\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(Utils.chooseOne(\"foo\", \"bar\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["and if we want to specify the type arguments, you have to\n", "specify them in between `<` and `>`, after the `.` and\n", "before the name of the method\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["System.out.println(Utils.<String>chooseOne(\"foo\", \"bar\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Raw type\n", "Types without the '<' '>', raw types in Java speak, are still supported\n", "to interact with old codes so you may by mistake forget the '<' '>' and\n", "have the declaration to compile.\n", "But it will be nasty when trying to use such type.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The for-loop below doesn't compile because StringList is an AbstractList\n", "so a List of Object and not a List<String>\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class StringList extends AbstractList {  // should be AbstractList<String>\n", "  public int size() {\n", "    return 5;\n", "  }\n", "  public String get(int index) {\n", "    Objects.checkIndex(index, 5);\n", "    return \"\" + index;\n", "  }\n", "}\n", "for(String s: new StringList());\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### So using inference\n", "`getCredentials()` can be simplified to\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["List<Pair<String, String>> getCredentials() {\n", "  var list = new ArrayList<Pair<String, String>>();\n", "  list.add(new Pair<>(\"login\", \"admin\"));\n", "  list.add(new Pair<>(\"password\", \"password\"));\n", "  return list; \n", "}\n", "var list = getCredentials();\n", "/*\n", " String value = (String) list.get(0);\n", "*/\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["And the last line (commented) that was throwing a ClassCastException\n", "now does not compile thank to the use of generics.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Bounds\n", "By default a type variable like `T` acts as Object, i.e.\n", "you can call on T only the public methods of java.lang.Object.\n", "you can defines a more precise __bound__ reusing the keyword `extends`\n", "Note: `extends` in this context mean subtype not inherits from.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["<T extends Comparable<T>> T min(T o1, T o2) {\n", "  return (o1.compareTo(o2) < 0)? o1: o2;\n", "}\n", "System.out.println(min(\"day\", \"night\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Because the bound of T is an object, you can not declare a List<int> !\n", "But you can declare a List<Integer> instead, see the next chapter for that !\n"]
}
],
  "metadata": {
    "kernelspec": {
      "display_name": "Java",
      "language": "java",
      "name": "java"
    },
    "language_info": {
      "codemirror_mode": "java",
      "file_extension": ".java",
      "mimetype": "text/x-java-source",
      "name": "Java",
      "pygments_lexer": "java",
      "version": "15"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 2
}