public class Livre {
  // Variables d'instance
  private String titre, auteur;
  private int nbPages

  // Constructeur
  public Livre(String unAuteur, String unTitre) {
    auteur = unAuteur;
    titre = unTitre;
  }

  // Accesseur
  public String getAuteur() {
    return auteur;
  }

  // Modificateur
  public void setNbPages(int n) {
    nbPages = nb;
}

La classe Livre représente un modèle pour la création d'objets de type "livre".

Pour informatiser un domaine, le développeur doit commencer par écrire un modèle de ce qu'il veut informatiser. Ce modèle doit représenter les objets qui appartiennent à ce modèle. Par exemple, s'il veut informatiser la gestion de cours d'une université, le développeur décrira la structure des objets "étudiant", "cours", "salle de classe", "enseignant",... dans des classes Etudiant, Cours, Salle, Enseignant,...

Quand un développeur écrit un programme en Java, il doit écrire le code de toutes les classes qu'il va utiliser. Le programme complet sera constitué d'un ensemble de classes. En Java il est impossible d'écrire du code en dehors d'une classe.

La classe Livre ci-dessus pourrait être utilisée pour représenter / modéliser les livres si on voulait informatiser la gestion d'une bibliothèque.

La classe Livre permettra de créer un objet "livre" avec le constructeur Livre(String unAuteur, String unTitre), en lui passant en paramètre l'auteur et le titre du livre. On dit que l'objet "livre" créé à partir de la classe Livre est une instance de la classe Livre. L'auteur et le titre du livre seront alors enregistrées dans l'objet "livre" et pourront être utilisées plus tard dans les traitements qui utiliseront ce livre.

Ces 2 valeurs, auteur et titre, forment l'état de l'objet. L'état d'un objet est constitué de valeurs nommées les "variables d'instance". Ces valeurs sont particulières à chaque instance : 2 livres peuvent avoir des valeurs différentes pour ces variables d'instance.

Il est de bon usage de protéger les variables d'instance du reste du programme (pour qu'on ne puisse pas, par mégarde ou malveillance, les modifier sans contrôler leur valeur), et c'est pour cela que les variables d'instance sont précédées du mot clé private. Les variables d'instance ne sont alors utilisables que dans la classe dans laquelle elles sont définies (ici la classe Livre). Si ces valeurs peuvent être lues par le reste du programme, on peut ajouter un "accesseur" (on utilise le mot anglais getter) qui est public (utilisable par toutes les autres classes du programme), ici getAuteur(). Si les autres classes peuvent modifier une variable d'instance, on peut ajouter un "modificateur" (on utilise le mot anglais setter). Ce n'est pas le cas ici mais, le plus souvent, les setters font des vérifications avant de modifier la valeur de la variable d'instance. Par exemple, on pourra vérifier que la valeur passée à setNbPages est bien un nombre positif.

Les setters et les getters sont des cas particulier de méthodes. On peut passer des valeurs à une méthode en donnant des valeurs aux paramètres de la méthode. Par exemple, la méthode setNbPage de l'exemple donné au début de cette page, a un paramètre de type int (un nombre entier). Une méthode peut ne pas avoir de paramètre comme la méthode getAuteur(). Une méthode peut retourner une valeur. Par exemple la méthode getAuteur() retourne l'auteur du livre, de type String (une chaîne de caractères).

Dans une classe Java, on peut avoir

• des variables d'instances (pour conserver l'état des objets) ;
• des constructeurs (pour créer de nouveaux objets) ;
• des méthodes (pour lancer des traitements sur les objets d'une classe).

Quand on programme avec Java, on écrit des classes. Une classe toute seule ne peut pas faire de traitements complexes. Les traitements complexes utilisent le plus souvent de nombreuses classses. Pensez, par exemple, au traitement pour préparer un emploi du temps dans une université ; il faudra au moins utiliser les classes Etudiant, Cours, Salle, Enseignant.

Les objets (instances de classes) doivent donc pouvoir s'échanger des données ou bien lancer des traitements dans les autres classes. Pour cela, les objets s'envoient des messages. Par exemple, un objet qui contient le traitement global pour vérifier un emploi du temps peut envoyer un message à une instance d'Enseignant (un objet créé par la classe Enseignant), du type "est-ce que tu es libre de telle heure à telle heure le jeudi 9 décembre ?". Evidemment on ne peut envoyer n'importe quelle message à un objet. Les messages qu'on peut lui envoyer doivent correspondre à une des méthodes de la classe de l'objet. Pour notre exemple, il devra y avoir dans la classe Enseignant une méthode du type

public boolean esTuLibre(Date dateDebut, Date dateFin) {
  ...
}

Le code de cette méthode devra retourner true si l'enseignant est libre et false sinon.

Ces méthodes s'appellent plus précisément des méthodes d'instance car ce sont des messages qui sont envoyés à une instance (un objet) d'une classe.

On envoie un message à un objet avec la notation "pointée" : objet.message(...). Avant le point, objet est un objet qui a été créé avant par un constructeur et message est le nom d'une des méthodes d'instance de la classe de l'objet.