User Tools

Site Tools


vocabulaire

Classe abstraite: Dans une modélisation, on souhait souvent qu'une classe de base ne présente qu'une interface pour ses classes dérivées. C'est à dire qu'on ne souhaite pas qu'il soit possible de créer un objet de cette classe de base, mais seulement pouvoir surtyper jusqu'à elle pour pouvoir utiliser son interface. Cela est possible en rendant cette classe abstraite en utilisant le mot clef “abstract”. Le compilateur se plaindra si une tentative est faite de créer un objet d'une classe définie comme abstract. C'est un outil utilisé pour forcer une certain conception.

Méthode abstraite: Le mot clef “abstract” est aussi utilisé pour décrire une méthode qui n'a pas encore été implémentée dans une classe abstraite - comme un panneau indiquant « voici une fonction de l'interface dont les types dérivés ont hérité, mais actuellement je n'ai aucune implémentation pour elle ». Une méthode abstract peut seulement être créée au sein d'une classe abstract. Quand cette classe est dérivée, cette méthode doit être implémentée, ou la classe dérivée devient abstract elle aussi. Créer une méthode abstract permet de l'inclure dans une interface sans être obligé de fournir une portion de code.

Interface: Le mot-clef interface pousse le concept abstract un cran plus loin. On peut y penser comme à une classe « purement » abstract. Il permet au créateur d'établir la forme qu'aura la classe : les noms des méthodes, les listes d'arguments et les types de retour, mais pas les corps des méthodes. Une interface peut aussi contenir des données membres (champs), mais elles seront implicitement static et final. Une interface fournit un patron pour la classe, mais aucune implémentation.

Pour créer une interface, il faut utiliser le mot-clef interface à la place du mot-clef class. Comme pour une classe, on peut ajouter le mot-clef public devant le mot-clef “interface” (mais seulement si l'interface est définie dans un fichier du même nom) ou ne rien mettre pour lui donner le statut « amical » afin qu'elle ne soit utilisable que dans le même package. Une interface déclare automatiquement tous ses membres comme public.

Le mot-clef “implements” permet de rendre une classe conforme à une interface particulière (ou à un groupe d'interfaces). Il dit en gros : « L'interface spécifie ce à quoi la classe ressemble, mais maintenant on va spécifier comment cela fonctionne ».

Instance: Tous les objets java qui réalisent une classe sont des instances de cette classe. Quand on “instancie” une classe on crée un object et donne de valeurs à ces membres/champes. Le “new” opérateur instancie une classe par l'allocation de mémoire pour un nouveau objet et retourne une référence à cette mémoire. Le “new” opérateur invoque également le constructeur de l'objet.

Avec le test “instanceof” et méthode “isInstance()” on peut tester si un objet est un instance d'une hiérarchie des classes, mais il faut faire attention car “instanceof” est vraie pour tous classes de la hiérarchie de la classe réalisée par l'objet. Pour tester pour la classe réalisée spécifiquement on utilise la méthode “getClass”.

class Base {}
class Derived extends Base {}
x = new Derived();
x instanceof Base => true
x instanceof Derived => true
Base.isInstance(x) => true
Derived.isInstance(x) => true
x.getClass() == Base.class false
x.getClass() == Derived.class true
x.getClass().equals(Base.class)) false
x.getClass().equals(Derived.class)) true

Classe interne Il est possible de placer la définition d'une classe à l'intérieur de la définition d'une autre classe. C'est ce qu'on appelle une classe interne. Les classes internes sont une fonctionnalité importante du langage car elles permettent de grouper les classes qui sont logiquement rattachées entre elles, et de contrôler la visibilité de l'une à partir de l'autre. Une classe interne est créée comme on pouvait s'y attendre - en plaçant la définition de la classe à l'intérieur d'une autre classe. Les classes internes prennent de l'intérêt lorsqu'on les utilise pour implémenter des interfaces et masquée cet implémentation.

Classe anonyme: Une classe interne anonyme est une classe interne sans nom. Une classe anonyme est définie et instanciée dans une seule expression succincte unique à l'aide de l'opérateur new. Quand une inner classe est utilisée une seule fois, pensez à utiliser la syntaxe classe anonyme, ce qui place la définition et l'utilisation de la classe dans exactement au même endroit.

	
// Une méthode qui renvoie une classe interne anonyme.
public class Parcel6 {
  public Contents cont() { // la class anonyme et son instance (objet)
    return new Contents() {
      private int i = 11;
      public int value() { return i; }
    }; // Point-virgule requis dans ce cas
  }
  public static void main(String[] args) {
    Parcel6 p = new Parcel6();
    Contents c = p.cont();
  }
}

Méthodes spéciales:

  • String Object.toString(): Indiquer quand elle est appelée automatiquement. Retourne une représentation en texte de l'objet. En général, la méthode toString renvoie une chaîne de characters qui “représente textuellement” cet objet. Il est recommandé que tous les sous-classes redéfinissent cette méthode.
  • Constructeur: Méthodes spéciales pour créer (initialiser) un objet et garantir les invariantes du programme (valuers et relations entre champes de la classe). Un constructeur par défaut (c.a.d un constructeur «no-arg» ) est un constructeur sans argument, utilisé pour créer des « objets de base ». Si une classe est créée sans constructeur, le compilateur créé automatiquement un constructeur par défaut.
  // constructeurs."
  public class Flower {
    int petalCount = 0;
    Flower(int petals) {
      petalCount = petals;
      // Constructeur avec un unique paramètre int
    }
  }
  
  • Accesseurs. Méthodes pour accéder à des attribues/champes. Cela permet de changer l'implémentation sans changer le code d'appel, et contrôler l' accès aux champs des objets (avec serialisation des accepteurs)

Liste des classes standards utiles:

  • Listes:
    • ArrayList
  • Lecture/écriture fichiers:
    • Texte:
      • BufferedReader, FileReader
      • BufferedWriter, FileWriter
    • Serialization:
      • ObjectOutputStream, FileOutputStream
      • ObjectInputStream, FileInputStream
vocabulaire.txt · Last modified: 2013/06/18 16:20 (external edit)