1.

Instanciation :
L'instanciation consiste à créer un objet d'une classe.

public class InstanciationExample {

public static void main(String[] args) {
// Instanciation d'un objet de la classe "Personne"
Personne personne = new Personne("John", 25);
personne.sePresenter();
}
}

class Personne {
private String nom;
private int age;

public Personne(String nom, int age) {

this.nom = nom;
this.age = age;
}

public void sePresenter() {

System.out.println("Je m'appelle " + nom + " et j'ai " + age + " ans.");
}
}
2. Définition d'une classe :
La définition d'une classe consiste à créer un modèle ou un plan pour créer des objets.

public class DefinitionClasseExample {

public static void main(String[] args) {
// Utilisation de la classe "Voiture" définie ci-dessous
Voiture maVoiture = new Voiture("Audi", "Noire");
maVoiture.afficherDetails();
}
}

class Voiture {
private String marque;
private String couleur;

public Voiture(String marque, String couleur) {

this.marque = marque;
this.couleur = couleur;
}

public void afficherDetails() {

System.out.println("Marque : " + marque);
System.out.println("Couleur : " + couleur);
}
}
3.
Polymorphisme :
Le polymorphisme permet à un objet d'une classe d'être traité comme un objet d'une autre classe
liée par l'héritage ou l'implémentation d'une interface.

public class PolymorphismeExample

{
}
public static void main(String[]
args) {
class Chien implements Animal {
Animal animal1 = new Chien();
@Override
Animal animal2 = new Chat();
public void faireSon() {
System.out.println("Le chien
animal1.faireSon();
aboie.");
animal2.faireSon();
}
}
}
}

class Chat implements Animal {

interface Animal {
@Override
void faireSon();
public void faireSon() {
System.out.println("Le chat
miaule.");
}
}
4. Interface :
Une interface est une collection de méthodes abstraites qui définissent un contrat que les classes
qui implémentent l'interface doivent respecter.

public class InterfaceExample { public Rectangle(int longueur, int

largeur) {
public static void main(String[]
args) { this.longueur = longueur;
Rectangle rectangle = new this.largeur = largeur;
Rectangle(5, 10);
}
rectangle.calculerSurface();
rectangle.calculerPerimetre();
public void calculerSurface() {
}
int surface = longueur * largeur;
}
System.out.println("La surface
du rectangle est : " + surface);
interface Forme { }
void calculerSurface();
public void calculerPerimetre() {
void calculerPerimetre(); int perimetre = 2 * (longueur +
largeur);
}
System.out.println("Le
périmètre du rectangle est : " +
class Rectangle implements Forme { perimetre);
private int longueur; }
private int largeur; }
5. Héritage :
L'héritage permet à une classe d'hériter des caractéristiques (variables et méthodes) d'une autre
classe appelée classe parente ou superclasse.

System.out.println("Je
m'appelle " + nom + " et j'ai " + age
public class HeritageExample {
+ " ans.");
public static void main(String[]
}
args) {
}
Etudiant etudiant = new
Etudiant("John", 25, "1234");
etudiant.sePresenter(); class Etudiant extends Personne {
etudiant.etudier(); private String numeroEtudiant;
}
} public Etudiant(String nom, int
age, String numeroEtudiant) {
super(nom, age);
class Personne {
this.numeroEtudiant =
protected String nom;
numeroEtudiant;
protected int age;
}

public Personne(String nom, int

public void etudier() {
age) {
System.out.println("L'étudiant "
this.nom = nom;
+ nom + " avec le numéro " +
this.age = age; numeroEtudiant + " étudie.");
} }
}
public void sePresenter() {
6. Encapsulation des données (getters and setters) :
L'encapsulation des données est le mécanisme qui permet de protéger les données d'une classe en
les rendant privées et en fournissant des méthodes publiques pour y accéder (getters) et les
modifier (setters).

private int age;

public class EncapsulationExample {
public static void main(String[] public String getNom() {
args) {
return nom;
Personne personne = new
}
Personne();
personne.setNom("John");
public void setNom(String nom) {
personne.setAge(25);
this.nom = nom;
System.out.println("Nom : " +
personne.getNom()); }
System.out.println("Age : " +
personne.getAge()); public int getAge() {
} return age;
} }

class Personne { public void setAge(int age) {

private String nom; this.age = age;
 7. Constructeur :
Un constructeur est une méthode spéciale qui est appelée lors de la création d'un objet d'une
classe. Il est utilisé pour initialiser les variables d'instance de la classe.

public Personne(String nom, int

age) {
public class ConstructeurExample {
this.nom = nom;
public static void main(String[]
args) { this.age = age;
Personne personne1 = new }
Personne("John", 25);
personne1.sePresenter();
public Personne(String nom) {
this.nom = nom;
Personne personne2 = new
this.age = 0;
Personne("Jane");
}
personne2.sePresenter();
}
public void sePresenter() {
}
System.out.println("Je
m'appelle " + nom + " et j'ai " + age
class Personne { + " ans.");
private String nom; }
private int age; }
8. Classes abstraites :
Une classe abstraite est une classe qui ne peut pas être instanciée directement, mais qui sert de
modèle pour d'autres classes.

public class class Chien extends

ClassesAbstraitesExample { AnimalDomestique {
public static void main(String[] public Chien(String nom) {
args) {
super(nom);
AnimalDomestique chien = new
}
Chien("Rex");
chien.faireSon();
@Override
public void faireSon() {
AnimalDomestique chat = new
Chat("Minou"); System.out.println("Le chien " +
nom + " aboie !");
chat.faireSon();
}
}
}
}

class Chat extends

abstract class AnimalDomestique {
AnimalDomestique {
protected String nom;
public Chat(String nom) {
super(nom);
public AnimalDomestique(String
}
nom) {
this.nom = nom;
@Override
}
public void faireSon() {
System.out.println("Le chat " +
public abstract void faireSon();
nom + " miaule !");
}
9. Classes anonymes :
Les classes anonymes sont des classes qui sont déclarées et instanciées en même temps, sans leur
donner de nom explicite.

public class ClassesAnonymesExample {

public static void main(String[] args) {
Animal oiseau = new Animal() {
@Override
public void faireSon() {
System.out.println("L'oiseau chante !");
}
};
oiseau.faireSon();
}
}

interface Animal {
void faireSon();
}

Ces exemples couvrent chacun des cas demandés : instanciation, définition

d'une classe, polymorphisme, interface, héritage, encapsulation des données
(getters and setters), constructeur, classes abstraites et classes anonymes.