Qu'est-ce que l'héritage?

** Reprenez les membres de la classe d'origine et définissez une nouvelle classe **
** Classe de base ** (super classe, classe parente): source d'héritage
** Classe dérivée ** (sous-classe, classe enfant): classe héritée
Un mécanisme pour découper les parties communes des fonctions et n'écrire que les différences
cf: ** Délégation **: Découpez un rôle spécifique comme une autre classe et enregistrez cette instance en tant que champ

Comment utiliser l'héritage

class La classe dérivée étend la classe de base {}
Si omis, cela signifie que la classe Object est héritée.
Recherchez le membre demandé dans la classe courante, ** s'il n'existe pas, appelez le membre défini dans la classe supérieure! ** **
Les méthodes de la classe de base et de la classe dérivée appellent préférentiellement la classe dérivée
Remarque:
** Une seule classe de base en Java ** (approbation de succession multiple impossible)
** Les membres définis dans la classe de base ne peuvent pas être supprimés dans la classe dérivée **
= Classe dérivée ** contient toutes les propriétés de la classe de base **

`Person.java`


public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%ré).", this.name, this.age);
  }
}

`BusinessPerson.java`


//Créer une classe BusinessPerson qui hérite de Person
public class BusinessPerson extends Person {
  //Définition de méthode de travail unique à la classe dérivée
  public String work() {
    return String.format("%d an%s fonctionne bien aujourd'hui.", this.age, this.name);
  }
}

public class InheritBasic {
  public static void main(String[] args) {
    //Appelez uniquement la personne d'affaires
    var bp = new BusinessPerson();
    bp.name = "Ichiro Sato";
    bp.age = 30;
    //La méthode show peut être appelée comme un membre de la classe bp!
    System.out.println(bp.show()); //Je suis Ichiro Sato (30 ans).
    System.out.println(bp.work());  //Ichiro Sato, 30 ans, fonctionne bien aujourd'hui.
  }
}

Points
Utilisez l'héritage si les classes parent et enfant ont une relation ** is-a ** * is-a：SubClass is a SuperClass * Person⊃BusinessPerson
Relation dans laquelle Business Person est inclus dans Person
Les classes dérivées sont ** spécialisées ** des classes de base
La classe de base est la ** généralisation ** de la classe dérivée

Dissimulation sur le terrain

L'héritage dépend du membre
** Override **: méthode possible
** Caché **: Champs, classes / interfaces imbriquées possibles

cache

** Si le champ avec le même nom dans la classe de base est défini dans la classe dérivée **, le champ dans la classe de base ne sera pas visible.
Même si le type de données est différent ** Si le nom est le même, il sera masqué **
Les champs cachés sont accessibles en utilisant la variable réservée ** super **
Remarque: les champs de classe de base sont inaccessibles s'ils sont privés

`Person.java`


import java.time.ZonedDateTime;
public class Person {
  public String name;
  public ZonedDateTime birth = ZonedDateTime.now();
}

`BusinessPerson.java`


import java.time.LocalDateTime;
public class BusinessPerson extends Person {
  //Masquer le champ de naissance de la classe de base
  public LocalDateTime birth = LocalDateTime.now();
  public void show() {
    //Accéder aux champs masqués
    System.out.println(super.birth);
  }
}

public class HideBasic {

  public static void main(String[] args) {
    var bp = new BusinessPerson();
    //BusinessPerson.Montrer la naissance
    System.out.println(bp.birth); 
    bp.show();
    //Person.Afficher le champ de naissance
    Person p = new BusinessPerson();
    System.out.println(p.birth);
  }
}

Remplacement de méthode

