Analyse des questions et réponses des entretiens pour développeur Java. Partie 5

Bonjour bonjour! Aujourd’hui, les développeurs Java sont très demandés. Bien sûr, je ne peux pas vous proposer de poste vacant, mais j'essaierai de vous aider à acquérir de nouvelles connaissances et à combler certaines lacunes. Nous continuons donc à analyser plus de 250 questions d'entretien pour les développeurs Java. Les liens vers les parties précédentes de l’analyse se trouvent à la fin de l’article.

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

J'ai déjà décrit les modificateurs d'accès dans la question sur les éléments d'encapsulation Java. Mais je vous le rappelle quand même. 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 peuvent être :

• public - un élément avec ce modificateur sera accessible publiquement. Ceux. champs et méthodes, les classes déclarées avec le modificateur public sont visibles par les autres classes à la fois depuis le package actuel et depuis les packages externes ;
• protected - un élément avec ce modificateur sera accessible depuis n'importe où dans la classe actuelle du package actuel ou dans les classes descendantes, même s'ils se trouvent dans d'autres packages ;
• default , ou modificateur manquant - ce modificateur est utilisé implicitement lorsque le modificateur d'accès n'est pas du tout spécifié. Il est similaire au précédent, sauf que la visibilité est autorisée dans les classes descendantes qui se trouvent dans d'autres packages ;
• private est le plus privé de tous les modificateurs, permettant l'accès à l'élément uniquement dans la classe actuelle.

40. Nommez la caractéristique principale des méthodes statiques et variables

Une formulation très étrange - « méthodes variables ». Cela fait sûrement référence à des méthodes ordinaires et non statiques. Ainsi, la principale différence est que les méthodes statiques appartiennent à la classe et, en fait, pour elles, vous n'avez pas besoin de créer une instance de cette classe : elle ne peut être appelée qu'en utilisant le type de classe. Par exemple, nous avons une méthode statique pour caresser le chat :

