---
# System prepended metadata

title: POO
tags: [Java]

---

# POO

La POO (programation orientée objet) est une manière d'organiser son code.

### Les classes

Une classe contient des propriétés et des méthodes.
Elle est comme un moule.

**Exemple avec une classe "Chien" :**
##### Propriétés (attributs)
* nom
* race
* age
* ...

##### Méthodes
* aboyer();
* courir();
* manger();
* ...

Pour utiliser une classe, il nous faudra l'instentier avec le mot clé `new`.
Il est possible d'ajouter des valeurs aux propriétés.

Les méthodes peuvent avoir un ou plusieurs arguments, qu'il faudra remplacer par la valeur que nous souhaitons au moment de son appel.

Exemple :

```
public void bark(String something) {
    System.out.println("Woof sur " + something);
}
```
`badDog.bark("postman");`

En vrai, il est mieux de `return` le résultat d'une méthode et le sysout dans le main. 

**Exemple :** 

```
// class Calculator
public class Calculator {
    public int add(int a, int b) {
        return a + b;
    }
}
```

```
// class App
public static void main(String[] args) {
    Calculator casio = new Calculator();
    int addition = casio.add(5, 2);
    System.out.println(addition); // 7
}

```

Une methode doit retourner l'argument avec laquelle on l'a déclaré (sauf void car void == néant).
Elle peut retourner une valeure nulle si l'argument est de type complexe (Integer, Double,...).


Exemple :

```
public int add(int a, int b){
    return a+b;
}
```

```
public void add(int a, int b){
    System.out.println(a+b);
}
```
```
public Integer divise (int a, int b){
    if (b == 0){
        System.out.println("impossible de diviser par 0!");
        return null;
    }else{
        return a/b;
    }
}

```

Une methode boolean peut retourner une condition seule sans if/else :

```
public boolean testValueIs0 (int a){
    return a == 0;
}
// return true si a == 0 et false si a!=0
```

##### Constructeur

Pour instancier une classe, c'est à dire créer un objet à partir d'une classe, il s'agit d'utiliser l'opérateur new.
En réalité l'opérateur new, lorsqu'il est utilisé, fait appel à une méthode spéciale de la classe: le **constructeur**.

le rôle du constructeur est de déclarer et de permettre d'initialiser les données membres de la classe (par exemple donner à ses propriétés des valeurs par défaut.), ainsi que de permettre différentes actions lors de l'instanciation.

Un constructeur se définit comme une méthode standar, mais ne renvoie aucun valeur.
Ainsi, le constructeur d'un objet porte le même nom que la classe et ne possède aucune valeur de retour (même pas void).

* un constructeur porte le même nom que la classe dans laquelle il est défini
* un constructeur n'a pas de type de retour (même pas void)
* un constructeur peut avoir des arguments
* la définition d'un constructeur n'est pas obligatoire lorsqu'il n'est pas nécessaire


raccourci constructeur : ctrl + shift + ; (sur la class)



```
public StringValidator(int minLength, int maxLength) {
    this.minLength = minLength;
    this.maxLength = maxLength;
}
```

On pourra alors assigner les valeurs des propriétés au moment de l'instanciation.
`StringValidator(2, 32)`



###### tags: `Java`