Écraser (redéfinir) la méthode définie dans la classe de base avec la classe dérivée
Vous ne voyez pas seulement le nom (contrairement à la dissimulation)
** Nom de la méthode **: correspondance exacte
** Argument formel **: correspondance type de données / nombre
La base (CharSequence s) ne peut pas être remplacée par les (String s) dérivées
** Valeur de retour **: correspondance de type / type dérivé
** Modificateur d'accès **: Plus lâche que le type match / base
public> protégé> non spécifié> privé
privé ne peut pas être remplacé
** clause throw (exception) **: type de correspondance / dérivé
→ ** @Override annotation ** est OK
** Déclarez explicitement que vous remplacez une méthode de la classe de base **

public class Person {
  public String name;
  public int age;

  public String show() {
    return String.format("%s（%ré).", this.name, this.age);
  }
}

public class BusinessPerson extends Person {
  public BusinessPerson() {}
  //Remplacez la méthode show avec le même nom dans la classe de base
  @Override
  public String show() {
    return String.format("Des employés de bureau%s（%ré).", this.name, this.age);
  }

  public String work() {
    return String.format("%d an%s fonctionne bien aujourd'hui.", this.age, this.name);
  }
}

Référence de classe de base (super)

L'appel de méthode par super est ** le début de la définition de méthode de la classe dérivée **

//Hériter de la classe BusinessPerson
public class EliteBusinessPerson extends BusinessPerson {
  @Override 
  //Appelez la méthode de travail de la classe de base et ajoutez votre propre traitement

  public String work() {
    //Appelez la super méthode au début de la classe dérivée
    var result = super.work();
    return String.format("%s Toujours sourire!", result);
  }
}

public class InheritBaseCall {
  public static void main(String[] args) {
    var ebp = new EliteBusinessPerson();
    ebp.name = "Yamada Taro";
    ebp.age = 35;
    System.out.println(ebp.work()); //Taro Yamada, 35 ans, fonctionne bien aujourd'hui. Toujours sourire!
  }
}

Constructeur de classe dérivée

** Les constructeurs ne sont pas hérités comme les méthodes **
Dans la classe héritée, ** le constructeur est appelé dans l'ordre depuis la classe supérieure, et enfin le constructeur de la classe courante est appelé **
L'initialisation de la classe de base est basée sur un constructeur de classe
L'initialisation de classe dérivée est un constructeur de classe dérivée
1. Initialisez tous les champs avec les valeurs spécifiées
1. Exécution du bloc d'initialisation de la classe de base
1. Exécution du constructeur de classe de base
1. Exécution du bloc d'initialisation de classe dérivée
1. Exécution du constructeur de la classe dérivée

`MyParent.java`


public class MyParent {
  public MyParent() {
    System.out.println("Je suis parent.");
  }
}

`MyChild.java`


public class MyChild extends MyParent {
  public MyChild() {
    System.out.println("Je suis un enfant.");
  }
}

public class InheritConstruct {
  public static void main(String[] args) {
    var c = new MyChild(); //Je suis parent. Je suis un enfant.
  }
}

Seul le constructeur sans argument est appelé implicitement dans la classe supérieure **
Si vous définissez explicitement un constructeur (= avec un argument), le constructeur par défaut n'est pas généré automatiquement.
→ Appeler le constructeur avec des arguments avec ** super du constructeur de la classe dérivée **
** Assurez-vous d'appeler ** au début du ** constructeur **

//Classe supérieure (constructeur avec argument)
public class MyParent {
  public MyParent(String name) {
    System.out.printf("%est le parent de l'art.\n", name);
  }
}

public class MyChild extends MyParent {
  public MyChild(String name) {
    //Appeler un constructeur sans argument de classe supérieure à partir d'un constructeur de classe dérivé
    super(name);
    //Les constructeurs sont appelés dans l'ordre de la classe de base → classe dérivée
    System.out.printf("D'enfant%s.\n", name); //Je suis le parent de Taro Yamada.\n Je suis un enfant de Taro Yamada.
  }
}

public class InheritConstruct {
  public static void main(String[] args) {
    var c = new MyChild("Yamada Taro");
  }
}

Aucun héritage / remplacement

