Vérifiez vos connaissances

Vous écrivez une classe Personne, puis vous exécutez trois fois new Personne(...). Que représente cette situation ?

Après Personne p = new Personne();, que contient la variable p ?

Que vaut a.prenom à la fin de ce programme ?

public class MainClass {
    public static void main(String[] args) {
        Personne a = new Personne();
        a.prenom = "Amine";
        Personne b = a;
        b.prenom = "Sara";
        System.out.println(a.prenom);
    }
}

Ici, a et b sont créés par deux new. Que se passe-t-il si l’on change ensuite b.nom ?

public class MainClass {
    public static void main(String[] args) {
        Personne a = new Personne();
        Personne b = new Personne();
        a.nom = "Alaoui";
        b.nom = "Benjelloun";
    }
}

Une classe Personne déclare int age. Vous créez Youssef (25 ans) et Fatima (30 ans). Combien de copies de l’attribut age existent ?

La méthode afficher() est une méthode d’instance de Personne. Quel appel est cohérent avec le chapitre ?

Que vaut a après l’appel ?

public class MainClass {
    static void essayerDeChanger(int age) {
        age = 30;
    }

    public static void main(String[] args) {
        int a = 22;
        essayerDeChanger(a);
        System.out.println(a);
    }
}

Qu’affiche ce programme ?

public class MainClass {
    static void changerAge(Personne p) {
        p.age = 30;
    }

    public static void main(String[] args) {
        Personne amine = new Personne();
        amine.age = 22;
        changerAge(amine);
        System.out.println(amine.age);
    }
}

Dans setAge, this.age = age; signifie :

On appelle p.setAge(22) alors que p.age valait 0. Que devient l’attribut age ?

public class Personne {
    int age;

    void setAge(int age) {
        age = age;
    }
}

Laquelle de ces déclarations est un constructeur de Personne ?

Aucun constructeur n’est écrit dans Personne. Que se passe-t-il avec new Personne() ?

Vous ajoutez uniquement public Personne(String nom, String prenom, int age). Quelle affirmation est exacte ?

La classe a deux constructeurs : (String, String) qui met l’âge à 0, et (String, String, int). Quel constructeur est choisi par cet appel ?

public class MainClass {
    public static void main(String[] args) {
        Personne p = new Personne("Alaoui", "Youssef", 25);
    }
}

Ce constructeur ne compile pas. Pourquoi ?

public class Personne {
    private String nom;
    private String prenom;
    private int age;

    public Personne(String nom) {
        this.nom = nom;
        this(nom, "Inconnu", 0);
    }

    public Personne(String nom, String prenom, int age) {
        this.nom = nom;
        this.prenom = prenom;
        this.age = age;
    }
}

Que valent le nom et l’âge d’un étudiant créé avec new Etudiant() ?

public class Etudiant {
    private String nom;
    private int age;

    public Etudiant(String nom, int age) {
        this.nom = nom;
        this.age = age;
    }

    public Etudiant() {
        this("Inconnu", 18);
    }
}

age est private dans Personne. Dans MainClass, que donne p.age = -5; ?

Un attribut est déclaré sans mot-clé devant son type (String codeInterne;). Qui peut l’utiliser ?

Vous voulez qu’une méthode soit appelable depuis n’importe quelle autre classe. Quel niveau d’accès choisissez-vous ?

Le setter refuse un âge négatif et ne change pas l’attribut. Au départ, getAge() vaut 22. Que vaut-il après setAge(-1) ?

public class Personne {
    private int age;

    public void setAge(int age) {
        if (age < 0) {
            System.err.println("Âge négatif");
            return;
        }
        this.age = age;
    }
}

L’attribut booléen s’appelle actif. Quelle méthode de lecture suit la convention du chapitre ?

Pourquoi rendre un attribut private et passer par un setter ?

Chaque constructeur fait compteur++, et compteur est static. Qu’affiche le programme ?

