J'ai récemment passé l'examen JavaBronze SE 7/8. Je présenterai les problèmes qui me préoccupaient personnellement pendant mes études.
public class Q1 {
public static void main(String[] args) {
char chr = 65;
int num = 'A';
Q1 q1 = new Q1();
q1.func1(chr, num);
}
void func1(char chr, int num) {
System.out.println("chr:" + chr);
System.out.println("num:" + num);
}
}
Les types primitifs int et char sont compatibles et permettent une conversion implicite. Lorsque vous affectez le type int à une variable de type char, le caractère correspondant à la table de codes ASCII est affecté. Inversement, si vous affectez le type char à une variable de type int, le nombre décimal correspondant à ce caractère sera attribué.
public class Q2 {
public static void main(String[] args) {
int num = 1;
System.out.print(++num + num++ + --num + num--);
}
}
A.4
B.6
C.7
D.8
++ num est calculé comme 2, num ++ est calculé comme 2, --num est calculé comme 2 et num-- est calculé comme 2, pour un total de 8. Il convient de noter que num ++ est calculé comme 2 puis incrémenté à 3 Peu de temps après, il est sur le point d'être décrémenté de --num à 2. Si la même variable est sur le côté droit, les opérateurs d'incrémentation et de décrémentation postfixés refléteront le traitement de cette variable.
public class Q3 {
public static void main(String[] args) {
char[] chr = { 'A', 'B', 'C' };
while (true)
for (int i = 0; i <= chr.length; i++)
System.out.println(chr[i]);
}
}
Une boucle infinie se produit dans l'instruction while et une erreur d'exécution (ArrayIndexOutOfBoundsException) se produit dans l'instruction for. Toutefois, lorsqu'une erreur d'exécution se produit dans l'instruction for, même si elle est au milieu du traitement en cours Le processus est arrêté à mi-chemin et est généré comme une erreur d'exécution. Si ceux-ci se produisent en même temps, la possibilité qu'ils se produisent dans l'ordre suivant sera déterminée.
class Super {
static void func(String str) {
}
}
class Sub extends Super {
String str;
void func(String str) {
this.str = str;
}
void print() {
System.out.println(str);
}
}
public class Q4 {
public static void main(String[] args) {
Sub sub = new Sub();
sub.func("Hello World");
sub.print();
}
}
La méthode func de la classe Super a été remplacée par la méthode func de la classe Sub, mais comme elle est qualifiée statiquement, une erreur de compilation se produira. Il est important de noter que le problème est que vous ne remarquez pas l'erreur lorsque vous tracez la méthode principale. Nous devons nous concentrer sur les méthodes liées aux remplacements de superclasses et de sous-classes, et non sur le traitement de la méthode principale.
class Super {
void print() {
System.out.println("Hello World");
}
}
class Sub extends Super {
}
public class Q5 {
public static void main(String[] args) {
Sub sub;
Super spr;
sub = new Sub();
spr = sub;
sub = spr;
sub.print();
}
}
Aucune erreur ne se produit sur la ligne spr = sub; qui affecte le type de sous-classe → type de superclasse.
Une erreur de compilation se produit sur la ligne sub = spr; qui affecte le type de superclasse → type de sous-classe.
Pour les types de données de base, une conversion explicite est requise lors de l'affectation d'une grande variable à une petite variable.
Exemple)
double double_01 = 100.0;
int int_01 = double_01; //Distribution implicite(Erreur se produit)
int int_01 = (int)double_01; //Distribution explicite(Aucune erreur ne se produit)
Ensuite, dans le cas d'un type de classe, une erreur ne se produit-elle pas même si elle est affectée à un type de sous-classe qui est un type grand (super classe + classe de différence) → une super classe qui est un petit type (super classe uniquement), et vice versa?
La raison en est que le compilateur vérifie la compilation de la compatibilité des types pour déterminer s'il s'agit d'une erreur. Dans le cas des données de base, la compatibilité est jugée par la taille du type, mais dans le cas du type de classe, elle est jugée en regardant le contenu de la classe.
La sous-classe dit de quelle superclasse elle hérite, mais la superclasse ne dit pas de quelle sous-classe elle hérite.
Par conséquent, si vous affectez une superclasse à une sous-classe, vous n'obtiendrez pas d'erreur car vous connaissez la compatibilité, mais si vous affectez une sous-classe à une superclasse, vous ne connaîtrez pas la compatibilité, donc si vous ne la castez pas explicitement, vous obtiendrez une erreur de compilation. Ce sera.
Qu'as-tu pensé. C'est parfait pour la préparation aux examens! !! !! Peut-être \ _ (: 3 "∠) \ _
Recommended Posts