Question 1

étant donné la classe suivante

                                    class DevInfo {
                                        //..code
                                    }
                            

Laquelle des options suivantes compilera?

AB
                                                        package java.dev.info;

                                                        class Learn {
                                                            DevInfo devinfo = new DevInfo();
                                                        }                                                        
                                                
                                                        package java.dev;

                                                        import DevInfo;
                                                        
                                                        class Learn {
                                                            DevInfo devinfo;
                                                        }
                                                
CD
                                                            package java.dev.*;
                                                            import java.default.*;

                                                            class Learn {
                                                                DevInfo devinfo;
                                                            }
                                                    
                                                            package java.dev.info;
                                                            import default.*;
                                                            
                                                            class Learn {
                                                                default.DevInfo devinfo;
                                                            }
                                                    

  • A
  • B
  • C
  • D
  • Aucune des options ci-dessus

Une classe qui n’est pas définie dans un package est implicitement définie dans le package par défaut de Java. Mais ces classes ne peuvent pas être accédées par des classes ou des interfaces, qui sont explicitement définies dans un package. (Réponse 5)

Question 2

La liste numérotée suivante de composants de classe Java ne se trouve dans aucun ordre particulier. Sélectionnez l'ordre acceptable de leur occurrence dans n'importe quelle classe Java (choisissez toutes les réponses qui s'appliquent):

  1. Commentaires
  2. Instruction import
  3. Instruction package
  4. Méthodes
  5. Déclaration de classe
  6. Variables

  • 1,3,2,5,6,4
  • 3,1,2,5,4,6
  • 3,2,1,4,5,6
  • 3,2,1,5,6,4

Les commentaires peuvent apparaître n'importe où dans une classe. Ils peuvent apparaître avant et après les instructions de package et d'importation. Ils peuvent apparaître avant ou après une déclaration de classe, de méthode ou de variable.

La première instruction (si présente) d'une classe doit être une instruction de package. Il ne peut pas être placé après une instruction d'importation ou une déclaration de classe.

L'instruction d'importation doit suivre une instruction de package et être suivie d'une déclaration de classe.

La déclaration de classe suit les instructions d'importation, si présentes. Il est suivi de la déclaration des méthodes et des variables.

(Responses 1, 2 et 4)

Question 3

Lequel des exemples suivants définit une structure de classe Java correcte?

ABC
                                                    #connect java compiler; 
                                                    #connect java virtual machine; 
                                                    class DevInfo {}
                                                
                                                    package java compiler; 
                                                    import java virtual machine; 
                                                    class DevInfo {} 
                                                
                                                    import javavirtualmachine.*; 
                                                    package javacompiler;
                                                    class DevInfo {
                                                        void methode1() {}
                                                        int compteur; 
                                                    }
                                                
DEF
                                                    package javacompiler; 
                                                    import javavirtualmachine.*; 
                                                    class DevInfo {
                                                        void methode1() {}
                                                        int compteur; 
                                                    }
                                                
                                                    #package javacompiler; 
                                                    $import javavirtualmachine; 
                                                    class DevInfo {
                                                        void method1() {}
                                                        int count; 
                                                    }
                                                
                                                    package javacompiler; 
                                                    import javavirtualmachine; 
                                                    Class DevInfo {
                                                        void method1() {}
                                                        int count; 
                                                    }
                                                

  • A
  • B
  • C
  • D
  • E
  • F

L’option 1 est incorrecte car #connect n’est pas une instruction en Java. # est utilisé pour ajouter des commentaires sous UNIX.

L’option 2 est incorrecte car un nom de package (compilateur Java) ne peut pas contenir d’espace. En outre, la machine virtuelle java n’est pas un nom de package valide à importer dans une classe. Le nom du paquet à importer ne peut pas contenir d'espaces.

L'option 3 est incorrecte car une instruction de package (si présente) doit être placée avant une instruction d'importation.

L'option 5 est incorrecte. #package et $ import ne sont pas des instructions ou directives valides en Java.

L'option 6 est incorrecte. Java étant sensible à la casse, le mot class n'est pas identique au mot class. Le mot clé correct pour définir une classe est classe.

(Réponse 4)

Question 4

Étant donné le contenu du fichier source Java MyClass.java,sélectionnez les options appropriées:

                                // Fichier source MyClass.java
                                package com.dev.info;
                                import java.util.Date;
                                class Etudiant {}
                                class Cours {}
                            

  • La classe importée, java.util.Date, est accessible uniquement dans la classe Etudiant.
  • La classe importée, java.util.Date, est accessible à la fois aux classes Etudiant et Cours.
  • Les classes Etudiant et Cours sont définies dans le package com.dev.info.
  • Seule la classe Etudiant est définie dans le package com.dev.info. La classe Cours est définie dans le package Java par défaut.

(Réponse 2 et 3)

Vous pouvez définir plusieurs classes, interfaces et énumérations dans un fichier de code source Java.

L'option 1 est incorrecte. L'instruction d'importation s'applique à toutes les classes, interfaces et énumérations définies dans le même fichier de code source Java.

L'option 4 est incorrecte. Si une instruction de package est définie dans le fichier de code source, toutes les classes, interfaces et énumérations définies dans celui-ci existeront dans le même package Java.

 

Question 5

Étant donné la classe DevInfo,

                                class DevInfo {
                                    public static void main(String[] args) {
                                        System.out.println(args[1] + ":" + args[2] + ":" + args[3]);
                                    }
                                }
                            

Quelle est la sortie de DevInfo, si elle est exécutée en utilisant la commande suivante?

                                java DevInfo Maroc Tunisie Algerie Espagne
                            

  • Maroc:Tunisie:ALgerie
  • DevInfo:Maroc:Tunisie
  • java:DevInfo:Maroc
  • Tunisie:Algerie:Espagne

(Réponse 4)

Les arguments de ligne de commande transmis à la méthode principale d'une classe ne contiennent pas le mot Java et le nom de la classe.

L'argument de la méthode se voit attribuer les valeurs suivantes:

  • args[0] ->Maroc 
  • args[1] -> Tunisie 
  • args[2] -> Algerie 
  • args[3] -> Espagne

la sortie est Tunisie:Algerie:Espagne

Question 6

Laquelle des options suivantes, lorsqu’elle est insérée dans // INSERER LE CODE ICI, affichera "Hello From maghreb" ?

                                public class DevInfo {
                                    // INSERT CODE HERE
                                    {
                                        System.out.println("Hello From maghreb");
                                    }
                                }
                            

  • public void main (String[] args)
  • public void main(String args[])
  • static public void main (String[] array)
  • public static void main (String args)
  • static public main (String args[])

(Réponse 3)

La méthode main doit être définie en tant que méthode static et public et accepte un tableau de String en tant qu'argument de méthode.

Question 7

Que signifie "écrire une fois, exécuter n'importe où" ? Sélectionner les bonnes réponses:

  • Le code Java peut être écrit par un membre de l'équipe et exécuté par d'autres membres de l'équipe.
  • C'est à des fins de marketing seulement.
  • Il permet aux programmes Java d'être compilés une fois et peut être exécuté par n'importe quelle machine virtuelle Java sans recompilation.
  • L’ancien code Java n’a pas besoin de recompilation lors de la publication de nouvelles versions de JVM.

(Réponse 3)

L’indépendance de la plate-forme, ou «écrire une fois, exécuter n'importe où», permet au code Java d’être compilé une fois et exécuté sur n’importe quel système doté d’une machine virtuelle Java. Ce n'est pas à des fins de marketing seulement. 

Question 8

Examinez le code suivant:

                                class Cours {
                                    String nomCours;
                                }
                                class DevInfo {
                                    public static void main(String args[]) {
                                        Cours c = new Cours();
                                        c.nomCours = "Java";
                                        System.out.println(c.nomCours);
                                    } 
                                }
                            

Parmi les affirmations suivantes, laquelle sera vraie si la variable nomCours est définie en tant que variable privée (private)?

  • La classe DevInfo affichera Java.
  • La classe DevInfo affichera null.
  • La classe DevInfo ne sera pas compilée.
  • La classe DevInfo lève une exception lors de l'exécution.

(Réponse 3)

Si la variable nomCours est définie en tant que membre privé, elle ne sera pas accessible à partir de la classe DevInfo. Une tentative en ce sens entraînera un échec lors de la compilation. Comme le code ne sera pas compilé, il ne peut pas être exécuté.

Question 9

Étant donné le code suivant, sélectionnez les réponses correctes:

                                package com.dev.info.learn;
                                class Cours {
                                    public String nomCours;
                                    public void setNomCours(private String nom) {
                                        nomCours = nom;
                                    }
                                }
                            

  • Vous ne pouvez pas définir un argument de méthode en tant que variable privée.
  • Un argument de méthode doit être défini avec une accessibilité publique ou par défaut.
  • Pour les méthodes redéfinies, les arguments de méthode doivent être définis avec une accessibilité protégée.
  • Aucune de ces réponses.

(réponse 1)

Vous ne pouvez pas ajouter de mot clé d'accessibilité(private) explicite aux paramètres de méthode. Si vous le faites, le code ne sera pas compilé.



Partager ce quiz avec tes amis :