L'héritage est un concept de la programmation orientée objet, qui permet d'utiliser les fonctions d'une superclasse, de redéfinir les fonctions de la superclasse, ou d'implémenter les fonctions d'une classe abstraite ou une interface.

package com.mtitek.inheritance;

public class SuperClass {
    protected Integer addOperation(Integer value1, Integer value2) {
        return value1 + value2;
    }

    protected Integer multiplyOperation(Integer value1, Integer value2) {
        return value1 * value2;
    }
}

package com.mtitek.inheritance;

public class SubClass extends SuperClass {
    public Integer multiplyOperation(Integer value1, Integer value2) {
        return (value1 * value2) * 10;
    }

    public Integer subtractOperation(Integer value1, Integer value2) {
        return (value1 - value2) * 10;
    }
}

Dans l'exemple précédent, la classe SubClass hérite de la classe SuperClass.
Elle hérite ainsi les deux fonctions de la classe SuperClass ; elle peut les utiliser comme s'elles entaient définies dans la classe SubClass.
Elle peut aussi redéfinir le comportement des fonctions de la superclasse en modifiant le code (par exemple, multiplyOperation).

Voici une idée de la structure de la classe SubClass en héritant le code de la classe SuperClass.

SubClass:
    public Integer [SuperClass].addOperation(Integer value1, Integer value2) { ... }

    public Integer [SuperClass].multiplyOperation(Integer value1, Integer value2) { ... }

    public Integer [SubClass].multiplyOperation(Integer value1, Integer value2) { ... }

    public Integer [SubClass].subtractOperation(Integer value1, Integer value2) { ... }

Les fonctions redéfinies sont toujours disponibles et ne sont pas totalement écrasés et peuvent être accessibles en utilisant le mot clé super.

Contrainte de visibilité de méthode :
Si la méthode dans la superclasse utilise le mot clé protected, et si une sous-classe est définie dans un package différent de la superclasse, alors cette méthode est accessible uniquement dans le code la sous-classe et ne peux pas être invoquée directement en utilisant l'operateur "." (par exemple, subClassInstance.doCallProtectedMethod()).

Une variable est d'abords déclarée et ensuite initialisée :

• La déclaration d'une variable détermine le type des valeurs que peut référencer cette variable.
  Le type de la variable ne peut être changé après la déclaration.
  

  public class TestClass {
      SuperClass superClass1;
      SubClass subClass1;
  }

  Dans l'exemple précédent la variable superClass1 peut référencer les instances de la classe SuperClass ou SubClass.
  Cependant, la variable subClass1 peut référencer uniquement les instances de la classe SubClass.
  
  