L'implémentation et la modification des classes héritables doivent également prendre en compte l'impact sur les classes dérivées
Pour les classes / méthodes qui n'assument pas l'héritage / le remplacement, ** interdire avec le modificateur final **

public class Person {
  String name;
  int age;
  public Person() {}
  //Ne pas remplacer la méthode show
  public final String show() {
    return String.format("%s（%ré).", this.name, this.age);
  }
}

//Pas d'héritage de la classe BusinessPerson
public final class BusinessPerson extends Person {
  public String intro() {
    return "Je suis un employé de bureau.";
  }
}

Conversion de type de type de référence

** Les types ont une relation héritage / implémentation **

Upcast

** Conversion de la classe dérivée vers la classe de base **
Convertir le type BusinessPerson en type de personne
La classe dérivée contient tous les membres de la classe de base
Les instances de classe dérivées sont disponibles en tant qu'instances de classe de base
** Dans ce cas, le type de conversion est Person et le type d'objet est BusinessPerson ** (* Type de variable / Type d'objet * Référence décrite plus loin)

//Upcast
public class CastUp {
  public static void main(String[] args) {
    //Convertir en affectant un objet BusinessPerson à une variable de type Person de classe de base
    Person bp = new BusinessPerson();
    bp.name = "Yamada Taro";
    bp.age = 20;
    System.out.println(bp.show());
  }
}

Abattu

** Conversion de la classe de base en classe dérivée **
Convertir le type de personne en type de personne d'affaires
La classe de base ne peut pas toujours se comporter comme une classe dérivée
** Conversion de type explicite requise dans la syntaxe de cast **
Person p = new BusinessPerson();
BusinessPerson bp = (BusinessPerson)p;

Type de variable / type d'objet

Remplacer la méthode show de la classe Person dans Business Person
Cependant, le code suivant ne peut pas appeler la méthode de travail de la classe BusinessPerson.
La variable p est une variable de type Personne
La variable p ** ne peut pas appeler la méthode de travail **
Le type d'objet (entité) de la variable p est BusinessPerson
** La méthode de show BusinessPerson est appelée **

`BusinessPerson.java`


public class BusinessPerson extends Person {
  public BusinessPerson() {}

  @Override
  public String show() {
    return String.format("Des employés de bureau%s（%ré).", this.name, this.age);
  }

  public String work() {
    return String.format("%d an%s fonctionne.", this.age, this.name);
  }
}

public class TypeDifference {

  public static void main(String[] args) {
    Person p = new BusinessPerson();
    p.name = "Yamada Taro";
    p.age = 30;
    // System.out.println(p.work()); //Erreur
    System.out.println(p.show()); //Je suis Taro Yamada (30 ans), employée de bureau.
  }
}

En d'autres termes,
Cast remplace ** type variable **
Convertir le type de variable BusinessPerson en type de variable Person
** Le type d'objet (entité) ne change pas même s'il est casté **
** La méthode à appeler est déterminée par le type d'objet **
La personne ne peut pas se comporter comme une personne d'affaires

Masquage des méthodes / champs de classe

Les méthodes de classe sont appelées avec nom de classe.nom de méthode (...)
Le type de variable / type d'objet n'existe pas
Puisque la méthode de la classe spécifiée est toujours appelée ** Il n'y a pas de concept de remplacement **
La sélection du champ dépend du type de variable

public class HideBasic {
  public static void main(String[] args) {
    var bp = new BusinessPerson();
    System.out.println(bp.birth);
    bp.show();
    //La variable p est de type Person
    Person p = new BusinessPerson();
    //Le champ de naissance de la classe Person est de type ZonedDateTime
    System.out.println(p.birth); //ZonedDateTime type
  }
}

Jugement de type