public class CatService {
   public static void petTheCat(Cat cat) {
       System.out.println("Погладить кота - " + cat.getName());
   }

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

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

Alors que les méthodes ordinaires sont liées à (appartiennent à) un objet, et pour les appeler, vous devez disposer d'une instance (objet) sur laquelle la méthode sera appelée. Par exemple, un chat a une méthode non statique - miauler :

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

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

Cat cat = new Cat(7, "Bobi");
cat.mew();

41. Quelles sont les principales restrictions sur les méthodes statiques et « variables » ?

Comme je l'ai dit plus tôt, la principale limitation d'une méthode standard est qu'il doit toujours y avoir une instance sur laquelle cette méthode sera appelée. Mais une méthode statique ne nécessite pas cela, mais elle ne peut pas faire référence à la référence this - aux éléments de l'objet courant - puisque l'objet courant n'existe pas pour elle.

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

Un élément désigné par le mot-clé static n'appartient pas à un objet de la classe, mais plutôt à la classe, et il est chargé lorsque la classe elle-même est chargée. Les éléments statiques sont les seuls pour l'ensemble du programme, et les éléments réguliers sont les seuls pour un objet spécifique. Le statique peut être :

• champs de classe ;
• bloc d'initialisation de classe ;
• méthode de classe ;
• classes internes d'une classe (cependant, cela reste 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 ?

Je l’ai déjà évoqué dans l’article précédent : une méthode ne peut pas être à la fois abstraite et statique. Le caractère abstrait d’une méthode signifie qu’elle doit être remplacée dans le successeur. En même temps, une méthode statique appartient à la classe et ne peut pas être surchargée : cela provoquerait une contradiction que le compilateur verra et commencera à maudire. Si vous êtes confronté à une telle situation, vous devriez réfléchir sérieusement à l'exactitude de l'architecture de votre application (après tout, il y a clairement quelque chose qui ne va pas).

44. Est-il possible d'utiliser des méthodes statiques au milieu de méthodes classiques ? Vice versa? Pourquoi?

Les méthodes statiques peuvent être utilisées de manière régulière, car rien ne l'empêche. En même temps, la situation inverse est impossible : une méthode statique ne peut pas utiliser une méthode régulière sans avoir une référence à une instance spécifique de cette classe. Et comme nous nous en souvenons, la référence this n'est pas disponible pour les membres de classe statiques : il peut y avoir autant d'objets spécifiques de la classe que vous le souhaitez, et chacun d'eux aura une référence à lui-même à l'intérieur - this . Et comment alors comprenez-vous quel lien particulier vous devez prendre ? Mais pas question. Par conséquent, les éléments statiques ne peuvent pas faire référence à des éléments non statiques, sans référence à un objet spécifique. En fait, 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 venu comme argument :

public static void petTheCat(Cat cat) {
   System.out.println("Погладить кота - " + cat.getName());
}

Nous voyons ici que la méthode statique petTheCat appelle la méthode normale et non statique de l' objet Cat - getName .

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

On s'en souvient, il n'y a pas d'héritage multiple en Java. Les interfaces sont en quelque sorte une alternative. L'interface ressemble à une classe très épurée. Ils définissent des fonctionnalités sans implémentation spécifique, qui sont implémentées par les classes qui implémentent (implémentent) ces interfaces. Exemple d'interface :

public interface Animal {
    void voice();
}

Un exemple d'implémentation d'interface par une classe :

class Cat implements Animal {

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

La principale chose que vous devez savoir sur l’utilisation des interfaces est :

1. Les méthodes d'interface ne doivent contenir qu'un en-tête, sans corps de méthode spécifique, c'est-à-dire doit être abstrait (mais sans utiliser le mot-clé abstract ). L'exception à cela concerne les méthodes statiques et 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, c'est une alternative à l'héritage multiple), qui sont écrites séparées par des virgules : la classe Lion implémente Animal, Wild .
3. Les interfaces sont créées à l'aide du mot-clé -interface .
4. Lors de l'implémentation d'une interface par une classe, le mot-clé est Implements .
5. Une classe qui implémente une interface particulière 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 (la capacité des objets à prendre plusieurs formes).
7. En règle générale, les modificateurs d'accès aux méthodes ne sont pas écrits dans l'interface : ils sont publics par défaut et d'autres modificateurs autres que public ne peuvent pas être spécifiés. Depuis Java 9, vous pouvez utiliser des modificateurs privés pour les méthodes.
8. Les variables d'interface sont par défaut des static final , c'est-à-dire des constantes : elles doivent toujours être initialisées directement dans l'interface.
9. Vous ne pouvez pas créer un objet d'interface.

La réponse à la question de savoir si les interfaces peuvent être définitives ne l’est bien sûr pas. Après tout, l’essence même des interfaces est d’être implémentées. Et comme nous nous en souvenons tous très bien, final au niveau de la classe le rend non héritable, et dans le cas d'une interface, non implémentable. Pourquoi avons-nous besoin d’une interface qui ne peut pas être implémentée et utilisée ? C'est vrai, ce n'est pas nécessaire ! Et le compilateur le pense)) Le sens n'est apparu qu'avec l'introduction de méthodes statiques dans les interfaces avec Java 8, mais cela n'a rien changé au fait que l'interface ne peut pas être définitive. J'ai parlé d'interfaces, très superficiellement, parce que... c'est un vaste sujet. Apprenez-en davantage à ce sujet dans les articles sur les interfaces en Java et la différence entre les classes abstraites et les interfaces .

46. ​​​​​​Où puis-je initialiser les champs statiques ?

Les champs statiques peuvent être initialisés :

• directement lors de la déclaration, via le signe égal = ;
• dans le bloc d'initialisation statique ;
• dans un bloc d'initialisation non statique, mais il faut comprendre qu'à chaque fois qu'un objet est créé, ce champ sera écrasé par ce bloc d'initialisation ;
• dans le constructeur de classe. Chaque fois que ce constructeur est appelé (c'est-à-dire lorsqu'un objet est créé via ce constructeur), ce champ sera écrasé ;
• dans les méthodes statiques ;
• dans des méthodes non statiques ;
• dans des classes internes 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é que vous ne pouvez pas créer d'objet d'interface : vous pouvez uniquement créer un objet d'une classe qui implémente l'interface. Que se passe-t-il si vous ne souhaitez pas implémenter d'interface dans une classe, mais que vous avez quand même besoin d'un objet de type interface ? Et très probablement, il s'agira d'un seul cas d'utilisation de cet objet. Et vous n'avez pas besoin de créer une classe d'implémentation à part entière. Comment allez-vous faire cela ? Droite! Grâce à un cours anonyme ! Disons que nous avons une interface Animal :

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

Si nous voulons instancier cette interface via une classe anonyme :

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

Et puis vous pouvez utiliser en toute sécurité cet objet et sa méthode implémentée - voice . Autrement dit, une classe anonyme implémente cette interface et toutes ses méthodes abstraites ici et maintenant. Sinon, nous ne pourrons pas créer d’objet interface/classe abstraite, car il existe 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 où un objet est utilisé une seule fois ou où une implémentation donnée de méthodes n'est nécessaire qu'une seule fois, et il n'est pas nécessaire de créer une classe distincte qui implémentera la classe/interface abstraite requise. Mais je noterai aussi que le recours à des classes anonymes est un phénomène rare dans le travail : en règle générale, la préférence est toujours donnée aux classes ordinaires. Vous pouvez en savoir plus sur les classes anonymes dans cet article .

48. Que sont les classes primitives ?

Quant à moi, c'est une question très étrange et, peut-être, une question piège, car en Java il n'existe pas de classes primitives : à l'exception peut-être du concept de types primitifs, que nous avons déjà évoqué plus tôt. Comme nous nous en souvenons, il existe 8 types primitifs en Java - byte , short , int , long , float , double , char , boolean .

49. Qu'est-ce que la classe « wrapper » ?

Le principal problème lié à l’utilisation de types primitifs en Java est qu’ils ne sont toujours pas des classes et que Java est toujours un langage POO. Autrement dit, les programmes écrits dans ce langage sont réduits à une interaction entre objets. Eh bien, les primitifs ne sont pas des objets. Ils n'ont pas de méthodes, pas même les méthodes standard de la classe Object . Eh bien, et si nous devions utiliser une primitive comme clé dans Map ? Ensuite, vous devez appeler la méthode hashCode . Vous pouvez également y appeler la méthode equals . Et alors ? Il peut y avoir de très, très nombreux moments où il devrait y avoir une classe, et non une primitive, ce qui rend les primitives inutilisées et indésirables dans le programme, car cela détruit l'idée même de la POO. Mais tout n’est pas aussi mauvais qu’il y paraît. Après tout, Java a le concept d'un wrapper primitif. Chaque type primitif possède une classe analogique :

• 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

Il s'agit d'une représentation de types simples, mais sous la forme de classes à part entière avec un tas de méthodes diverses et fonctionnelles. Pour une utilisation pratique de ces classes, les concepts d'autoboxing et de unboxing ont été introduits. Autoboxing - conversion automatique d'un type primitif en classe analogique si nécessaire (par exemple, int en Integer ). Le déballage est le processus inverse du précédent : conversion automatique d'une classe wrapper primitive en un type primitif (par exemple, Integer en int ). Grâce à l'introduction de classes wrapper primitives et aux processus d'autoboxing et de unboxing , les types primitifs ont pu devenir des membres à part entière du langage POO - Java. Pour en savoir plus sur ce sujet, je vous recommande fortement de lire cet article .

50. Qu'est-ce que la classe imbriquée ? Quand est-il utilisé ?

Une classe imbriquée est une classe interne qui est membre d’une autre classe. En Java, il existe 4 types de telles classes internes : 1. Classe interne Ce type de classe est déclaré directement dans le corps d'une autre classe. Une classe interne imbriquée peut accéder à n’importe quel champ ou méthode privé d’une instance de la classe externe. A titre d'exemple, créons un zoo dans lequel nous aurons un animal - un zèbre :

public class Zoo {
   class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

Rien de compliqué, non ? Jetons un coup d'œil à un exemple de création d'un objet de classe interne :

Zoo.Zebra zebra = new Zoo().new Zebra();
zebra.toFeed("яблоко");

Comme vous l'avez déjà vu, il est impératif de créer un objet de la classe framing, à partir de la référence duquel vous pourrez créer un objet de la classe interne. Je voudrais également noter qu'une classe interne imbriquée ne peut pas avoir de méthodes statiques ou de champs statiques. C'est parce qu'une classe interne est implicitement associée à l'objet de sa classe externe et qu'elle ne peut déclarer aucune méthode statique en elle-même. 2. Classes imbriquées statiques Cette classe est similaire à la précédente, sauf qu'elle possède un modificateur d'accès statique à proximité de 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 à la partie statique de la classe externe qu’à une classe interne. Dans ce cas, les données de classe ont accès à tous les membres statiques de la classe externe, même privés. Exemple de classe imbriquée statique :

public class Zoo {
   static class Zebra {
       public void toFeed(String food) {
           System.out.println("Дать зебре - " + food);
       }
   }
}

La méthode de création est légèrement différente de la précédente :

Zoo.Zebra zebra = new Zoo.Zebra();
zebra.toFeed("яблоко");

Ici, nous n'avons pas besoin d'un objet d'une classe externe pour créer un objet d'une classe statique imbriquée. À partir de la classe externe, nous n’avons besoin que de son type pour pouvoir trouver l’emplacement de la classe imbriquée. 3. Classes locales Les classes locales sont des classes déclarées dans le corps d'une méthode, et la création et l'utilisation d'un objet d'une classe locale sont possibles exclusivement au sein de cette méthode. Exemple:

public class Zoo {
   public void toFeed(String animal, String food) {
       switch(animal){
           case "зебра":
               class Zebra {
                   void toFeedZebra(String food) {
                       System.out.println("Дать зебре - " + food);
                   }
               }
               Zebra zebra = new Zebra();
               zebra.toFeedZebra(food);
               ...

Exemple d'utilisation :

Zoo zoo = new Zoo();
zoo.toFeed("зебра", "яблоко");

Sans voir le code de la méthode toFeed , vous ne soupçonneriez même pas l'existence d'une classe locale, n'est-ce pas ? Une classe locale ne peut pas être static ou transient , mais elle peut être marquée comme abstract ou final (uniquement OR, car l'utilisation de ces deux modificateurs provoquera un conflit). 4. Classes anonymes Nous avons déjà parlé des classes anonymes ci-dessus, et comme vous vous en souvenez, elles peuvent être créées à partir de deux sources : les interfaces et les classes. Raisons d'utiliser des classes statiques et non statiques internes car il est parfois préférable d'intégrer de petites classes dans des classes plus grandes et de les conserver ensemble : de cette façon, elles auront un couplage plus élevé et un objectif commun. En fait, l’utilisation de classes imbriquées augmente l’encapsulation du code. La raison du choix des classes locales peut être qu'une classe donnée est utilisée exclusivement dans une seule méthode. Dans ce cas, est-il nécessaire de répartir le code dans toute l’application ? Non. Mais en même temps, j'ajouterai que dans ma pratique, je n'ai jamais vu l'utilisation de cours locaux, car leur nécessité est très controversée. Eh bien, la raison de l'utilisation de classes anonymes peut être qu'une implémentation spécifique d'une interface ou d'une classe abstraite ne sera nécessaire qu'une seule fois, il n'est donc pas nécessaire de créer une classe distincte à part entière avec une implémentation pour cela. Au lieu de cela, d'une manière simple, nous avons implémenté la ou les méthodes dont nous avions besoin via une classe anonyme, utilisé cet objet et l'avons oublié (enfin, le Garbage collector s'en est souvenu). Ceci et cet article vous aideront à étudier plus en détail les cours internes .

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

On le rappelle, il existe différents types de classes et différents modificateurs d'accès leur sont applicables :

• une classe externe peut avoir le modificateur d'accès public ou être sans modificateur (modificateur par défaut) ;
• la classe interne prend en charge les 4 modificateurs d'accès ;
• La classe statique imbriquée prend en charge tous les modificateurs d'accès sauf protected , car ce modificateur implique l'héritage, ce qui contredit le membre statique de la classe (les éléments statiques ne sont pas hérités) ;
• une classe locale ne peut avoir qu'un modificateur par défaut (c'est-à-dire aucun modificateur du tout) ;
• classe anonyme : s'il n'y a pas de déclaration de type de classe, alors il n'y a aucun modificateur d'accès.

C'est là que nous nous arrêterons aujourd'hui. À bientôt!