• L'initialisation d'une variable est l'instruction qui va créer une référence sur un objet en mémoire et affecter cette référence à la variable.
  Une variable ne peut pas référencer n'importe quel objet en mémoire ; elle peut référencer uniquement les instances des classes dont le type correspond à celui déclaré pour cette variable.
  Cependant, il est possible de référencer des objets dont le type est un sous-type du type déclaré pour la variable.
  
  Il y a deux vérifications qui sont faites, une statique (faite par le compilateur) et une autre dynamique (faite par la JVM à l'exécution du programme).
  

  public class TestClass {
      public static void main(String[] args) {
          SuperClass superClass1 = new SuperClass(); // OK : Même type (superClass1 est de type SuperClass qui référence un objet de type SuperClass)
          SuperClass superClass2 = new SubClass(); // OK : sous-type - SubClass sous-classe de SuperClass (superClass1 est de type SuperClass qui référence un objet de type SubClass)
  
          SubClass subClass1 = new SubClass(); // OK : Même type (subClass1 est de type SubClass qui référence un objet de type SubClass)
          SubClass subClass2 = new SuperClass(); // compiler error: Type mismatch: cannot convert from SuperClass to SubClass
          SubClass subClass3 = (SubClass) new SuperClass(); // Runtime error: java.lang.ClassCastException: SuperClass cannot be cast to SubClass
      }
  }

Note: java.lang.ArrayStoreException
It's possible to assign an array "c" of type of a subclass to an array "p" of type of a superclass. But you will get an ArrayStoreException exception if you try to assign an instance of the superclass to the array "p" of type of a superclass. The exception is to prevent the situation when you will use an element of the array "c" to call a method of the subclass that's no defined in the superclass instance!

class P {}

class C extends P {}

C[] c = new C[1];
P[] p = c;
p[0] = new P(); // java.lang.ArrayStoreException:
// this will prevent: C[0].subclass_method()

Dans une instruction d'affectation (refVar1 = refVar2;), le compilateur verifie que le type de la variable refVar1 est le même ou un type parent du type de la variable refVar2.
Au cas contraire le compilateur affichera une erreur.

package com.mtitek.overloading;

public class TestClass {
    public static void main(String[] args) {
        TestClass testClass = new TestClass();

        TestClass testClass1 = testClass; // OK : testClass1 et testClass sont du même type

        Object obj = testClass; // OK : Object est une superclasse de TestClass

        TestClass testClass2 = obj; // compiler error: Type mismatch: cannot convert from Object to TestClass

        String str = obj; // compiler error: Type mismatch: cannot convert from Object to String
    }
}

• UpCasting :
  Permet de convertir le type d'une référence vers un type parent.
  

  Object obj1 = new String(); // UpCasting implicite
  
  Object obj2 = (Object) new String(); // UpCasting explicite

  La conversion (implicite ou explicite) vers un type parent est toujours acceptée par le compilateur et elle ne posera aucun problème à l'exécution du programme : une référence d'un type parent peut, sans risque, lire/modifier les attributs ou invoquer les méthodes dont elle a accès, indépendamment si l'instance référée et du même type ou un sous-type du type de la référence.
  
  
• DownCasting :
  Permet de convertir le type d'une référence vers un sous type.
  

  String str1 = new Object(); // DownCasting implicite - compiler error: Type mismatch: cannot convert from Object to String)
  
  String str2 = (String) new Object(); // DownCasting explicite (erreur à l'exécution : java.lang.ClassCastException: java.lang.Object cannot be cast to java.lang.String)

  La conversion implicite (String str1 = new Object();) vers un sous type est toujours refusée par le compilateur.
  La conversion explicite (String str2 = (String) new Object();) vers un sous type est toujours acceptée par le compilateur. Cependant à l'exécution du programme, la JVM va vérifier si le type de l'instance (Object) est le même ou un sous type du type qu'on a spécifiée pour la conversion (String) : si ce n'est pas le cas, la JVM déclenchera une exception.
  

L'invocation d'une méthode passe par deux vérifications, une statique (faite par le compilateur) et une autre dynamique (faite par la JVM à l'exécution du programme).

Le compilateur regarde uniquement le type déclaré pour la variable (et non pas le type d'instance).
Lorsqu'on invoque une méthode, le compilateur vérifie si cette méthode est déclarée pour le type de la variable ou un super-type (les sous-types ne sont pas considérés).
Si la méthode n'est pas déclarée par ces types, le compilateur générera une erreur de compilation.
Aussi, si la méthode invoquée déclenche une exception, le compilateur générera une erreur de compilation si l'appel n'est pas à l'intérieur du bloc try-catch, et cela même si la redéfinition de cette méthode dans les sous-types ne déclenche aucune exception.

Notez qu'à l'exécution du programme, la JVM utilise l'instance référencée et donc si la méthode a été redéfinie dans la classe de cette instance alors elle sera invoquée au lieu de la méthode de la superclasse.

public class TestClass {
    public static void main(String[] args) {
        SuperClass superClass1 = new SuperClass();
        SuperClass superClass2 = new SubClass();
        SubClass subClass1 = new SubClass();

        superClass1.multiplyOperation(1, 2); // la méthode implémentée dans SuperClass sera exécutée
        superClass2.multiplyOperation(1, 2); // la méthode implémentée dans SubClass sera exécutée
        subClass1.multiplyOperation(1, 2); // la méthode implémentée dans SubClass sera exécutée
    }
}

Pour invoquer la méthode (multiplyOperation) de la superclasse (SuperClass) au lieu de la méthode redéfinie dans la sous-classe (SubClass), il faut utiliser le mot clé super qui est disponible à partir du code de la sous-classe.