make examples compiles, reformat a little

Author: forax

chapter15-inheritance.jsh

@@ -15,12 +15,12 @@ class B extends A {  // I want to reuse and augment the definition of A
 }
 
 // Precisely, inheritance is 3 different things grouped together 
-// - _subtyping_
-//    everywhere something is typed `A`, you can send a `B` instead
-// - _members inheritance_
-//    all instance members of `A` are copied in `B`
-// - _polymorphism_
-//    you can replace the code of a method from `A` to adapt it to `B`
+// - __subtyping__
+//   everywhere something is typed `A`, you can send a `B` instead
+// - __members inheritance__
+//   all instance members of `A` are copied in `B`
+// - __polymorphism__
+//   you can replace the code of a method from `A` to adapt it to `B`
 
 // ## Subtyping
 // Subtyping is the most important part of the inheritance, it allows to reuse
@@ -42,15 +42,15 @@ class B extends A {  // so B is a subtype of A
 var b = new B();
 sayHello(b);
 
-// _subtyping_ is very important, because it means that we can reuse a
+// __subtyping__ is very important, because it means that we can reuse a
 // method by calling it with several different types. And given that,
 // The more a method is used, the less buggy it is, _subtyping_ helps
 // to make applications more robust by sharing methods.
 
 
 // ## Polymorphism
-// _Polymorphism_ works with _subtyping_, _subtyping_ allow to call a
-// code with a subtype of the declared type. _Polymorphism_ allows to
+// Polymorphism works with __subtyping__, __subtyping__ allow to call a
+// code with a subtype of the declared type. Polymorphism allows to
 // adapt parts of the shared code to the subclass at runtime.
 
 // By example, let suppose we have a class able to 'enhance' a text
@@ -76,22 +76,22 @@ var enhancer = new StarEnhancer();
 sayHello(enhancer, "polymorphism");
 
 
-// So not only we can call `sayHello()` with a `StarEnhancer` (_subtyping_),
+// So not only we can call `sayHello()` with a `StarEnhancer` (__subtyping__),
 // but inside `sayHello()`, the method call to `enhance()` will call
 // the methode `StarEnhancer.enhance()` adapting the code of `hello()`
 // to the fact that at runtime the enhancer is in fact a `StarEnhancer`.
 
 // The mechanism that choose the `right` method in function of the object
-// at runtime is called _polymorphism_.
+// at runtime is called __polymorphism__.
 
 
 // ### Overriding
 // In the example above, `enhancer.enhance()` inside the method `sayHello()`
 // can call `Enhancer.enhance()` or `StarEnhancer.enhance()`.
-// We say that the method `enhance()` of  `StarEnhancer` _overrides_
+// We say that the method `enhance()` of  `StarEnhancer` __overrides__
 // the method `enhance()` of  `Enhancer`.
 
-// A method to _override_ another has to
+// A method to __override__ another has to
 // - have the same name
 // - have the same number of parameter
 // - can have a subtype as return type
@@ -154,7 +154,6 @@ class Animal {
 }
 class Lion extends Animal {
   boolean young;
-  
   void roar() {
     System.out.println(name + " roar");
   }
@@ -266,7 +265,7 @@ var palace = new Palace(100, 50);
 System.out.println(palace.price(2));
 
 
-// ### field protected
+// ### Field protected
 // In the code above, one can use the modifier `protected` too but
 // because a `protected` field is visible by any subclass even the one
 // the author of the subclass do not control. It means that the field
@@ -277,7 +276,7 @@ System.out.println(palace.price(2));
 
 // ## Relation with interfaces
 // Nowadays, inheritance is used less and less in Java because interface
-// provides _subtyping_ and _overriding_ without _members inheritance_.
+// provides __subtyping__ and __overriding__ without __members inheritance__.
 // Given that the later mechanism is the one causing trouble,
 // using an interface is often preferred to using inheritance.
 
@@ -308,7 +307,7 @@ System.out.println(palace.price(2));
 
 // ## Use delegation not inheritance
 // Sometimes people are using inheritance where they should not !
-// The worst occurrences is when people want _members inheritance_
+// The worst occurrences is when people want __members inheritance__
 // to avoid to write too many methods but forget that they get
 // all the methods even the one they don't want.
 
@@ -353,7 +352,7 @@ class Properties {
   }
 }
 var properties = new Properties();
-properties.setProperty("java", "best language ever");
+properties.setProperty("java", "best language ever, for life !");
 System.out.println(properties.getProperty("java", "??"));
 System.out.println(properties.getProperty("brainfuck", "??"));
 

guide/chapter15-inheritance.md

@@ -14,12 +14,12 @@ class B extends A {  // I want to reuse and augment the definition of A
 ```
 
 Precisely, inheritance is 3 different things grouped together 
-- _subtyping_
-   everywhere something is typed `A`, you can send a `B` instead
-- _members inheritance_
-   all instance members of `A` are copied in `B`
-- _polymorphism_
-   you can replace the code of a method from `A` to adapt it to `B`
+- __subtyping__
+  everywhere something is typed `A`, you can send a `B` instead
+- __members inheritance__
+  all instance members of `A` are copied in `B`
+- __polymorphism__
+  you can replace the code of a method from `A` to adapt it to `B`
 
 ## Subtyping
 Subtyping is the most important part of the inheritance, it allows to reuse
@@ -45,15 +45,15 @@ var b = new B();
 sayHello(b);
 ```
 
-_subtyping_ is very important, because it means that we can reuse a
+__subtyping__ is very important, because it means that we can reuse a
 method by calling it with several different types. And given that,
 The more a method is used, the less buggy it is, _subtyping_ helps
 to make applications more robust by sharing methods.
 
 
 ## Polymorphism
-_Polymorphism_ works with _subtyping_, _subtyping_ allow to call a
-code with a subtype of the declared type. _Polymorphism_ allows to
+Polymorphism works with __subtyping__, __subtyping__ allow to call a
+code with a subtype of the declared type. Polymorphism allows to
 adapt parts of the shared code to the subclass at runtime.
 
 By example, let suppose we have a class able to 'enhance' a text
@@ -83,22 +83,22 @@ sayHello(enhancer, "polymorphism");
 ```
 
 
-So not only we can call `sayHello()` with a `StarEnhancer` (_subtyping_),
+So not only we can call `sayHello()` with a `StarEnhancer` (__subtyping__),
 but inside `sayHello()`, the method call to `enhance()` will call
 the methode `StarEnhancer.enhance()` adapting the code of `hello()`
 to the fact that at runtime the enhancer is in fact a `StarEnhancer`.
 
 The mechanism that choose the `right` method in function of the object
-at runtime is called _polymorphism_.
+at runtime is called __polymorphism__.
 
 
 ### Overriding
 In the example above, `enhancer.enhance()` inside the method `sayHello()`
 can call `Enhancer.enhance()` or `StarEnhancer.enhance()`.
-We say that the method `enhance()` of  `StarEnhancer` _overrides_
+We say that the method `enhance()` of  `StarEnhancer` __overrides__
 the method `enhance()` of  `Enhancer`.
 
-A method to _override_ another has to
+A method to __override__ another has to
 - have the same name
 - have the same number of parameter
 - can have a subtype as return type
@@ -166,9 +166,6 @@ class Animal {
 }
 class Lion extends Animal {
   boolean young;
-```
-  
-```java
   void roar() {
     System.out.println(name + " roar");
   }
@@ -289,7 +286,7 @@ System.out.println(palace.price(2));
 ```
 
 
-### field protected
+### Field protected
 In the code above, one can use the modifier `protected` too but
 because a `protected` field is visible by any subclass even the one
 the author of the subclass do not control. It means that the field
@@ -300,7 +297,7 @@ can not be changed the same way a `public` field can not be changed.
 
 ## Relation with interfaces
 Nowadays, inheritance is used less and less in Java because interface
-provides _subtyping_ and _overriding_ without _members inheritance_.
+provides __subtyping__ and __overriding__ without __members inheritance__.
 Given that the later mechanism is the one causing trouble,
 using an interface is often preferred to using inheritance.
 
@@ -333,7 +330,7 @@ System.out.println(palace.price(2));
 
 ## Use delegation not inheritance
 Sometimes people are using inheritance where they should not !
-The worst occurrences is when people want _members inheritance_
+The worst occurrences is when people want __members inheritance__
 to avoid to write too many methods but forget that they get
 all the methods even the one they don't want.
 
@@ -381,7 +378,7 @@ class Properties {
   }
 }
 var properties = new Properties();
-properties.setProperty("java", "best language ever");
+properties.setProperty("java", "best language ever, for life !");
 System.out.println(properties.getProperty("java", "??"));
 System.out.println(properties.getProperty("brainfuck", "??"));
 ```

jupyter/chapter15-inheritance.ipynb

@@ -34,7 +34,7 @@
 {
   "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"]
+  "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"]
 }
 ,
 {
@@ -74,13 +74,13 @@
 {
   "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"]
+  "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"]
+  "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"]
 }
 ,
 {
@@ -114,25 +114,25 @@
 {
   "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"]
+  "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"]
+  "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"]
+  "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"]
+  "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"]
 }
 ,
 {
@@ -186,15 +186,7 @@
   "execution_count": null,
   "metadata": {},
   "outputs": [],
-  "source": ["class Animal {\n", "  String name;\n", "}\n", "class Lion extends Animal {\n", "  boolean young;\n"]
-}
-,
-{
-  "cell_type": "code",
-  "execution_count": null,
-  "metadata": {},
-  "outputs": [],
-  "source": ["  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"]
+  "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"]
 }
 ,
 {
@@ -286,7 +278,7 @@
 {
   "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"]
+  "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"]
 }
 ,
 {
@@ -298,7 +290,7 @@
 {
   "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"]
+  "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"]
 }
 ,
 {
@@ -324,7 +316,7 @@
 {
   "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"]
+  "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"]
 }
 ,
 {
@@ -370,7 +362,7 @@
   "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\");\n", "System.out.println(properties.getProperty(\"java\", \"??\"));\n", "System.out.println(properties.getProperty(\"brainfuck\", \"??\"));\n"]
+  "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"]
 }
 ,
 {