public class MainClass {
    public static void main(String[] args) {
        Personne a = new Personne("Tazi", "Amine", 22);
        Personne b = new Personne("Idrissi", "Sara", 20);
        System.out.println(Personne.getCompteur());
    }
}

Dans la même classe, nombreInstances est static. Après trois new, combien de compteurs existent en mémoire ?

Laquelle de ces méthodes ne compile pas ?

Pourquoi main est-elle static ?

Quelle déclaration correspond à une constante de classe, telle que le chapitre la présente ?

Une méthode d’instance afficher() peut utiliser :

Quel est le résultat de ce programme ?

public class MainClass {
    public static void main(String[] args) {
        Personne p = null;
        p.afficher();
    }
}

Pourquoi liste[0].setNom("Tazi") provoque une NullPointerException ?

public class MainClass {
    public static void main(String[] args) {
        Personne[] liste = new Personne[5];
        liste[0].setNom("Tazi");
    }
}

Quelle suite permet d’écrire dans la case 0 sans NullPointerException ?

Qu’affiche a.getAge() ?

public class MainClass {
    public static void main(String[] args) {
        Personne a = new Personne("Tazi", "Amine", 22);
        Personne b = a;
        b.setAge(23);
        System.out.println(a.getAge());
    }
}

Sara est copiée dans un nouvel objet, puis l’âge de b passe à 21. Que vaut a.getAge() ?

public class MainClass {
    public static void main(String[] args) {
        Personne a = new Personne("Idrissi", "Sara", 20);
        Personne b = new Personne(a.getNom(), a.getPrenom(), a.getAge());
        b.setAge(21);
        System.out.println(a.getAge());
    }
}

Dans l’exemple du cours, Voiture fait this.moteur = new Moteur(puissance) dans son constructeur. De quelle relation s’agit-il ?

Youssef existe. Fatima existe déjà. Youssef fait setContact(fatima). Quelle relation le cours décrit-il ?

Vous avez redéfini toString() pour afficher le prénom, le nom et l’âge. Que se passe-t-il avec System.out.println(p) ?

equals n’est pas redéfinie. Deux personnes distinctes ont le même nom, le même prénom et le même âge. Que vaut a.equals(b) ?

equals compare le nom, le prénom et l’âge, pas l’adresse. Youssef à Rabat et Youssef à Fès ont les mêmes nom, prénom et âge. Quels résultats obtenez-vous ?

Vous voulez savoir si deux variables désignent exactement le même objet en mémoire. Qu’utilisez-vous ?

Vous redéfinissez equals. Quelle obligation rappelle le chapitre à propos de hashCode ?

Deux objets ont le même hashCode. Que pouvez-vous en conclure ?

Pourquoi new Statut("Stagiaire") n’est-il pas la façon de créer une valeur d’enum ?

Qu’affiche Statut.SALARIE.description() ?

public enum Statut {
    SALARIE("Salarié");

    private final String libelle;

    Statut(String libelle) {
        this.libelle = libelle;
    }

    public String description() {
        return name() + " → " + libelle;
    }
}

Par rapport à un enum du chapitre 1 (simple liste de constantes), qu’apporte un enum « avancé » ?

compteur est incrémenté seulement dans le constructeur. On exécute Personne b = a; (sans new). Que devient le compteur ?

Ce programme appelle afficher seulement si p n’est pas null. Avec p valant null, que se passe-t-il ?

public class MainClass {
    public static void main(String[] args) {
        Personne p = null;
        if (p != null) {
            p.afficher();
        }
    }
}

La seule déclaration écrite dans une classe encore sans constructeur est public void Personne() { }. Que produit new Personne() ?

Un attribut d’instance int age n’est pas initialisé dans la classe ni dans le constructeur. Quelle est sa valeur juste après new ?

Vous écrivez AGE_MAJORITE = 21; plus loin, alors que le champ est public static final int AGE_MAJORITE = 18;. Que se passe-t-il ?