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

Bonjour bonjour! Les développeurs Java sont aujourd’hui très demandés. Bien sûr, je ne peux pas vous proposer d'offre d'emploi, mais j'essaierai de vous aider à acquérir de nouvelles connaissances et à combler certaines lacunes. Continuons donc notre examen des questions d'entretien pour les développeurs Java. Vous pouvez trouver des liens vers les parties précédentes de la revue à la fin de l’article.

39. Quels sont les modificateurs d'accès en Java ? Nomme les. Pour quoi sont-ils utilisés?

J'ai déjà abordé les modificateurs d'accès dans une question sur les éléments Java utilisés pour réaliser l'encapsulation. Mais je vais quand même vous le rappeler. Les modificateurs d'accès en Java sont des mots-clés qui décrivent le niveau d'accès accordé à un composant Java particulier. Les modificateurs d'accès suivants existent :

• public — un élément marqué avec ce modificateur est public. En d'autres termes, les champs, les méthodes et les classes déclarées avec le modificateur public sont visibles par les autres classes à la fois dans leur propre package et dans les packages externes ;
• protected — un élément marqué avec ce modificateur est accessible depuis n'importe où dans sa propre classe dans le package actuel ou dans les classes dérivées, même s'ils se trouvent dans d'autres packages ;
• par défaut (ou aucun modificateur du tout) s'applique implicitement lorsqu'aucun modificateur d'accès n'est indiqué. Il est similaire au précédent, sauf qu'il est visible dans les classes dérivées trouvées dans d'autres packages ;
• private — c'est le plus privé de tous les modificateurs. Il permet d'accéder à un élément uniquement dans la classe actuelle.

40. Nommer les principales caractéristiques des méthodes statiques et non statiques

La principale différence est que les méthodes statiques appartiennent à une classe. En fait, vous n'avez pas besoin de créer une instance de cette classe : les méthodes statiques peuvent être appelées uniquement à partir du type de classe. Par exemple, supposons que nous ayons une méthode statique pour caresser un chat :

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Pet the cat: " + cat.getName());
   }

Nous n'avons pas besoin d'une instance de la classe CatService pour l'appeler :

Cat cat = new Cat(7, "Bobby");
CatService.petTheCat(cat);

En revanche, les méthodes ordinaires sont liées (appartiennent) à un objet. Pour les appeler, vous devez disposer d’une instance (objet) sur laquelle la méthode sera appelée. Par exemple, supposons que notre chat ait une méthode non statique meow() :

class Cat {
   public void meow() {
       System.out.println("Meow! Meow! Meow!");
   }

Pour appeler cette méthode, nous avons besoin d’une instance spécifique d’un chat :

Cat cat = new Cat(7, "Bobby");
cat.meow();

41. Quelles sont les principales restrictions qui s'appliquent aux méthodes statiques et non statiques ?

Comme je l'ai dit plus tôt, la principale limitation d'une méthode ordinaire (non statique) est qu'il doit toujours y avoir une instance sur laquelle la méthode est appelée. Mais une méthode statique ne l’exige pas. De plus, une méthode statique ne peut pas utiliser la référence this aux éléments d'un objet puisqu'il existe désormais un objet actuel pour la méthode.

42. Que signifie le mot-clé static ? Une méthode statique peut-elle être remplacée ou surchargée ?

Un élément marqué du mot-clé static n'appartient pas à une instance d'une classe mais plutôt à la classe elle-même. Il est chargé lorsque la classe elle-même est chargée. Les éléments statiques sont les mêmes pour l'ensemble du programme, tandis que les éléments non statiques ne sont les mêmes que pour un objet spécifique. Les éléments suivants peuvent être statiques :

• champs d'une classe;
• bloc d'initialisation d'une classe ;
• une méthode d'une classe ;
• classes imbriquées d'une classe (bien sûr, c'est aussi une tautologie).

