Résumé syntaxique élémentaire #

Utilisation d’objets/classes existantes #

Création d’une date (rappel: cette classe est obsolète) #

Date d = new Date(1981, 5, 1);

• Se traduit par: d est une référence de type Date qui pointe sur un objet de type Date.
• Date(...) est un constructeur d’objet
• new indique que l’objet est instancié ; un espace mémoire lui est réservé ; plus ou moins équivalent à un malloc en C.

Création à l’aide de fabriques (méthodes statiques) #

1
2
3

LocalDate d1 = LocalDate.now();
LocalDate d2 = LocalDate.of(1981, 5, 1);
LocalDate d3 = LocalDate.parse("1981-05-01");

Méthodes #

Méthodes statiques #

Les méthodes statiques sont des méthodes rattachée à une classe. Permet la programmation “sans objets”.

1
2

double d = Math.sin(0.5);
double d = Double.parse("3.141592");

Méthodes d’instance #

Rattachée à un objet instancié

1
2
3
4

date1.isBefore(date2)
account.deposte(1000);
device.shutdown();
student1.equals(student2);

Exceptions (notion de base) #

Retourner une exception:

1
2
3

  if ( somethingGoesWrong() ) {
    throw new RuntimeException("Something Goes Wrong");
  }

Traitement possible #

1
2
3
4
5
6
7
8
9

try {
    /* tenter une opération qui peut lever une exception */
} catch (TheExceptionToTreat e) { 
    /* corriger le problème ; logguer l'exception ; propage
       l'exception plus haut ; lever une autre exception ; ... */
} finally {
    /* bloc facultatif qui sera exécuter dans tous les cas
       par ex: fermer une ressource */
}

Si le traitement est obligatoire, mais qu’il n’est pas possible de résoudre le problème, il est possible d’ajouter une clause throws dans la signature de la ou des méthodes.

1
2
3

public static void main(String[] args) throws IOException {
    tryToMakeAnIO();
}

Classes mutables vs classes immutables #

Classe mutable #

modifie l’état interne de l’objet

1
2

List<Integer> is = new ArrayList<>();
is.add(1); // le contenu de la liste a changé

dans le cas général:

class MyObject {
  void action(...) { ... }
}

Classe immutable #

L’état de l’objet ne varie jamais. Une action retourne un nouvel état si nécessaire.

1
2
3

String greetings = "hello";
greetings.toUpperCase(); // greetings vaut toujours "hello"
String upperGreetings = greetings.toUpperCase(); // greetings retourne sa version en majuscule

dans le cas général:

class MyObject {
  MyObject action(...) { ... }
}

Super-classe Object #

Toute classe dérive implicitement de Object.

Possibilité de redéfinir : toString, equals et hashCode.

Règles:

• idéalement, toujours redéfinir toString pour nos classes
• retourner un résultat concis et informatif
• si equals est redéfini, hashCode doit être également redéfini

Redéfinition #

Action de redéfinir une méthode d’une classe/interface parente.

Redéfinitioin du equals #

N’utilisez jamais instanceof (pour préserver la symétrique de l’égalité) sauf si votre classe est final.

1
2
3
4
5
6
7
8
9

  @Override
  public boolean equals(Object o) {
    if(this == o) return true;
    if(o == null || o.getClass() != this.getClass()) {
      return false; 
    }
    CurrentClass other = (CurrentClass)o;
    return ... /* comparer les attributs internes avec ceux de `other` */
  }

Redéfinitioin du hashCode #

Redéfinissez toujours hashCode si la méthode equals est redéfinie.

1
2
3
4
5
6
7

import java.util.Objects;
  ...

  @Override
  public int hashCode() {
    return Objects.hash(this.attr1, this.attr2, this.attr3, ...);
  }

Polymorphisme de sous-typage #

Le polymorphisme de sous-typage permet de substituer un type par un sous-type.

1
2
3
4
5

Object o = new Counter.withValue(42); // o pointe sur un sous-type
o.toString(); // ==> Counter(0042)  appel de toString redéf. dans Counter

o = List.of(1,2,3); // o pointe sur un sous-type
o.toString(); // ==> [1,2,3]  appel de toString redéf. dans UnmodifiableList

Polymorphisme ad-hoc : La surcharge #

La surcharge ne doit pas être confondu avec la redéfinition.

• redéfinition:
  • la méthode redéfinie a le même nom et les mêmes arguments
  • action de redéfinir une méthode d’une classe/interface parente.
  • s’applique donc dans le contexte de l’héritage
  • le type de retour peut appartenir à un sous-type de la classe
• surcharge:
  • la méthode surchargée a le même nom, mais les arguments sont différents
  • le type de retour différents ne permet pas d’appliquer la surcharge. Un type de retour peut donc appartenir à un sous-type

Surcharge de la méthode test:

1
2
3
4
5

class Test {
  void test(int i) { System.out.println("int: " + i); }
  void test(short s) { System.out.println("short: " + s); }
  void test(Schtroumpf s) { System.out.println("Je suis un schtroumpf: " + s.schtroumpf()); }
}