Table des matières

Qu’est-ce que l’héritage ?
Quels sont les avantages de l’héritage ?
Caractéristiques de l'héritage
Remarques sur l'utilisation de l'héritage
Quelle est la différence entre super et this ?
Redéfinition de méthode (écrasement)
Le mot-clé final
Polymorphisme
Abstraction (abstract)
Classes internes
Contenu modifié par différents modificateurs (sans rapport avec les classes internes)
Quatre modificateurs d'accès

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

Lorsque plusieurs classes ont les mêmes attributs et comportements, extrayez ces contenus dans une seule classe. Ensuite, les multiples classes n'ont plus besoin de définir ces attributs et comportements ; elles ont seulement besoin d'hériter de cette classe.

Les multiples classes peuvent être appeléessous-classes, et cette classe unique est appelée laclasse parente、superclasseouclasse de base。

Les sous-classes peuvent accéder directement aux attributs et comportementsnon privésde la classe parente.

Grâce auextendsmot-clé, une relation d'héritage est créée entre les classes.

class SubDemo extends Demo{}    //SubDemo是子类，Demo是父类

Quels sont les avantages de l’héritage ?

Améliore laréutilisabilité du code。
Crée des relations entre les classes, ce qui est leprérequis au polymorphisme.。

Caractéristiques de l'héritage

1. Java ne prend en charge que l'héritage simple, pas l'héritage multiple.

//一个类只能有一个父类，不可以有多个父类。
class SubDemo extends Demo{} //ok
class SubDemo extends Demo1,Demo2...//error

2. Java prend en charge l'héritage à plusieurs niveaux (répété) (hiérarchie d'héritage).

class A{}
class B extends A{}
class C extends B{}

Remarques sur l'utilisation de l'héritage

S'il existe une relation « est un » entre les classes, envisagez d'utiliser l'héritage.
N'utilisez pas l'héritage juste pour hériter d'une partie des fonctionnalités.

Quelle est la différence entre super et this ?

supersuper est un mot-clé qui représente l'identifiant d'espace de stockage de la classe parente. (Il peut être compris comme une référence au parent.)

L'utilisation de super et this est similaire.

this représenteune référence à l'objet(celui qui l'appelle, il représente cet objet) ;
super représentelaPairclasse parenteréférence de la sous-classe actuelle.

Scénarios d'utilisation

Lorsque les classes enfant et parent ont des membres portant le même nom, super peut être utilisé pour les distinguer ;
Lorsqu’une sous-classe doit appeler le constructeur de la classe parente, l’instruction super peut être utilisée.

Différences

1. Variables membres

this.变量    --    本类的
super.变量    --    父类的

2. Constructeurs

this(...)    --    本类的
super(...)    --    父类的

3. Méthodes membres

this.方法名()    --    本类的    
super.方法名()    --    父类的

super(); et this(); doivent tous deux se trouver sur la première ligne du constructeur, et ils ne peuvent pas apparaître en même temps.

Redéfinition de méthode (écrasement)

Lorsqu’une sous-classe possède une méthode exactement identique à la méthode de la classe parente (à l’exception du modificateur d’accès, le modificateur d’accès doit être supérieur ou égal et non private ; le type de retour, le nom de la méthode et la liste des paramètres sont identiques), une opération de redéfinition se produit, également appelée réécriture ou écrasement.

Les méthodes private de la classe parente sont invisibles pour la sous-classe, il est donc hors de question de redéfinir les méthodes private de la classe parente.

Remarques sur la redéfinition：

Lors d’une redéfinition, le niveau d’accès de la méthode de la sous-classe doit être supérieur ou égal à celui de la méthode de la classe parente ;
Les méthodes static ne peuvent redéfinir que des méthodes static.

Cas d’utilisation de la redéfinition：

Lorsque la sous-classe a besoin des fonctionnalités de la classe parente, mais que le corps de la fonction contient du contenu spécifique à la sous-classe, la méthode de la classe parente peut être redéfinie. Ainsi, elle hérite non seulement des fonctionnalités de la classe parente, mais définit également du contenu spécifique à la sous-classe.

Quelle est la différence entre la redéfinition de méthode et la surcharge de méthode ?？

La redéfinition de méthode est utilisée lorsque la méthode de la sous-classe est exactement identique à la méthode de la classe parente ; à l'exception du modificateur d'accès, le type de retour, le nom de la méthode et la liste des paramètres sont tous identiques.
La surcharge est utilisée lorsque des méthodes d'une même classe ont le même nom de méthode mais des listes de paramètres différentes (cela n'a rien à voir avec le type de retour).