Une méthode statique ne peut pas être surchargée : elle appartient à la classe et n'est pas héritée, mais en même temps, elle peut être surchargée.

43. Une méthode peut-elle être à la fois statique et abstraite ?

J’y ai déjà répondu dans un article précédent : une méthode ne peut pas être à la fois abstraite et statique. Si une méthode est abstraite, cela implique qu’elle doit être substituée dans une classe enfant. Mais une méthode statique appartient à la classe et ne peut pas être remplacée. Cela crée une contradiction que le compilateur remarquera et qui s'énervera. Si vous vous trouvez dans cette situation, vous devriez réfléchir sérieusement à l'exactitude de l'architecture de votre application (indice : quelque chose ne va clairement pas).

44. Les méthodes statiques peuvent-elles être utilisées au milieu de méthodes non statiques ? Et vice versa? Pourquoi?

Nous pouvons utiliser des méthodes statiques dans des méthodes non statiques. Rien ne l'empêche. Cela dit, l’inverse n’est pas possible : une méthode statique ne peut pas utiliser une méthode non statique sans référencer une instance spécifique de la classe. N'oubliez pas que les membres statiques d'une classe n'ont pas accès à une référence this : vous pouvez avoir autant d'objets concrets de la classe que vous le souhaitez, et chacun d'eux contiendra une référence this , qui est une auto-référence. Alors comment déterminer quelle référence utiliser ? Euh, ce n'est pas le cas. C'est pourquoi les éléments statiques ne peuvent pas faire référence à des éléments non statiques sans référence à un objet spécifique. Fondamentalement, une méthode statique ne peut utiliser une méthode non statique que si elle fait référence à un objet spécifique. Par exemple, celui qui est entré comme argument de méthode :

public static void petTheCat(Cat cat) {
   System.out.println("Pet the cat: " + cat.getName());
}

Ici, nous voyons que dans la méthode statique petTheCat() appelle getName , une méthode non statique ordinaire d'un objet Cat .

45. Qu'est-ce qu'une interface ? Peut-il y avoir une interface finale ?

Rappelons que Java ne possède pas d'héritage multiple. Les interfaces sont en quelque sorte une alternative. Une interface est comme une classe très épurée. Ils définissent une fonctionnalité mais pas une implémentation concrète. Cette tâche est laissée aux classes qui implémentent ces interfaces. Exemple d'interface :

public interface Animal {
    void speak();
}

Exemple d'implémentation d'interface par une classe

class Cat implements Animal {

   @Override
   public void speak() {
       System.out.println("Meow! Meow! Meow!");
   }
}

Voici l’essentiel à savoir sur l’utilisation des interfaces :

1. Les méthodes d'interface ne doivent contenir qu'un en-tête. Ils ne doivent pas avoir de corps de méthode spécifique, c'est-à-dire qu'ils doivent être abstraits (bien qu'ils n'utilisent pas le mot-clé abstract ). Il existe des exceptions : les méthodes statiques et les méthodes par défaut, qui nécessitent un corps de méthode.

2. Une classe peut implémenter de nombreuses interfaces (comme je l'ai dit, les interfaces sont une alternative à l'héritage multiple). Les noms d'interface sont séparés par des virgules dans l'en-tête de la méthode : la classe Lion implémente Animal, Wild .

3. Les interfaces sont créées à l'aide du mot-clé interface .

4. Lorsqu'une classe implémente une interface, nous utilisons le mot-clé Implements .

5. Une classe qui implémente une certaine interface doit implémenter toutes ses méthodes abstraites ou doit se déclarer abstraite.

6. L’objectif principal de l’utilisation des interfaces est d’implémenter le polymorphisme (pour donner à un objet la capacité de prendre plusieurs formes).

7. En règle générale, les modificateurs d'accès aux méthodes ne sont pas indiqués dans les interfaces : ils sont publics par défaut et vous ne pouvez pas spécifier de modificateurs autres que public . À partir de Java 9, vous pouvez utiliser des modificateurs privés sur les méthodes.

