Malentendus courants et détails de Java

J'ai trouvé un livre intitulé "Java In-owned Analysis", qui implique de nombreux malentendus auxquels je ne prête généralement pas attention. Il ne peut pas être utilisé pendant le développement, mais ces concepts ne doivent pas être vagues. Le contenu du livre est toujours très utile, voici quelques notes récapitulatives.

1. En Java, il n'y a pas d'instruction goto. Étant donné qu'une utilisation intensive des instructions goto réduirait la lisibilité et la maintenabilité du programme, l'utilisation de goto a été annulée dans le langage Java. Dans le même temps, afin d'éviter la confusion causée par les programmeurs utilisant goto seuls, le langage Java définit toujours goto comme un mot-clé, mais ne définit aucune syntaxe, c'est pourquoi on l'appelle un « mot réservé ».

2, true, false et null sont affichés dans différentes couleurs dans l'EDI, mais ce ne sont pas des mots-clés, mais des "constantes littérales", tout comme abc de type String.

3. Essayez d'éviter d'utiliser $ lors de la définition des noms, car lorsque le compilateur compilera le fichier .java, il compilera "$" dans un connecteur entre le type supérieur et le type inférieur. Voir l'exemple suivant :

package com.laixintao.Test;   

public class Outer$Inner {   
    public static void main(String[] args) {   
        Outer o = new Outer();   
        Outer.Inner i = o.new Inner();   
        i.innerPrint();   
    }   
}   

class Outer {   
    class Inner {   
        void innerPrint() {   
            System.out.println("Inner Print!");   
        }   
    }   
}

Lors de la compilation (javac Test3.java) de ce code, le compilateur signalera l'erreur suivante : Test.java:12 : Erreur : Classe en double : com.laixintao.Test . Outer.Inner class Inner{ ^

4. Les caractères d'échappement Unicode sont traités très tôt, avant le programme d'analyse. Par exemple :

// char c1 = 'u00a';   
// char c2 = 'u00d';

Lorsque ces deux lignes de code apparaissent dans le programme, une erreur de compilation est signalée. Ces deux codes Unicode représentent respectivement le « saut de ligne » et le « retour chariot », donc lorsque le compilateur compile, le code ressemble à ceci :

// char c1 = '   
';   
// char c2 = '   
';

5. Le code Unicode utilise des caractères 16 bits Encodage est représenté par le type char en Java. Désormais, Unicode a été étendu à un million de caractères, et ceux dépassant la limite de 16 bits deviennent des caractères supplémentaires. Tous les caractères supplémentaires ne peuvent pas être représentés par des constantes de caractères.

6. Lorsque short, byte et char participent à l'opération, le résultat est de type int, pas le même que le type supérieur. Si une variable est de type byte, short ou byte et qu'une constante de compilation lui est affectée et que la constante ne dépasse pas la plage de valeurs de la variable, le compilateur peut effectuer une conversion de contraction implicite. Cette conversion de retrait implicite est sûre car elle s'applique uniquement aux affectations de variables et non aux instructions d'appel de méthode, c'est-à-dire qu'elle ne s'applique pas au passage de paramètres lors de l'appel de méthodes. (Voir les problèmes mineurs avec la conversion de type par défaut en Java pour plus de détails)

7. Faites attention au type char, qui est un type non signé. Par conséquent, la conversion entre char et short ou char et byte doit explicitement utiliser la conversion de type. La conversion d'octet en char est une conversion d'expansion et de contraction. Cette conversion est assez spéciale, c'est-à-dire que l'octet est d'abord développé et converti en int, puis contracté en char.

8. Dans la conversion d'expansion entre des données entières, si l'opérande est de type char (type non signé), une extension non signée est effectuée et le bit d'extension est 0. Si l'opérande est octet, court ou int (signé type), l'extension du signe est effectuée et le bit d'extension est le bit de signe de la variable.

9. La conversion de contraction entre les données entières tronque et supprime uniquement les bits de poids fort sans aucun autre traitement.

