Programmation Java/this
Le mot-clé "this" désigne, dans une classe, l'instance courante de la classe elle-même.
Il est utilisé à différentes fins décrites dans les sections suivantes.
Rendre univoque.
Il peut être utilisé pour rendre le code explicite et non ambigu.
Par exemple, si dans une méthode, on a un paramètre ayant le même nom qu'un attribut de la classe dont la méthode fait partie, on peut désigner explicitement l'attribut grâce à "this" :
public class Calculateur
 protected int valeur;
 public void calcule(int valeur)
 this.valeur = this.valeur + valeur;
Dans cet exemple, la méthode "calcule" additionne le paramètre "valeur" à l'attribut "valeur" et stocke le résultat dans l'attribut "valeur" de l'objet.
L'attribut a été désigné explicitement par le mot-clé "this", désignant l'instance de la classe, préfixé au nom de l'attribut.
S'auto-désigner comme référence.
Le mot-clé codice_1 peut être utilisé pour passer une référence à l'instance elle-même comme paramètre d'une méthode.
Par exemple : s'enregistrer comme écouteur d'évènement :
source.addListener(this);
Désigner l'instance de la classe qui encadre.
Dans le cas de classes imbriquées, c'est-à-dire qu'une classe interne utilise l'instance de la classe externe, le mot-clé codice_1 préfixé du nom de la classe externe permet de désigner l'instance de la classe externe. S'il n'est pas préfixé, il désigne l'instance de la classe interne.
Exemple :
public class Livre
 String titre = "Le livre";
 class Chapitre
 String titre = "Chapitre 1";
 public String toString()
 return
 Livre.this.titre + // "Le livre"
 this.titre ; // "Chapitre 1"
 // ou Chapitre.this.titre ; // "Chapitre 1"
 // -> "Le livre/Chapitre 1"
Appeler un autre constructeur de la classe.
Un constructeur peut appeler un autre constructeur de la classe en utilisant le mot-clé codice_1 comme nom appelé.
Il doit s'agir de la première instruction du constructeur.
Ce genre d'appel est utile pour définir des constructeurs alternatifs avec moins de paramètres, pour utiliser des valeurs par défaut.
Exemple :
public class Livre
 String titre, auteur, editeur;
 int pages, annee;
 public Livre(String titre)
 this(titre, "Moi", "fr.wikibooks.org");
 public Livre(String titre, String auteur, String editeur)
 this(titre, auteur, editeur, 800, 2021);
 public Livre(String titre, String auteur, String editeur, int pages, int annee)
 this.titre = titre;
 this.auteur = auteur;
 this.editeur = editeur;
 this.pages = pages;
 this.annee = annee;

Programmation Java/Encapsulation
En Java, comme dans beaucoup de langages orientés objet, les classes, les attributs et les méthodes bénéficient de niveaux d'accessibilité, qui indiquent dans quelles circonstances on peut accéder à ces éléments.
Ces niveaux sont au nombre de 4, correspondant à 3 mots-clés utilisés comme modificateurs : "private", "protected" et "public".
La quatrième possibilité est de ne pas spécifier de modificateur (comportement par défaut).
Les sections suivantes décrivent les modificateurs du plus restrictif au moins restrictif.
Chaque modificateur moins restrictif que le précédent ajoute une nouvelle possibilité d'accès.
Modificateur "private".
Un attribut ou une méthode déclarée "private" n'est accessible que depuis l'intérieur de la même classe.
Comportement par défaut (paquetage).
Si aucun modificateur n'est indiqué, l'élément n'est accessible que depuis les classes faisant partie du même paquetage ("package").
Exemple :
package org.wikibooks.fr.temps;
class Horloge
 // corps de la classe
public class Calendrier
 void ajouteJour()
 // corps de la methode
 int mois;
 // suite de la classe
La classe "Horloge", la méthode "ajouteJour" et l'attribut "mois" ne sont accessibles que depuis les classes faisant partie du "package" "org.wikibooks.fr.temps".
Modificateur "protected".
Un attribut ou une méthode déclarée "protected" est accessible uniquement aux classes d'un package et à ses sous-classes même si elles sont définies dans un package différent.
Si la classe qui accède au membre est dans un paquetage différent, elle doit être une sous-classe de la classe définissant le membre accédé.
Toutefois, elle ne peut le faire que pour la référence codice_1 ou codice_2 ; elle ne peut pas accéder au membre d'un autre objet.
Exemple :
Modificateur "public".
Une classe, un attribut ou une méthode déclarée "public" est visible par toutes les classes et les méthodes.
En résumé.
Le tableau résume les différents mode d'accès des membres d'une classe.

Programmation Java/Héritage
L’héritage est la définition d’une classe par extension des caractéristiques d’une autre classe, exemple : on a créé une classe "Vehicule". Ainsi les classes Automobile et Avion ont pu hériter des caractéristiques de "Vehicule".
L'héritage, est l'un des mécanismes les plus puissants de la programmation orientée objet, permet de reprendre des membres d'une classe (appelée "superclasse" ou "classe mère") dans une autre classe (appelée "sous-classe", "classe fille" ou encore "classe dérivée"), qui en hérite. De cette façon, on peut par exemple construire une classe par héritage successif.
En Java, ce mécanisme est mis en œuvre au moyen du mot-clé "extends"
Exemple :
 public class Vehicule
 public int vitesse;
 public int nombre_de_places;

public class Automobile extends Vehicule
 public Automobile()
 this.vitesse = 90;
 this.nombre_de_places = 5;
Dans cet exemple, la classe "Automobile" hérite de la classe "Vehicule", ce qui veut dire que les attributs "vitesse" et "nombre_de_places", bien qu'étant définis dans la classe "Vehicule", sont présents dans la classe "Automobile". Le constructeur défini dans la classe "Automobile" permet d'ailleurs d'initialiser ces attributs.
En Java, le mécanisme d'héritage permet de définir une hiérarchie de classes comprenant toutes les classes. En l'absence d'héritage indiqué explicitement, une classe hérite implicitement de la classe "Object". Cette classe "Object" est la racine de la hiérarchie de classe.
La classe "Object".
Au moment de l'instanciation, la classe fille reçoit les caractéristiques qui peuvent être héritées de sa super-classe, qui elle-même reçoit les caractéristiques qui peuvent être héritées de sa propre superclasse, et ce récursivement jusqu'à la classe "Object".
Ce mécanisme permet de définir des classes génériques réutilisables, dont l'utilisateur précise le comportement dans des classes dérivées plus spécifiques.
Il faut préciser que, contrairement à C++, Java ne permet pas l'héritage multiple, ce qui veut dire qu'une classe dérive toujours d'une et d'une seule classe.
Héritage d'interface.
L'héritage d'interface est aussi possible en Java. À la différence des classes, l'héritage multiple est autorisé, ce qui veut dire qu'une interface peut hériter d'autant d'autres interfaces que désiré.
L'héritage d'interface se fait avec le mot clé extends, puisque c'est une interface qui "étend" une interface existante. Les différentes interfaces héritées sont séparées par une virgule. 
L'héritage « multiple » pour une classe (via les interfaces) se fait avec le mot-clé implements. Exemple :
 public interface InterfaceA {
 public void methodA();
 public interface InterfaceB {
 public void methodB();
 public interface InterfaceAB extends InterfaceA, InterfaceB {
 public void otherMethod();
 public class ClassAB implements InterfaceAB{
 public void methodA(){
 System.out.println("A");

public void methodB(){
 System.out.println("B");
 public void otherMethod(){
 System.out.println("blablah");