Essai de base de Java à huit pattes

https://zhuanlan.zhihu.com/p/516271873

1. Java huit types de données de base

6 types numériques :
- 4 types d'entiers : byte, short, int, long
- 2 types de virgule flottante : float, double
1 type de caractère : caractère
1 Type booléen : booléen.

2. La différence entre le type de base et le type d'emballage

Le type wrapper de la variable membre est null si aucune valeur ne lui est affectée, tandis que le type de base a une valeur par défaut et n'est pas null.
Les types wrapper peuvent être utilisés avec des génériques, les types primitifs ne le peuvent pas.
Les variables locales des types de données de base sont stockées dans la table des variables locales de la pile de la machine virtuelle Java, et les variables membres des types de données de base (non modifiées par statique) sont stockées dans le tas de la machine virtuelle Java. Les types wrapper sont des types d'objets et nous savons que presque toutes les instances d'objets existent dans le tas.
Les types de données primitifs occupent très peu d'espace par rapport aux types d'objets.

3. Quelle est la différence entre hashmap et treemap

TreeMap et HashMap héritent tous deux d'AbstractMap, mais il convient de noter que TreeMap implémente également l'interface NavigableMap et l'interface SortedMap.
L'implémentation de l'interface NavigableMap permet à TreeMap de rechercher des éléments dans la collection.
L'implémentation de l'interface SortedMap donne à TreeMap la possibilité de trier les éléments de la collection en fonction des clés. La valeur par défaut est de trier par clé dans l'ordre croissant, mais nous pouvons également spécifier un comparateur de tri.
En résumé, par rapport à HashMap, TreeMap a principalement la possibilité de trier les éléments de la collection selon les clés et la possibilité de rechercher des éléments dans la collection.

4. Quelle est la structure de données sous-jacente du treemap

L'implémentation sous-jacente du treemap est basée sur l'arbre rouge-noir, qui assure l'ordre des éléments dans le treemap grâce à l'auto-équilibrage de l'arbre rouge-noir, et prend en charge des opérations de recherche, d'insertion et de suppression efficaces.
Un arbre rouge-noir est un arbre de recherche binaire auto-équilibré, qui a les propriétés suivantes :

Chaque nœud est soit noir, soit rouge.
Le nœud racine est noir.
Chaque nœud feuille est un nœud vide noir (NIL).
Si un nœud est rouge, ses enfants doivent être noirs.
Pour chaque nœud, tous les chemins du nœud à ses descendants contiennent le même nombre de nœuds noirs.

L'arbre rouge-noir garantit que la complexité temporelle des opérations de recherche, d'insertion et de suppression est O(log n) en maintenant ces propriétés.

5. Plusieurs façons de parcourir ArrayList

方法一:for (int i = 0; i < j; i++)
Méthode 2 : itérateur

for (Iterator iterator = list.iterator(); iterator.hasNext(); ) {
            iterator.next();
        }

Méthode 3 : améliorer la boucle for
Méthode 4 : pour chaque

Méthode 5 : stream().forEach

6. Convertir la liste en arborescence

import java.util.ArrayList;
import java.util.List;

public class TreeNode {
    private String id;
    private String parentId;
    private String name;
    private List<TreeNode> children = new ArrayList<>();

    public TreeNode(String id, String parentId, String name) {
        this.id = id;
        this.parentId = parentId;
        this.name = name;
    }

    public void addChild(TreeNode child) {
        children.add(child);
    }

    public String getId() {
        return id;
    }

    public String getParentId() {
        return parentId;
    }

    public String getName() {
        return name;
    }

    public List<TreeNode> getChildren() {
        return children;
    }

    // 将List转换为树状结构的方法
    public static List<TreeNode> buildTree(List<TreeNode> nodeList, String parentId) {
        List<TreeNode> treeList = new ArrayList<>();
        for (TreeNode node : nodeList) {
            if (node.getParentId().equals(parentId)) {
                // 递归构建子树
                node.setChildren(buildTree(nodeList, node.getId()));
                treeList.add(node);
            }
        }
        return treeList;
    }
}

