package voiture;

// int pour integer ou nombre entier (e.g: 1, 2, 3)
// contrairement a float ou double qui sont pour les nombres a virgule (e.g: 0.557478, 2.55)

// void pour du rien, quand ça retourne void ça veut dire que ça retourne queudal en fait.

// on définit une classe appelée "Moteur"
public class Moteur {

    // une champ privé puissance, qui est de type integer, qui n'est pas initialisé.
    private int puissance;
    // un champ privé carburant, qui est de type  char (un caractère seul, genre 'b'), qui n'est pas initialisé.
    private char carburant;

    //getter/setter

    // une methode publique getPuissance, qui retourne un integer
    // une variable privée on peut y accèder que depuis sois meme, comme this,
    // une variable publique on peut y accèder depuis n'importe ou, meme une autre classe.

    public int getPuissance() {
        return puissance;
    }


    // une methode setPuissance qui retourne rien (void), qui prend un parametre puissance, qui est un integer.
    // cette methode met a jour la puissance du moteur depuis le parametre,
    // cependant, la puissance en parametre est controllée, si elle est en dessous de, ou égale a 1000,
    // bah elle va etre mise a 1000,

    //mais le code est bizarre! regarde:  this.puissance = (puissace <= 1000 ? 1000 : puissance);
    // qu'est ce que ça veut dire?

    // et bien on aurait aussi pu l'écrire de la sorte:

    /*
        if (puissance <= 1000)
        {
            this.puissance = 1000;
        }
        else
        {
            this.puissance = puissance;
        }

    */

    // en fait, il s'agit d'un "ternaire", c'est une abréviation pour ce que j'ai écrit au dessus,
    // comme ça on va plus vite plutot que d'écrire plein de truc ça tiens en une seule ligne de code.

    // this.puissance = (puissace <= 1000 ? 1000 : puissance); // bien plus pratique non?

    public void setPuissance(int puissance) { // set je vais ecire a present dans ce cahier
        this.puissance = (puissance<=1000? 1000 : puissance); // ici this selectionne une puissance a partir du moteur

        /* si la condition est vrai ( inferieur ou egale a mille ca sera mille)*/
    }

//  une methode publique qui retourne un caractere seul,
//
    public char getCarburant() { // le bonhomme demande l'acces au carburant puis
        return carburant; // demande l'acces et le recupere
    }

// une methode publique qui retourne void (donc rien), et qui met a jour le caractere  this.carburant
// si le carburant en parametre est différent de 'E', et différent de 'D', bah on met 'E', sinon on met la valeur en parametre.

// en gros c'est pour etre sur d'accepter seulement un 'E' ou un 'D'
    public void setCarburant(char carburant) { // il renvoi rien
        this.carburant = (carburant != 'E' && carburant != 'D' ? 'E': carburant);
        // si le carburant est different de grand e et grand b sinon la valeur est acceptable
        // != signifie different
    }

    //CONSTRUCTEURS

    // le constructeur par défaut de la classe moteur
    // il met des valeurs par défaut a carburant et puissance.
    public Moteur() {
        setCarburant('E');
        setPuissance(1000);
    }

    // un constructeur supplémentaire, qui prend en parametre de quoi initialiser puissance et carburant,
    // d'une manière personnalisée.
    public Moteur(int puissance, char carburant) { // dans les parentheses nous avons les arguments
        this.setPuissance(puissance);
        this.setCarburant(carburant);
    }

    /// redefinir toString

    // ici on force java a executer cette methode quand on appel uneInstanceDeMoteur.toString();
    // plutot que ce que java ferait par défaut.
    // et on retourne une belle chaine de charactere décrivant bien le moteur.
    @java.lang.Override
    public java.lang.String toString() {
        return "Moteur{" +
                "puissance=" + puissance +
                ", carburant=" + carburant +
                '}';


    }
    //test unitaire

//  ici c'est l'entrée du progamme, donc on va pouvoir par exemple faire des tests,
//  et quelques instances de la classe Moteur pour s'amuser.
    public static void main(String[] args) {
            // ces instanciations utilisent le constructeur supplémentaire qui prend des parametres pour puissance et carburant.
            // mais on pourrait faire un moteur en appelant le constructeur par défaut, sans le personnaliser:
            // Moteur m3 = new Moteur();

            // et pourquoi pas ensuite mettre a jour la puissance sois meme par exemple:
            // m3.setPuissance(150000);  // oulala ce moteur est très puissant!

                Moteur m1 = new Moteur( 1200,'D');
                Moteur m2 = new Moteur( 1600,'F');
                // ici pour récuperer la puissance j'ai tapé la valeur et virgule
                // ici pour récuperer carburant j'ai entré la valeur 'D' et virgule


    }
}