Licence d'informatique |
Programmation objet et Java
|
public void show() {
if (this == null)
System.out.println("vide");
else
System.out.println("plein");
}(a) la méthode ne compile pas;
(b) elle compile mais lève une NullPointerException;
(c) elle affiche vide si l'objet appelant est nul;
(d) elle n'affiche jamais vide.
class Test {
public static void main(String[] args) {
for (int i = 0; i < args.length; i++)
System.out.print(args[i] + " ");
}
}class MainTest {
public static void main(String[] args) {
String[] a = {"Bonjour", "monde" };
Test.main(a);
System.out.println(".");
}
}(a) il ne compile pas parce que main est un mot réservé;
(b) il compile mais java MainTest lève une ClassNotFoundException;
(c) java MainTest provoque l'affichage de Bonjour, monde .
(d) java MainTest provoque l'affichage d'un point seulement.
Item b = new ItemB();
essai(b);
(a) ne compile pas,
(b) compile mais lève une exception,
(d) exécute la méthode essai(ItemB b).
Chien c = new ChienDeChasse();
boolean x = c instanceof Animal;
boolean y = c instanceof ChienDeChasse;
(a) true et true ;
(b) true et false;
(c) false et true ;
(d) false et false.
interface Animal {
void mord(Gardien g);
}
class Chien implements Animal {
public void mord(Gardien g) {
System.out.println(this + " ne mord pas " + g);
}
}
class ChienDeChasse extends Chien {
public void mord(Gardien g) {
System.out.println(this + " mord " + g);
}
}
class Gardien {
void tatoue(Animal a) { a.mord(this); }
}class TestZoo {
public static void main(String[] args) {
Gardien g = new Gardien();
Animal a = new ChienDeChasse();
g.tatoue(a);
}
}(a) ne compile pas, parce que le type de la variable a dans le main est une interface,
(b) compile mais lève un exception parce que Animalest une interface,
(c) affiche une ligne semblable à ChienDeChasse@273d3c mord Gardien@256a7c
(d) affiche une ligne semblable à Chien@720eeb ne mord pas Gardien@256a7c.
class WrapperTest {
public static void main(String[] args) {
double d = 0;
String s = "chaine";
Double enveloppe;
try {
try {
enveloppe = Double.valueOf(s);
d = enveloppe.doubleValue();
}
catch(NumberFormatException e) {
System.out.println("Erreur");
throw e;
}
}
catch(NumberFormatException e) {
System.out.println("Incorrect");
}
}
}
(a) ne compile pas parce que des blocs try imbriqués ne sont pas autorisés;
(b) le programme affiche Erreur et Incorrect;
(c) ne compile pas parce que throw doit créer un nouvel objet exception;
(d) ne compile pas parce que les types des deux catch sont les mêmes;
(e) affiche seulement Erreur
(f) affiche seulement Incorrect
class Question57 {
public static void main(String[] args) {
UneClasse ref1 = new UneClasse(5);
UneClasse ref2 = new UneClasse(10);
ref1.getAndShow(ref2);
}
}
class UneClasse {
private int x;
UneClasse(int x) {
this.x = x;
}
void getAndShow(UneClasse ref) {
System.out.println(ref.x + " ");
}
}(a) ne compile pas.
(b) compile mais lève une exception.
(c) affiche 10.
(d) rien de tout ça.
public static void main(String[] args) {...}
(a) int num = args.length;
(b) int num = args.length - 1;
(c) int num = 0; while (args[num] != null) num++;
(d) int num = 0; while (!(args[num].equals(""))) num++;
class Base {
public void print(String s) { System.out.println("Base: " + s); }
}
class Dérivée extends Base {
public void print(String s) { System.out.println("Dérivée: " + s); }
public void bis() {
this.print("Un");
super.print("Deux");
}
public static void main(String[] args) {
Dérivée d = new Dérivée():
d.bis();
}
}
(a) Dérivée: Un sur une ligne et Base: Deux sur la ligne suivante
(b) Dérivée: Un sur une ligne et Dérivée: Deux sur la ligne suivante
(c) Base: Un sur une ligne et Dérivée: Deux sur la ligne suivante
(d) Base: Un sur une ligne et Base: Deux sur la ligne suivante
(e) rien de tout ça.
class Base {
private int num = 10;
public void print() { System.out.println(num); }
public void setNum(int j) { num = j; }
}
class Dérivée extends Base {
public void setNum(int j) { num = j + 10; }public static void main(String[] args) {
Dérivée d = new Dérivée();
d.setNum(20);
d.print();
}
}
(a) Ne compile pas
(b) Compile mais lève une exception à l'exécution
(c) Affiche 10
(d) Affiche 20
(e) Affiche 30.