Utilisation des constructeurs dans les classes enfant et parente：

Lors de l'initialisation d'une sous-classe, l'initialisation de la classe parente est exécutée en premier. Cela est dû au fait que le constructeur de la sous-classe contient un appel super() par défaut. La sous-classe a besoin d'utiliser les variables membres de la classe parente, et cette initialisation doit être terminée avant l'initialisation de la sous-classe. Par conséquent, lors de l'initialisation de la sous-classe, l'initialisation de la classe parente est exécutée en premier.
Si la classe parente n'a pas de constructeur sans argument

Utiliser super pour appeler le constructeur paramétré de la classe parente. Approche recommandée.
Utiliser this pour appeler d'autres constructeurs de la même classe.

Ordre d'exécution des blocs de code statiques, des blocs de code du constructeur et des constructeurs：

Bloc de code statique de la classe parente → bloc de code statique de la sous-classe → bloc de code du constructeur de la classe parente → constructeur de la classe parente → bloc de code du constructeur de la sous-classe → constructeur de la sous-classe

Le mot-clé final

final est un mot-clé qui peut être utilisé pour modifier des classes, des variables membres et des méthodes membres.

Caractéristiques：

La classe qu'il modifie ne peut pas être héritée.
La variable membre qu'il modifie est une constante.
La méthode membre qu'il modifie ne peut pas être redéfinie par les sous-classes.

Les constantes modifiées par final ont généralement des conventions de nommage. Pour les constantes modifiées par final, toutes les lettres sonten majuscules.。

Une variable membre modifiée par final doit être initialisée. Il y a deux façons de l'initialiser :

Initialisation explicite ;
Initialisation par le constructeur.
Mais les deux ne peuvent pas être utilisées ensemble pour l'initialisation.

La différence entre final et private：

Une classe modifiée par final est accessible ;
private ne peut pas modifier les classes externes, mais il peut modifier les classes internes (en fait, rendre une classe externe private n'a pas de sens).
Les méthodes modifiées par final ne peuvent pas être redéfinies par les sous-classes ;
Les méthodes modifiées par private semblent pouvoir être redéfinies par les sous-classes, mais en fait elles ne le peuvent pas, car les sous-classes ne peuvent pas voir les méthodes private de la classe parente.
Une variable modifiée par final ne peut être affectée qu'une seule fois lors de l'initialisation explicite ou de l'initialisation du constructeur, et ne peut plus être modifiée par la suite ;
Une variable modifiée par private ne peut pas non plus être directement accessible ou modifiée par les sous-classes ou d'autres classes du même package, mais elle peut être modifiée et récupérée via les méthodes set et get.

Polymorphisme

Concept：

Les différents états qu'un objet présente à différents moments.

Conditions préalables au polymorphisme：

Il doit y avoir une relation d'héritage ou d'implémentation.
Il doit y avoir une redéfinition de méthode.
Il doit y avoir une référence de classe parente pointant vers un objet de sous-classe.

Manifestation dans les programmes：
Une référence de la classe parente ou de l'interface pointe vers ou reçoit son propreobjet de sous-classe.。

Avantages et effets：
L'existence du polymorphisme améliore l'extensibilitédu programme et lamaintenabilité ultérieure.。

Inconvénients:
Lorsqu'une classe parente est appelée, seules les méthodes de la classe parente peuvent être appelées, pas les méthodes spécifiques de la sous-classe, car on ne sait pas quels types de sous-classes en hériteront à l'avenir.

Caractéristiques des membres du polymorphisme：

Variables membres: à la compilation : vérifier si la classe à laquelle appartient la variable de référence possède la variable appelée ;
À l'exécution : vérifier aussi si la classe à laquelle appartient la variable de référence possède la variable appelée.
Pour les variables membres, tant la compilation que l'exécution dépendent de la classe à laquelle appartient la variable de référence. Retenez simplement :Pour les variables membres, tant la compilation que l'exécution regardent le côté gauche du signe égal.。
Méthodes membres: à la compilation : vérifier si la classe à laquelle appartient la variable de référence possède le membre appelé ;
À l'exécution : vérifier si la classe à laquelle appartient l'objet possède le membre appelé. Si la classe parente et la classe enfant ont des méthodes du même nom, la méthode de la sous-classe s'exécutera, car les méthodes ont la caractéristique de redéfinition.
La compilation regarde à gauche, l'exécution regarde à droite.。
Méthodes statiques: à la compilation : vérifier si la classe à laquelle appartient la variable de référence possède la variable appelée ;
À l'exécution : vérifier aussi si la classe à laquelle appartient la variable de référence possède la variable appelée.
Tant la compilation que l'exécution regardent le côté gauche du signe égal.。

Vous ne devez absolument pas convertir un objet de classe parente en un type de sous-classe !

Une référence de classe parente pointant vers un objet de sous-classe peut être convertie vers le haut, et peut aussi êtreforcée/convertie.。

Tout au long du polymorphisme, c'est toujours l'objet de la sous-classe qui change !

//多态向下转型和向上转型的例子，多态转型解决了多态中父类引用不能使用子类特有成员的弊端。
class PolymorphicTest2 {
    public static void main(String[] args) {
        Phone p1 = new Nokia();        //向上转型，类型提升
        Nokia no = (Nokia)p1;          //向下转型，强制将父类的引用转换成子类类型，不能将Nokia类型转成Moto或Nexus类型
        no.print();                    //输出结果为Phone---null---0，因为继承了父类的方法

        Phone p2 = new Moto();
        Moto m = (Moto)p2;
        m.print();                    //输出结果为Moto---yellow---1599，方法重写，子类方法覆盖父类方法

        Phone p3 = new Nexus();
        Nexus ne = (Nexus)p3;
        ne.print();
    }
}

class Phone{    
    String color;
    int price;

    public void print(){
        System.out.println("Phone---" + color + "---" + price );
    }    
}

class Nokia extends Phone{
    String color = "red";
    int price = 1009;

    //public void print(){
    //    System.out.println("Nokia---" + color + "---" + price);
    //}
}

class Moto extends Phone{
    String color = "yellow";
    int price = 1599;

    public void print(){
        System.out.println("Moto---" + color + "---" + price);
    }
}

class Nexus extends Phone{
    String color = "black";
    int price = 1999;

    public void print(){
        System.out.println("Nexus---" + color + "---" + price);
    }
}
}