10, 0.1 0.2 n'est pas égal à 0.3.System.out.println((double)0.1 (double)0.2); Le résultat de sortie de cette instruction est 0.30000000000000004. Étant donné que les ordinateurs utilisent le binaire pour stocker des données et que de nombreuses décimales ne peuvent pas être représentées avec précision en utilisant le binaire (en fait, la plupart des décimales sont approximatives), tout comme l'utilisation de décimales, les décimales ne peuvent pas représenter avec précision des fractions comme 1/3 . La plupart des types à virgule flottante ne stockent leurs valeurs qu'approximativement dans l'ordinateur, pas aussi précisément que les entiers. Autre exemple, il s'agit d'une boucle infinie : for(float f = 10.1f;f != 11;f =0.1f){}

11. Le type float peut conserver 7 à 8 chiffres significatifs, tandis que le type float peut conserver 7 à 8 chiffres significatifs. type double Le type peut conserver 15 à 16 chiffres significatifs. Par conséquent, lorsque la valeur de type int ou de type long a plus de chiffres significatifs que le double ou le float, certains des bits les moins significatifs de la valeur seront perdus, entraînant une perte de précision. À ce stade, le mode d'arrondi le plus proche IEEE754 extrait la valeur à virgule flottante la plus proche de la valeur entière. Bien que la conversion d'un entier en virgule flottante soit une conversion étendue, lorsque la valeur numérique est très grande ou très petite (la valeur absolue est très grande), une certaine perte de précision se produira.

12. Comment calculer i j ? (Ce problème est abordé dans C/C) n'a pas beaucoup de sens, car C/C dépend de la structure matérielle de l'implémentation et les résultats seront différents selon les environnements. Cependant, en Java, ce résultat est corrigé et n'est pas affecté par l'environnement matériel et la plate-forme sur laquelle il s'exécute) Réponse : selon la règle gloutonne, le préfixe ++ est meilleur que le postfix ++, et le résultat est (i) +j

13. i et i sont en fait +1 d'abord, puis attribués. i, il n'y a rien à dire ; i, en prenant j=i comme exemple, l'implémentation sous-jacente est : temp = i;i = i 1; Donc, i=15;i=i; cette expression est 15. (Parce qu'une autre affectation est effectuée après en avoir ajouté une, passant de 16 à 15)

14. Les bits de signe 0 et -0 dans le stockage des variables de type virgule flottante sont différents. Lorsque -0 et 0 participent à des opérations liées au type à virgule flottante (telles que les opérations de division et de reste), différents résultats peuvent être produits.

15. Les opérations de division et de reste d'une virgule flottante sont différentes des opérations de division et de reste d'entiers. Lorsque le diviseur est 0, les opérations en virgule flottante ne généreront pas d'ArithmeticException.

16. La classe String est une classe non mutable. Une fois son objet créé, il ne peut pas être détruit. Les méthodes de la classe String qui semblent modifier les séquences de caractères renvoient en réalité des objets String nouvellement créés au lieu de modifier l'objet lui-même.

17. L'objet String étant immuable, il est thread-safe et peut être librement partagé.

18 Au sein de la classe String, un tableau de caractères (char[]) est utilisé pour conserver la séquence de caractères. La longueur maximale de String est la longueur maximale du tableau de caractères. Théoriquement, la longueur maximale est la valeur maximale du type int, qui est 2147483647. En pratique, la valeur maximale pouvant généralement être obtenue est inférieure à la valeur maximale théorique. .

19. La méthode main() est fondamentalement la même que les autres méthodes en termes de comportement en termes de performances. Elle peut être surchargée, appelée par d'autres méthodes, héritée, masquée et peut également lever des exceptions avec des paramètres de type. On peut également appeler la méthode main (ou d'autres méthodes) par réflexion dans un programme.

20. Lorsque deux méthodes ou plus ont le même nom mais des listes de paramètres différentes, ces méthodes constituent une surcharge. Les méthodes surchargées peuvent être distinguées en fonction du type correspondant à la liste de paramètres et du nombre de paramètres. Cependant, le nom du paramètre, le type de retour de la méthode, la liste d'exceptions de la méthode et les paramètres de type ne peuvent pas être utilisés comme tels. conditions permettant de distinguer les méthodes surchargées.

21. Quelle méthode appeler, l'ordre est le suivant :

Dans la première étape, le boxing automatique (unboxing) et les paramètres variables ne sont pas pris en compte, et le type de paramètre formel correspondant est recherché Les méthodes qui peuvent correspondre au type de paramètre réel et le nombre de paramètres formels est le même que le nombre de paramètres réels