8. Par défaut, les variables d'interface sont static final . En d’autres termes, ce sont des constantes : elles doivent toujours être initialisées directement dans l’interface.

9. Vous ne pouvez pas créer une instance d'une interface.

La réponse à la question de savoir si les interfaces peuvent être définitives est bien entendu non. En effet, tout l’intérêt d’avoir des interfaces est qu’elles soient implémentées. Et comme nous nous en souvenons tous très bien, le modificateur final au niveau de la classe rend une classe non héritable et, dans le cas d'une interface, non implémentable. Pourquoi aurions-nous besoin d’une interface que nous ne pouvons pas implémenter et utiliser ? Vous avez raison, nous ne le ferions pas ! Et le compilateur est d'accord. :) En fait, avec l'introduction des méthodes d'interface statiques depuis Java 8, cela peut être utile, mais cela ne change rien au fait qu'une interface ne peut pas être définitive. Je n'ai parlé des interfaces que très superficiellement, car il s'agit d'un vaste sujet. Pour en savoir plus, consultez les articles sur les interfaces en Java et la différence entre les classes abstraites et les interfaces .

46. ​​Où les champs statiques peuvent-ils être initialisés ?

Les champs statiques peuvent être initialisés :

• immédiatement après la déclaration, en utilisant le signe égal ( = );
• dans un bloc d'initialisation statique ;
• dans un bloc d'initialisation non statique (mais vous devez comprendre qu'à chaque fois qu'un objet est créé, le champ statique sera écrasé lors de l'exécution de ce bloc d'initialisation ;
• dans un constructeur de classe. Chaque fois que le constructeur est appelé (c'est-à-dire chaque fois qu'un objet est créé à l'aide de ce constructeur), le champ sera écrasé ;
• dans les méthodes statiques ;
• dans des méthodes non statiques ;
• dans des classes imbriquées statiques et non statiques, locales et anonymes.

47. Que sont les cours anonymes ?

Les classes anonymes sont des classes qui n'ont pas leur propre type. De quoi je parle ? Lorsque nous avons parlé d'interfaces, j'ai mentionné qu'on ne pouvait pas créer une instance d'un objet : on ne pouvait créer qu'une instance d'une classe qui implémentait une interface. Que se passe-t-il si vous ne souhaitez pas qu'une classe implémente une interface mais que vous avez besoin d'un objet qui implémente l'interface ? Et c’est probablement la seule utilité de l’objet. Et vous n'avez pas besoin de créer une classe d'implémentation à part entière. Comment feriez-vous? C'est exact! En utilisant une classe anonyme ! Supposons que nous ayons une interface Animal :

public final interface Animal {
   public void speak();
}

Si nous voulons utiliser une classe anonyme pour instancier une interface donnée :

Animal cat = new Animal() {
   @Override
   public void speak() {
       System.out.println("Meow! Meow! Meow!");
   }
};

Et puis, vous pouvez utiliser en toute sécurité cet objet et sa méthode speak() implémentée . En d’autres termes, la classe anonyme implémente l’interface et toutes ses méthodes abstraites, ici et maintenant. Sinon, nous ne serions pas en mesure de créer un objet interface/classe abstraite car il y aurait des méthodes non implémentées/abstraites. Comme je l'ai mentionné, les classes anonymes sont utilisées non seulement pour implémenter les méthodes abstraites d'une interface, mais également pour implémenter les méthodes abstraites d'une classe abstraite. Cette approche convient aux situations dans lesquelles un objet est utilisé une seule fois ou lorsqu'une implémentation de méthode donnée n'est nécessaire qu'une seule fois. Il n'est pas nécessaire de créer une classe distincte qui implémentera la classe/interface abstraite requise. Mais je constate aussi que les cours anonymes sont rarement utilisés dans le travail. En règle générale, les classes ordinaires restent privilégiées. Vous pouvez en savoir plus sur les cours anonymes ici dans cet article .

48. Que sont les classes primitives ?

Je pense que c'est une question trompeuse, peut-être une question piège, puisque Java n'a pas de classes primitives. Il n’existe que la notion de types primitifs, que nous avons considérée précédemment. Rappelons que Java possède 8 types primitifs : byte , short , int , long , float , double , char , boolean .

49. Qu'est-ce qu'une classe wrapper ?

Le principal problème lié à l’utilisation de types primitifs en Java est qu’ils ne sont pas des classes et que Java est un langage POO. Autrement dit, les programmes écrits dans ce langage équivalent à des interactions entre objets. Mais les primitifs ne sont pas des objets. Ils n'ont pas de méthodes, même les méthodes standards de la classe Object . Mais que se passe-t-il si nous devons utiliser une primitive comme clé dans un Map ? Ensuite, nous devons appeler sa méthode hashCode() . Vous pouvez également y appeler sa méthode equals() . Et alors ? Il y a des tas et des tas de moments où vous avez besoin d’un cours, pas d’un primitif. Cela rend les primitives inutilisables et indésirables dans un programme car elles violent l'idée même de la POO. Mais la situation n’est pas aussi mauvaise qu’il y paraît. Après tout, Java a le concept de wrappers primitifs. En Java, chaque type primitif a un jumeau : une classe wrapper.

• octet -> Octet.class
• court -> Court.class
• int -> Entier.class
• long -> Long.class
• float -> Float.class
• double -> Double.classe
• char -> Caractère.class
• booléen -> Booléen.class

Ces types représentent des types simples, mais dans des classes à part entière avec un tas de méthodes variées et utiles. Les concepts d'autoboxing et de unboxing ont été introduits pour permettre une utilisation pratique de ces classes. L'autoboxing est la conversion automatique d'un type primitif en sa classe analogue, si nécessaire (par exemple, conversion de int en Integer ). Le déballage est le processus inverse : conversion automatique d'une classe wrapper primitive en un type primitif (par exemple, conversion d' Integer en int ). Grâce à l'introduction de classes wrapper primitives et aux processus de boxing et de unboxing automatiques , les types primitifs sont désormais des membres à part entière de Java en tant que langage POO. Pour une discussion plus approfondie sur ce sujet, je vous recommande fortement de lire cet article .

50. Qu'est-ce qu'une classe imbriquée ? Où est-il utilisé ?

Une classe imbriquée est une classe qui est elle-même membre d’une autre classe. Il existe 4 types de ces classes imbriquées en Java : 1. Classe interne Ce type de classe est déclaré directement dans le corps d'une autre classe. Une classe interne est une classe imbriquée non statique et peut accéder à n’importe quel champ privé ou méthode d’instance de la classe externe. À titre d'exemple, créons un zoo contenant un animal, un zèbre :

public class Zoo {
   class Zebra {
       public void eat(String food) {
           System.out.println("Zebra eats " + food);
       }
   }
}

Pas compliqué, non ? Jetons un coup d'œil à un exemple de création d'une instance de la classe interne :

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.eat("apple");

Comme vous l'avez déjà vu, il faut d'abord créer un objet de la classe englobante. Ensuite, vous utilisez la référence d'objet pour créer une instance de la classe interne. Je voudrais également souligner qu'une classe interne (classe imbriquée non statique) ne peut pas avoir de méthodes statiques ou de champs statiques. C'est précisément parce que la classe interne est implicitement associée à une instance de sa classe externe et ne peut donc déclarer aucune méthode statique en elle-même. 2. Classes imbriquées statiques Ces classes sont similaires à la catégorie précédente, mais elles ont le modificateur d'accès statique dans la déclaration de classe. Puisque ce type de classe n’a pas accès aux champs non statiques de la classe externe, elle ressemble plus à une partie statique de la classe externe qu’à une classe interne. Mais cette classe a accès à tous les membres statiques de la classe externe, même les membres privés. Exemple de classe imbriquée statique :

public class Zoo {
   static class Zebra {
       public void eat(String food) {
           System.out.println("Zebra eats " + food);
       }
   }
}

Il est créé de manière légèrement différente du précédent :

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.eat("apple");

Ici, nous n'avons pas besoin d'un objet de la classe externe pour créer un objet de la classe imbriquée statique. Il suffit de connaître le nom de la classe imbriquée pour la trouver dans la classe externe. 3. Classes locales Les classes locales sont des classes déclarées dans le corps d'une méthode. Les objets d'une classe locale peuvent être créés et utilisés uniquement dans la méthode englobante. Exemple:

public class Zoo {
   public void feed(String animal, String food) {
       switch(animal) {
           case "zebra":
               class Zebra {
                   public void eat(String food) {
                       System.out.println("Zebra eats " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.eat(food);
               ...

Voici un exemple :

Zoo zoo = new Zoo();
zoo.feed("zebra", "apple");

Si vous ne voyiez pas le code de la méthode feed() , vous ne soupçonneriez même pas qu'une classe locale existe, n'est-ce pas ? Une classe locale ne peut pas être static ou transient , mais elle peut être marquée comme abstract ou final (l'une OU l'autre, mais pas les deux, car l'utilisation simultanée de ces deux modificateurs crée un conflit). 4. Classes anonymes Nous avons déjà parlé des classes anonymes ci-dessus, et comme vous vous en souviendrez, elles peuvent être créées à partir de deux sources : les interfaces et les classes. Raisons de les utiliser Des classes statiques et non statiques imbriquées sont utilisées car il est parfois préférable d'intégrer de petites classes dans des classes plus générales et de les conserver ensemble afin qu'elles aient une plus grande cohésion et un objectif commun. Fondamentalement, les classes imbriquées vous permettent d'augmenter l'encapsulation de votre code. Vous pouvez choisir d'utiliser une classe locale si la classe est utilisée exclusivement dans une seule méthode. Dans ce cas, faut-il répartir le code sur l’application ? Non. Cela dit, j’ajouterai que, d’après mon expérience, je n’ai jamais vu personne utiliser les cours locaux, car leur nécessité ou non est très controversée. Vous pouvez utiliser des classes anonymes lorsqu'une implémentation spécifique d'une interface ou d'une classe abstraite n'est nécessaire qu'une seule fois. Dans ce cas, il n’est pas nécessaire de créer une classe distincte à part entière avec une implémentation. Au lieu de cela, nous avons gardé les choses simples et implémenté la ou les méthodes dont nous avions besoin en utilisant une classe anonyme, utilisé l'objet, puis l'avons oublié (bien sûr, le ramasse-miettes ne l'a pas oublié). Votre compréhension des classes imbriquées sera améliorée par l'article ici.

51. Quels modificateurs d'accès une classe peut-elle avoir ?

Il existe différents types de classes et différents modificateurs d'accès s'y appliquent :

• une classe externe peut avoir le modificateur d'accès public ou aucun modificateur du tout (le modificateur par défaut) ;
• une classe interne (classe imbriquée non statique) peut avoir l'un des 4 modificateurs d'accès ;
• une classe statique imbriquée peut avoir n'importe lequel des modificateurs d'accès, sauf protégé car ce modificateur implique un héritage, ce qui contredit tout membre statique de la classe (les membres statiques ne sont pas hérités) ;
• une classe locale ne peut avoir que le modificateur par défaut (c'est-à-dire aucun modificateur du tout) ;
• une classe anonyme n'a pas de déclaration de classe, elle n'a donc aucun modificateur d'accès.

C'est là que nous terminerons pour aujourd'hui. À bientôt!