7. Quelle est la différence entre une interface et une classe abstraite ?

Méthode pour réaliser

Une classe abstraite est une classe spéciale qui ne peut pas être instanciée mais seulement héritée. Il peut contenir à la fois des méthodes abstraites et non abstraites. Les méthodes abstraites n'ont pas d'implémentation concrète, mais sont implémentées par des sous-classes. Les méthodes non abstraites ont des implémentations concrètes et peuvent être utilisées directement dans les sous-classes.
Une interface est une classe complètement abstraite qui ne peut pas être instanciée, seulement implémentée. Il ne contient que des méthodes abstraites et des constantes, les méthodes abstraites n'ont pas d'implémentation concrète, mais sont implémentées par la classe qui implémente l'interface.

Héritage

Une classe ne peut hériter que d'une seule classe abstraite et une classe peut implémenter plusieurs interfaces.

modificateur d'accès

Les méthodes des classes abstraites peuvent avoir des modificateurs d'accès tels que public, protected et default, tandis que les méthodes des interfaces sont publiques.

Variables membres

Il peut y avoir des variables membres dans une classe abstraite, mais il ne peut y avoir que des constantes (c'est-à-dire des variables modifiées par final) dans une interface.

implémentation par défaut

Une méthode abstraite dans une classe abstraite peut avoir une implémentation par défaut, tandis qu'une méthode dans une interface n'a pas d'implémentation par défaut.

Le but d'une classe abstraite est de permettre aux sous-classes de remplacer les méthodes abstraites et de fournir des implémentations courantes. Le but de l'interface est de permettre à différentes classes d'implémenter la même interface et de pouvoir interagir.

8. Dans quelles circonstances une classe abstraite doit-elle être utilisée ?

Certaines méthodes doivent être implémentées par toutes les sous-classes, mais l'implémentation spécifique de ces méthodes peut être différente dans chaque sous-classe.
Il existe des variables membres publiques dans les sous-classes, et ces variables membres publiques peuvent être placées dans des classes abstraites pour éviter les déclarations répétées dans chaque sous-classe.
Il est nécessaire de limiter la hiérarchie d'héritage des sous-classes, ce qui peut être réalisé en définissant certaines méthodes comme finales ou privées, puis en définissant d'autres méthodes comme méthodes abstraites.
Il est nécessaire de définir une méthode modèle, c'est-à-dire de définir le squelette d'un algorithme et de laisser les sous-classes implémenter certaines étapes. Vous pouvez utiliser une classe abstraite pour implémenter cette méthode modèle.

Il convient de noter que si toutes les méthodes d'une classe sont des méthodes abstraites, ou s'il n'y a que des variables membres mais pas de méthodes dans la classe, alors cette classe doit être définie comme une interface plutôt que comme une classe abstraite. Parce que le rôle de la classe abstraite est de fournir certaines implémentations spécifiques, et le rôle de l'interface est de définir certaines spécifications ou contraintes, sans inclure des implémentations spécifiques.

9. Fonctionnalités de Java

Facile à apprendre;
Orienté objet (encapsulation, héritage, polymorphisme) ;
Indépendance de la plate-forme (la machine virtuelle Java implémente l'indépendance de la plate-forme) ;
Prend en charge le multi-threading (le langage C++ n'a pas de mécanisme multi-threading intégré, de sorte que la fonction multi-threading du système d'exploitation doit être appelée pour la programmation multi-thread, tandis que le langage Java fournit un support multi-threading) ;
fiabilité;
sécurité;
Prend en charge la programmation réseau et est très pratique (la naissance du langage Java lui-même est conçue pour simplifier la programmation réseau, de sorte que le langage Java prend non seulement en charge la programmation réseau mais est également très pratique);
Compilation et interprétation coexistent ;

La puissante écologie de Java est.

10. La différence entre Java et C++

Java ne fournit pas de pointeurs pour accéder directement à la mémoire, la mémoire programme est plus sûre
Les classes Java sont à héritage unique et C++ prend en charge l'héritage multiple ; bien que les classes Java ne puissent pas être à héritage multiple, les interfaces peuvent être à héritage multiple.
Java dispose d'un mécanisme de gestion automatique de la mémoire (GC), qui n'oblige pas les programmeurs à libérer manuellement la mémoire inutile.
C++ prend en charge à la fois la surcharge de méthode et la surcharge d'opérateur, mais Java ne prend en charge que la surcharge de méthode (la surcharge d'opérateur ajoute de la complexité, ce qui n'est pas conforme à l'idée de conception originale de Java).

11. Quelle est la différence entre orienté objet et orienté processus ?

L'orientation processus consiste à analyser les étapes nécessaires à la résolution du problème, puis à utiliser des fonctions pour implémenter ces étapes étape par étape. Lors de leur utilisation, elles peuvent être appelées une par une.
L'orienté objet consiste à décomposer le problème constitutif en divers objets. Le but de l'établissement d'un objet n'est pas de terminer une étape, mais de décrire le comportement de quelque chose dans l'ensemble de l'étape de résolution du problème.

12. Quelle est la différence entre JDK et JRE ?

JDK est l'abréviation de Java Development Kit, qui est un SDK Java complet. Il a tout ce qu'un JRE a, plus un compilateur (javac) et des outils comme javadoc et jdb. Il est capable de créer et de compiler des programmes .
JRE est l'environnement d'exécution Java. Il s'agit d'une collection de tout ce qui est nécessaire pour exécuter un programme Java compilé, y compris la machine virtuelle Java (JVM), la bibliothèque de classes Java, la commande java et d'autres composants de base. Cependant, il ne peut pas être utilisé pour créer de nouveaux programmes .

13. Quelles sont les caractéristiques de l'orienté objet ?

Encapsulation, héritage, polymorphisme (une référence à une classe mère pointe vers une instance d'une sous-classe)

14. Qu'est-ce que le passage par valeur et le passage par référence ?

Passage par valeur : cela signifie que lors de l'appel d'une méthode, une copie du paramètre réel est transmise à la méthode, de sorte que lorsque le paramètre formel est modifié dans la méthode, le paramètre réel ne sera pas affecté.
Passage par référence : également appelé passage d'adresse, il s'agit de transmettre l'adresse du paramètre réel à la méthode lors de l'appel de la méthode, de sorte que la modification du paramètre formel dans la méthode affectera le paramètre réel.
C'est-à-dire que la valeur est transmise et ce qui est transmis est une copie. Passe par référence, l'adresse mémoire réelle est passée.
Dans le langage Java, il n'y a essentiellement que le passage de valeurs, ce qui signifie que le passage de paramètres de Java ne passera que sa copie et ne passera pas le paramètre lui-même.

15. Mise en boîte et déballage automatiques

Boxing : Enveloppez les types primitifs avec leurs types de référence correspondants ;
Unboxing : conversion d'un type wrapper en un type de données primitif ;

L1

LINENUMBER 8 L1

ALOAD 0

BIPUSH 10

INVOKESTATIC java/lang/Integer.valueOf (I)Ljava/lang/Integer;

PUTFIELD AutoBoxTest.i : Ljava/lang/Integer;

L2

LINENUMBER 9 L2

ALOAD 0

ALOAD 0

GETFIELD AutoBoxTest.i : Ljava/lang/Integer;

INVOKEVIRTUAL java/lang/Integer.intValue ()I

PUTFIELD AutoBoxTest.n : I

RETURN

À partir du bytecode, nous avons découvert que boxing appelait en fait la méthode valueOf() de la classe d'emballage, et unboxing appelait en fait la méthode intValue().

Integer i = 10 等价于 Integer i = Integer.valueOf(10)
int n = i 等价于 int n = i.intValue();

16. Pourquoi String est-il immuable

Le tableau contenant la chaîne est final et privé, et la classe String ne fournit/n'expose pas de méthodes pour modifier cette chaîne.
La classe String est finalement modifiée de sorte qu'elle ne puisse pas être héritée, empêchant ainsi les sous-classes de détruire l'immuabilité de String.

L'immuabilité de String peut être brisée par réflexion

17. Différence entre String, StringBuffer et StringBuilder

Les deux sont des classes finales, non autorisées à être héritées et thread-safe ;
la longueur de la classe String est immuable et la longueur des classes StringBuffer et StringBuilder peut être modifiée ; la
classe StringBuffer est thread-safe et StringBuilder ne l'est pas thread-safe ;
pour les trois, utilisez Summary :

Exploiter une petite quantité de données : la chaîne est applicable
Exploitez une grande quantité de données sous un tampon de chaîne d'opération à un seul thread : appliquez StringBuilder
Exploiter une grande quantité de données sous un tampon de chaîne d'opération multithread : applicable à StringBuffer

18. Quelles sont les méthodes couramment utilisées de la classe String

length() la longueur de la chaîne
2. charAt() intercepte un caractère
3、toCharArray() …
4、égal()

19.new String("dabin") créera plusieurs objets

L'utilisation de cette méthode créera deux objets de chaîne (à condition qu'il n'y ait pas d'objet de chaîne "dabin" dans le pool de constantes de chaîne).

"dabin" est un littéral de chaîne, donc un objet chaîne sera créé dans le pool de constantes de chaîne lors de la compilation, pointant vers ce littéral de chaîne "dabin" ;
L'utilisation de new créera un objet chaîne dans le tas.

20. Qu'est-ce qu'un pool de constantes de chaîne

https://juejin.cn/post/6995715596092440584#heading-0
Le pool de constantes de chaîne (String Pool) stocke tous les littéraux de chaîne, qui sont déterminés au moment de la compilation.

Java6 et versions antérieures, le pool de constantes de chaîne est stocké dans la génération permanente.
Dans Java7, les ingénieurs d'Oracle ont apporté un grand changement à la logique du pool de chaînes, c'est-à-dire pour ajuster l'emplacement du pool de constantes de chaînes au tas Java.
Toutes les chaînes sont enregistrées dans le tas (Heap), tout comme les autres objets ordinaires, de sorte que vous n'avez qu'à ajuster la taille du tas lors du réglage de l'application.
Le concept de pool de constantes de chaîne a été beaucoup utilisé à l'origine, mais ce changement nous donne suffisamment de raisons pour reconsidérer l'utilisation de String.intern() dans Java7.
Métaspace Java8, les constantes de chaîne sont sur le tas.
La chaîne a défini la valeur finale char [] dans jdk8 et avant pour stocker les données de chaîne. Passez à byte[] dans jdk9.

21. La différence entre le pool constant statique, le pool constant d'exécution et le pool constant de chaîne

Les données de ces fichiers .class statiques et déchargés sont appelées un pool de constantes statiques, mais une fois que jvm a chargé les fichiers .class en mémoire et les a chargés dans la zone de méthode, le pool de constantes deviendra un pool de constantes d'exécution ! La référence de symbole correspondante sera convertie en une référence directe au code chargé dans la zone de méthode lorsque le programme est chargé ou en cours d'exécution. Lorsque la jvm appelle cette méthode, vous pouvez trouver l'emplacement de la méthode dans la zone de méthode en fonction de la référence, puis exécutez-le. .
Le pool de constantes de chaîne est une petite partie du pool de constantes d'exécution. L'emplacement du pool de constantes de chaîne est différent selon les différentes versions de jdk !

22. Quelles sont les méthodes courantes d'Object ?

getClass()、finalize()、toString()、equals()、hashcode()、wait(）、notify()、notifyAll()和clone()。

23. Copie superficielle et copie profonde

Copie superficielle : la copie superficielle créera un nouvel objet sur le tas (différent de la copie de référence). Cependant, si la propriété interne de l'objet d'origine est un type de référence, la copie superficielle copiera directement l'adresse de référence de l'objet interne, c'est-à-dire dire L'objet copié partage le même objet interne que l'objet d'origine.
Copie profonde : Une copie profonde copiera complètement l'objet entier, y compris les objets internes contenus par cet objet.

24. Si le hashCode de deux objets est le même, est-ce que equals est nécessairement le même ?

1. Les objets égaux (identiques) doivent avoir des codes de hachage égaux (ou des codes de hachage).
2. Si le hashCode de deux objets est le même, ils ne sont pas nécessairement les mêmes.
La relation entre égal et hashcode :

Si deux objets appellent equals pour comparer et renvoient true, alors leurs valeurs hashCode doivent être identiques ;
Si deux objets ont le même hashCode, ils ne sont pas nécessairement identiques.

La méthode hashcode est principalement utilisée pour améliorer l'efficacité de la comparaison d'objets . Comparez d'abord hashcode(). S'ils ne sont pas identiques, il n'est pas nécessaire de comparer des valeurs égales, ce qui réduit considérablement le nombre de comparaisons égales. Lorsque le nombre de comparaisons objets est grand temps peut améliorer l'efficacité.
La raison pour laquelle la réécriture de equals() consiste à réécrire hashcode() est de s'assurer que la valeur de hashcode est également cohérente lorsque la méthode equals() renvoie true. Si la réécriture de equals() ne réécrit pas hashcode(), deux objets sont égaux mais hashcode () n'est pas égal. De cette façon, lorsque l'un des objets est utilisé comme clé pour l'enregistrer dans hashMap, hashTable ou hashSet, puis qu'un autre objet est utilisé comme clé pour les trouver, il ne sera pas trouvé.

25. Il existe plusieurs façons de créer des objets en Java

nouveau mot clé
Class.newInstance

C'est la façon la plus courante d'utiliser la réflexion pour créer des objets. La newInstance de la classe Class utilise le constructeur public sans argument de la classe. C'est-à-dire que la prémisse de l'utilisation de cette méthode pour créer un objet est qu'il doit y avoir un constructeur public sans argument.

Constructor.newInstance

Cette méthode est similaire à la méthode newInstance de la classe Class, mais elle est beaucoup plus puissante. Il existe également une méthode newInstance dans la classe java.lang.relect.Constructor pour créer des objets. Nous pouvons utiliser cette méthode newInstance pour appeler des paramètres (ne doivent plus être aucun paramètre) et des constructeurs privés (ne doivent plus être publics) .

Méthode de clonage

Chaque fois que nous appelons la méthode clone d'un objet, la JVM crée un nouvel objet, y copie tout le contenu de l'objet précédent et crée un objet avec la méthode clone sans appeler de constructeur. Pour utiliser la méthode clone, nous devons d'abord implémenter l'interface Cloneable et remplacer la méthode clone d'Object (car cette méthode d'Object est protégée, si vous ne la remplacez pas, elle ne peut pas être appelée de l'extérieur).

désérialisation

Lorsque nous sérialisons et désérialisons un objet, la JVM crée un objet séparé pour nous. Lors de la désérialisation, la JVM crée l'objet et n'appelle aucun constructeur . Afin de désérialiser un objet, nous devons faire en sorte que notre classe implémente l'interface Serializable.

26. Parlez de l'ordre d'instanciation des classes

初始化顺序
父类静态变量
父类静态代码块
子类静态变量
子类静态代码块
父类非静态变量
父类非静态代码块
父类构造函数
子类非静态变量
子类非静态代码块
子类构造函数

27. Quelle est la différence entre égal et ==

Pour les variables de chaîne, utilisez ""Compare les chaînes différemment de "est égal à".""En comparant les valeurs des deux variables elles-mêmes, c'est-à-dire les premières adresses des deux objets en mémoire, "égal" compare si le contenu des chaînes est le même.
Pour les variables non-chaîne, si égal() est non réécrit, Les méthodes "==" et "equals" ont la même fonction, toutes deux sont utilisées pour comparer la première adresse de l'objet dans la mémoire tas, c'est-à-dire pour comparer si deux variables de référence pointent vers le même objet.

28. La différence entre final, enfin et finaliser

final est utilisé pour modifier les attributs, les méthodes et les classes, indiquant respectivement que les attributs ne peuvent pas être réaffectés, les méthodes ne peuvent pas être remplacées et les classes ne peuvent pas être héritées.
enfin fait partie de la structure de l'instruction de gestion des exceptions, apparaît généralement comme try-catch-finally, et enfin le bloc de code indique qu'il est toujours exécuté.
finalize est une méthode de la classe Object. Cette méthode est généralement appelée par le garbage collector. Lorsque nous appelons la méthode System.gc(), le garbage collector appelle la méthode finalize() pour recycler les déchets. La JVM ne garantit pas que cela la méthode sera toujours appelée.

29. La différence entre la surcharge de méthode et la réécriture

(1) Le remplacement est "le shell reste inchangé, mais le noyau est remplacé", c'est-à-dire qu'il existe une méthode dans la sous-classe avec le même nom que la méthode de la classe parente, et le nombre et le type de paramètres sont les mêmes , et la valeur de retour est également la même.
(2) La surcharge (surcharge) est dans une classe, le nom de la méthode est le même, mais les paramètres sont différents. Les types de retour peuvent être identiques ou différents.
(3) La réécriture de méthode (Overriding) et la surcharge (Overloading) sont différentes manifestations du polymorphisme Java. La surcharge est une manifestation du polymorphisme entre les classes parentes et les sous-classes. La surcharge peut être comprise comme des manifestations concrètes du polymorphisme.

30. Quelle est la différence entre une interface et une classe abstraite ?

terrain d'entente :

Ni l'un ni l'autre ne peut être instancié.
Les deux peuvent contenir des méthodes abstraites.
peut avoir une méthode d'implémentation par défaut (Java 8 peut utiliser le mot-clé default pour définir une méthode par défaut dans une interface).

différence :

L'interface est principalement utilisée pour contraindre le comportement de la classe, et si vous implémentez une interface, vous aurez le comportement correspondant. Les classes abstraites sont principalement utilisées pour la réutilisation du code, mettant l'accent sur la relation de propriété.
Une classe ne peut hériter que d'une seule classe, mais peut implémenter plusieurs interfaces.
Les variables membres de l'interface ne peuvent être que de type public static final, ne peuvent pas être modifiées et doivent avoir une valeur initiale, tandis que les variables membres de la classe abstraite default default peuvent être redéfinies dans des sous-classes et peuvent également être réaffectées.

31. Quelles sont les exceptions courantes ?

NullPointerException : exception de pointeur nul
IndexOutOfBoundsException : indice hors limites
IOException : exception IO

32. Quelle est la différence entre erreur et exception ?

En Java, toutes les exceptions ont un ancêtre commun, la classe Throwable dans le package java.lang. La classe Throwable a deux sous-classes importantes :

Exception : L'exception que le programme lui-même peut gérer peut être interceptée par catch. L'exception peut être divisée en exception vérifiée (l'exception vérifiée doit être gérée) et l'exception non vérifiée (l'exception non vérifiée ne peut pas être gérée).
Error : Error est une erreur qui ne peut pas être gérée par le programme, et ~~nous ne pouvons pas l'attraper via catch.~~ Il n'est pas recommandé de l'attraper via catch. Par exemple, erreur d'exécution de la machine virtuelle Java (Virtual MachineError), erreur de mémoire de la machine virtuelle insuffisante (OutOfMemoryError), erreur de définition de classe (NoClassDefFoundError), etc. Lorsque ces exceptions se produisent, la machine virtuelle Java (JVM) choisit généralement le thread à terminer.

33. Quelle est la différence entre une exception d'exécution et une exception non d'exécution (cochée) ?

La différence entre les exceptions vérifiées et les exceptions non vérifiées
est principalement : les exceptions vérifiées sont appliquées par le compilateur et doivent être interceptées pour indiquer des conditions anormales qui ne sont pas contrôlées par le programme (telles que les erreurs d'E/S), tandis que les exceptions non vérifiées se produisent au moment de l'exécution pour indiquent des erreurs de programmation (par exemple, des pointeurs nuls . De ce fait, les exceptions vérifiées nécessitent plus de code à utiliser que les exceptions non vérifiées pour éviter les erreurs de compilation.

34. Qu'est-ce qu'un thread démon ?

Les threads démons sont différents des threads utilisateur. Les threads utilisateur sont des threads que nous créons manuellement, tandis que les threads démons sont des threads qui fournissent un service général en arrière-plan lorsque le programme est en cours d'exécution . Le thread de récupération de place est un thread démon typique.
Le thread démon est spécialement utilisé pour servir d'autres threads. Si d'autres threads (c'est-à-dire des threads définis par l'utilisateur) sont exécutés, même le thread principal est exécuté, alors la jvm se fermera (c'est-à-dire cessera de fonctionner) - à ce moment, même le jvm All a cessé de fonctionner, et bien sûr le thread démon a cessé de s'exécuter.

35. Comment implémenter le clonage d'objets

(1) Implémentez l'interface Cloneable dans la classe d'objets à cloner.
L'interface Cloneable est une interface de marqueur (l'interface de marqueur permet à l'utilisateur de marquer la classe qui implémente l'interface avec la fonction du marqueur d'interface. Les interfaces de marqueur courantes incluent Serializable, Cloneable et RandomAccess). Si cette interface n'est pas implémentée, elle sera levée lorsque la méthode de clonage est appelée exception CloneNotSupportException.
(2) Remplacer la méthode clone de Object dans la classe.
Le but de la réécriture est d'étendre les droits d'accès. S'il n'est pas réécrit, car le modificateur de la méthode clone d'Object est protégé, les autres classes n'ont aucun droit d'accès à l'exception du même package que Object (java.lang) et des sous-classes directes. Et par défaut, le clone d'Object affiche une copie superficielle. Si vous souhaitez implémenter une copie profonde, vous devez également réécrire cette méthode.

Copie superficielle : la copie superficielle créera un nouvel objet sur le tas (différent de la copie de référence). Cependant, si la propriété interne de l'objet d'origine est un type de référence, la copie superficielle copiera directement l'adresse de référence de l'objet interne, c'est-à-dire dire L'objet copié partage le même objet interne que l'objet d'origine.
Copie profonde : Une copie profonde copiera complètement l'objet entier, y compris les objets internes contenus par cet objet.

36. La différence entre synchrone et asynchrone

Synchrone est un mode bloquant et asynchrone est un mode non bloquant.
La synchronisation signifie que lorsqu'un processus exécute une demande, si la demande prend un certain temps pour renvoyer des informations, le processus attendra jusqu'à ce qu'il reçoive les informations de retour avant de continuer à s'exécuter ; asynchrone signifie que le processus n'a pas besoin d'attendre tout le temps
Descendez, mais continuez à exécuter les opérations suivantes, quel que soit l'état des autres processus. Lorsqu'un message est renvoyé, le système notifie au processus de le traiter, ce qui peut améliorer l'efficacité de l'exécution.

37. La différence entre blocage et non blocage

Un appel bloquant signifie que le thread en cours sera suspendu avant que le résultat de l'appel ne soit renvoyé. Le thread appelant ne reviendra pas tant qu'il n'aura pas le résultat.
Un appel non bloquant signifie que l'appel ne bloquera pas le thread en cours tant que le résultat ne pourra pas être obtenu immédiatement.

38. Quelle est la différence entre BIO/NIO/AIO ?

https://javaguide.cn/java/io/io-model.html#bio-blocking-io
BIO appartient au modèle IO de blocage synchrone .
Dans le modèle d'E/S à blocage synchrone, une fois que l'application a lancé un appel de lecture, elle est bloquée jusqu'à ce que le noyau copie les données dans l'espace utilisateur.
NIO appartient au modèle d'E/S non bloquantes synchrones.
NIO en Java peut être considéré comme un modèle de multiplexage d'E/S .
AIO est NIO 2. Une version améliorée de NIO, NIO 2, a été introduite dans Java 7, qui est un modèle IO asynchrone.
Les E/S asynchrones sont implémentées sur la base du mécanisme d'événement et de rappel, c'est-à-dire que l'application reviendra directement après l'opération et n'y sera pas bloquée. Lorsque le traitement en arrière-plan est terminé, le système d'exploitation notifie au thread correspondant d'effectuer les opérations suivantes. .