Explorer les questions et réponses d'un entretien d'embauche pour un poste de développeur Java. Partie 8

Pratique ou théorie ? Qu'est-ce qui est le plus important ? Beaucoup de gens diront naturellement que la pratique est plus importante. Par exemple, entraînez-vous jusqu'à ce que le soleil se couche et vous serez heureux. J'oserai être en désaccord avec cela. Pendant les entretiens, personne ne saura à quel point vous êtes cool lorsque vous vous entraînez. Au lieu de cela, il vous sera demandé de démontrer vos connaissances théoriques. Ce n'est que plus tard, lorsque vous aurez franchi toutes les étapes des entretiens et serez affecté à un projet, que vous appliquerez vos compétences pratiques. Vous pouvez vous y opposer, en disant que parfois ils vous confient une tâche de test, donc la pratique est toujours nécessaire. Je ne suis pas en désaccord, mais ce que je veux dire est que c'est PARFOIS, mais vous devez TOUJOURS démontrer votre connaissance de la théorie lors d'un entretien. Sentez-vous la différence ? Tout cela signifie qu’il faut avoir sous les pieds une base théorique solide, et c’est ce que nous allons continuer à construire aujourd’hui. Plus précisément, nous continuerons d’examiner les questions souvent posées lors des entretiens.

71. Que se passe-t-il si nous ne remplaçons pas la méthode toString() d'Enum ?

Supposons que nous ayons l' énumération suivante :

public enum Role {
   STUDENT,
   TEACHER,
   DIRECTOR,
   SECURITY_GUARD;
}

Affichons le champ STUDENT sur la console en appelant sa méthode toString() :

System.out.println(Role.STUDENT.toString());

En conséquence, nous obtenons la sortie de console suivante : Ainsi, nous voyons que pour une enum , l'implémentation par défaut de toString() renvoie le nom de la constante elle-même.

72. Pouvez-vous déclarer un constructeur dans un Enum ?

Oui bien sûr. Le constructeur est ce qui définit les valeurs des champs internes de l'énumération . À titre d'exemple, ajoutons deux champs à l' énumération précédente ( ageFrom et ageTo ) pour indiquer la tranche d'âge pour chaque rôle :

public enum Role {
   STUDENT(5,18),
   TEACHER(20,60),
   DIRECTOR(40,70),
   SECURITY_GUARD(18,50);
 
   int ageFrom;
   int ageTo;
 
   Role(int ageFrom, int ageTo) {
       this.ageFrom = ageFrom;
       this.ageTo = ageTo;
   }
}

73. Quelle est la différence entre == et equals() ?

C’est l’une des questions d’entretien les plus fréquemment posées aux futurs développeurs Java. Pour commencer, lors de la comparaison de valeurs simples ( int , char , double ...), nous utilisons == , car ces variables contiennent des valeurs concrètes qui peuvent être comparées directement. De plus, les variables primitives ne sont pas des objets à part entière : elles n'héritent pas de la classe Object et n'ont pas de méthode equals() . Si nous parlons de comparer des variables qui font référence à des objets, alors nous devons savoir que == compare uniquement la valeur des références, c'est-à-dire si elles font référence au même objet ou non. Même si toutes les données d'un objet sont identiques à toutes les données d'un autre, utiliser == pour une comparaison donnera un résultat négatif ( false ), car ce sont des objets séparés. Comme vous l'avez peut-être deviné, nous utilisons la méthode equals() pour comparer les variables de référence. Il s'agit de l'une des méthodes standard de la classe Object et elle est nécessaire pour une comparaison complète des objets. Mais je dois dire tout de suite que pour que cette méthode fonctionne correctement, elle doit être remplacée pour indiquer exactement comment comparer les objets. Si vous ne remplacez pas la méthode, vous obtiendrez l'implémentation par défaut, qui compare les objets en utilisant == . Dans IntelliJ IDEA, vous pouvez le remplacer automatiquement à l'aide d'un raccourci IDEA : Alt+Insert . Dans la fenêtre qui apparaît, sélectionnez equals() et hashCode() . Sélectionnez ensuite les champs qui doivent être impliqués. Voilà ! Les méthodes sont automatiquement mises en œuvre. Voici un exemple de la façon dont une méthode equals générée automatiquement recherche la classe Cat la plus simple possible avec deux champs — int age et String name :

@Override
public boolean equals(final Object o) {
   if (this == o) return true;
   if (o == null || this.getClass() != o.getClass()) return false;
   final Cat cat = (Cat) o;
   return this.age == cat.age &&
           Objects.equals(this.name, cat.name);
}

En ce qui concerne enum , il n'y a pas de différence pratique entre == et equals() . Après tout, une énumération stocke des constantes, et même lorsque nous comparons des valeurs identiques en utilisant == , nous obtiendrons true , puisque les références comparées pointeront toujours vers les mêmes objets. Et utiliser equals() nous donne également le résultat correct. Si vous allez dans le corps de la méthode equals pour Enum , vous verrez que la classe Enum a l'implémentation suivante : A l'intérieur on peut voir une bonne vieille comparaison de références ! Pour résumer, pour enum s, nous pouvons comparer correctement en utilisant à la fois == et equals() .