Abstraction (abstract)

L'abstraction consiste à extraire le contenu commun et essentiel de plusieurs choses.

Classes abstraites：

En Java, vous pouvez définirdes méthodes sans corps de méthode.L'implémentation spécifique d'une telle méthode est fournie parSous-classeUne méthode incomplète est appelée méthode abstraite, et une classe contenant une méthode abstraite est une classe abstraite.

Origine：

Lorsque plusieurs objets ont tous la même fonction, mais que le contenu spécifique de la fonction diffère, lors du processus d'extraction, seule la définition de la fonction est extraite, pas le corps de la fonction. Une méthode qui n'a qu'une déclaration de fonction et pas de corps de fonction est appelée méthode abstraite.

Caractéristiques des classes abstraites：

Les méthodes abstraites doivent être dans une classe abstraite ;
Les méthodes abstraites et les classes abstraites doivent toutes deux être modifiées avec le mot-clé `abstract` ;
Les classes abstraites ne peuvent pas utiliser `new` pour créer des objets, car appeler une méthode abstraite n'a pas de sens ;
Pour que les méthodes abstraites d'une classe abstraite puissent être utilisées, une sous-classe doit redéfinir toutes ses méthodes abstraites, puis créer un objet de sous-classe pour les appeler ; si une sous-classe ne redéfinit qu'une partie des méthodes abstraites, elle reste une classe abstraite ;
Une classe abstraite peut avoir des méthodes abstraites ou des méthodes non abstraites ; les méthodes abstraites servent à l'instanciation des sous-classes ;
Si une classe est une classe abstraite, alors les sous-classes qui en héritent doivent soit être des classes abstraites, soit redéfinir toutes les méthodes abstraites.
Cas particulier : une classe abstraite peut ne définir aucune méthode abstraite ; cela sert uniquement à empêcher la classe de créer des objets.

Caractéristiques des membres des classes abstraites：

Variables membres : peuvent être des variables ou des constantes ;
Constructeurs : il y a des constructeurs ;
Méthodes membres : peuvent être des méthodes abstraites ou des méthodes non abstraites.

abstract class 葵花宝典 {
    public abstract void 自宫();
}

class 岳不群 extends 葵花宝典 {
    public void 自宫(){
        System.out.println("剪刀");
    }
}