Vérification du type d'objet requise lors du downcasting **
Par exemple, quelque chose comme ça. .. ..
BusinessPerson / Student est une classe dérivée de Person * Person p = new BusinessPerson(); //OK * BusinessPerson bp = (BusinessPerson)p; //OK * Student st = (Student)p; //NG
L'entité (type d'objet) de la variable p est BusinessPerson
Au moment de la compilation, je ne connais que la relation d'héritage entre Person et BusinessPerson / Student, donc ** Je n'obtiens pas d'erreur de compilation, mais j'obtiens une erreur lors de l'exécution! ** **
→ ** ʻUtiliser l'opérateur instanceof` **
Vrai si le type d'objet stocké dans la variable peut être converti dans le type spécifié

//Vérification de type
if(p instanceof Student){
    Student st = (Student)p;
    //Le traitement lors de la diffusion est correct
}

Acquisition de type

Obtenez le type d'objet avec la méthode getClass
Obtenez le type d'objet quel que soit le type de variable

public class Main {
    public static void main(String[] args) {
    Person p1 = new Person();
    System.out.println(p1.getClass()); //class Person
    Person p2 = new BusinessPerson();
    System.out.println(p2.getClass()); //class BusinessPerson
  }
}

transfert

L'héritage est étroitement lié aux classes de base / dérivées
Quand utiliser l'héritage
** La classe de base / dérivée est une relation **
** Principe de substitution de Rifkov **: L'affectation d'une instance de la classe dérivée à une variable de la classe de base ne compromet pas la validité du code
** En supposant une expansion, en documentant ce fait **
Exemples d'héritage inapproprié

import java.util.Random;

public class Roulette extends Random {
//Limite supérieure de la roulette
private int bound;

  public Roulette(int bound) {
    this.bound = bound;
  }
  //Obtenez la valeur comme étant la limite supérieure du champ lié et générez un nombre aléatoire
  @Override
  public int nextInt() {
    return nextInt(this.bound);
  }
  //D'autres méthodes inutiles sont désactivées (contrairement au principe de remplacement de Rifkov)
  @Override
  public boolean nextBoolean() {
    throw new UnsupportedOperationException();
  }

  @Override
  public long nextLong() {
    throw new UnsupportedOperationException();
  }
}

import java.util.Random;

public class RouletteClient {
  public static void main(String[] args) {
    Random rou = new Roulette(10);
    System.out.println(rou.nextBoolean()); //UnsupportedOperationException
  }
}

** En délégation, importez un objet avec la fonction que vous souhaitez réutiliser comme champ de la classe courante **
La délégation est ** une relation dynamique entre les instances **
Tenez (a) un objet Random dans le champ aléatoire de la classe Roulette ** et utilisez la méthode de classe Random si nécessaire **
** a une relation **
mérite:
** Relations lâches entre les classes **
Parce qu'il utilise des membres publics ** Cela ne dépend pas de l'implémentation interne **
La relation n'est pas fixe car l'instance est conservée sur le terrain
** Le cessionnaire peut être changé plus tard **
** Le traitement peut être délégué à plusieurs classes **
** Le cessionnaire peut être changé pour chaque instance **

import java.util.Random;

public class Roulette {
  private int bound;
  //Tenez l'objet ci-dessus dans le champ
  private Random random = new Random();

  public Roulette(int bound) {
    this.bound = bound;
  }
  //Déléguer le traitement au besoin
  public int nextInt() {
    return this.random.nextInt(this.bound);
  }
}

[Java] Héritage

Qu'est-ce que l'héritage?

Comment utiliser l'héritage

Person.java

BusinessPerson.java

Dissimulation sur le terrain

cache

Person.java

BusinessPerson.java

Remplacement de méthode

Référence de classe de base (super)

Constructeur de classe dérivée

MyParent.java

MyChild.java

Aucun héritage / remplacement

Conversion de type de type de référence

Upcast

Abattu

Type de variable / type d'objet

BusinessPerson.java

Masquage des méthodes / champs de classe

Jugement de type

Acquisition de type

transfert

`Person.java`

`BusinessPerson.java`

`Person.java`

`BusinessPerson.java`

`MyParent.java`

`MyChild.java`

`BusinessPerson.java`