74. Que fait la méthode ordinal() d'Enum ?

Lorsque nous appelons la méthode int ordinal() sur un champ d'énumération , nous obtenons l'index de base zéro du champ dans la liste des valeurs d'énumération. Appelons cette méthode sur un champ de l' énumération Role , que nous avons considéré précédemment :

System.out.println(Role.DIRECTOR.ordinal());

En conséquence, la console affiche :

75. Enum peut-il être utilisé avec TreeSet ou TreeMap en Java ?

Nous pouvons utiliser des types enum dans TreeSet et TreeMap . Et on peut écrire ceci :

TreeSet<Role> treeSet = new TreeSet<>();
treeSet.add(Role.SECURITY_GUARD);
treeSet.add(Role.DIRECTOR);
treeSet.add(Role.TEACHER);
treeSet.add(Role.STUDENT);
treeSet.forEach(System.out::println);

Et la console affichera : Nous avons obtenu le résultat, mais pas par ordre alphabétique. Le fait est que si nous utilisons des champs d'énumération comme valeurs TreeSet ou comme clés TreeMap , alors les champs sont triés dans leur ordre naturel (dans l'ordre dans lequel ils sont spécifiés dans le enum ). Comprendre que c'est ainsi que cela fonctionne nous aide à écrire un meilleur code.

76. Quel est le lien entre les méthodes ordinal() et compareTo() d'Enum ?

Comme mentionné précédemment, ordinal() renvoie l'index d'un champ dans la liste des champs d'énumération. De plus, lors de notre examen de la question précédente, vous avez vu que lorsque les champs d'énumération sont placés dans un TreeSet (qui est un ensemble trié), ils suivent l'ordre dans lequel ils sont déclarés dans l' enum . Et comme nous le savons, TreeSet et TreeMap trient les éléments en appelant la méthode compareTo() de leur interface Comparable . Cela nous indique que la classe Enum implémente l' interface Comparable , ce qui signifie qu'elle implémente la méthode compareTo() , qui utilise en interne la méthode ordinal() pour déterminer l'ordre de tri. En entrant dans la classe Enum , nous pouvons confirmer notre hypothèse : Et voici le corps de la méthode elle-même : La méthode ordinal() n'est pas appelée ici. Au lieu de cela, la variable ordinale est utilisée, qui est le numéro d'index de l'élément dans l'énumération. La méthode ordinal() elle-même n’est rien de plus qu’un getter pour la variable ordinale .

77. Écrivez un exemple Enum

Dans les questions abordées ci-dessus, j'ai déjà donné des exemples d' énumérations . Je ne vois aucune raison de dupliquer le code ici. Par exemple, voir la question 72 concernant un constructeur dans une énumération.

78. Un Enum peut-il être utilisé dans un boîtier de commutation ?

Cela peut et devrait être le cas ! En regardant mon expérience, je noterai que l'une des utilisations les plus courantes de l'énumération concerne les constructions logiques telles que les instructions switch . Dans ce cas, vous pouvez fournir tous les case possibles — une fois que vous avez écrit la logique pour chaque champ d'énumération , vous n'avez même pas besoin d'une clause par défaut ! Après tout, si vous utilisez String ou une valeur numérique, telle qu'un int , vous pouvez recevoir une valeur inattendue, mais cela est impossible avec un enum . Voici à quoi ressemblerait une instruction switch pour l’exemple ci-dessus :

public void doSomething(Role role) {
   switch (role) {
       case STUDENT:
           // some logic for STUDENT
           break;
       case TEACHER:
           // some logic for TEACHER
           break;
       case DIRECTOR:
           // some logic for DIRECTOR
           break;
       case SECURITY_GUARD:
           // some logic for SECURITY_GUARD
           break;
   }
}

79. Comment puis-je obtenir toutes les valeurs possibles d'un Enum ?

Si vous avez besoin d'obtenir toutes les valeurs possibles de l'énumération, il existe une méthode values() , qui renvoie un tableau de toutes les valeurs possibles de l' énumération dans leur ordre naturel (c'est-à-dire dans l'ordre dans lequel elles sont spécifiées dans l' énumération ). Exemple:

Role[] roles = Role.values();
for (Role role : roles) {
   System.out.println(role);
}

Nous aurons ce qui suit sur la console :

API de flux

80. Qu'est-ce qu'un flux en Java ?

L' API Java Stream est une manière relativement nouvelle d'interagir avec un flux de données, nous permettant de traiter le Big Data de manière plus pratique et plus compacte, ainsi que de traiter les données en parallèle entre un certain nombre de flux, améliorant potentiellement les performances.

81. Nommer les principales propriétés des transactions

Le sujet ici est l'API Stream, mais la question concerne les transactions. Hmm... Tout d'abord, comprenons ce qu'est une transaction. Une transaction est un groupe d'opérations séquentielles sur une base de données. Il représente une unité logique de travail. Une transaction peut être exécutée indépendamment des autres transactions concurrentes, soit entièrement et avec succès, préservant ainsi l'intégrité des données, soit ne pas être exécutée du tout, auquel cas elle n'a aucun effet. Les transactions ont quatre propriétés principales, que l'on peut facilement retenir grâce à l'acronyme ACID . Voyons ce que signifie chaque lettre de cet acronyme : A signifie Atomicité . Cette propriété garantit qu'aucune transaction n'est partiellement validée dans le système. Soit toutes ses sous-opérations seront exécutées, soit aucune d'entre elles ne sera exécutée ( tout ou rien ). С signifie Cohérence . Cette propriété garantit que chaque transaction réussie ne validera que des résultats valides. En d’autres termes, il s’agit d’une garantie que si la transaction réussit, toutes les règles du système concernant des données spécifiques seront respectées. Si la transaction échoue, elle ne sera pas exécutée et les données du système reviendront à leur état précédent. Je représente l'isolement . Cette propriété signifie que lorsqu'une transaction est exécutée, les transactions simultanées ne doivent pas affecter son résultat. Cette propriété est gourmande en ressources, elle est donc généralement partiellement mise en œuvre, permettant certains niveaux d'isolement qui résolvent des problèmes d'isolement spécifiques. Nous en discuterons plus en détail dans la question suivante. D signifie Durabilité . Cette propriété garantit que si l'utilisateur reçoit la confirmation que la transaction est terminée, il peut alors être sûr que les modifications ne seront pas annulées en raison d'un échec. Autrement dit, vous pouvez être certain qu'une panne du système d'exploitation n'aura aucun effet sur vos données si vous avez déjà reçu la confirmation que votre transaction s'est terminée avec succès.

82. Quels sont les niveaux d’isolement des transactions ?

Comme je l'ai dit plus tôt, lorsqu'il s'agit de propriétés ACID, assurer l'isolation est un processus gourmand en ressources. En conséquence, cette propriété est partiellement mise en œuvre. Il existe différents niveaux d’isolement : plus le niveau est élevé, plus l’impact sur les performances est important. Avant de passer aux niveaux d'isolation des transactions, nous devons considérer divers problèmes qui surviennent en raison d'une isolation insuffisante des transactions :

• lectures fantômes : lorsqu'une même requête, appelée plusieurs fois au sein d'une même transaction, donne des résultats différents en raison d'insertions par une autre transaction ;

• lectures non répétables : lorsqu'une même requête, appelée plus d'une fois au sein d'une même transaction, produit des données différentes en raison de modifications (mises à jour) et de suppressions par une autre transaction ;

• lectures sales : lecture de données non encore validées qui ont été ajoutées ou modifiées par une transaction et qui sont ensuite annulées ;

• mises à jour perdues : lorsqu'un bloc de données est modifié simultanément par différentes transactions, et que toutes les modifications sauf la dernière sont perdues (similaire à une condition de concurrence critique en multithreading).

En l’occurrence, les niveaux d’isolement des transactions sont caractérisés par les problèmes d’isolement contre lesquels ils protègent. Considérez le tableau suivant des niveaux d’isolement et des problèmes contre lesquels ils protègent : Et n'oubliez pas le revers de la médaille : plus le niveau d'isolement est élevé, plus le traitement des transactions est long (étant donné l'exécution parallèle de plusieurs transactions).

83. Quelle est la différence entre un Statement et un PreparedStatement ?

Ici, nous avons brusquement modifié la transition vers les fonctionnalités de JDBC . Quoi qu'il en soit, voyons d'abord ce qu'est une déclaration . C'est un objet utilisé pour former des requêtes SQL. JDBC utilise trois types : Statement , PreparedStatement et CallableStatement . Nous ne considérerons pas CallableStatement aujourd'hui. Au lieu de cela, nous parlons de la différence entre Statement et PreparedStatement .

1. L'instruction est utilisée pour exécuter des requêtes SQL simples sans paramètres d'entrée d'exécution. PrepareStatement peut accepter des paramètres d'entrée au moment de l'exécution.

2. Pour définir les paramètres de PreparedStatement , les paramètres d'entrée sont écrits sous forme de points d'interrogation dans la requête, ils peuvent donc être remplacés par une valeur à l'aide de divers paramètres, tels que setDouble() , setFloat() , setInt() , setTime() ... Ceci signifie que vous n'insérerez pas le mauvais type de données dans la requête.

3. PreparedStatement est précompilé et utilise la mise en cache, il peut donc être exécuté légèrement plus rapidement qu'une requête composée d' objets Statement . Par conséquent, les instructions SQL exécutées fréquemment sont créées en tant qu'objets PreparedStatement afin d'améliorer les performances.

4. L'instruction est vulnérable à l'injection SQL, mais PreparedStatement les empêche.

Et avec ça, c'est fini !