class 林平之 extends 葵花宝典{
    public void 自宫(){
        System.out.println("指甲刀");
    }
}
class AbstractTest  {
    public static void main(String[] args) {
        岳不群 岳 = new 岳不群();
        岳.自宫();

        林平之 林 = new 林平之();
        林.自宫();
    }
}

Précautions concernant les classes abstraites：

Une classe abstraite ne peut pas être instanciée ; pourquoi possède-t-elle encore un constructeur ?？

Tant qu'une classe est définie avec `class`, elle doit avoir un constructeur. Le constructeur d'une classe abstraite sert à instancier les sous-classes.

Une classe n'a pas de méthodes abstraites ; pourquoi est-elle définie comme une classe abstraite ??

Elle veut être héritée, mais pas instanciée.

Quels mots-clés ne peuvent pas coexister avec le mot-clé `abstract` ?？

`final`: si une méthode est abstraite, elle doit être redéfinie, mais `final` ne peut pas être redéfini, donc ils sont en conflit.
`private`: si une méthode est privée, les sous-classes ne peuvent pas y accéder directement, alors comment peut-elle être redéfinie?
`static`: aucun objet n'est nécessaire, et la méthode abstraite peut être appelée par le nom de la classe. Mais appeler une méthode abstraite n'a pas de sens.

Interface (`interface`)

InterfaceOuiMéthodes abstraitesetValeurs constantesUne collection de. Essentiellement, une interface est un type spécial de classe abstraite qui ne contient que des constantes et des définitions de méthodes, sans variables et sans implémentations de méthodes.

Format:`interface InterfaceName {}`

L'émergence des interfaces exprime "l'héritage multiple" sous une autre forme, à savoir "l'implémentation multiple".

Implémentation (`implements`)

Format:`class ClassName implements InterfaceName {}`

Caractéristiques：

Les interfaces ne peuvent pas être instanciées.
Si une classe implémente une interface, elle doit soit être une classe abstraite, soit implémenter toutes les méthodes de l'interface.

Caractéristiques des membres des interfaces：

Les modificateurs des membres dans une interface sont fixes !

Constantes de membre : `public static final`. Les variables définies dans une interface sont des constantes globales, et les modificateurs ne peuvent être que ces trois mots-clés ; tous peuvent être omis. Les noms de constantes doivent être en majuscules.
Méthodes de membre : `public abstract`. Les méthodes définies dans une interface sont toutes abstraites, et les deux mots-clés de modificateur peuvent être omis.
Recommandation : fournissez toujours les modificateurs manuellement.

Différences entre l'héritage et l'implémentation：

La relation entre les classes et les classes est appelée héritage : car, qu'une classe soit abstraite ou non abstraite, elle peut définir des méthodes non abstraites en son sein, et ces méthodes peuvent être utilisées directement par les sous-classes ; les sous-classes n'ont qu'à hériter. Seul l'héritage simple est autorisé, et l'héritage à plusieurs niveaux est autorisé.(class)）
La relation entre une classe et une interface est l'implémentation : car toutes les méthodes d'une interface sont abstraites, elles doivent être implémentées par une sous-classe avant qu'elle puisse être instanciée. Une classe peut avoir une implémentation unique ou multiple ; elle peut aussi implémenter plusieurs interfaces tout en héritant d'une classe.(class) extends (class) implements (interface1,interface2…)）
La relation entre les interfaces et les interfaces est l'héritage : une interface peut hériter d'une autre interface et ajouter de nouvelles propriétés et méthodes abstraites, et les interfaces peuvent avoir un héritage multiple.(interface) extends (interface1,interface2…)）

Différences entre les classes abstraites et les interfaces：

Variables membres

Une classe abstraite peut avoir des variables et des constantes
Une interface ne peut avoir que des constantes

Méthodes membres

Une classe abstraite peut avoir des méthodes non abstraites et des méthodes abstraites
Une interface ne peut avoir que des méthodes abstraites

Constructeurs

- Les classes abstraites ont des constructeurs
- Les interfaces n'ont pas de constructeurs

Relation entre les classes, les classes abstraites et les interfaces

La relation entre une classe et une classe abstraite est l'héritage `extends`
La relation entre une classe et une interface est l'implémentation `implements`

Caractéristiques conceptuelles des interfaces：