S'il n'y a pas de méthode qualifiée à la première étape, dans la deuxième phase, le boxing et le unboxing automatiques seront effectués ; être exécuté.

S'il n'y a pas de méthode qualifiée à l'étape 2, dans la troisième étape, la méthode à paramètres variables sera considérée.

Si aucune méthode qualifiée n'est trouvée dans les trois étapes, une erreur de compilation se produira. S’il existe plusieurs façons de conditionner, la méthode la plus spécifique sera choisie. La définition de méthode la plus claire est la suivante : si le type de liste de paramètres formels correspondant de la méthode A peut être attribué au type de liste de paramètres formels de la méthode B, alors la méthode A est plus claire que la méthode B. Si la méthode la plus claire ne peut pas être sélectionnée, une erreur de compilation se produira.

22. La différence essentielle entre la réécriture et le masquage est la suivante : la réécriture est liée dynamiquement et la méthode d'appel des classes associées est déterminée en fonction du type réel de l'objet pointé. par le membre de référence d’exécution. Hidden est lié statiquement et les membres pertinents à appeler sont déterminés en fonction du type statique référencé au moment de la compilation. En d’autres termes, si une sous-classe remplace une méthode de classe parent, lorsque la référence de classe parent pointe vers l’objet de sous-classe, la méthode de sous-classe est appelée via la référence de classe parent. Si une sous-classe cache une méthode (variable membre) de la classe parent, la méthode (variable membre) de la classe parent est toujours appelée via une référence à la classe parent.

23. Le constructeur est appelé de manière récursive. Le constructeur de la sous-classe appellera le constructeur de la classe parent jusqu'à ce que le constructeur de la classe Object soit appelé.

24 Le constructeur ne crée pas d'objet. Le constructeur est appelé par le système lors de l'utilisation de new pour créer un objet et est utilisé pour initialiser les membres d'instance de la classe. En termes de séquence, l'objet est créé en premier puis le constructeur est appelé. (Le constructeur ne génère pas de nouvel objet)

25. Le constructeur par défaut n'est pas vide. Ce constructeur appellera le constructeur sans paramètre de la classe parent et pourra effectuer l'initialisation des variables membres de l'instance. Par conséquent, le constructeur par défaut appelle au moins le constructeur de la classe parent, et il peut effectuer plus de travail, y compris l'initialisation de la déclaration des variables d'instance et le bloc d'initialisation de l'instance, qui sont tous exécutés dans le constructeur.

26 Lorsque l'un des deux opérandes de l'opérateur == ou != est un type de données de base et que l'autre est un type de référence de classe wrapper, déballez le type de référence et convertissez-le en type de données de base, et puis comparez si les valeurs de deux types de données de base sont égales.

27. En Java, les tableaux sont aussi des classes, et les variables de référence déclarées dans le tableau pointent vers des objets de type tableau. Tous les tableaux héritent de la classe Object et implémentent les interfaces java.lang.Cloneable et java.io.Serializing. Les membres du tableau incluent la longueur variable (qui existe implicitement) et les membres hérités de la classe Object. Cloneable et Serialisable sont deux interfaces marquées qui ne déclarent explicitement aucun membre.

28. L'interface est une conception complètement abstraite et ne peut pas être instanciée. L'utilisation du type d'excuse créé par A à l'aide de la nouvelle méthode crée en fait une classe anonyme qui implémente le type d'interface.

29. Si deux interfaces déclarent la même variable x, alors lorsqu'une interface hérite des deux interfaces en même temps, ou qu'une classe implémente les deux interfaces en même temps, une erreur de compilation se produira via un simple accès au nom.

30. Si deux interfaces déclarent des méthodes m avec le même nom et que les deux méthodes ne constituent pas une surcharge, alors lorsqu'une interface peut hériter des deux interfaces en même temps, ou qu'une classe peut hériter des deux interfaces, il y a doit être une signature de méthode telle que la signature soit une sous-signature de deux m signatures de méthode en même temps, et dans le type de retour de la méthode, il doit y avoir un type tel que le type soit le type de retour des deux m méthodes en même temps type remplaçable.

Ce qui précède sont les malentendus et les détails courants de Java. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !