QCM sur Java avec des réponses pour la préparation des entretiens d’embauche, des tests en ligne, aux examens et aux certifications. Ces questions et réponses sur Java comprennent divers sujets. Et sont tirés d’un vrai entretien écrit et certaines parties sont en direct. Cette méthode d’apprentissage systématique préparera facilement toute personne pour réussir son test sur Java .
1. Laquelle de ces conditions est-elle nécessaire pour la conversion automatique de type en Java?
A Le type de destination est plus petit que le type source
B Le type de destination est plus grand que le type source
C Le type de destination peut être plus grand ou plus petit que le type source
D Aucun de ces réponses
B
La conversion de type automatique en Java a lieu lorsque :
Les deux types de données sont compatibles.
Lorsque nous assignons la valeur d’un plus petit type de données(par exemple: byte) à un plus grand type de données(par exemple: double).
Par exemple, en Java, les types de données numériques(int, float, double, etc) sont compatibles entre eux, mais aucune conversion automatique n’est prise en charge du type numérique au type ‘char’ ou ‘boolean’. Pareil, les types ‘char’ et ‘boolean’ ne sont pas compatibles entre eux.
Exemple:
class Conversion
{
public static void main(String[] args)
{
int i = 50;
// conversion automatique de type (int -> long)
long l = i;
// conversion automatique de type (long -> float)
float f = l;
System.out.println("Convertir en Int: "+i);
System.out.println("Convertir en Long: "+l);
System.out.println("Convertir en Float: "+f);
}
}
Sortie:
Convertir en Int: 50
Convertir en Long: 50
Convertir en Float: 50.0
2. Quel sera le constructeur de la classe Prototype par défaut?
public class Prototype { }
A Prototype( )
B public prototype(void)
C prototype(void)
D prototype( )
A
Un constructeur par défaut est un constructeur créé par le compilateur si nous ne définissons pas de constructeur(s) pour une classe. Voici un exemple :
public class Prototype {
int N;
public static void main(String args[]){
System.out.println(new Prototype().N);
}
}
Si vous compilez et exécutez le programme ci-dessus, le constructeur par défaut initialise la variable entière N avec 0 et, vous obtiendrez 0 comme résultat.
Voici à quoi ressemblera le code ci-dessus lorsque le compilateur commencera à faire son job :
public class Prototype {
int N;
/* Constructeur vide créé par le compilateur.
Ce constructeur ne sera pas vu dans votre code. */
Prototype() {
}
public static void main(String args[]){
System.out.println(new Prototype().N);
}
}
A La variable « a » ne peut pas contenir la valeur 180(limitée par sa portée).
B L’opérateur * converti « a * 90 » en « int », qui ne peut pas être converti en « byte » sans conversion.
C La variable « a » ne peut pas contenir la valeur 90.
D Aucune erreur dans ce code
B
Lors de l’évaluation d’une expression contenant « int, bytes ou shorts », l’expression est convertie en « int » puis évaluée, et le résultat est également de type « int ».
4. Si une expression contient « double, int, float ou long », alors le résultat de l’expression sera dans lequel de ces types de données?
A float
B double
C int
D long
B
Si un opérande de type double, le résultat de l’expression sera de type double.
Voici un exemple : double meters = totalMeters * 5.63; Dans l’expression à droite, totalMeters est un int , alors que le littéral 5.63 est un double. Cela déclenche une conversion automatique, qui dit que le résultat de totalMètres * 5,63 doit être un double.
Truncate c’est de raccourcir ou couper une partie de quelque chose. En Java, le terme est souvent utilisé en référence à des types de données ou à des variables, telles que des nombres à virgule flottante et des strings. Par exemple, une fonction peut tronquer la partie décimale d’un nombre à virgule flottante pour en faire un entier. Par exemple :
L’opérateur ++ incrémente la valeur du caractère de 1. char1 et char2 reçoivent les valeurs D et 84, lorsque nous utilisons l’opérateur ++ leurs valeurs sont incrémentées de 1 donc char1 et char2 deviennent E et U respectivement. La sortie est comme suivante:
$ javac char_inc.java
$ java char_inc
E U
La raison est que chaque fois que nous stockons un caractère dans un type de données char, celui-ci contient la valeur ascii de ce caractère. La valeur ascii de A est 65, B est 66, C est 67, D est 68, E est 69, et ainsi de suite.
class conversion
{
public static void main(String args[])
{
double x = 295.04;
int y = 300;
byte z = (byte) x;
byte w = (byte) y;
System.out.println(z + " " + w);
}
}
A 295.04 300
B 295 300
C 39 44
D 38 43
D
La conversion d’une variable plus grande en une variable plus petite produit un modulo. la variable y contient 300 qui est plus grand que l’intervalle de byte i: e -128 à 127 donc la variable d contient 300 % 256 i: e 44. La sortie est comme suivante:
class sayHello
{
public void main( String[] args )
{
System.out.println( "Hello" + args[0] );
}
}
A Hello world
B Hello
C Hello sayHello
D Erreur d’exécution
D
Une erreur d’exécution se produira si la méthode principale n’est pas déclarée statique. La sortie est comme suivante:
$ javac sayHello.java
Exception in thread “main” java.lang.NoSuchMethodError: main
9. Quelle est la sortie de ce programme?
class main_arg
{
public static void main(String [] args)
{
String [][] arg = new String[2][2];
int a;
arg[0] = args;
a = arg[0].length;
for (int b = 0; b < a; b++)
System.out.print(" " + arg[0][b]);
}
}
Si on l’exécute avec la commande suivante:
$ javac main_arg.java
$ java main_arg 1 2 3
A 1 2 3
B 1 0 3
C 1 0
D 1 1
A
La sortie est comme suivante:
$ javac main_arg.java
$ java main_arg 1 2 3
1 2 3
Les arguments de ligne de commande en Java sont utilisés pour passer des arguments au programme main(). Si vous regardez la syntaxe de la méthode main(), elle accepte un tableau de type String (String [] args) comme argument. Lorsque nous transmettons des arguments de ligne de commande, ils sont considérés comme des Strings et sont transmis à la fonction main() dans le tableau de type String (String [] args). Les arguments doivent être transmis sous forme de valeurs séparées par des espaces. Nous pouvons passer des chaînes de caractères et des types de données primitifs comme arguments de ligne de commande. Les arguments seront convertis en strings et transmis à la méthode principale dans l’argument (String [] args).
class X
{
final public int calculate(int x, int y) { return 1; }
}
class Y extends X
{
public int calculate(int x, int y) { return 2; }
}
public class output
{
public static void main(String args[])
{
y object = new Y();
System.out.print("y est " + y.calculate(0, 1));
}
}
A y est: 2
B y est: 1
C Erreur de compilation.
D Une exception est levée lors de l’exécution
C
Le code ne se compile pas car la méthode « calculate () » dans la classe X est « final » et ne peut donc pas être surchargée par la méthode de la classe Y.