Une interface estexposée à l'extérieurrègles;
Une interface est l'extension fonctionnelle；
d'un programme ;L'émergence des interfacesréduit le couplage ; (elle met en œuvre le développement modulaire : les règles sont définies, chacun implémente son propre module, ce qui améliore grandement l'efficacité du développement)
Les interfaces peuvent être utilisées pourune implémentation multiple；
Plusieursclasses sans lien peuvent implémenter la même interface ;
Une classe peut implémenterplusieursinterfaces qui n'ont pas de relation directe entre elles ;
Semblable à la relation d'héritage, entre une interface et sa classe d'implémentation il existedu polymorphisme。

//运动员和教练的案例（下图是思路分析）

/*
    篮球运动员和教练
    乒乓球运动员和教练
    现在篮球运动员和教练要出国访问,需要学习英语
    请根据你所学的知识,分析出来哪些是类,哪些是抽象类,哪些是接口
*/
interface SpeakEnglish {
    public abstract void speak();
}

interface GoAboard{
    public abstract void aboard();
}

abstract class Person {
    private String name;
    private int age;

    public Person(){}

    public Person(String name,int age){
        this.name = name;
        this.age = age;
    }

    public void setName(String name){
        this.name = name;
    }
    public String getName(){
        return name;
    }

    public void setAge(int age){
        this.age = age;
    }
    public int getAge(){
        return age;
    }

    //吃饭
    public abstract void eat();
    //睡觉
    public void sleep(){
        System.out.println("Zzz...");
    }
}
//运动员
abstract class Player extends Person {
    public abstract void study();
}
//教练
abstract class Coach extends Person {
    public abstract void teach();
}

//篮球运动员
class BasketballPlayer extends Player implements SpeakEnglish,GoAboard{
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "吃鸡腿");
    }

    public void study(){
        System.out.println(getAge() + "岁的" + getName() + "学扣篮");
    }

    public void speak(){
        System.out.println(getAge() + "岁的" + getName() + " Say Hello World");
    }

    public void aboard(){
        System.out.println(getAge() + "岁的" + getName() + " Go Aboard");
    }
}
//乒乓运动员
class PingPangPlayer extends Player{
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "吃鸡蛋");
    }

    public void study(){
        System.out.println(getAge() + "岁的" + getName() + "学扣球");
    }
}
//篮球教练
class BasketballCoach extends Coach implements SpeakEnglish {
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "啃鸡爪");
    }

    public void teach(){
        System.out.println(getAge() + "岁的" + getName() + "教扣篮");
    }

    public void speak(){
        System.out.println(getAge() + "岁的" + getName() + " Say Hello Java");
    }

    public void aboard(){
        System.out.println(getAge() + "岁的" + getName() + " Go Aboard");
    }
}
//乒乓球教练
class PingPangCoach extends Coach{
    public void eat(){
        System.out.println(getAge() + "岁的" + getName() + "吃鸡蛋皮");
    }

    public void teach(){
        System.out.println(getAge() + "岁的" + getName() + "教扣球");
    }
}
class PlayerAndCoach {
    public static void main(String[] args) {
        //篮球运动员
        BasketballPlayer bp = new BasketballPlayer();
        bp.setName("郭艾伦");
        bp.setAge(33);
        bp.eat();
        bp.sleep();
        bp.study();
        bp.speak();
        bp.aboard();
        System.out.println("***********************");
        //篮球教练
        BasketballCoach bc = new BasketballCoach();
        bc.setName("波波维奇");
        bc.setAge(65);
        bc.eat();
        bc.sleep();
        bc.teach();
        bc.speak();
        bc.aboard();
        System.out.println("***********************");
        //多态
        Person p = new BasketballPlayer();
        p.setName("Kobe Bryant");
        p.setAge(33);
        p.eat();
        p.sleep();
        //p.study();
        //p.speak();

        BasketballPlayer bp2 = (BasketballPlayer)p;
        bp2.study();
        bp2.speak();
        bp2.aboard();
        System.out.println("***********************");
    }
}

Classes internes

Définir une classe à l'intérieur d'une autre classe ; la classe interne est appelée classe interne. L'émergence des classes internes brise une fois de plus la limitation de l'héritage simple de Java.

Caractéristiques d'accès：

Une classe interne peut accéder directement aux membres de la classe externe, y compris aux membres privés.
Pour que la classe externe accède aux membres de la classe interne, elle doit créer un objet de la classe interne.
Classification et points communs des classes internes：

Caractéristique commune：

