Conversion de types. Conversions avec élargissement et réduction

« Salut, Amigo ! Le thème de la leçon d'aujourd'hui est les conversions avec élargissement et réduction pour les types de référence. Tu as découvert l'élargissement et la réduction des types primitifs il y a longtemps. Au niveau 10. Aujourd'hui, nous allons parler de la façon dont cela fonctionne pour les types de référence, à savoir les instances de classes. »

En fait, tout cela est très simple. Imagine la chaîne d'héritage d'une classe : la classe, son parent, le parent du parent, etc., jusqu'à arriver à la classe Object. Comme une classe contient toutes les méthodes membres de la classe dont elle hérite, une instance de la classe peut être enregistrée dans une variable dont le type est celui de n'importe lequel de ses parents.

Voici un exemple :

class Animal
{
public void doAnimalActions();
}class Cat extends Animal
{
public void doCatActions();
}class Tiger extends Cat
{
public void doTigerActions();
}

public static void main(String[] args)
{
Tiger tiger = new Tiger();
Cat cat = new Tiger(); Animal animal = new Tiger(); Object obj = new Tiger();
}

Maintenant, nous allons nous pencher sur les conversions avec élargissement et réduction.

Si une opération d'affectation nous fait remonter la chaîne d'héritage (en direction de la classe Object), nous avons affaire à une conversion avec élargissement (ce qu'on appelle également transtypage ascendant). Si on descend la chaîne dans la direction du type de l'objet, il s'agit d'une conversion avec réduction (ce qu'on appelle également transtypage descendant).

Remonter la chaîne d'héritage est appelé élargissement, car cela conduit à un type plus général. Toutefois, ce faisant, nous perdons la possibilité d'appeler les méthodes ajoutées à la classe par héritage.

public static void main(String[] args)
{
Object obj = new Tiger();
Animal animal = (Animal) obj; Cat cat = (Cat) obj; Tiger tiger = (Tiger) animal; Tiger tiger2 = (Tiger) cat;
}

public static void main(String[] args)
{
Object obj = new Tiger();
if (obj instanceof Cat)
{
Cat cat = (Cat) obj;
cat.doCatActions();
}}

public static void main(String[] args)
{
Animal animal = new Tiger();
doAllAction(animal);

Animal animal2 = new Cat();
doAllAction(animal2);

Animal animal3 = new Animal();
doAllAction(animal3);
}

public static void doAllAction(Animal animal)
{
if (animal instanceof Tiger)
{
Tiger tiger = (Tiger) animal;
tiger.doTigerActions();
}

if (animal instanceof Cat)
{
Cat cat = (Cat) animal;
cat.doCatActions();
}

animal.doAnimalActions();
}

public static void main(String[] args)
{
Cat cat = new Tiger(); Animal animal = cat; Object obj = cat;
}

« Oh, l'avant-dernier exemple rend tout cela clair : pourquoi le contrôle est nécessaire, et pourquoi la conversion de type est nécessaire. »

« J'espère bien. Je tiens à attirer ton attention sur ce fait : »

Rien de tout cela ne cause le moindre changement pour l'objet ! La seule chose qui change est le nombre de méthodes disponibles à l'appel sur une variable de référence particulière.

Par exemple, une variable Cat te permet d'appeler les méthodes doAnimalActions et doCatActions. Elle ne sait rien au sujet de la méthode doTigerActions, même si elle pointe vers un objet Tiger.

« Oui, je comprends ça. C'est plus facile que je l'imaginais. »