java

1
2
3
4
5

int monNombre = 0;
String monTexte = "texte"; // Le type String doit avoir une majuscule, comme expliqué après
boolean monBool = true;
char monCharactere = 'c';
float monNombreAVirgule = 0.0;

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108

public class Voiture {
    /* On utilise private pour rendre les "getters" et "setters" utiles, sinon on peut accéder au élement comme tel : voiture.age
    Ce n'est pas recommandé car les getters / setters peuvent avoir une certaine logique (pas de nombre en dessous de 1, le modèle doit avoir un certain nombre de charactères...)
    ,*/
    private String modele;
    private int age;
    private String marque;
// Un constructeur permet d'initialiser l'objet avec tout ou un certain nombre d'éléments
    public Voiture(String modele, int age, String marque) {
        // le 'this.element' référence la classe
        // On pourrait donc mettre :
        // this.modele = toto;
        // Si dans le constructeur on met 'toto' au lieu de modele
        this.modele = modele;
        this.age = age;
        this.marque = marque;
    }
    // Ici, le constructeur ne prend que 2 paramètres, l'age est initialisé automatiquement
    public Voiture(String modele, String marque) {
        this.modele = modele;
        this.age = 1;
        this.marque = marque;
    }
// Renvoi l'élément de la classe
    public String getModele() {
        return modele;
    }
    public int getAge() {
        return age;
    }
    public String getMarque() {
        return marque;
    }
    public void setModele(String modele) {
        this.modele = modele;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void setMarque(String marque) {
        this.marque = marque;
    }
// Une fonction très pratique en java est le 'equals' qui vérifie si un objet est égale à une autre instance du même objet (avec des paramètres différents)
/* L'utilisation de '@override' permet de redéfinir une fonction déja définit.
Ne pas l'utiliser est possible mais l'utiliser est une bonne pratique :
- Le compilateur vas check si la fonction existe dans la classe de base, si non, erreur de compilation */
// Tout les objets descende du primitif 'Object' qui possède des fonctions 'equals' et 'toString'
    @Override
    public boolean equals(Object autreVoiture) {
        if (this == autreVoiture) {
            return true;
        }
        if (autreVoiture == null) {
            return false;
        }
        // getClass renvoi la classe
        if (getClass() != autreVoiture.getClass()) {
            return false;
        }
        // On fait du upcast de Object (le type le plus primitif) vers notre type Voiture
        Voiture autre = (Voiture) autreVoiture;
        if (modele == null) {
            if (autre.modele != null)
                return false;
        }
        else if (!modele.equals(autre.modele)) {
            return false;
        }
        if (this.age != autre.age)
            return false;
        if (marque == null) {
            if (autre.marque != null)
                return false;
        }
        else if (!marque.equals(autre.marque)) {
            return false;
        }
        return true;
    }
    // Le equals() ce dessus est correct, mais en pratique on utilise plutôt ce genre de code
    /*
      // On import la classe Objects qui permet de caster
      // Les imports sont TOUJOURS en haut du code (comme en python ou autre)
      import java.util.Objects;
      @Override
      public boolean equals(Object objet) {
      if (this == objet) return true;
      if (!(objet instanceof Voiture)) return false;
      Voiture autre = (Voiture) objet;
      return age == autre.age &&
      Objects.equals(modele, autre.modele) &&
      Objects.equals(marque, autre.marque);
      }*/
    @Override
    public String toString() {
        return "La voiture " + getMarque() +
            " à un " + getAge() +
            " ans et est de modèle " + getModele();
    }
    // Le main est la classe qui est executé, comme le main en python
    public static void main(String[] args) {
        Voiture v1 = new Voiture("Classe A", "Mercedes");
        Voiture v2 = new Voiture("Capture", "Renault");
    System.out.println(v1.toString());
    System.out.println(v2.toString());
    System.out.println(v1.equals(v2));
    }
}

1
2
3
4
5
6
7

// Dans le même fichier
public void vieillir() {
    age++;
}
public boolean estAncienne() {
    return age > 10;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

// le extends est UNIQUE
// Un objet ne peut avoir q'un seul objet père
public class VoitureElectrique extends Voiture {
    private int autonomie;
    public int getAutonomie() {
        return autonomie;
    }
    public void setAutonomie(int autonomie) {
        this.autonomie = autonomie;
    }
    // L'utilisation du 'super' appel la fonction de la classe de base, ici, voiture
    public VoitureElectrique(String modele, int age, String marque, int autonomie) {
        super(modele, age, marque); // idem que faire appel au constructeur de 'voiture'
        this.autonomie = autonomie;
    }
    public VoitureElectrique(String modele, String marque, int autonomie) {
        super(modele, 1, marque);
        this.autonomie = autonomie;
    }
    @Override
    public boolean equals(Object objet) {
        if (!super.equals(objet)) {
            return false;
        }
        if (!(objet instanceof VoitureElectrique)) {
            return false;
        }
        VoitureElectrique autre = (VoitureElectrique) objet;
        return autonomie == autre.autonomie;
    }
    @Override
    public void vieillir() {
        super.vieillir();
        autonomie -= 10; // perte de capacité batterie
        if (autonomie < 0) {
            autonomie = 0;
        }
    }
    public void rouler(int kilometres) {
        int consommation = kilometres / 5; // ex: 5 km = 1 km d'autonomie
        autonomie -= consommation;
        if (autonomie < 0) {
            autonomie = 0;
        }
    }
    public void recharger(int km) {
        autonomie += km;
    }
    public boolean batterieFaible() {
        return autonomie < 50;
    }
}

1
2
3
4
5
6
7
8

class Exemple {
    public static void main(String[] args) {
        String s = "-20";
        // On utilise Integer car c'est la classe primitive des int
        int i = Integer.parseInt(s);
        System.out.println(i);
    }
}