Une classe interne reste une classe indépendante. Après compilation, la classe interne est compilée en un fichier `.class` indépendant, mais il est préfixé par le nom de la classe externe et le symbole `$`.
Les classes internes ne peuvent pas être accédées de la manière normale. Une classe interne est un membre de la classe externe, donc elle peut accéder librement aux variables membres de la classe externe, qu'elles soient privées ou non.

Classe interne membre

Dans la classe externe, il y a des variables membres et des méthodes membres ; une classe interne membre traite une classe entière comme un membre de la classe externe.
Une classe interne membre est définieà l'intérieur de la classe mais à l'extérieur des méthodesde la classe.
Le format pour créer un objet est :`OuterClassName.InnerClassName objectName = outerClassObject.innerClassObject`；
La raison pour laquelle une classe interne membre peut accéder directement aux membres de la classe externe est que la classe interne détient une référence à un objet de la classe externe :`OuterClassName.this`；
Les modificateurs qui peuvent être utilisés pour les classes internes membres sont `final`, `abstract`, `public`, `private`, `protected`, `static`.

Classe interne statique

Une classe interne statique est une classe interne membre avec le modificateur statique `static`, définieà l'intérieur de la classe mais à l'extérieur des méthodes.。

Il y a deux scénarios pour accéder à une classe interne statique depuis la classe externe :

Accéder aux membres non statiques d'une classe interne statique depuis la classe externe :`*OuterClassName.InnerClassName objectName = OuterClassName.innerObject*`Vous devez y accéder en créant un objet ;
Accéder aux membres statiques d'une classe interne statique depuis la classe externe : vous pouvez également utiliser le format ci-dessus, ou utiliser directement`OuterClassName.InnerClassName.member`。

Classe interne locale

Une classe interne locale est une classe définie à l'intérieur d'une méthode.

Une classe interne à une méthode ne peut être instanciéequ'à l'intérieur de la méthode dans laquelle elle est définieet ne peut pas être instanciée en dehors de cette méthode.
Un objet de classe interne à une méthode ne peut pas utiliser les variables locales non finales de la méthode dans laquelle la classe interne se trouve.

Les modificateurs qui peuvent être utilisés pour une classe interne à une méthode sontfinal，abstract；

Une classe interne à une méthode dans une méthode static ne peut accéderqu'aux membres statiques de la classe externe。

Classe interne anonyme

Une classe interne anonyme est une forme simplifiée d'une classe interne ; elle crée un objet de sous-classe anonyme dont le contenu hérite d'une classe externe ou implémente une interface.
Prérequis :
Une classe interne peut hériter d'une classe externe ou implémenter une interface.
Format :
`new OuterClassNameOrInterfaceName() { override methods };`
Habituellement, lorsqu'un paramètre formel d'une méthode est une interface ou une classe abstraite, et que l'interface n'a pas plus de trois méthodes, une classe interne anonyme peut être passée en argument.

Contenu modifié par différents modificateurs (sans rapport avec les classes internes)

	Classe	Variables membres	Méthodes membres	Constructeurs
private		Y	Y	Y
Default	Y	Y	Y	Y
protected		Y	Y	Y
public	Y	Y	Y	Y
abstract	Y		Y
static		Y	Y	Y
final	Y	Y	Y

Remarque, les règles courantes sont les suivantes :

À l'avenir, toutes les classes devraient être modifiées avec `public`. De plus, dans un fichier Java, une seule classe devrait être écrite.
À l'avenir, toutes les variables membres doivent être modifiées avec `private`.
À l'avenir, toutes les méthodes membres doivent être modifiées avec `public`.
S'il s'agit d'une classe abstraite ou d'une interface : `public abstract` + ...
Désormais, tous les constructeurs doivent être modifiés avec public.
Si la classe est une classe utilitaire ou une classe singleton : utilisez private pour modifier le constructeur.

Quatre modificateurs d'accès

	Même classe	Même package (classes non apparentées ou sous-classes)	Package différent (sous-classes)	Package différent (classes non apparentées)
private	Y
Default	Y	Y
protected	Y	Y	Y
public	Y	Y	Y	Y

Recommandation :

Variables membres : private
Constructeur : public
Méthodes membres : public

Plus de tutoriels

Pour des tutoriels plus détaillés, reportez-vous à :Tutoriel Java

Source : http://www.codeceo.com/article/java-extends.html

L'héritage Java expliqué

Catégorie Technologie de programmation