jupyter/chapter15-inheritance.ipynb

{
  "cells": [{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["# Inheritance\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Historically, inheritance have been the way to sell Object Oriented Programming.\n", "It appears later that, inheritance is less important that it was envision first.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The initial idea is to be able to reuse part of the definition of one class `A`\n", "to define another class `B` which is a kind of like `A`.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class A {\n", "}\n", "class B extends A {  // I want to reuse and augment the definition of A\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Precisely, inheritance is 3 different things grouped together \n", "- __subtyping__\n", "  everywhere something is typed `A`, you can send a `B` instead\n", "- __members inheritance__\n", "  all instance members of `A` are copied in `B`\n", "- __polymorphism__\n", "  you can replace the code of a method from `A` to adapt it to `B`\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Subtyping\n", "Subtyping is the most important part of the inheritance, it allows to reuse\n", "an existing code written for an `A` with an instance of `B`.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["let suppose, I have a method `sayHello()` for a `A`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class A {\n", "}\n", "void sayHello(A a) {\n", "  System.out.println(\"hello \" + a);\n", "}\n", "var a = new A();\n", "sayHello(a);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["if I create a `B` that inherits `A`, then i can use instance of `B`\n", "as argument of `hello()`.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class B extends A {  // so B is a subtype of A\n", "}\n", "var b = new B();\n", "sayHello(b);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["__subtyping__ is very important, because it means that we can reuse a\n", "method by calling it with several different types. And given that,\n", "The more a method is used, the less buggy it is, _subtyping_ helps\n", "to make applications more robust by sharing methods.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Polymorphism\n", "Polymorphism works with __subtyping__, __subtyping__ allow to call a\n", "code with a subtype of the declared type. Polymorphism allows to\n", "adapt parts of the shared code to the subclass at runtime.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["By example, let suppose we have a class able to 'enhance' a text\n", "by making it more beautiful\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Enhancer {\n", "  String enhance(String text) {\n", "    return \"_\" + text + \"_\";\n", "  }\n", "}\n", "void sayHello(Enhancer enhancer, String text) {\n", "  System.out.println(\"hello \" + enhancer.enhance(text));\n", "}\n", "var enhancer = new Enhancer();\n", "sayHello(enhancer, \"polymorphism\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class StarEnhancer extends Enhancer {\n", "  String enhance(String text) {\n", "    return \"*\" + text + \"*\";\n", "  }\n", "}\n", "var enhancer = new StarEnhancer();\n", "sayHello(enhancer, \"polymorphism\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["So not only we can call `sayHello()` with a `StarEnhancer` (__subtyping__),\n", "but inside `sayHello()`, the method call to `enhance()` will call\n", "the methode `StarEnhancer.enhance()` adapting the code of `hello()`\n", "to the fact that at runtime the enhancer is in fact a `StarEnhancer`.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The mechanism that choose the `right` method in function of the object\n", "at runtime is called __polymorphism__.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Overriding\n", "In the example above, `enhancer.enhance()` inside the method `sayHello()`\n", "can call `Enhancer.enhance()` or `StarEnhancer.enhance()`.\n", "We say that the method `enhance()` of  `StarEnhancer` __overrides__\n", "the method `enhance()` of  `Enhancer`.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["A method to __override__ another has to\n", "- have the same name\n", "- have the same number of parameter\n", "- can have a subtype as return type\n", "- can have subtypes of the declared exceptions (`throws`).  \n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### `@Override`\n", "You can notice in the code below that we are using the annotation\n", "`@Override`. It is an annotation to document that the method\n", "override an existing method. The compiler also verifies that\n", "there is  a method in the base class with the same parameter types.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Enhancer {\n", "  String enhance(String text) {\n", "    return \"_\" + text + \"_\";\n", "  }\n", "}\n", "void sayHello(Enhancer enhancer, String text) {\n", "  System.out.println(\"hello \" + enhancer.enhance(text));\n", "}\n", "class StarEnhancer extends Enhancer {\n", "  @Override  // <-- aah\n", "  String enhance(String text) {\n", "    return \"*\" + text + \"*\";\n", "  }\n", "}\n", "var enhancer = new StarEnhancer();\n", "sayHello(enhancer, \"polymorphism\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The annotation is not used by the runtime so it just make\n", "the code easier to understand for a human.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Calling a method using `super.`\n", "The method that override another one can call the method it replace\n", "using the syntax `super.enhance(...)`.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Enhancer {\n", "  String enhance(String text) {\n", "    return \"_\" + text + \"_\";\n", "  }\n", "}\n", "class StarEnhancer extends Enhancer {\n", "  @Override\n", "  String enhance(String text) {\n", "    return \"*\" + super.enhance(text) + \"*\";\n", "  }\n", "}\n", "var enhancer = new StarEnhancer();\n", "sayHello(enhancer, \"polymorphism\");\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Members inheritance\n", "And last, when a class inherits from another one, then\n", "all the fields and methods defined in the super class\n", "are defined in the subclass.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Here by example, the field `name` defined in `Animal`\n", "is also _implicily_ defined in `Lion`.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Animal {\n", "  String name;\n", "}\n", "class Lion extends Animal {\n", "  boolean young;\n", "  void roar() {\n", "    System.out.println(name + \" roar\");\n", "  }\n", "}\n", "var lion = new Lion();\n", "lion.name = \"leo\";\n", "lion.young = true;\n", "lion.roar();\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["This mechanism is controversial because if the implementation of\n", "`Animal` change, the implementation of `Lion` has to be changed too.\n", "So a super class and a subclass are tightly bound to the point\n", "it's hard to maintain an application if the maintainer of the super class\n", "and the sub class are not the same person.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["> It's discouraged to inherits from a class you don't control.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Constructor and inheritance\n", "In Java, the initialization of the super class has to be done first,\n", "before the initialization of the subclass.\n", "It's mandatory that the first statement of the constructor of the subclass\n", "to call the constructor of the super class.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["With a class `Point`\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Point {\n", "  private final int x;\n", "  private final int y;\n", "  Point(int x, int y) {\n", "    this.x = x;\n", "    this.y = y;\n", "  }\n", "  public String toString() {\n", "    return \"x: \" + x + \" y: \" + y;\n", "  }\n", "}\n", "var point = new Point(1, 5);\n", "System.out.println(point);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["If the class `Point3D` inherits from `Point`, then the first statement of\n", "the constructor has to be a call to the constructor of the super class\n", "using the syntax `super(...)`.\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Point3D extends Point {\n", "  private final int z;\n", "  Point3D(int x, int y, int z) {\n", "    super(x, y);  // call constructor of the super class\n", "    this.z = z;\n", "  }\n", "  public String toString() {\n", "    return super.toString() + \" z: \" + z;\n", "  }\n", "}\n", "var point3D = new Point3D(2, 4, 7);\n", "System.out.println(point3D);\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["> Note: that unlike the other members of a class, constructors are not inherited.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Members inheritance and encapsulation\n", "We have seen that to have encapsulation, we have to declare the fields `private`.\n", "But with inheritance, a private field declared in the super class is present\n", "in the subclass but not accessible.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Here the field `roomPrice` is inherited in `Palace` but can not be accessed\n", "in the method `price()` of the class `Palace` which doesn't compile \n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Hotel {\n", "  private final int roomPrice;\n", "  public Hotel(int roomPrice) {\n", "    this.roomPrice = roomPrice;\n", "  }\n", "  public int price(int rooms) {\n", "    return rooms * roomPrice;\n", "  }\n", "}\n", "class Palace extends Hotel {\n", "  private final int extra;\n", "  public Palace(int roomPrice, int extra) {\n", "    super(roomPrice);\n", "    this.extra = extra;\n", "  }\n", "  public int price(int rooms) {\n", "    return rooms * (roomPrice + extra);  // don't compile !\n", "  }\n", "}\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The usual practice is to declare the super class and the subclass\n", "in the same package so declaring the field `roomPrice` with no keyword\n", "make it visible to the subclass\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Hotel {\n", "  /*package*/ final int roomPrice;\n", "  public Hotel(int roomPrice) {\n", "    this.roomPrice = roomPrice;\n", "  }\n", "  public int price(int rooms) {\n", "    return rooms * roomPrice;\n", "  }\n", "}\n", "class Palace extends Hotel {\n", "  private final int extra;\n", "  public Palace(int roomPrice, int extra) {\n", "    super(roomPrice);\n", "    this.extra = extra;\n", "  }\n", "  public int price(int rooms) {\n", "    return rooms * (roomPrice + extra);\n", "  }\n", "}\n", "var palace = new Palace(100, 50);\n", "System.out.println(palace.price(2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Field protected\n", "In the code above, one can use the modifier `protected` too but\n", "because a `protected` field is visible by any subclass even the one\n", "the author of the subclass do not control. It means that the field\n", "can not be changed the same way a `public` field can not be changed.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["> Never use the keyword protected in Java.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Relation with interfaces\n", "Nowadays, inheritance is used less and less in Java because interface\n", "provides __subtyping__ and __overriding__ without __members inheritance__.\n", "Given that the later mechanism is the one causing trouble,\n", "using an interface is often preferred to using inheritance.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["### Records doesn't support inheritance\n", "Records doesn't support inheritance because it's so simple to declare\n", "a new record component that trying to share them will result into more\n", "code that necessary.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Here is the class `Hotel` and `Palace` rewritten without inheritance\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["interface Bookable {\n", "  int price(int rooms);  \n", "}\n", "record Hotel(int roomPrice) implements Bookable {\n", "  public int price(int rooms) {\n", "    return rooms * roomPrice;\n", "  }\n", "}\n", "record Palace(int roomPrice, int extra) implements Bookable {\n", "  public int price(int rooms) {\n", "    return rooms * (roomPrice + extra);\n", "  }\n", "}\n", "Bookable hotel = new Hotel(100);\n", "System.out.println(hotel.price(2));\n", "Bookable palace = new Palace(100, 50);\n", "System.out.println(palace.price(2));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["## Use delegation not inheritance\n", "Sometimes people are using inheritance where they should not !\n", "The worst occurrences is when people want __members inheritance__\n", "to avoid to write too many methods but forget that they get\n", "all the methods even the one they don't want.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The problem is that if a class has a lot of methods, you are sure\n", "that at least one will not work correctly with the subclass.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["By example, this is a snippet of how the class `java.util.Properties`\n", "is defined in JDK. Because it inherits from `Hashtable<Object, Object>`,\n", "it means you can store a value which is not a String but get it as a String.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["Obviously, it will not work at runtime\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Properties extends Hashtable<Object, Object> {\n", "  public String getProperty(String key, String defaultValue) {\n", "    Objects.requireNonNull(key);\n", "    return (String)getOrDefault(key, defaultValue);\n", "  }\n", "  public void setProperty(String key, String value) {\n", "    Objects.requireNonNull(key);\n", "    Objects.requireNonNull(value);\n", "    put(key, value);\n", "  }\n", "}\n", "var properties = new Properties();\n", "properties.put(\"java\", 42);\n", "System.out.println(properties.getProperty(\"java\", \"??\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["The traditional advice is if you want to use part of an existing\n", "implementation, instead of inherits from that class, store it\n", "in a field and so your method can delegate a part of their implementations.\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["So for the class `Properties`, it should be implemented like this\n"]
}
,
{
  "cell_type": "code",
  "execution_count": null,
  "metadata": {},
  "outputs": [],
  "source": ["class Properties {\n", "  private final HashMap<String, String> map = new HashMap<>();\n", "  public String getProperty(String key, String defaultValue) {\n", "    Objects.requireNonNull(key);\n", "    return map.getOrDefault(key, defaultValue);\n", "  }\n", "  public void setProperty(String key, String value) {\n", "    Objects.requireNonNull(key);\n", "    Objects.requireNonNull(value);\n", "    map.put(key, value);\n", "  }\n", "}\n", "var properties = new Properties();\n", "properties.setProperty(\"java\", \"best language ever, for life !\");\n", "System.out.println(properties.getProperty(\"java\", \"??\"));\n", "System.out.println(properties.getProperty(\"brainfuck\", \"??\"));\n"]
}
,
{
  "cell_type": "markdown",
  "metadata": {},
  "source": ["> Always prefer delegation to inheritance\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
}