Java est l'un des langages de programmation les plus populaires au monde, connu pour sa polyvalence, sa portabilité et sa large gamme d'applications. Java est le langage le plus utilisé dans les grandes entreprises telles que Uber, Airbnb, Google, Netflix, Instagram, Spotify, Amazon et bien d'autres en raison de ses fonctionnalités et de ses performances.

Dans cet article, nous fournirons Plus de 200 questions d'entretien sur Java de base adapté aux professionnels débutants et expérimentés avec 3, 5 et 8 ans d'expérience. Ici, nous couvrons tout, y compris les concepts de base de Java, la programmation orientée objet (POO), le multithreading, la gestion des exceptions, les modèles de conception, les collections Java, et bien plus encore, qui vous aideront sûrement à réussir les entretiens Java.

Table des matières

• Questions d'entretien Java pour les débutants
• Questions d'entretien intermédiaire Java
• Questions d'entretien Java pour les expérimentés
• Questions d'entretien sur les différences Java

Questions d'entretien Java pour les débutants

1. La plate-forme Java est-elle indépendante, si et comment ?

Oui, Java est un langage indépendant de la plate-forme. Contrairement à de nombreux langages de programmation, le compilateur Javac compile le programme pour former un fichier bytecode ou .class. Ce fichier est indépendant du logiciel ou du matériel en cours d'exécution mais nécessite un fichier JVM (Java Virtual Machine) préinstallé dans le système d'exploitation pour une exécution ultérieure du bytecode.

Bien que JVM dépend de la plate-forme , le bytecode peut être créé sur n'importe quel système et peut être exécuté sur n'importe quel autre système malgré l'utilisation du matériel ou du logiciel, ce qui rend la plate-forme Java indépendante.

2. Quelles sont les principales fonctionnalités Java ?

Java est l'un des langages les plus connus et les plus utilisés dans le monde réel. Java présente de nombreuses fonctionnalités qui le rendent meilleur que tout autre langage, dont certaines sont mentionnées ci-dessous :

• Simple : Java est assez simple à comprendre et la syntaxe
• Indépendant de la plateforme : Java est indépendant de la plate-forme, ce qui signifie que nous pouvons exécuter le même programme dans n'importe quel logiciel et matériel et obtiendrons le même résultat.
• Interprété : Java est interprété comme un langage basé sur un compilateur.
• Robuste : fonctionnalités telles que le garbage collection, la gestion des exceptions, etc. qui rendent le langage robuste.
• Orienté objet : Java est un langage orienté objet qui supporte les concepts de classe, d'objets, des quatre piliers de OOPS, etc.
• Sécurisé : Comme nous pouvons partager directement une application avec l'utilisateur sans partager le programme lui-même, Java est un langage sécurisé.
• Haute performance: plus rapide que les autres langages de programmation interprétés traditionnels.
• Dynamique : prend en charge le chargement dynamique des classes et des interfaces.
• Distribué : fonctionnalité de Java nous permet d'accéder aux fichiers en appelant les méthodes depuis n'importe quelle machine connectée.
• Multithread  : gérer plusieurs tâches à la fois en définissant plusieurs threads
• Architecture neutre : cela ne dépend pas de l'architecture.

3. Qu'est-ce que la JVM ?

JVM signifie Java Virtual Machine, c'est un interpréteur Java. Il est responsable du chargement, de la vérification et de l'exécution du bytecode créé en Java.

Bien qu'il dépende de la plate-forme, ce qui signifie que le logiciel de la JVM est différent selon les systèmes d'exploitation, il joue un rôle essentiel en rendant la plate-forme Java indépendante.

Pour en savoir plus sur le sujet, référez-vous à JVM en Java .

4. Qu'est-ce que le JIT ?

JIT signifie (Just-in-Time) le compilateur fait partie de JRE (Java Runtime Environment), il est utilisé pour de meilleures performances des applications Java pendant l'exécution. L'utilisation de JIT est mentionnée dans le processus étape par étape mentionné ci-dessous :

1. Le code source est compilé avec javac compilateur pour former du bytecode
2. Le bytecode est ensuite transmis à la JVM
3. JIT fait partie de JVM, JIT est responsable de la compilation du bytecode en code machine natif au moment de l'exécution.
4. Le compilateur JIT est activé partout, tandis qu'il est activé lorsqu'une méthode est invoquée. Pour une méthode compilée, la JVM appelle directement le code compilé, au lieu de l'interpréter.
5. Comme JVM appelle le code compilé, cela augmente les performances et la vitesse d’exécution.

Pour en savoir plus sur le sujet, référez-vous à JIT en Java .

5. Quels sont les stockages de mémoire disponibles avec JVM ?

JVM se compose de quelques stockages de mémoire comme mentionné ci-dessous :

1. Zone de classe (méthode) : stocke les données au niveau de la classe de chaque classe, telles que le pool de constantes d'exécution, les données de champ et de méthode, ainsi que le code des méthodes.
2. Heap : les objets sont créés ou les objets sont stockés. Il est utilisé pour allouer de la mémoire aux objets pendant l'exécution.
3. Pile : stocke les données et les résultats partiels qui seront nécessaires lors du renvoi de la valeur de la méthode et de l'exécution de liaisons dynamiques
4. Registre du compteur de programme : stocke l'adresse de l'instruction de la machine virtuelle Java en cours d'exécution.
5. Native Method Stack : stocke toutes les méthodes natives utilisées dans l’application.

Pour en savoir plus sur le sujet, référez-vous à Stockages de mémoire JVM .

6. Qu'est-ce qu'un chargeur de classe ?

Classloader fait partie de JRE (Java Runtime Environment), lors de l'exécution du bytecode ou du fichier .class créé, le classloader est responsable du chargement dynamique des classes et des interfaces Java vers JVM (Java Virtual Machine). En raison des chargeurs de classes, le système d'exécution Java n'a pas besoin de connaître les fichiers et les systèmes de fichiers.

Pour en savoir plus sur le sujet, référez-vous à ClassLoader en Java.

7. Différence entre JVM, JRE et JDK.

JVM : JVM également connue sous le nom de Java Virtual Machine fait partie de JRE. JVM est un type d'interpréteur chargé de convertir le bytecode en code lisible par machine. La JVM elle-même dépend de la plate-forme, mais elle interprète le bytecode, qui est la raison indépendante de la plate-forme pour laquelle Java est indépendant de la plate-forme.

JRE : JRE signifie Java Runtime Environment, c'est un package d'installation qui fournit un environnement pour exécuter le programme ou l'application Java sur n'importe quelle machine.

JDK : JDK signifie Java Development Kit qui fournit l'environnement nécessaire pour développer et exécuter des programmes Java. JDK est un package qui comprend deux outils de développement pour fournir un environnement pour développer vos programmes Java et JRE pour exécuter des programmes ou des applications Java.

Pour en savoir plus sur le sujet, consultez le Différences entre JVM, JRE et JDK .

8. Quelles sont les différences entre Java et C++ ?

9. Expliquez public static void main(String args[]) en Java.

Contrairement à tout autre langage de programmation comme C, C++, etc. En Java, nous avons déclaré la fonction principale comme une fonction principale statique publique (String args[]). La signification des termes est mentionnée ci-dessous :

1. publique : le public est le modificateur d'accès chargé de mentionner qui peut accéder à l'élément ou à la méthode et quelle est la limite. Il est chargé de rendre la fonction principale disponible à l’échelle mondiale. Il est rendu public afin que JVM puisse l'invoquer depuis l'extérieur de la classe car il n'est pas présent dans la classe actuelle.
2. statique : static est un mot-clé utilisé pour que l'on puisse utiliser l'élément sans initier la classe afin d'éviter l'allocation inutile de la mémoire.
3. vide : void est un mot-clé et est utilisé pour spécifier qu'une méthode ne renvoie rien. Comme la fonction principale ne renvoie rien, nous utilisons void.
4. principal : main représente que la fonction déclarée est la fonction principale. Cela aide JVM à identifier que la fonction déclarée est la fonction principale.
5. Arguments de chaîne[] : Il stocke les arguments de ligne de commande Java et est un tableau de classe java.lang.String.

10. Qu'est-ce que le pool de chaînes Java ?

Un pool de chaînes Java est un emplacement dans la mémoire tas où sont stockées toutes les chaînes définies dans le programme. Un endroit distinct dans une pile est celui où la variable stockant la chaîne est stockée. Chaque fois que nous créons un nouvel objet chaîne, JVM vérifie la présence de l'objet dans le pool String. Si String est disponible dans le pool, la même référence d'objet est partagée avec la variable, sinon un nouvel objet est créé.

Exemple:

String str1='Hello'; // 'Hello' will be stored in String Pool // str1 will be stored in stack memory>

11. Que se passera-t-il si nous déclarons ne pas déclarer le main comme statique ?

Nous pouvons déclarer la méthode principale sans utiliser de static et sans obtenir d'erreurs. Mais la méthode principale ne sera pas traitée comme le point d’entrée de l’application ou du programme.

12. Que sont les packages en Java ?

Les packages en Java peuvent être définis comme un regroupement de types connexes de classes, d'interfaces, etc. donnant accès à la protection et à la gestion des espaces de noms.

13. Pourquoi les packages sont-ils utilisés ?

Les packages sont utilisés en Java afin d'éviter les conflits de noms, de contrôler l'accès et de faciliter la recherche/localisation et l'utilisation des classes, des interfaces, etc.

14. Quels sont les avantages des packages en Java ?

La définition de packages en Java présente de nombreux avantages.

• Les packages évitent les conflits de noms.
• Le package offre un contrôle d’accès plus facile.
• Nous pouvons également avoir les classes cachées qui ne sont pas visibles à l'extérieur et qui sont utilisées par le package.
• Il est plus facile de localiser les classes associées.

15. Combien de types de packages existe-t-il en Java ?

Il existe deux types de packages en Java

• Packages définis par l'utilisateur
• Forfaits intégrés

16. Expliquez les différents types de données en Java.

Il existe 2 types de types de données en Java, comme mentionné ci-dessous :

1. Type de données primitif
2. Type de données non primitif ou type de données objet

Type de données primitives : les données primitives sont des valeurs uniques sans fonctionnalités particulières. Il existe 8 types de données primitifs :

• booléen : stocke la valeur vraie ou fausse
• octet : stocke un entier complémentaire à deux signé de 8 bits
• carboniser : stocke un seul caractère Unicode 16 bits
• court : stocke un entier complémentaire à deux signé de 16 bits
• int : stocke un entier complémentaire à deux signé de 32 bits
• long : stocke un entier complémentaire à deux de 64 bits
• flotter : stocke une virgule flottante IEEE 754 32 bits simple précision
• double : stocke une virgule flottante IEEE 754 double précision 64 bits

Type de données non primitif : les types de données de référence contiendront une adresse mémoire des valeurs de la variable car ils ne sont pas capables de stocker directement les valeurs dans la mémoire. Les types de non-primitifs sont mentionnés ci-dessous :

• Cordes
• Tableau
• Classe
• Objet
• Interface

17. Quand un type de données octet est-il utilisé ?

Un octet est un entier signé de 8 bits à deux compléments. La valeur minimale prise en charge par les octets est -128 et 127 est la valeur maximale. Il est utilisé dans des conditions où nous devons économiser de la mémoire et où la limite des nombres nécessaires est comprise entre -128 et 127.

18. Pouvons-nous déclarer Pointer en Java ?

Non, Java ne prend pas en charge Pointer. Comme Java devait être plus sécurisé car quelle fonctionnalité du pointeur n’est pas fournie en Java.

19. Quelle est la valeur par défaut du type de données octet en Java ?

La valeur par défaut du type de données octet en Java est 0.

20. Quelle est la valeur par défaut des types de données float et double en Java ?

La valeur par défaut du float est 0.0f et du double est 0.0d en Java.

21. Qu'est-ce que la classe Wrapper en Java ?

Wrapper, en général, fait référence à une entité plus grande qui encapsule une entité plus petite. Ici, en Java, la classe wrapper est une classe d'objets qui encapsule les types de données primitifs.

Les types de données primitifs sont ceux à partir desquels d'autres types de données peuvent être créés. Par exemple, les entiers peuvent en outre conduire à la construction de long, byte, short, etc. D'un autre côté, la chaîne ne le peut pas, elle n'est donc pas primitive.

Pour en revenir à la classe wrapper, Java contient 8 classes wrapper. Ils sont booléens, octets, courts, entiers, caractères, longs, flottants et doubles. De plus, des classes wrapper personnalisées peuvent également être créées en Java, ce qui est similaire au concept de structure dans le langage de programmation C. Nous créons notre propre classe wrapper avec les types de données requis.

22. Pourquoi avons-nous besoin de classes wrapper ?

La classe wrapper est une classe d'objets qui encapsule les types de données primitifs, et nous en avons besoin pour les raisons suivantes :

1. Les classes Wrapper sont définitives et immuables
2. Fournit des méthodes comme valueOf(), parseInt(), etc.
3. Il fournit la fonctionnalité de boxe automatique et de déballage.

23. Faites la différence entre les variables d'instance et les variables locales.

24. Quelles sont les valeurs par défaut attribuées aux variables et aux instances en Java ?

En Java Lorsque nous n'avons pas initialisé les variables d'instance, le compilateur les initialise avec les valeurs par défaut. Les valeurs par défaut des instances et des variables dépendent de leurs types de données. Certains types courants de types de données par défaut sont :

• La valeur par défaut pour les types numériques (byte, short, int, long, float et double) est 0.
• La valeur par défaut du type booléen est false.
• La valeur par défaut des types d'objets (classes, interfaces et tableaux) est nulle.
• Le caractère nul, u0000, est la valeur par défaut du type char.

Exemple:

// Java Program to demonstrate use of default values import java.io.*; class GFG {  // static values  static byte b;  static int i;  static long l;  static short s;  static boolean bool;  static char c;  static String str;  static Object object;  static float f;  static double d;  static int[] Arr;  public static void main(String[] args)  {  // byte value  System.out.println('byte value' + b);  // short value  System.out.println('short value' + s);  // int value  System.out.println('int value' + i);  // long value  System.out.println('long value' + l);  System.out.println('boolean value' + bool);  System.out.println('char value' + c);  System.out.println('float value' + f);  System.out.println('double value' + d);  System.out.println('string value' + str);  System.out.println('object value' + object);  System.out.println('Array value' + Arr);  } }>

byte value0 short value0 int value0 long value0 boolean valuefalse char value float value0.0 double value0.0 string valuenull object valuenull Array valuenull>

25. Qu'est-ce qu'une variable de classe ?

En Java, une variable de classe (également appelée variable statique) est une variable déclarée dans une classe mais en dehors de toute méthode, constructeur ou bloc. Les variables de classe sont déclarées avec le mot-clé static et sont partagées par toutes les instances (objets) de la classe ainsi que par la classe elle-même. Quel que soit le nombre d’objets dérivés d’une classe, chaque variable de classe n’existe qu’une seule fois.

Exemple:

// Java program to demonstrate use of Clas Variable class GFG {  public static int ctr = 0;  public GFG() { ctr++; }  public static void main(String[] args)  {  GFG obj1 = new GFG();  GFG obj2 = new GFG();  GFG obj3 = new GFG();  System.out.println('Number of objects created are '  + GFG.ctr);  } }>

Number of objects created are 3>

26. Quelle est la valeur par défaut stockée dans les variables locales ?

Aucune valeur par défaut n'est stockée avec les variables locales. De plus, les variables et objets primitifs n’ont pas de valeurs par défaut.

27. Expliquez la différence entre une variable d'instance et une variable de classe.

Variable d'instance : Une variable de classe sans modificateur statique appelée variable d'instance est généralement partagée par toutes les instances de la classe. Ces variables peuvent avoir des valeurs distinctes parmi plusieurs objets. Le contenu d'une variable d'instance est complètement indépendant d'une instance d'objet à une autre car il est lié à une instance d'objet spécifique de la classe.

Exemple:

// Java Program to demonstrate Instance Variable import java.io.*; class GFG {  private String name;  public void setName(String name) { this.name = name; }  public String getName() { return name; }  public static void main(String[] args)  {  GFG obj = new GFG();  obj.setName('John');  System.out.println('Name ' + obj.getName());  } }>

Name John>

Variable de classe : La variable de variable de classe peut être déclarée n'importe où au niveau de la classe à l'aide du mot-clé static. Ces variables ne peuvent avoir qu'une seule valeur lorsqu'elles sont appliquées à différents objets. Ces variables peuvent être partagées par tous les membres de la classe puisqu’elles ne sont connectées à aucun objet spécifique de la classe.

Exemple:

// Java Program to demonstrate Class Variable import java.io.*; class GFG {  // class variable  private static final double PI = 3.14159;  private double radius;  public GFG(double radius) { this.radius = radius; }  public double getArea() { return PI * radius * radius; }  public static void main(String[] args)  {  GFG obj = new GFG(5.0);  System.out.println('Area of circle: '  + obj.getArea());  } }>

Area of circle: 78.53975>

28. Qu'est-ce qu'une variable statique ?

Le mot-clé static est utilisé pour partager la même variable ou méthode d'une classe donnée. Les variables statiques sont les variables qui, une fois déclarées, une seule copie de la variable est créée et partagée entre tous les objets au niveau de la classe.

29. Quelle est la différence entre System.out, System.err et System.in ?

Système.out – Il s'agit d'un PrintStream qui est utilisé pour écrire des caractères ou peut être dit qu'il peut générer les données que nous voulons écrire sur la console/terminal de l'interface de ligne de commande.

Exemple:

// Java Program to implement // System.out import java.io.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  {  // Use of System.out  System.out.println('');  } }>

Système.err – Il est utilisé pour afficher les messages d'erreur.

Exemple:

// Java program to demonstrate // System.err import java.io.*; // Driver Class class GFG {  // Main function  public static void main(String[] args)  {  // Printing error  System.err.println(  'This is how we throw error with System.err');  } }>

Sortir:

This is how we throw error with System.err>

Bien que System.err présente de nombreuses similitudes, les deux ont également beaucoup de différences, vérifions-les.

Système.in – Il s'agit d'un InputStream utilisé pour lire les entrées de la fenêtre du terminal. Nous ne pouvons pas utiliser directement System.in, nous utilisons donc la classe Scanner pour saisir les entrées avec system.in.

Exemple:

// Java Program to demonstrate // System.in import java.util.*; // Driver Class class Main {  // Main Function  public static void main(String[] args)  {  // Scanner class with System.in  Scanner sc = new Scanner(System.in);  // Taking input from the user  int x = sc.nextInt();  int y = sc.nextInt();  // Printing the output  System.out.printf('Addition: %d', x + y);  } }>

Sortir:

3 4 Addition: 7>

30. Qu’entendez-vous par flux IO ?

Java apporte divers Streams avec son package d'E/S qui aide l'utilisateur à effectuer toutes les opérations d'entrée-sortie. Ces flux prennent en charge tous les types d'objets, types de données, caractères, fichiers, etc. pour exécuter pleinement les opérations d'E/S.

31. Quelle est la différence entre la hiérarchie des classes Reader/Writer et la hiérarchie des classes InputStream/OutputStream ?

La principale différence entre eux est que les données du flux d'octets sont lues et écrites par les classes de flux d'entrée/sortie. Les personnages sont gérés par les classes Reader et Writer. Contrairement aux classes Reader/Writer, qui acceptent les tableaux de caractères comme paramètres, les méthodes de classe de flux d'entrée/sortie acceptent les tableaux d'octets. Par rapport aux flux d'entrée/sortie, les classes Reader/Writer sont plus efficaces, gèrent tous les caractères Unicode et sont utiles pour l'internalisation. Utilisez des classes Reader/Writer au lieu de données binaires, telles que des images, à moins que vous ne le fassiez.

Exemple:

// Java Program to demonstrate Reading Writing Binary Data // with InputStream/OutputStream import java.io.*; class GFG {  public static void main(String[] args) {  try {  // Writing binary data to a file using OutputStream  byte[] data = {(byte) 0xe0, 0x4f, (byte) 0xd0, 0x20, (byte) 0xea};  OutputStream os = new FileOutputStream('data.bin');  os.write(data);  os.close();  // Reading binary data from a file using InputStream  InputStream is = new FileInputStream('data.bin');  byte[] newData = new byte[5];  is.read(newData);  is.close();  // Printing the read data  for (byte b : newData) {  System.out.println(b);  }  } catch (IOException e) {  e.printStackTrace();  }  } }>

-32 79 -48 32 -22>

32. Quels sont les super cours pour tous les flux ?

Toutes les classes de flux peuvent être divisées en deux types de classes : les classes ByteStream et les classes CharacterStream. Les classes ByteStream sont divisées en classes InputStream et classes OutputStream. Les classes CharacterStream sont également divisées en classes Reader et en classes Writer. Les classes SuperMost pour toutes les classes InputStream sont java.io.InputStream et pour toutes les classes de flux de sortie, java.io.OutPutStream. De même, pour toutes les classes de lecteurs, la classe la plus importante est java.io.Reader, et pour toutes les classes d'écrivain, c'est java.io.Writer.

33. Que sont FileInputStream et FileOutputStream ?

Pour lire et écrire des données, Java propose des flux d'E/S. Un Stream représente une source d'entrée ou une destination de sortie, qui peut être un fichier, un périphérique d'E/S, un autre programme, etc. FichierInputStream en Java, il est utilisé pour lire les données d'un fichier sous forme de flux d'octets. Il est principalement utilisé pour lire des données binaires telles que des images, des fichiers audio ou des objets sérialisés.

Exemple:

File file = new File('path_of_the_file'); FileInputStream inputStream = new FileInputStream(file);>

En Java, le FichierOutputStream La fonction est utilisée pour écrire des données octet par octet dans un fichier ou un descripteur de fichier donné. Habituellement, les données brutes en octets, telles que les images, sont écrites dans un fichier à l'aide de FileOutputStream.

Exemple:

File file = new File('path_of_the_file'); FileOutputStream outputStream = new FileOutputStream(file);>

34. Quel est le but d'utiliser les classes BufferedInputStream et BufferedOutputStream ?

Lorsque nous travaillons avec des fichiers ou un flux, pour augmenter les performances d'entrée/sortie du programme, nous devons utiliser les classes BufferedInputStream et BufferedOutputStream. Ces deux classes offrent la capacité de mise en mémoire tampon, ce qui signifie que les données seront stockées dans un tampon avant d'être écrites dans un fichier ou de les lire à partir d'un flux. Cela réduit également le nombre de fois où notre système d'exploitation a besoin d'interagir avec le réseau ou le disque. La mise en mémoire tampon permet aux programmes d'écrire une grande quantité de données au lieu de les écrire en petits morceaux. Cela réduit également la surcharge liée à l'accès au réseau ou au disque.

BufferedInputStream(InputStream inp); // used to create the bufferinput stream and save the arguments.>

BufferedOutputStream(OutputStream output); // used to create a new buffer with the default size.>

35. Que sont les FilterStreams ?

Filtre de flux ou Filtrer les flux renvoie un flux composé des éléments de ce flux qui correspondent au prédicat donné. Pendant qu'il fonctionne avec filter(), il n'effectue pas réellement de filtrage mais crée à la place un nouveau flux qui, une fois parcouru, contient les éléments des flux initiaux qui correspondent au prédicat donné.

Exemple:

FileInputStream fis =new FileInoutStream('file_path');  FilterInputStream = new BufferedInputStream(fis);>

36. Qu'est-ce qu'un filtre d'E/S ?

Un filtre d'E/S également défini comme filtre d'entrée et de sortie est un objet qui lit à partir d'un flux et écrit des données dans des sources d'entrée et de sortie. Il a utilisé le package java.io pour utiliser ce filtre.

37. De combien de façons pouvez-vous recevoir les entrées de la console ?

Il existe deux méthodes pour récupérer les entrées de la console en Java mentionnées ci-dessous :

1. Utilisation de l'argument de ligne de commande
2. Utilisation de la classe de lecteur tamponné
3. Utiliser la classe console
4. Utilisation de la classe Scanner

Le programme démontrant l’utilisation de chaque méthode est donné ci-dessous.

Exemple:

// Java Program to implement input // using Command line argument import java.io.*; class GFG {  public static void main(String[] args)  {  // check if length of args array is  // greater than 0  if (args.length > 0) {  System.out.println(  'The command line arguments are:');  // iterating the args array and printing  // the command line arguments  for (String val : args)  System.out.println(val);  }  else  System.out.println('No command line '  + 'arguments found.');  } } // Use below commands to run the code // javac GFG.java // java Main techcodeview.com>

// Java Program to implement // Buffer Reader Class import java.io.*; class GFG {  public static void main(String[] args)  throws IOException  {  // Enter data using BufferReader  BufferedReader read = new BufferedReader(  new InputStreamReader(System.in));  // Reading data using readLine  String x = read.readLine();  // Printing the read line  System.out.println(x);  } }>

// Java program to implement input // Using Console Class public class GfG {  public static void main(String[] args)  {  // Using Console to input data from user  String x = System.console().readLine();  System.out.println('You entered string ' + x);  } }>

// Java program to demonstrate // working of Scanner in Java import java.util.Scanner; class GfG {  public static void main(String args[])  {  // Using Scanner for Getting Input from User  Scanner in = new Scanner(System.in);  String str = in.nextLine();  System.out.println('You entered string ' + str);  } }>

Sortir:

techcodeview.com>

38. Différence dans l'utilisation de print, println et printf.

print, println et printf sont tous utilisés pour imprimer les éléments mais print imprime tous les éléments et le curseur reste sur la même ligne. println déplace le curseur sur la ligne suivante. Et avec printf, nous pouvons également utiliser des identifiants de format.

39. Que sont les opérateurs ?

Les opérateurs sont les types spéciaux de symboles utilisés pour effectuer certaines opérations sur des variables et des valeurs.

40. Combien de types d’opérateurs sont disponibles en Java ?

Tous les types d’opérateurs en Java sont mentionnés ci-dessous :

1. Opérateurs arithmétiques
2. Opérateurs unaires
3. Opérateur d'assignation
4. Opérateurs relationnels
5. Opérateurs logiques
6. Opérateur ternaire
7. Opérateurs au niveau du bit
8. Opérateurs de quarts
9. instance d'opérateur

Les opérateurs Postfix sont considérés comme ayant la priorité la plus élevée selon la priorité des opérateurs Java.

41. Expliquez la différence entre les opérateurs>> et>>>.

Les opérateurs comme>> et>>> semblent être les mêmes mais agissent un peu différemment. L'opérateur>> décale les bits de signe et l'opérateur>>> est utilisé pour décaler les bits remplis de zéros.

Exemple:

// Java Program to demostrate //>Les opérateurs> et>>> importent java.io.* ; // Classe de pilote GFG { public static void main(String[] args) { int a = -16, b = 1;  // Utilisation de>> System.out.println(a >> b);  une = -17 ;  b = 1 ;  // Utilisation de>>> System.out.println(a >>> b);  } }>

-8 2147483639>

42. Quel opérateur Java est correctement associatif ?

Il n’y a qu’un seul opérateur associatif à droite qui est l’opérateur =.

43. Qu'est-ce que l'opérateur point ?

L'opérateur Dot en Java est utilisé pour accéder aux variables d'instance et aux méthodes des objets de classe. Il est également utilisé pour accéder aux classes et sous-packages du package.

44. Qu'est-ce que le type de retour covariant ?

Le type de retour covariant spécifie que le type de retour peut varier dans le même sens que la sous-classe. Il est possible d'avoir différents types de retour pour une méthode de remplacement dans la classe enfant, mais le type de retour de l'enfant doit être un sous-type du type de retour du parent et, de ce fait, la méthode de remplacement devient une variante par rapport au type de retour.

Nous utilisons le type de retour covariant pour les raisons suivantes :

• Évite les conversions de types confuses présentes dans la hiérarchie des classes et rend le code lisible, utilisable et maintenable.
• Donne la liberté d’avoir des types de retour plus spécifiques lors du remplacement des méthodes.
• Aide à empêcher les ClassCastExceptions d’exécution lors des retours.

45. Quel est le mot-clé transitoire ?

Le mot-clé transient est utilisé au moment de la sérialisation si l'on ne souhaite pas enregistrer la valeur d'une variable particulière dans un fichier. Lorsque la JVM rencontre un mot-clé transitoire, elle ignore la valeur d'origine de la variable et enregistre la valeur par défaut de ce type de données variable.

46. ​​Quelle est la différence entre les méthodes sleep() et wait() ?

47. Quelles sont les différences entre String et StringBuffer ?

48. Quelles sont les différences entre StringBuffer et StringBuilder ?

49. Lequel parmi String ou String Buffer faut-il privilégier lorsque de nombreuses mises à jour doivent être effectuées dans les données ?

La chaîne est préférée à StringBuffer car StringBuilder est plus rapide que StringBuffer, mais les objets StringBuffer sont préférés car ils offrent plus de sécurité pour les threads.

50. Pourquoi StringBuffer est-il appelé mutable ?

La classe StringBuffer en Java est utilisée pour représenter une chaîne de caractères modifiable. Il offre une alternative à la classe String immuable en vous permettant de modifier le contenu d’une chaîne sans créer constamment de nouveaux objets. Les chaînes mutables (modifiables) sont créées à l'aide de la classe StringBuffer. La classe StringBuffer en Java est identique à la classe String sauf qu'elle est modifiable.

Exemple:

// Java Program to demonstrate use of stringbuffer public class StringBufferExample {  public static void main(String[] args)  {  StringBuffer s = new StringBuffer();  s.append('Geeks');  s.append('for');  s.append('Geeks');  String message = s.toString();  System.out.println(message);  } }>

techcodeview.com>

51. En quoi la création d'une chaîne à l'aide de new() est-elle différente de celle d'un littéral ?

La chaîne utilisant new() est différente du littéral car lorsque nous déclarons la chaîne, elle stocke les éléments dans la mémoire de la pile tandis que lorsqu'elle est déclarée à l'aide de new(), elle alloue une mémoire dynamique dans la mémoire du tas. L'objet est créé dans la mémoire tas même si le même objet de contenu est présent.

Syntaxe:

String x = new String('ABC');>

52. Qu'est-ce qu'un tableau en Java ?

Un tableau en Java est une structure de données utilisée pour stocker une séquence d'éléments de taille fixe du même type. Les éléments d'un tableau sont accessibles par leur index, qui commence à partir de 0 et va jusqu'à une longueur de moins 1. La déclaration d'un tableau en Java se fait à l'aide de crochets et la taille est également spécifiée lors de la déclaration.

Syntaxe:

int[] Arr = new int[5];>

53. Sur quelles matrices de mémoire sont créées en Java ?

Les tableaux en Java sont créés dans la mémoire tas. Lorsqu'un tableau est créé à l'aide d'un nouveau mot-clé, de la mémoire est allouée dans le tas pour stocker les éléments du tableau. En Java, la mémoire tas est gérée par la machine virtuelle Java (JVM) et elle est également partagée entre tous les threads du programme Java. La mémoire qui n'est plus utilisée par le programme, JVM utilise un garbage collector pour récupérer la mémoire. Les tableaux en Java sont créés dynamiquement, ce qui signifie que la taille du tableau est déterminée pendant l'exécution du programme. La taille du tableau est spécifiée lors de la déclaration du tableau et elle ne peut plus être modifiée une fois le tableau créé.

54. Quels sont les types d’un tableau ?

Il existe deux types de tableaux, à savoir les tableaux primitifs et les tableaux de références.

• Tableaux unidimensionnels : Les tableaux qui n'ont qu'une seule dimension, c'est-à-dire un tableau d'entiers ou un tableau de chaînes, sont appelés tableaux unidimensionnels.

Syntaxe:

data_type[] Array_Name = new data_type[ArraySize];>

• Tableaux multidimensionnels : Tableaux comportant deux dimensions ou plus, tels que des tableaux à deux ou trois dimensions.

55. Pourquoi l'index du tableau Java commence-t-il par 0 ?

L'index d'un tableau signifie la distance depuis le début du tableau. Ainsi, le premier élément a une distance de 0 donc l'indice de départ est 0.

Syntaxe:

[Base Address + (index * no_of_bytes)]>

56. Quelle est la différence entre le tableau int[] et le tableau int[] ?

Les tableaux int array[] et int[] sont utilisés pour déclarer un tableau d'entiers en Java. La seule différence entre eux réside dans leur syntaxe, aucune différence de fonctionnalité n'est présente entre eux.

int arr[] is a C-Style syntax to declare an Array.>

int[] arr is a Java-Style syntax to declare an Array.>

Cependant, il est généralement recommandé d'utiliser une syntaxe de style Java pour déclarer un Array. Comme il est facile à lire et à comprendre, il est également plus cohérent avec les autres constructions du langage Java.

57. Comment copier un tableau en Java ?

En Java, il existe plusieurs façons de copier un tableau en fonction des exigences.

• Méthode clone() en Java : Cette méthode en Java est utilisée pour créer une copie superficielle du tableau donné, ce qui signifie que le nouveau tableau partagera la même mémoire que le tableau d'origine.

int[] Arr = { 1, 2, 3, 5, 0}; int[] tempArr = Arr.clone();>

• Méthode arraycopy() : Pour créer une copie complète du tableau, nous pouvons utiliser cette méthode qui crée un nouveau tableau avec les mêmes valeurs que le tableau d'origine.

int[] Arr = {1, 2, 7, 9, 8}; int[] tempArr = new int[Arr.length]; System.arraycopy(Arr, 0, tempArr, 0, Arr.length);>

• Méthode copyOf() : Cette méthode est utilisée pour créer un nouveau tableau d'une longueur spécifique et copie le contenu du tableau d'origine dans le nouveau tableau.

int[] Arr = {1, 2, 4, 8}; int[] tempArr = Arrays.copyOf(Arr, Arr.length);>

• Méthode copyOfRange() : Cette méthode est très similaire à la méthode copyOf() en Java, mais cette méthode nous permet également de spécifier la plage des éléments à copier à partir du tableau d'origine.

int[] Arr = {1, 2, 4, 8}; int[] temArr = Arrays.copyOfRange(Arr, 0, Arr.length);>

58. Qu'entendez-vous par tableau irrégulier ?

Un tableau irrégulier en Java n'est qu'un tableau bidimensionnel dans lequel chaque ligne du tableau peut avoir une longueur différente. Étant donné que toutes les lignes d'un tableau 2D ont la même longueur, un tableau irrégulier permet plus de flexibilité dans la taille de chaque ligne. Cette fonctionnalité est très utile dans des conditions où les données ont des longueurs variables ou lorsque l'utilisation de la mémoire doit être optimisée.

Syntaxe:

int[][] Arr = new int[][] {  {1, 2, 8},   {7, 5},   {6, 7, 2, 6} };>

59. Est-il possible de rendre un tableau volatile ?

En Java, il n'est pas possible de créer un volatile. Les mots-clés volatils en Java ne peuvent être appliqués qu'à des variables individuelles, mais pas aux tableaux ou aux collections. La valeur de la variable est toujours lue et écrite dans la mémoire principale lorsqu'elle est définie comme volatile plutôt que d'être mise en cache dans la mémoire locale d'un thread. Cela permet de s'assurer plus facilement que tous les threads qui accèdent à la variable peuvent voir les modifications qui y sont apportées.

60. Quels sont les avantages et les inconvénients d’un réseau ?

Les avantages des tableaux sont :

• L'accès direct et efficace à n'importe quel élément de la collection est rendu possible par les tableaux. Les éléments d’un tableau sont accessibles à l’aide d’une opération O(1), ce qui signifie que le temps nécessaire pour y parvenir est constant et indépendant de la taille du tableau.
• Les données peuvent être stockées efficacement en mémoire à l'aide de tableaux. La taille d'un tableau est connue au moment de la compilation puisque ses éléments sont stockés dans des régions mémoire contiguës.
• Étant donné que les données sont stockées dans des zones de mémoire contiguës, les tableaux permettent une récupération rapide des données.
• Les tableaux sont faciles à mettre en œuvre et à comprendre, ce qui en fait un choix idéal pour les débutants qui apprennent la programmation informatique.

Les inconvénients des tableaux sont :

• Les tableaux sont créés avec une taille prédéterminée choisie à ce moment-là. Cela signifie que si la taille du tableau doit être étendue, un nouveau tableau devra être créé et les données devront être copiées de l'ancien tableau vers le nouveau tableau, ce qui peut prendre beaucoup de temps et de mémoire.
• Il peut y avoir de l’espace mémoire inutilisé dans l’espace mémoire d’une baie si la baie n’est pas complètement occupée. Si vous avez un mauvais rappel, cela peut être un problème.
• Comparés à d'autres structures de données telles que les listes chaînées et les arbres, les tableaux peuvent être rigides en raison de leur taille fixe et de leur prise en charge limitée des types de données sophistiqués.
• Étant donné que les éléments d’un tableau doivent tous être du même type de données, il ne prend pas en charge les types de données complexes tels que les objets et les structures.

61. Qu'est-ce qu'un paradigme orienté objet ?

Paradigme signifie littéralement un modèle ou une méthode. Les paradigmes de programmation sont les méthodes permettant de résoudre un programme de quatre types, à savoir impératif, logique, fonctionnel et orienté objet. Lorsque des objets sont utilisés comme entités de base sur lesquelles les méthodes sont appliquées, des fonctionnalités d'encapsulation ou d'héritage sont exécutées, on parle de paradigme orienté objet.

62. Quels sont les principaux concepts des POO en Java ?

Les principaux concepts des POO en Java sont mentionnés ci-dessous :

• Héritage
• Polymorphisme
• Abstraction
• Encapsulation

63. Quelle est la différence entre un langage de programmation orienté objet et un langage de programmation basé sur les objets ?

64. En quoi l'opérateur « new » est-il différent de l'opérateur « newInstance() » en Java ?

l'opérateur new est utilisé pour créer des objets, mais si nous voulons décider du type d'objet à créer au moment de l'exécution, nous ne pouvons pas utiliser l'opérateur new. Dans ce cas, nous devons utiliser le Méthode newInstance() .

65. Que sont les classes en Java ?

En Java, les classes sont une collection d'objets partageant des caractéristiques et des attributs similaires. Les classes représentent le plan ou le modèle à partir duquel les objets sont créés. Les classes ne sont pas des entités du monde réel mais nous aident à créer des objets qui sont des entités du monde réel.

66. Quelle est la différence entre la méthode statique (classe) et la méthode d'instance ?

67. Quel est ce mot-clé en Java ?

« this » est un mot-clé utilisé pour référencer une variable qui fait référence à l'objet actuel.

68. Que sont les brefs spécificateurs d'accès et les types de spécificateurs d'accès ?

Les spécificateurs d'accès en Java aident à restreindre la portée d'une classe, d'un constructeur, d'une variable, d'une méthode ou d'un membre de données. Il existe quatre types de spécificateurs d'accès en Java mentionnés ci-dessous :

1. Publique
2. Privé
3. Protégé
4. Défaut

69. Quelle sera la valeur initiale d'une référence d'objet définie comme variable d'instance ?

La valeur initiale d'une référence d'objet définie comme variable d'instance est une valeur NULL.

70. Qu'est-ce qu'un objet ?

L’objet est une entité réelle à laquelle sont associées certaines propriétés et méthodes. L'objet est également défini comme l'instance d'une classe. Un objet peut être déclaré à l'aide d'un nouveau mot-clé.

71. Quelles sont les différentes manières de créer des objets en Java ?

Les méthodes pour créer des objets en Java sont mentionnées ci-dessous :

1. Utilisation d'un nouveau mot-clé
2. Utiliser une nouvelle instance
3. Utilisation de la méthode clone()
4. Utiliser la désérialisation
5. Utilisation de la méthode newInstance() de la classe Constructor

Pour en savoir plus sur les méthodes de création d'objets en Java, reportez-vous à Cet article .

72. Quels sont les avantages et les inconvénients du clonage d'objets ?

L’utilisation du clonage d’objets présente de nombreux avantages et inconvénients, comme mentionné ci-dessous :

Avantages :

• En Java, l'opérateur d'affectation « = » ne peut pas être utilisé pour le clonage car il crée simplement une copie des variables de référence. Pour surmonter un tel écart, la méthode clone() de la classe Object peut être utilisée sur l'opérateur d'affectation.
• La méthode clone() est une méthode protégée de la classe Object ce qui signifie que seule la classe Employee peut cloner des objets Employee. Cela signifie qu'aucune classe autre que Employee ne peut cloner les objets Employee puisqu'elle ne connaît pas les attributs de la classe Employee.
• La taille du code diminue à mesure que la répétition diminue.
• Permet la réplication (un peu comme un modèle de prototype) en initiant manuellement chaque champ, cela crée un code volumineux si l'objet est complexe, c'est plus rapide avec le clonage.

Désavantages:

• Comme la méthode Object.clone() est protégée, vous devez donc fournir notre propre clone() et appeler indirectement Object.clone() à partir de celle-ci.
• Si nous n'avons aucune méthode, nous devons fournir une interface clonable car nous devons fournir des informations JVM afin que nous puissions effectuer un clone() sur notre objet. Sinon, nous ne pouvons pas cloner, le clone fait une copie superficielle des champs si nous retournez simplement super.clone() à partir de la méthode clone qui peut poser problème.

73. Quels sont les avantages de transmettre cela dans une méthode au lieu de l'objet de classe actuel lui-même ?

Il y a quelques avantages à passer cela dans une méthode au lieu de l'objet de classe actuel lui-même :

• il s'agit de la variable finale à cause de laquelle elle ne peut être attribuée à aucune nouvelle valeur alors que l'objet de classe actuel peut ne pas être final et peut être modifié.
• cela peut être utilisé dans le bloc synchronisé.

74. Qu'est-ce que le constructeur ?

Le constructeur est une méthode spéciale utilisée pour initialiser des objets. Le constructeur est appelé lorsqu'un objet est créé. Le nom du constructeur est le même que celui de la classe.

Exemple:

// Class Created class XYZ{  private int val;    // Constructor  XYZ(){  val=0;  } };>

75. Que se passe-t-il si vous ne fournissez pas de constructeur dans une classe ?

Si vous ne fournissez pas de constructeur dans une classe en Java, le compilateur génère automatiquement un constructeur par défaut sans argument ni opération qui est un constructeur par défaut.

76. Combien de types de constructeurs sont utilisés en Java ?

Il existe deux types de constructeurs en Java, comme mentionné ci-dessous :

1. Constructeur par défaut
2. Constructeur paramétré

Constructeur par défaut : c'est le type qui n'accepte aucune valeur de paramètre. Il est utilisé pour définir les valeurs initiales des attributs d'objet.

class_Name(); // Default constructor called>

Constructeur paramétré : c'est le type de constructeur qui accepte les paramètres comme arguments. Ceux-ci sont utilisés pour attribuer des valeurs aux variables d'instance lors de l'initialisation des objets.

class_Name(parameter1, parameter2......); // All the values passed as parameter will be // allocated accordingly>

77. Quel est le but d'un constructeur par défaut ?

Les constructeurs aident à créer des instances d'une classe ou peuvent être considérés comme créant des objets d'une classe. Le constructeur est appelé lors de l'initialisation des objets. Un constructeur par défaut est un type de constructeur qui n'accepte aucun paramètre. Ainsi, quelle que soit la valeur attribuée aux propriétés des objets, elles sont considérées comme des valeurs par défaut.

78. Qu'entendez-vous par constructeur de copie en Java ?

Le constructeur de copie est le type de constructeur dans lequel nous passons un autre objet en paramètre car les propriétés des deux objets semblent identiques, c'est pourquoi il semble que les constructeurs créent une copie d'un objet.

79. Où et comment faire appel à un constructeur privé ?

Un constructeur privé est utilisé si vous ne souhaitez pas qu’une autre classe instancie l’objet pour éviter le sous-classement. Le constructeur use private peut être considéré comme implémenté dans l’exemple.

Exemple:

// Java program to demonstrate implementation of Singleton // pattern using private constructors. import java.io.*; class GFG {  static GFG instance = null;  public int x = 10;  // private constructor can't be accessed outside the  // class  private GFG() {}  // Factory method to provide the users with instances  static public GFG getInstance()  {  if (instance == null)  instance = new GFG();  return instance;  } } // Driver Class class Main {  public static void main(String args[])  {  GFG a = GFG.getInstance();  GFG b = GFG.getInstance();  a.x = a.x + 10;  System.out.println('Value of a.x = ' + a.x);  System.out.println('Value of b.x = ' + b.x);  } }>

Value of a.x = 20 Value of b.x = 20>

80. Quelles sont les différences entre les constructeurs et les méthodes ?

Les constructeurs Java sont utilisés pour initialiser les objets. Lors de la création, les constructeurs sont appelés pour définir les attributs des objets, à part quelques différences fondamentales entre eux :

1. Les constructeurs ne sont appelés que lorsque l'objet est créé, mais d'autres méthodes peuvent être appelées plusieurs fois au cours de la vie d'un objet.
2. Les constructeurs ne renvoient rien, alors que les autres méthodes peuvent tout renvoyer.
3. Les constructeurs sont habitués à configurer l'état initial mais les méthodes sont utilisées pour effectuer des actions spécifiques.

81. Qu'est-ce qu'une interface ?

Une interface en Java est une collection de variables finales statiques et de méthodes abstraites qui définissent le contrat ou l'accord pour un ensemble de classes liées. Toute classe qui implémente une interface doit implémenter un ensemble spécifique de méthodes. Il spécifie le comportement qu'une classe doit présenter mais pas les détails de la manière dont elle doit être implémentée.

Syntaxe:

interface  {  // constant fields  // methds that are abstract by default }>

Exemple:

0,04 en fraction

// Java Program to demonstrate Interface import java.io.*; interface Shape {  double getArea();  double getPerimeter(); } class Circle implements Shape {  private double radius;  public Circle(double radius) { this.radius = radius; }  public double getArea()  {  return Math.PI * radius * radius;  }  public double getPerimeter()  {  return 2 * Math.PI * radius;  } } class GFG {  public static void main(String[] args)  {  Circle circle = new Circle(5.0);  System.out.println('Area of circle is '  + circle.getArea());  System.out.println('Perimeter of circle is'  + circle.getPerimeter());  } }>

Area of circle is 78.53981633974483 Perimeter of circle is31.41592653589793>

82. Donnez quelques fonctionnalités de l'interface.

Une interface dans le langage de programmation Java est définie comme un type abstrait utilisé pour spécifier le comportement d'une classe. Une interface en Java est un modèle de comportement. Une interface Java contient des constantes statiques et des méthodes abstraites.

Les fonctionnalités de l'interface sont mentionnées ci-dessous :

• L'interface peut aider à atteindre une abstraction totale.
• Nous permet d'utiliser plusieurs héritages en Java.
• N'importe quelle classe peut implémenter plusieurs interfaces même lorsqu'une classe ne peut étendre qu'une seule classe.
• Il est également utilisé pour obtenir un couplage lâche.

83. Qu'est-ce qu'une interface de marqueur ?

Une interface est reconnue comme une interface vide (sans champ ni méthode), elle est appelée interface marqueur. Des exemples d'interfaces de marqueur sont les interfaces sérialisables, clonables et distantes.

84. Quelles sont les différences entre la classe abstraite et l'interface ?

85. Qu'entendez-vous par encapsulation des données ?

L'encapsulation de données est le concept de propriétés OOPS et de caractéristiques des classes que l'interface est liée entre elles. Fondamentalement, il regroupe les données et les méthodes qui fonctionnent sur ces données au sein d’une seule unité. L'encapsulation est réalisée en déclarant les variables d'instance d'une classe comme privées, ce qui signifie qu'elles ne sont accessibles qu'au sein de la classe.

86. Quels sont les avantages de l'encapsulation en Java ?

Les avantages de l'encapsulation en Java sont mentionnés ci-dessous :

1. Masquage des données : c'est un moyen de restreindre l'accès de nos données membres en masquant les détails de mise en œuvre. L'encapsulation permet également de masquer les données. L'utilisateur n'aura aucune idée de l'implémentation interne de la classe.
2. Flexibilité accrue : nous pouvons rendre les variables de la classe en lecture seule ou en écriture seule selon nos besoins.
3. Réutilisabilité : l'encapsulation améliore également la réutilisation et est facile à modifier en fonction des nouvelles exigences.
4. Tester le code est simple : le code est facile à tester pour les tests unitaires.

87. Quel est le principal avantage de l’encapsulation ?

Le principal avantage de l'encapsulation en Java est sa capacité à protéger l'état interne d'un objet contre toute modification ou accès externe. C'est un moyen de masquer les détails d'implémentation d'une classe aux accès extérieurs et d'exposer uniquement une interface publique qui peut être utilisée pour interagir avec la classe. Le principal avantage est de fournir un moyen de contrôler et de gérer l’état et le comportement d’un objet tout en le protégeant contre les modifications et les accès non autorisés.

Exemple:

// Java Program to demonstrate use of Encapsulation import java.io.*; class Person {  private String Name;  private int age;  public String getName() { return Name; }  public void setName(String Name) { this.Name = Name; }  public int getAge() { return age; }  public void setAge(int age) { this.age = age; } } // Driver class class GFG {  // main function  public static void main(String[] args)  {  Person p = new Person();  p.setName('Rohan');  p.setAge(29);  System.out.println('Name is ' + p.getName());  System.out.println('Age is ' + p.getAge());  } }>

Name is Rohan Age is 29>

88. Qu’entendez-vous par agrégation ?

L'agrégation est un terme lié à la relation entre deux classes mieux décrite comme une relation has-a. Ce type est la version la plus spécialisée de l'association. Il s’agit d’une association unidirectionnelle, ce qui signifie qu’il s’agit d’une relation à sens unique. Il contient la référence à une autre classe et est censé en être propriétaire.

89. Quelle est la relation « IS-A » dans les POO Java ?

'IS-A' est un type de relation dans les POO Java où une classe hérite d'une autre classe.

90. Définir l'héritage.

Lorsqu'un objet appartenant à une sous-classe acquiert toutes les propriétés et le comportement d'un objet parent appartenant à la superclasse, on parle d'héritage. Une classe au sein d’une classe est appelée sous-classe et cette dernière est appelée superclasse. La sous-classe ou la classe enfant est dite spécifique alors que la superclasse ou la classe parent est générique. L'héritage permet la réutilisabilité du code.

91. Quels sont les différents types d’héritage en Java ?

L'héritage est la méthode par laquelle la classe Child peut hériter des fonctionnalités de la classe Super ou Parent. En Java, l'héritage est de quatre types :

• Héritage unique : Lorsqu’un enfant ou une sous-classe n’étend qu’une seule superclasse, il s’agit d’un héritage unique. Les propriétés de la classe monoparentale sont transmises à la classe enfant.
• Héritage multiniveau : Lorsqu'un enfant ou une sous-classe étend une autre sous-classe, une hiérarchie d'héritage est créée, appelée héritage multiniveau. En d’autres termes, une sous-classe devient la classe parent d’une autre.
• Héritage hiérarchique : Lorsque plusieurs sous-classes dérivent de la même classe parent, on parle d’héritage hiérarchique. En d’autres termes, une classe qui n’a qu’un seul parent possède de nombreuses sous-classes.
• Héritage multiple : Lorsqu’une classe enfant hérite de plusieurs classes parents, on parle d’héritage multiple. En Java, il ne prend en charge que l'héritage multiple d'interfaces, pas de classes.

92. Qu'est-ce que l'héritage multiple ? Est-il supporté par Java ?

Un composant de la notion orientée objet appelé héritages multiples permet à une classe d'hériter des propriétés de nombreuses classes parentes. Lorsque des méthodes portant la même signature sont présentes à la fois dans les superclasses et les sous-classes, un problème survient. L’appelant de la méthode ne peut pas spécifier au compilateur quelle méthode de classe doit être appelée ni même quelle méthode de classe doit avoir la priorité.

Note: Java ne prend pas en charge l'héritage multiple

Exemple:

// Java Program to show multiple Inheritance import java.io.*; interface Animal {  void eat(); } interface Mammal {  void drink(); } class Dog implements Animal, Mammal {  public void eat() { System.out.println('Eating'); }  public void drink() { System.out.println('Drinking'); }  void bark() { System.out.println('Barking'); } } class GFG {  public static void main(String[] args)  {  Dog d = new Dog();  d.eat();  d.drink();  d.bark();  } }>

Eating Drinking Barking>

93. En quoi l'héritage en C++ est-il différent de Java ?

94. Y a-t-il des limites à l'utilisation de l'héritage ?

Oui, il existe une limitation à l'utilisation de l'héritage en Java, car en raison de l'héritage, on peut tout hériter de la super classe et de l'interface, car la sous-classe est trop regroupée et parfois sujette aux erreurs lors d'une substitution dynamique ou d'une surcharge dynamique dans certaines situations.

95. Bien que l’héritage soit un concept populaire des POO, il est moins avantageux que la composition. Expliquer.

L'héritage est un concept populaire de programmation orientée objet (POO), dans lequel une classe peut hériter des propriétés et des méthodes de toute autre classe, appelée parent ou superclasse. D'un autre côté, dans Composition, une classe peut contenir une instance d'une autre classe en tant que variable membre, souvent appelée partie ou composant. Voici quelques raisons pour lesquelles la composition est plus avantageuse que l’héritage :

• Couplage serré: Chaque fois que des modifications sont apportées à la superclasse, ces modifications peuvent affecter le comportement de tous ses enfants ou sous-classes. Ce problème rend le code moins flexible et crée également des problèmes lors de la maintenance. Ce problème conduit également au couplage étroit entre les classes.
• Problème de classe de base fragile : Lorsque les modifications apportées à la classe de base peuvent interrompre la fonctionnalité de ses classes dérivées. Ce problème peut rendre difficile l'ajout de nouvelles fonctionnalités ou la modification de celles existantes. Ce problème est connu sous le nom de problème de classe Fragile Base.
• Réutilisation limitée : L'héritage en Java peut conduire à une réutilisation limitée du code ainsi qu'à une duplication de code. Comme une sous-classe hérite de toutes les propriétés et méthodes de sa superclasse, elle peut parfois se retrouver avec du code inutile qui n'est pas nécessaire. Cela conduit à une base de code moins maintenable.

96. Qu'est-ce qu'une association ?

L'association est une relation entre deux classes distinctes établies à travers leurs objets. Cela représente la relation de Has-A.

97. Qu’entendez-vous par agrégation ?

La composition est une forme restreinte d'agrégation dans laquelle deux entités sont fortement dépendantes l'une de l'autre. Cela représente partie de la relation.

98. Quelle est la composition de Java ?

La composition implique une relation où l'enfant ne peut pas exister indépendamment du parent. Par exemple, le cœur humain, le cœur n’existe pas séparément d’un humain.

99. Énoncez la différence entre la composition et l’agrégation.

100. Le constructeur peut-il être hérité ?

Non, nous ne pouvons pas hériter d'un constructeur.

101. Qu'est-ce que le polymorphisme ?

Le polymorphisme est défini comme la capacité de prendre plusieurs formes. Il est de deux types, à savoir le polymorphisme au moment de la compilation ou la surcharge de méthode - une fonction appelée pendant la compilation. Par exemple, prenons une « zone » de classe. En fonction du nombre de paramètres, il peut calculer l'aire d'un carré, d'un triangle ou d'un cercle. Polymorphisme au moment de l'exécution ou remplacement de méthode - liens pendant l'exécution. La méthode à l’intérieur d’une classe remplace la méthode de la classe parent.

102. Qu'est-ce que le polymorphisme d'exécution ou la répartition de méthode dynamique ?

La répartition dynamique des méthodes est un mécanisme de résolution du remplacement de méthode pendant l'exécution. Le remplacement de méthode est celui où la méthode d'une sous-classe a le même nom, les mêmes paramètres et le même type de retour qu'une méthode de la superclasse. Lorsque la méthode remplacée est appelée via une référence de superclasse, Java détermine quelle version (superclasse ou sous-classe) de cette méthode doit être exécutée en fonction du type d'objet auquel il est fait référence au moment de l'appel. La décision est donc prise au moment de l'exécution. C’est ce qu’on appelle la répartition de méthode dynamique.

103. Qu'est-ce que la substitution de méthode ?

Le remplacement de méthode, également connu sous le nom de polymorphisme d'exécution, est celui où la classe enfant contient la même méthode que la classe parent. Par exemple, nous avons une méthode nommée « gfg() » dans la classe parent. Une méthode gfg() est à nouveau définie dans la sous-classe. Ainsi, lorsque gfg() est appelé dans la sous-classe, la méthode de l'identifiant de classe est exécutée. Ici, gfg() dans la classe a remplacé la méthode à l'extérieur.

104. Qu'est-ce que la surcharge de méthode ?

Le remplacement de méthode est une méthode permettant d'obtenir le polymorphisme d'exécution en Java. La substitution de méthode est une fonctionnalité qui permet à une classe enfant de fournir une implémentation spécifique d'une méthode déjà fournie par l'une de ses classes parentes. Lorsqu'une méthode d'une classe enfant a le même nom, les mêmes paramètres ou signature et le même type de retour (ou sous-type) qu'une méthode de sa classe parent, alors la méthode de la sous-classe est censée remplacer la méthode dans la superclasse.

105. Pouvons-nous remplacer la méthode statique ?

Non, car les méthodes statiques font partie de la classe plutôt que de l'objet, nous ne pouvons donc pas les remplacer.

106. Pouvons-nous remplacer la méthode surchargée ?

Oui, puisque la méthode surchargée est une méthode complètement différente aux yeux du compilateur. Remplacer n’est pas du tout la même chose. La décision quant à la méthode à appeler est reportée au moment de l'exécution.

107. Pouvons-nous surcharger la méthode main() ?

Oui, en Java, nous pouvons surcharger la méthode principale pour appeler la méthode principale à l'aide de sa méthode d'appel prédéfinie.

108. Que sont la surcharge et le remplacement de méthode ?

Surcharge de méthode : Il est également connu sous le nom de polymorphisme au moment de la compilation. Lors de la surcharge de méthodes, deux méthodes ou plus sont partagées dans la même classe avec une signature différente.

Exemple:

// Java Program to demonstrate use of Method Overloading import java.io.*; class GFG {  static int multiply(int a, int b) { return a * b; }  static int multiply(int a, int b, int c)  {  return a * b * c;  }  static int multiply(int a, int b, int c, int d)  {  return a * b * c * d;  }  public static void main(String[] args)  {  System.out.println('multiply() with 2 parameters');  System.out.println(multiply(4, 5));  System.out.println('multiply() with 3 parameters');  System.out.println(multiply(2, 3, 4));  System.out.println('multiply() with 4 parameters');  System.out.println(multiply(2, 3, 4, 1));  } }>

multiply() with 2 parameters 20 multiply() with 3 parameters 24 multiply() with 4 parameters 24>

Remplacement de méthode : Le remplacement de méthode se produit lorsqu'une sous-classe peut fournir l'implémentation d'une méthode déjà définie dans la classe ou la superclasse parent. Le type de retour, le nom et les arguments doivent être similaires aux méthodes de la superclasse.

Exemple:

// Java Program to demonstrate use of Method Overriding import java.io.*; class Vehicle {  void drive()  {  System.out.println('drive() method of base class');  System.out.println('driving the Car.');  } } class Car extends Vehicle {  void drive()  {  System.out.println(  'drive() method of derived class');  System.out.println('Car is driving.');  } } class GFG {  public static void main(String[] args)  {  Car c1 = new Car();  Vehicle v1 = new Vehicle();  c1.drive();  v1.drive();  Vehicle vehicle = new Car();  // drive() method of Vehicle class is overridden by  // Car class drive()  vehicle.drive();  } }>

drive() method of derived class Car is driving. drive() method of base class driving the Car. drive() method of derived class Car is driving.>

109. Pouvons-nous remplacer les méthodes privées ?

Il n'est pas possible de remplacer les méthodes privées en Java. Le remplacement de méthode est l'endroit où la méthode de la sous-classe est implémentée à la place de la méthode de la classe parent. Les méthodes privées ne sont accessibles qu'au sein de la classe dans laquelle elles sont déclarées. Étant donné que cette méthode n’est pas visible par les autres classes et n’est pas accessible, elle ne peut pas être remplacée.

110. Pouvons-nous modifier la portée de la méthode remplacée dans la sous-classe ?

En Java, il n’est pas possible de modifier la portée de la méthode remplacée. La portée de la méthode de sous-classe doit être égale ou plus large que la portée de la méthode remplacée par la méthode Superclass. La méthode substituée dans la sous-classe, par exemple, peut avoir une portée publique ou une portée plus accessible comme protected ou default si la méthode substituée dans la superclasse a une portée publique. Elle ne peut cependant pas avoir une portée plus exclusive comme privée.

111. Pouvons-nous modifier la clause throws de la méthode superclasse tout en la remplaçant dans la sous-classe ?

Nous pouvons modifier la clause throws de la méthode Superclass avec certaines limitations, nous pouvons changer la clause throws de la méthode superclass tout en la remplaçant dans la sous-classe. La méthode de substitution de sous-classe ne peut spécifier des exceptions non vérifiées que si la méthode de superclasse ne déclare aucune exception. Si la méthode superclasse déclare une exception, la méthode sous-classe peut déclarer la même exception, une exception de sous-classe ou aucune exception. Cependant, la méthode de sous-classe ne peut pas déclarer une exception parent plus large que celles déclarées dans la méthode de superclasse.

112. Pouvez-vous avoir des fonctions virtuelles en Java ?

Oui, Java prend en charge les fonctions virtuelles. Les fonctions sont virtuelles par défaut et peuvent être rendues non virtuelles à l'aide du mot-clé final.

113. Qu'est-ce que l'abstraction ?

L'abstraction fait référence à l'acte de représenter des caractéristiques essentielles sans inclure les détails d'arrière-plan. Les informations détaillées ou la mise en œuvre sont masquées. L'exemple d'abstraction le plus courant est une voiture, nous savons comment allumer le moteur, accélérer et se déplacer, cependant, la façon dont le moteur fonctionne et ses composants internes sont une logique complexe cachée aux utilisateurs généraux. Ceci est généralement fait pour gérer la complexité.

114. Qu'est-ce que la classe abstraite ?

Une classe déclarée abstraite ne peut pas être instanciée, c'est-à-dire que l'objet ne peut pas être créé. Elle peut contenir ou non des méthodes abstraites mais si une classe possède au moins une méthode abstraite, elle doit être déclarée abstraite.

Exemple de classe abstraite avec méthode abstraite :

// Java Program to implement // abstract method import java.io.*; // Abstract class abstract class Fruits {  abstract void run(); } // Driver Class class Apple extends Fruits {  void run()  {  System.out.println('Abstract class example');  }  // main method  public static void main(String args[])  {  Fruits obj = new Apple();  obj.run();  } }>

115. Quand les méthodes abstraites sont-elles utilisées ?

Une méthode abstraite est utilisée lorsque nous voulons utiliser une méthode mais que nous voulons que les classes enfants décident de l'implémentation. Dans ce cas, nous utilisons des méthodes abstraites avec les classes parentes.

116. Comment pouvez-vous éviter la sérialisation dans la classe enfant si la classe de base implémente l'interface Serialisable ?

Sérialisation dans la classe enfant si la classe de base implémente l'interface Serialisable, nous pouvons l'éviter en définissant la méthode writeObject() et en lançant NotSerializingException().

117. Qu'est-ce que Collection Framework en Java ?

Les collections sont des unités d'objets en Java. Le framework de collection est un ensemble d'interfaces et de classes en Java utilisées pour représenter et manipuler des collections d'objets de diverses manières. Le cadre de collection contient des classes (ArrayList, Vector, LinkedList, PriorityQueue, TreeSet) et plusieurs interfaces (Set, List, Queue, Deque) où chaque interface est utilisée pour stocker un type spécifique de données.

118. Expliquer les différentes interfaces utilisées dans le framework Collection.

Implémentations du cadre de collecte

1. Interface de collecte
2. Interface de liste
3. Définir l'interface
4. Interface de file d'attente
5. Et l'interface
6. Interface cartographique

Interface de collecte : Collection est la principale interface disponible qui peut être importée à l'aide de java.util.Collection.

Syntaxe:

public interface Collection extends iterable>

119. Comment synchroniser une ArrayList en Java ?

Une ArrayList peut être synchronisée à l'aide de deux méthodes mentionnées ci-dessous :

1. Utilisation de Collections.synchronizedList()
2. Utilisation de CopyOnWriteArrayList

Utilisation de Collections.synchronizedList() :

public static List synchronizedList(List list)>

Utilisation de CopyOnWriteArrayList :

1. Créez une liste vide.
2. Il implémente l'interface List
3. Il s'agit d'une variante thread-safe d'ArrayList
4. T représente générique

120. Pourquoi avons-nous besoin d'une ArrayList synchronisée alors que nous avons des vecteurs (qui sont synchronisés) en Java ?

ArrayList est nécessaire même lorsque nous avons des vecteurs pour certaines raisons :

1. ArrayList est plus rapide que Vectors.
2. ArrayList prend en charge le multithreading alors que Vectors ne prend en charge que l'utilisation d'un seul thread.
3. ArrayList est plus sûr à utiliser, car les vecteurs prennent en charge les threads uniques et les opérations individuelles sont moins sûres et prennent plus de temps à synchroniser.
4. Les vecteurs sont considérés comme obsolètes en Java en raison de leur nature synchronisée.

121. Pourquoi ne pouvons-nous pas créer un tableau générique ?

Les tableaux génériques ne peuvent pas être créés car un tableau porte tapez les informations de ses éléments au moment de l’exécution, ce qui fait que pendant l’exécution, il lance « ArrayStoreException » si le type des éléments n’est pas similaire. Étant donné que les informations de type générique sont effacées au moment de la compilation par Type Erasure, la vérification du magasin de tableau aurait été réussie là où elle aurait dû échouer.

122. Les emplacements mémoire contigus sont généralement utilisés pour stocker les valeurs réelles dans un tableau mais pas dans ArrayList. Expliquer.

Les éléments d'un tableau sont stockés dans des emplacements mémoire contigus, ce qui signifie que chaque élément est stocké dans un bloc distinct basé sur celui-ci situé dans le tableau. Étant donné que les éléments du tableau sont stockés dans des emplacements contigus, il peut être relativement facile d'accéder à n'importe quel élément par son index, car l'adresse de l'élément peut être calculée en fonction de l'emplacement de l'élément. Mais Java implémente les ArrayLists sous forme de tableaux dynamiques, ce qui signifie que la taille peut changer à mesure que des éléments sont supprimés ou ajoutés. Les éléments ArrayList ne sont pas stockés dans des emplacements mémoire contigus afin de s'adapter à cette nature dynamique. Au lieu de cela, ArrayList utilise une méthode connue sous le nom de tableau extensible dans laquelle le tableau sous-jacent est étendu à une taille plus grande selon les besoins et les éléments sont ensuite copiés vers le nouvel emplacement. Contrairement à une ArrayList, qui a une taille dynamique et ne stocke pas ses éléments dans des emplacements mémoire contigus, un tableau a une taille fixe et ses éléments y sont stockés.

123. Expliquez la méthode pour convertir ArrayList en Array et Array en ArrayList.

Conversion de liste en ArrayList

Il existe plusieurs méthodes pour convertir List en ArrayList

Les programmeurs peuvent convertir un tableau en ArrayList en utilisant la méthode asList() de la classe Arrays. C'est une méthode statique de la classe Arrays qui accepte l'objet List.

Syntaxe:

Arrays.asList(item)>

Exemple:

// Java program to demonstrate conversion of // Array to ArrayList of fixed-size. import java.util.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  {  String[] temp = { 'Abc', 'Def', 'Ghi', 'Jkl' };  // Conversion of array to ArrayList  // using Arrays.asList  List conv = Arrays.asList(temp);  System.out.println(conv);  } }>

[Abc, Def, Ghi, Jkl]>

Conversion de ArrayList en tableau

Les programmeurs Java peuvent convertir ArrayList en

Syntaxe:

List_object.toArray(new String[List_object.size()])>

Exemple:

// Java program to demonstrate working of // Objectp[] toArray() import java.io.*; import java.util.List; import java.util.ArrayList; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  {  // List declared  List<Integer>  arr = new ArrayList<Integer>();  arr.add(1);  arr.add(2);  arr.add(3);  arr.add(2);  arr.add(1);  // Conversion  Object[] objects = arr.toArray();  // Printing array of objects  for (Object obj : objects)  System.out.print(obj + ' ');  } }>

1 2 3 2 1>

124. Comment la taille d'ArrayList augmente-t-elle de manière dynamique ? Et indiquez également comment il est mis en œuvre en interne.

En raison de la nature basée sur un tableau ArrayLists, sa taille augmente de manière dynamique, garantissant qu'il y a toujours suffisamment de place pour les éléments. Lorsqu'un élément ArrayList est créé pour la première fois, la capacité par défaut est d'environ 10 à 16 éléments, ce qui dépend essentiellement de la version de Java. Les éléments ArrayList sont copiés du tableau d'origine vers le nouveau tableau lorsque la capacité du tableau d'origine est pleine. À mesure que la taille d'ArrayList augmente dynamiquement, la classe crée un nouveau tableau de plus grandes tailles et copie tous les éléments de l'ancien tableau vers le nouveau tableau. Désormais, la référence du nouveau tableau est utilisée en interne. Ce processus de croissance dynamique d’un tableau est appelé redimensionnement.

125. Qu'est-ce qu'un vecteur en Java ?

Les vecteurs en Java sont similaires et peuvent stocker plusieurs éléments à l’intérieur. Les vecteurs suivent certaines règles mentionnées ci-dessous :

1. Le vecteur peut être importé à l’aide de Java.util.Vector.
2. Le vecteur est implémenté à l'aide d'un tableau dynamique à mesure que la taille du vecteur augmente et diminue en fonction des éléments qui y sont insérés.
3. Éléments du vecteur utilisant des numéros d'index.
4. Les vecteurs sont de nature synchronisée, ce qui signifie qu'ils n'utilisent qu'un seul thread (un seul processus est effectué à un moment donné).
5. Le vecteur contient de nombreuses méthodes qui ne font pas partie du framework des collections.

Syntaxe:

Vector gfg = new Vector(size, increment);>

126. Comment rendre Java ArrayList en lecture seule ?

Une ArrayList ne peut être préparée qu'à l'aide de la méthode fournie par Collections à l'aide de la méthode Collections.unmodifiableList().

Syntaxe:

array_readonly = Collections.unmodifiableList(ArrayList);>

Exemple:

// Java program to demonstrate // unmodifiableList() method import java.util.*; public class Main {  public static void main(String[] argv) throws Exception  {  try {  // creating object of ArrayList  <Character> ArrayList<Character>  temp  = new ArrayList<Character>();  // populate the list  temp.add('X');  temp.add('Y');  temp.add('Z');  // printing the list  System.out.println('Initial list: ' + temp);  // getting readonly list  // using unmodifiableList() method  List<Character>  new_array  = Collections.unmodifiableList(temp);  // printing the list  System.out.println('ReadOnly ArrayList: '  + new_array);  // Adding element to new Collection  System.out.println('
If add element in '  + ' the ReadOnly ArrayList');  new_array.add('A');  }  catch (UnsupportedOperationException e) {  System.out.println('Exception is thrown : '  + e);  }  } }>

Initial list: [X, Y, Z] ReadOnly ArrayList: [X, Y, Z] If add element in the ReadOnly ArrayList Exception is thrown : java.lang.UnsupportedOperationException>

127. Qu'est-ce qu'une file d'attente prioritaire en Java ?

Une file d'attente prioritaire est un type de données abstrait similaire à une structure de données de file d'attente ou de pile normale. Les éléments stockés dans elements dépendent de la priorité définie de faible à élevée. PriorityQueue est basé sur le tas prioritaire.

Syntaxe:

// Java program to demonstrate the // working of PriorityQueue import java.util.*; class PriorityQueueDemo {  // Main Method  public static void main(String args[])  {  // Creating empty priority queue  PriorityQueue<Integer>  var1  = new PriorityQueue<Integer>();  // Adding items to the pQueue using add()  var1.add(10);  var1.add(20);  var1.add(15);  // Printing the top element of PriorityQueue  System.out.println(var1.peek());  } }>

10>

128. Expliquez la classe LinkedList.

La classe LinkedList est Java qui utilise une liste doublement chaînée pour stocker des éléments. Il hérite de la classe AbstractList et implémente les interfaces List et Deque. Les propriétés de la classe LinkedList sont mentionnées ci-dessous :

1. Les classes LinkedList ne sont pas synchronisées.
2. Conserve l’ordre d’insertion.
3. Il peut être utilisé comme liste, pile ou file d'attente.

Syntaxe:

LinkedList list_name=new LinkedList();>

129. Qu'est-ce que la classe Stack en Java et quelles sont les différentes méthodes qu'elle fournit ?

Une classe Stack en Java est une structure de données LIFO qui implémente la structure de données Last In First Out. Elle est dérivée d'une classe Vector mais possède des fonctions spécifiques aux piles. La classe Stack en Java fournit les méthodes suivantes :

• coup d'oeil() : renvoie l'élément le plus haut de la pile sans le supprimer
• vide(): renvoie vrai si la pile est vide et faux sinon
• pousser(): pousse un élément en haut de la pile
• populaire(): supprime et renvoie l'élément supérieur de la pile
• recherche(): renvoie la position basée sur 1 de l'objet à partir du haut de la pile. Si l'objet n'est pas dans la pile, il renvoie -1

130. Qu'est-ce qui est défini dans le framework Java Collections et répertoriez ses différentes implémentations ?

Les ensembles sont des collections qui ne stockent pas d’éléments en double. Ils ne respectent aucun ordre des éléments. Le framework Java Collections fournit plusieurs implémentations de l'interface Set, notamment :

• Ensemble de hachage : HashSet en Java, stocke les éléments dans une table has qui permet des recherches et une insertion plus rapides. HashSet n'est pas commandé.
• LinkedHashSet : LinkedHashSet est une implémentation de HashSet qui maintient l'ordre d'insertion des éléments.
• Ensemble d'arbres : TreeSet stocke les éléments dans un ordre trié déterminé par l'ordre naturel des éléments ou par un comparateur personnalisé fourni au moment de la création.

131. Qu'est-ce que la classe HashSet en Java et comment stocke-t-elle les éléments ?

La classe HashSet implémente l'interface Set dans Java Collections Framework et est membre de la classe HashSet. Contrairement aux valeurs en double, il stocke une collection d’éléments distincts. Dans cette implémentation, chaque élément est mappé à un index dans un tableau à l'aide d'une fonction de hachage, et l'index est utilisé pour accéder rapidement à l'élément. Il produit un index pour l'élément du tableau où il est stocké en fonction de l'élément d'entrée. En supposant que la fonction de hachage distribue les éléments entre les compartiments de manière appropriée, la classe HashSet fournit des performances en temps constant pour les opérations de base (ajouter, supprimer, contenir et taille).

132. Qu'est-ce que LinkedHashSet dans Java Collections Framework ?

Le LinkedHashSet est une version ordonnée de Hashset maintenue par une liste doublement liée sur tous les éléments. C'est très utile lorsque l'ordre des itérations est nécessaire. Lors de l'itération dans LinkedHashSet, les éléments sont renvoyés dans le même ordre dans lequel ils sont insérés.

Syntaxe:

LinkedHashSet hs = new LinkedHashSet();>

Exemple:

// Java Program to implement // LinkedHashSet import java.io.*; import java.util.*; // Driver Class class GFG {  // Main Function  public static void main(String[] args)  {  // LinkedHashSet declared  LinkedHashSet<Integer>  hs = new LinkedHashSet<Integer>();  // Add elements in HashSet  hs.add(1);  hs.add(2);  hs.add(5);  hs.add(3);  // Print values  System.out.println('Values:' + hs);  } }>

Values:[1, 2, 5, 3]>

133. Qu'est-ce qu'une interface Map en Java ?

L'interface cartographique est présente dans la collection Java et peut être utilisée avec le package Java.util. Une interface cartographique est utilisée pour mapper les valeurs sous la forme d'une forme clé-valeur. La carte contient toutes les clés uniques. En outre, il fournit des méthodes qui lui sont associées comme containKey(), contain value(), etc.

Il existe plusieurs types de cartes dans l'interface cartographique, comme mentionné ci-dessous :

1. Carte triée
2. ArbreCarte
3. Carte de hachage
4. LinkedHashMap

134. Expliquer Treemap en Java

TreeMap est un type de carte qui stocke les données sous forme de paire clé-valeur. Il est implémenté à l’aide de l’arbre rouge-noir. Les fonctionnalités de TreeMap sont :

1. Il ne contient que des éléments uniques.
2. Il ne peut pas avoir de clé NULL
3. Il peut avoir plusieurs valeurs NULL.
4. Il n'est pas synchronisé.
5. Il maintient l'ordre croissant.

135. Qu'est-ce qu'EnumSet ?

EnumSet est une implémentation spécialisée de l’interface Set à utiliser avec le type énumération. Quelques fonctionnalités d'EnumSet sont :

1. Il n'est pas synchronisé.
2. Plus rapide que HashSet.
3. Tous les éléments d’un EnumSet doivent provenir d’un seul type d’énumération.
4. Il n'autorise pas les objets nuls et lève NullPointerException pour les exceptions.
5. Il utilise un itérateur de sécurité.

Syntaxe:

public abstract class EnumSet>

Paramètre: E précise les éléments.

136. Qu'est-ce que BlockingQueue ?

Une file d'attente bloquante est une file d'attente qui prend en charge les opérations qui attendent que la file d'attente ne soit pas vide lors de la récupération et de la suppression de l'élément, et attendent que de l'espace soit disponible dans la file d'attente lors de l'ajout de l'élément.

Syntaxe:

public interface BlockingQueue extends Queue>

Paramètres: E est le type d'éléments stockés dans la Collection

137. Qu'est-ce que ConcurrentHashMap en Java et l'implémentez-vous ?

ConcurrentHashMap est implémenté à l'aide de Hashtable.

Syntaxe:

public class ConcurrentHashMap  extends AbstractMap  implements ConcurrentMap, Serializable>

Paramètres : K est le type d'objet clé et V est le type d'objet valeur

138. Pouvez-vous utiliser n'importe quelle classe comme clé de carte ?

Oui, nous pouvons utiliser n'importe quelle classe comme Map Key si elle suit certaines règles prédéfinies mentionnées ci-dessous :

1. La classe remplaçant la méthode equals() doit également remplacer la méthode hashCode()
2. La classe concurrentHashMap est thread-safe.
3. Le niveau de concurrence par défaut de ConcurrentHashMap est 16.
4. L'insertion d'objets nuls dans ConcurrentHashMap n'est pas possible en tant que clé ou valeur.

139. Qu'est-ce qu'un itérateur ?

L'interface Iterator fournit des méthodes pour parcourir n'importe quelle collection en Java. Iterator remplace Enumeration dans Java Collections Framework. Il peut obtenir une instance d'itérateur d'une collection en utilisant la méthode _iterator()_. Cela permet également à l'appelant de supprimer des éléments de la collection sous-jacente pendant l'itération.

140. Qu'est-ce qu'une énumération ?

L'énumération est un type de données défini par l'utilisateur. Il est principalement utilisé pour attribuer des noms aux constantes intégrales, les noms rendent un programme facile à lire et à maintenir. L'objectif principal de l'énumération est de définir des types de données définis par l'utilisateur.

Exemple:

// A simple enum example where enum is declared  // outside any class (Note enum keyword instead of  // class keyword)  enum Color  {   RED, GREEN, BLUE;  }>

141. Quelle est la différence entre Collection et Collections ?

142. Faites la différence entre Array et ArrayList en Java.

143. Quelle est la différence entre un tableau et une collection en Java ?

144. Différence entre ArrayList et LinkedList.

145. Faites la différence entre ArrayList et Vector en Java.

146. Quelle est la différence entre Iterator et ListIterator ?

147. Faites la différence entre HashMap et HashTable.

148. Quelle est la différence entre Itérateur et Énumération ?

149. Quelle est la différence entre Comparable et Comparateur ?

150. Quelle est la différence entre Set et Map ?

Questions d'entretien intermédiaire Java

151. Expliquez l'itérateur FailFast et l'itérateur FailSafe ainsi que des exemples pour chacun.

Un itérateur FailFast est un itérateur qui lance un ConcurrentModificationException s'il détecte que la collection sous-jacente a été modifiée pendant l'utilisation de l'itérateur. Il s'agit du comportement par défaut des itérateurs dans Java Collections Framework. Par exemple, l'itérateur d'un HashMap est FailFast.

Exemple:

// Java Program to demonstrate FailFast iterator import java.io.*; import java.util.HashMap; import java.util.Iterator; import java.util.Map; class GFG {  public static void main(String[] args)  {  HashMap<Integer, String> map = new HashMap<>();  map.put(1, 'one');  map.put(2, 'two');  Iterator<Map.Entry<Integer, String> > iterator  = map.entrySet().iterator();  while (iterator.hasNext()) {  Map.Entry<Integer, String> entry  = iterator.next();  // this will throw a  // ConcurrentModificationException  if (entry.getKey() == 1) {  map.remove(1);  }  }  } }>

Sortir:

Exception in thread 'main' java.util.ConcurrentModificationException>

Un itérateur FailSafe ne lance pas de message ConcurrentModificationException si la collection sous-jacente est modifiée pendant l'utilisation de l'itérateur. Alternativement, il crée un instantané de la collection au moment où l'itérateur est créé et parcourt l'instantané. Par exemple, l'itérateur d'un ConcurrentHashMap est FailSafe.

Exemple:

// Java Program to demonstrate FailSafe import java.io.*; import java.util.Iterator; import java.util.Map; import java.util.concurrent.ConcurrentHashMap; class GFG {  public static void main(String[] args)  {  ConcurrentHashMap<Integer, String> map  = new ConcurrentHashMap<>();  map.put(1, 'one');  map.put(2, 'two');  Iterator<Map.Entry<Integer, String> > iterator  = map.entrySet().iterator();  while (iterator.hasNext()) {  Map.Entry<Integer, String> entry = iterator.next();  // this will not throw an exception  if (entry.getKey() == 1) {  map.remove(1);  }  }  } }>

152. Qu'est-ce que la gestion des exceptions ?

Un Exception est un événement qui interrompt le flux normal du programme et nécessite un traitement spécial. Lors de l'exécution d'un programme, les erreurs et les occurrences imprévues peuvent être traitées à l'aide du mécanisme de gestion des exceptions Java. Vous trouverez ci-dessous quelques raisons pour lesquelles des exceptions se produisent en Java :

• Panne de l'appareil
• Perte de connexion réseau
• Erreurs de code
• Ouvrir un fichier indisponible
• Entrée utilisateur invalide
• Limitations physiques (manque de mémoire disque)

153. Combien de types d'exceptions peuvent survenir dans un programme Java ?

Il existe généralement deux types d'exceptions en Java :

• Exceptions intégrées : Les exceptions intégrées à Java sont fournies par les bibliothèques Java. Ces exceptions peuvent être divisées en deux sous-catégories, à savoir les exceptions cochées et non cochées. Vous trouverez ci-dessous quelques-unes des exceptions intégrées à Java :
  • ArrayIndexOutOfBoundsExceptions
  • ClassNotFoundException
  • FileNotFoundException
  • IOException
  • NullPointerException
  • ArithmétiqueException
  • Exception interrompue
  • Exception d'exécution
• Exceptions définies par l'utilisateur : Les exceptions définies par l'utilisateur sont définies par les programmeurs eux-mêmes pour gérer certaines situations ou erreurs spécifiques qui ne sont pas couvertes par les exceptions intégrées. Pour définir des exceptions définies par l'utilisateur, une nouvelle classe qui étend la classe d'exception appropriée doit être définie. Les exceptions définies par l'utilisateur en Java sont utilisées lorsque les exceptions intégrées sont en Java.

154. Différence entre une erreur et une exception.

155. Expliquez la hiérarchie des classes d'exception Java.

Tous les types d'exceptions et d'erreurs en Java sont des sous-classes de la classe throwable, qui est la classe de base de la hiérarchie. Cette classe est ensuite utilisée pour des conditions exceptionnelles que les programmes utilisateur doivent détecter. NullPointerException est un exemple d'une telle exception. Une autre branche, error est utilisée par le système d'exécution Java pour indiquer les erreurs liées au JRE. StackOverflowError est un exemple d’une telle erreur.

156. Expliquez les exceptions d'exécution.

Les exceptions d'exécution sont des exceptions qui se produisent lors de l'exécution d'un code, par opposition aux exceptions de compilation qui se produisent lors de la compilation. Les exceptions d'exécution sont des exceptions non vérifiées, car elles ne sont pas prises en compte par la JVM.

Exemples d'exceptions d'exécution en Java :

• NullPointerException : cela se produit lorsqu'une application tente d'utiliser une référence d'objet nulle.
• ArrayIndexOutOfBoundsException : cela se produit lorsqu'une application tente d'accéder à un index de tableau hors limites.
• ArithmeticException : cela se produit lorsqu'une application tente de diviser par zéro.
• IllegalArgumentException : cela se produit lorsqu'une méthode est transmise avec un argument illégal ou inapproprié.

Contrairement aux exceptions vérifiées, les exceptions d'exécution ne nécessitent pas de déclaration dans la clause throws ni de capture dans un bloc try-catch. Cependant, il est conseillé de gérer les exceptions d'exécution afin de fournir des messages d'erreur significatifs et d'éviter un crash du système. Étant donné que les exceptions d'exécution fournissent des informations plus spécifiques sur le problème que les exceptions vérifiées, elles permettent aux développeurs de détecter et de corriger les erreurs de programmation plus facilement et plus rapidement.

157. Qu'est-ce que NullPointerException ?

Il s'agit d'un type d'exception d'exécution qui est levée lorsque le programme tente d'utiliser une référence d'objet ayant une valeur nulle. L'utilisation principale de NullPointerException est d'indiquer qu'aucune valeur n'est attribuée à une variable de référence. Elle est également utilisée pour implémenter des structures de données telles que des listes chaînées et des arbres.

158. Quand l'ArrayStoreException est-elle levée ?

ArrayStoreException est levée lorsqu'une tentative est faite pour stocker le mauvais type d'objet dans un tableau d'objets.

Exemple:

// Java Program to implement // ArrayStoreException public class GFG {  public static void main(String args[])  {  // Since Double class extends Number class  // only Double type numbers  // can be stored in this array  Number[] a = new Double[2];  // Trying to store an integer value  // in this Double type array  a[0] = new Integer(4);  } }>

Exemple:

Exception in thread 'main' java.lang.ArrayStoreException: java.lang.Integer  at GFG.main(GFG.java:6)>

159. Quelle est la différence entre l'exception vérifiée et l'exception non vérifiée ?

Exception vérifiée :

Les exceptions vérifiées sont les exceptions qui sont vérifiées pendant la compilation d'un programme. Dans un programme, si du code dans une méthode lève une exception vérifiée, alors la méthode doit soit gérer l'exception, soit spécifier l'exception à l'aide du mot-clé throws.

Les exceptions vérifiées sont de deux types :

• Exceptions entièrement vérifiées : toutes ses classes enfants sont également vérifiées, comme IOException et InterruptedException.
• Exceptions partiellement vérifiées : certaines de ses classes enfants ne sont pas cochées, comme une exception.

Exception non cochée :

Les exceptions qui ne sont pas vérifiées au moment de la compilation d'un programme ne sont pas cochées. Les exceptions sous les classes Error et RuntimeException sont des exceptions non vérifiées, tout le reste sous throwable est vérifié.

160. Quelle est la classe de base pour Error et Exception ?

Une erreur est une opération illégale effectuée par l'utilisateur qui provoque une anomalie dans le programme. Les exceptions sont les événements ou conditions inattendus qui surviennent lors de l’exécution du programme, l’exception perturbe le flux normal des instructions du programme.

Les erreurs et les exceptions ont toutes deux une classe parent commune qui est la classe java.lang.Throwable.

161. Est-il nécessaire que chaque bloc try soit suivi d'un bloc catch ?

Non, il n'est pas nécessaire d'utiliser le bloc catch après le bloc try en Java car nous pouvons créer une autre combinaison avec le bloc final. Enfin, le bloc s'exécute malgré le fait que l'exception soit levée ou non.

162. Qu'est-ce que la propagation des exceptions ?

La propagation d'une exception est un processus dans lequel l'exception est supprimée du haut vers le bas de la pile. Si elle n'est pas interceptée une fois, l'exception revient à la méthode précédente, et ainsi de suite jusqu'à ce qu'elle soit interceptée ou jusqu'à ce qu'elle atteigne le bas de la pile d'appels.

163. Que se passera-t-il si vous placez System.exit(0) sur le bloc try ou catch ? Le bloc sera-t-il finalement exécuté ?

System.exit(int) a la capacité de lancer SecurityException. Ainsi, si pour des raisons de sécurité, l'exception est levée, le bloc sera finalement exécuté, sinon la JVM sera fermée lors de l'appel du système. exit(0) à cause de quoi le bloc final ne sera pas exécuté.

164. Qu'entendez-vous par clonage d'objets et comment y parvenez-vous en Java ?

C'est le processus de création d'une copie exacte de n'importe quel objet. Afin de prendre en charge cela, une classe Java doit implémenter l'interface Cloneable du package java.lang et remplacer la méthode clone() fournie par la classe Object dont la syntaxe est :

L'objet protégé clone() lance CloneNotSupportedException{ return (Object)super.clone();}Dans le cas où l'interface Cloneable n'est pas implémentée et que seule la méthode est remplacée, cela entraîne CloneNotSupportedException en Java.

165. Comment les exceptions affectent-elles le programme s'il ne les gère pas ?

Les exceptions sont responsables de l'arrêt brusque de l'exécution du programme pendant l'exécution et le code écrit après l'apparition de l'exception n'est pas exécuté.

166. A quoi sert le mot-clé final ?

Le mot-clé final est utilisé pour rendre les fonctions non virtuelles. Par défaut, toutes les fonctions sont virtuelles donc pour les rendre non virtuelles nous utilisons le mot-clé final.

167. Quel est le but des mots-clés final, final et finalize ?

je). final:

final est un mot-clé utilisé avec la variable, la méthode ou la classe afin qu'ils ne puissent pas être remplacés.

Exemple:

// Java Program to use final // keyword import java.io.*; // Driver Class class GFG {  // Main function  public static void main(String[] args)  {  final int x = 100;  x = 50;  } }>

Sortir:

./GFG.java:6: error: cannot assign a value to final variable x  x=50;  ^ 1 error>

ii). enfin

est enfin un bloc de code utilisé avec try-catch dans la gestion des exceptions. Le code écrit dans le bloc final s'exécute même si une exception est levée ou non.

Exemple:

// Java Program to implement finally import java.io.*; // Driver class class GFG {  // Main function  public static void main(String[] args)  {  int x = 10;  // try block  try {  System.out.println('Try block');  }  // finally block  finally {  System.out.println(  'Always runs even without exceptions');  }  } }>

Try block Always runs even without exceptions>

iii). finaliser

Il s'agit d'une méthode qui est appelée juste avant de supprimer/détruire les objets éligibles au garbage collection pour effectuer une activité de nettoyage.

Exemple:

/*package whatever // do not write package name here */ import java.io.*; class GFG {  public static void main(String[] args)  {  System.out.println('Main function running');  System.gc();  }  // Here overriding finalize method  public void finalize()  {  System.out.println('finalize method overridden');  } }>

Main function running>

168. Quelle est la différence entre this() et super() en Java ?

169. Qu'est-ce que le multitâche ?

Le multitâche en Java fait référence à la capacité d’un programme à effectuer plusieurs tâches à la fois. Les threads, qui sont des opérations rapides contenues dans un seul programme, peuvent le faire. Exécuter plusieurs choses à la fois est connu sous le nom de multitâche.

Exemple:

// Java program for multitasking import java.io.*; public class MyThread extends Thread {  public void run()  {  // Code to be executed in this thread  for (int i = 0; i < 10; i++) {  System.out.println(  'Thread ' + Thread.currentThread().getId()  + ': ' + i);  }  } } public class GFG {  public static void main(String[] args)  {  MyThread thread1 = new MyThread();  MyThread thread2 = new MyThread();  // Start the threads  thread1.start();  thread2.start();  } }>

170. Qu'entendez-vous par programme multithread ?

Les programmes multithread en Java contiennent des threads qui s'exécutent simultanément au lieu de s'exécuter séquentiellement. Un ordinateur peut utiliser ses ressources plus efficacement en combinant plusieurs tâches à la fois. Tout programme multithread permet à plusieurs utilisateurs d'utiliser simultanément le programme sans exécuter plusieurs copies. Un programme multithread est conçu pour exécuter plusieurs processus en même temps, ce qui peut améliorer les performances d'un programme, permettre au programme d'utiliser plusieurs processeurs et améliorer le débit global.

171. Quels sont les avantages du multithreading ?

L’utilisation du multithreading présente de nombreux avantages :

• Réactivité : la réactivité de l'utilisateur augmente car l'application interactive multithread permet d'exécuter du code même lorsque la section est bloquée ou exécute un processus long.
• Partage de ressources : le processus peut effectuer la transmission de messages et la mémoire partagée grâce au multithreading.
• Économie : Nous sommes capables de partager de la mémoire grâce à quoi les processus sont économiques.
• Évolutivité : le multithreading sur plusieurs machines à processeur augmente le parallélisme.
• Meilleure communication : les fonctions de synchronisation des threads améliorent la communication inter-processus.
• Utilisation d'une architecture multiprocesseur
• Utilisation réduite des ressources système

172. Quelles sont les deux manières de créer un Thread ?

Le multithreading est une fonctionnalité Java qui permet l'exécution simultanée de deux ou plusieurs parties d'un programme pour une utilisation maximale du processeur. En général, les threads sont des processus petits et légers avec des chemins d'exécution distincts. Ces threads utilisent la mémoire partagée, mais ils agissent indépendamment, donc si l'un des threads échoue, cela n'affecte pas les autres threads. Il existe deux manières de créer un fil de discussion :

• En étendant la classe Thread
• En implémentant une interface Runnable.

En étendant la classe Thread

Nous créons une classe qui étend le classe java.lang.Thread . Cette classe remplace la méthode run() disponible dans la classe Thread. Un thread commence sa vie dans la méthode run().

Syntaxe:

public class MyThread extends Thread { public void run() {  // thread code goes here  } }>

En implémentant l'interface Runnable

Nous créons une nouvelle classe qui implémente java.lang.Runnable interface et remplacez la méthode run(). Ensuite, nous instancions un objet Thread et appelons la méthode start() sur cet objet.

Syntaxe:

public class MyRunnable implements Runnable { public void run() {  // thread code goes here  } }>

173. Qu'est-ce qu'un fil ?

Les threads en Java sont des sous-processus légers avec la plus petite unité de processus et ont également des chemins d'exécution distincts. Ces threads utilisent la mémoire partagée mais ils agissent indépendamment donc s'il y a une exception dans les threads qui n'affecte pas le fonctionnement des autres threads bien qu'ils partagent la même mémoire. Un thread possède son propre compteur de programme, sa pile d'exécution et ses variables locales, mais il partage le même espace mémoire avec les autres threads du même processus. Java fournit une prise en charge intégrée du multithreading via le Interface exécutable et le Classe de fil de discussion .

174. Faire la différence entre processus et thread ?

Un processus et un thread sont tous deux des unités d'exécution dans un système informatique, mais ils sont différents de plusieurs manières :

175. Décrivez le cycle de vie du fil ?

UN fil en Java, à tout moment, existe dans l'un des états suivants. Un thread se trouve uniquement dans l'un des états affichés à tout instant :

1. Nouveau: Le fil de discussion a été créé mais n'a pas encore démarré.
2. Exécutable : Le thread est en cours d'exécution, exécute sa tâche ou est prêt à s'exécuter s'il n'y a pas d'autres threads de priorité plus élevée.
3. Bloqué: Le fil est temporairement suspendu, en attente d'une ressource ou d'un événement.
4. En attendant: Le thread attend qu'un autre thread exécute une tâche ou qu'un laps de temps spécifié s'écoule.
5. Terminé : Le thread a terminé sa tâche ou a été terminé par un autre thread.

176. Expliquez la méthode suspend() sous la classe Thread.

La méthode suspend() de la classe Thread en Java suspend temporairement l'exécution d'un thread. Lorsqu'un thread est suspendu, il passe dans un état bloqué et il ne sera pas planifié par le système d'exploitation, ce qui signifie qu'il ne pourra pas exécuter sa tâche jusqu'à sa reprise. Il existe des alternatives plus sûres et plus flexibles aux méthodes suspend() dans le langage de programmation Java moderne. Cette méthode ne renvoie aucune valeur.

Syntaxe:

  public final void   suspend();>

Exemple:

// Java program to show thread suspend() method import java.io.*; class MyThread extends Thread {  public void run()  {  for (int i = 0; i < 10; i++) {  System.out.println(' Running thread : ' + i);  try {  Thread.sleep(1000);  }  catch (Interrupted_Exception e) {  e.printStackTrace();  }  }  } } class GFG {  public static void main(String[] args)  {  MyThread t1 = new MyThread();  t1.start();  try {  Thread.sleep(3000);  }  catch (InterruptedException e) {  e.printStackTrace();  }  // suspend the execution of the thread  t1.suspend();  System.out.println('Suspended thread ');  try {  Thread.sleep(3000);  }  catch (InterruptedException e) {  e.printStackTrace();  }  // resume the execution of the thread  t1.resume();  System.out.println('Resumed thread');  } }>

Sortir:

Thread running: 0 Thread running: 1 Thread running: 2 Suspended thread Resumed thread Thread running: 3 Thread running: 4 Thread running: 5 Thread running: 6 Thread running: 7 Thread running: 8 Thread running: 9>

177. Expliquez le thread principal sous Exécution de la classe Thread.

Java fournit une prise en charge intégrée pour la programmation multithread. Le thread principal est considéré comme le thread parent de tous les autres threads créés lors de l’exécution du programme. Le thread principal est automatiquement créé lorsque le programme démarre. Ce thread exécute la méthode principale du programme. Il est responsable de l’exécution de la logique principale du programme Java ainsi que de la gestion des opérations de saisie utilisateur. Le thread principal sert de thread de base à partir duquel tous les autres threads enfants sont générés.

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

Un thread démon en Java est un thread de faible priorité utilisé pour effectuer des opérations en arrière-plan ou des tâches utilisées en continu. tels que le garbage collection, les répartitions de signaux, les écouteurs d'action, etc. Les threads démons en Java ont une priorité inférieure à celle des threads utilisateur, ce qui signifie qu'ils ne peuvent s'exécuter que lorsqu'aucun thread utilisateur n'est en cours d'exécution. Les threads démons en Java sont des fonctionnalités utiles requises pour les tâches en arrière-plan qui ne nécessitent pas d'arrêt ou de finalisation explicite. Il permet une utilisation plus efficace des ressources système et est utilisé pour simplifier les ressources et peut simplifier les tâches de longue durée.

179. Quelles sont les manières dont un thread peut entrer dans l'état d'attente ?

Thread est un processus léger qui s’exécute simultanément avec l’autre thread au sein d’un seul processus. Chaque thread peut exécuter une tâche différente et partager les ressources au sein d'un seul processus. Les threads en Java peuvent entrer dans l'état d'attente de différentes manières :

• Méthode Sleep() Appel : Le sommeil () est utilisée pour suspendre l'exécution du thread pendant une durée spécifique. Pendant que le thread est en pause, il passe en état d'attente.
• Méthode Attendre() : Cette méthode est utilisée pour attendre un thread jusqu'à ce que l'autre thread lui signale de se réveiller. Le thread passe à l'état d'attente jusqu'à ce qu'il reçoive une notification d'un autre thread.
• Méthode Join() : La méthode Join() peut être utilisée pour attendre que le thread termine l’exécution. Le thread appelant passe à l’état d’attente jusqu’à ce que le thread cible soit terminé.
• En attente des opérations d'E/S : Si le thread attend la fin de l’opération d’entrée/sortie, il passe en état d’attente jusqu’à ce que l’opération soit terminée.
• Problèmes de synchronisation : S'il existe des problèmes de synchronisation dans une application multithread, les threads peuvent passer en état d'attente jusqu'à ce que les problèmes de synchronisation soient résolus.

180. Comment se déroule le multithreading sur un ordinateur doté d'un seul processeur ?

Java utilise une technique appelée partage du temps, communément appelée time-slicing, pour implémenter le multithread sur des ordinateurs dotés d'un seul processeur. L'apparence d'une exécution parallèle est créée par la commutation du processeur entre les threads actifs. Le système d'exploitation est chargé d'allouer le temps CPU à chaque thread de manière séquentielle et de planifier les threads.

Afin d'empêcher les threads d'interagir les uns avec les autres et de créer des situations de concurrence ou d'autres problèmes, Java dispose de plusieurs moyens pour gérer le comportement des threads, notamment la synchronisation et le verrouillage. Il est possible de créer des programmeurs multithread qui fonctionnent correctement et efficacement sur une machine dotée d'un seul processeur en régulant l'interaction entre les threads et en s'assurant que les parties de code cruciales sont synchronisées. Contrairement à l'exécution du même programme sur un ordinateur doté de plusieurs processeurs ou cœurs, le multithreading sur un seul processeur ne peut donner qu'une apparence de parallélisme, et les gains de performances réels peuvent être modestes. Le système d'exploitation divise le temps CPU disponible lorsque de nombreux threads s'exécutent sur un seul processeur en petites tranches de temps et donne à chaque thread une tranche de temps à exécuter. La commutation rapide entre les threads par le système d'exploitation crée l'apparence d'une exécution parallèle. La commutation entre les threads semble immédiate car les tranches de temps sont souvent très petites, de l'ordre de la milliseconde ou de la microseconde.

Questions d'entretien Java pour les expérimentés

181. Quels sont les différents types de priorités de thread en Java ? Et quelle est la priorité par défaut d'un thread attribué par JVM ?

Les priorités dans les threads sont un concept où chaque thread a une priorité qui, en langage profane, on peut dire que chaque objet a ici une priorité qui est représentée par des nombres allant de 1 à 10. Il existe différents types de propriétés de thread en Java mentionnés ci-dessous :

• MIN_PRIORITÉ
• MAX_PRIORITY
• NORM_PRIORITÉ

Par défaut, le thread se voit attribuer NORM_PRIORITY.

182. Pourquoi le Garbage Collection est-il nécessaire en Java ?

Pour Java, le garbage collection est nécessaire pour éviter les fuites de mémoire qui peuvent provoquer le crash du programme et devenir instable. Il n'y a aucun moyen d'éviter le garbage collection en Java. Contrairement au C++, le garbage collection en Java aide les programmeurs à se concentrer sur le développement de l'application au lieu de gérer les ressources mémoire et de s'inquiéter des fuites de mémoire. Java Virtual Machine (JVM) gère automatiquement la mémoire périodiquement en exécutant un garbage collector qui libère la mémoire inutilisée dans l'application. Le garbage collection rend la mémoire Java efficace car il supprime les objets non référencés de la mémoire tas.

183. Quel est l'inconvénient du Garbage Collection ?

Outre de nombreux avantages, Garbage Collector présente certains inconvénients mentionnés ci-dessous :

1. Le principal inconvénient du garbage collection est qu’il peut provoquer des pauses dans l’exécution d’une application car il efface la mémoire, ce qui ralentit les performances de l’application.
2. Le processus de récupération de place n'est pas déterministe, ce qui rend difficile la prédiction du moment où la récupération de place se produit, ce qui entraîne un comportement imprévisible dans les applications. Par exemple, si nous écrivons un programme, il est difficile pour les programmeurs de décider si le problème est causé par le garbage collection ou par tout autre facteur du programme.
3. Le garbage collection peut également augmenter l'utilisation de la mémoire si le programme crée et supprime de nombreux objets de courte durée.

184. Expliquez la différence entre une collecte des déchets mineure, majeure et complète.

La machine virtuelle Java (JVM) supprime les objets qui ne sont plus utilisés à l'aide d'un garbage collector qui vérifie et supprime périodiquement ces objets. Il existe différents types de garbage collection dans la JVM, chacun avec des caractéristiques et des implications en termes de performances différentes. Les principaux types de collecte des déchets sont :

• Petite collecte des déchets : Également connu sous le nom de garbage collection de jeune génération, ce type de garbage collection est utilisé pour collecter et récupérer la mémoire utilisée par les objets de courte durée (objets qui sont rapidement créés et supprimés).
• Grande collecte des déchets : Également connu sous le nom de garbage collection d'ancienne génération, ce type de garbage collection est utilisé pour collecter et récupérer la mémoire utilisée par les objets à longue durée de vie (objets qui survivent à plusieurs garbage collection mineurs et sont promus à l'ancienne génération).
• Collecte complète des déchets : Lors de la collecte complète des déchets, les souvenirs de toutes les générations sont collectés et récupérés, y compris les souvenirs des jeunes et des moins jeunes. Un garbage collection complet prend normalement plus de temps qu’un garbage collection mineur ou majeur, ce qui entraîne une pause temporaire de cette application.

185. Comment allez-vous identifier les garbage collection majeurs et mineurs en Java ?

Le ramassage des déchets majeur fonctionne sur l'espace survivant et le ramassage des déchets mineur fonctionne sur l'espace Eden pour effectuer une routine de marquage et de balayage. Et nous pouvons les identifier tous les deux en fonction de la sortie où la collection mineure imprime GC, tandis que la collection majeure imprime Full GC pour le cas où la journalisation du garbage collection est activée avec -XX:PrintGCDetails ou verbose:gc.

186. Qu'est-ce qu'une fuite de mémoire et comment affecte-t-elle le garbage collection ?

En Java, les fuites de mémoire peuvent être causées par divers facteurs, tels que la fermeture incorrecte des ressources, la conservation des références d'objet plus longtemps que nécessaire ou la création d'un trop grand nombre d'objets inutilement. Il existe des situations dans lesquelles le garbage collector ne collecte pas les objets car il existe une référence à ces objets. Dans ces situations où l'application crée beaucoup d'objets et ne les utilise pas et où chaque objet a des références valides, un garbage collector en Java ne peut pas détruire les objets. Ces objets inutiles qui n’apportent aucune valeur au programme sont appelés fuites de mémoire. Les fuites de mémoire peuvent avoir un impact négatif sur le garbage collection en empêchant le garbage collector de récupérer la mémoire inutilisée. Ce comportement entraînera un ralentissement des performances ou parfois une panne du système. Dans un programme, il est important d’éviter les fuites de mémoire en gérant correctement les ressources et les références d’objets.

Exemple:

// Java Program to demonstrate memory leaks import java.io.*; import java.util.Vector; class GFG {  public static void main(String[] args)  {  Vector a = new Vector(21312312);  Vector b = new Vector(2147412344);  Vector c = new Vector(219944);  System.out.println('Memory Leak in Java');  } }>

Sortir:

Exception in thread 'main' java.lang.OutOfMemoryError: Java heap space  at java.base/java.util.Vector.(Vector.java:142)  at java.base/java.util.Vector.(Vector.java:155)  at GFG.main(GFG.java:9)>

187. Nommez certaines classes présentes dans le package java.util.regex.

Les expressions régulières ou Regex en Java sont une API utilisée pour rechercher et manipuler des chaînes en Java. Il crée des modèles de chaînes qui peuvent extraire les données nécessaires des chaînes ou généraliser un modèle.

Il y a 3 classes présentes dans java.util.regex mentionnées ci-dessous :

• Classe de modèles : peut définir des modèles
• Classe Matcher : peut effectuer des opérations de correspondance sur du texte à l'aide de modèles
• Classe PatternSyntaxException : peut indiquer une erreur de syntaxe dans un modèle d'expression régulière.

De plus, outre les 3 classes, le package comprend une seule interface MatchResult Interface qui peut être utilisée pour représenter le résultat d'une opération de correspondance.

188. Écrivez une expression régulière pour valider un mot de passe. Un mot de passe doit commencer par un alphabet et suivi de caractères alphanumériques ; Sa longueur doit être comprise entre 8 et 20.

regex = ^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&-+=()])(?=S+$).{8, 20}$>

Explication:

• ^ utilisé pour le caractère de début de la chaîne.
• (?=.*[0-9]) utilisé pour un chiffre doit apparaître au moins une fois.
• (?=.*[a-z]) utilisé pour un alphabet minuscule doit apparaître au moins une fois.
• (?=.*[A-Z]) utilisé pour un alphabet majuscule qui doit apparaître au moins une fois dans la sous-chaîne.
• (?=.*[@#$%^&-+=()] utilisé pour un caractère spécial qui doit apparaître au moins une fois.
• (?=S+$) les espaces blancs ne sont pas autorisés dans la chaîne entière.
• .{8, 20} utilisé pour au moins 8 caractères et au plus 20 caractères.
• $ utilisé pour la fin de la chaîne.

189. Qu'est-ce que JDBC ?

JDBC L'API standard est utilisée pour relier les applications Java et les bases de données relationnelles. Il fournit une collection de classes et d'interfaces permettant aux programmeurs d'utiliser le langage de programmation Java pour communiquer avec la base de données. Les classes et l'interface de JDBC permettent à l'application d'envoyer les requêtes effectuées par les utilisateurs à la base de données spécifiée. Il existe généralement quatre composants de JDBC par lesquels il interagit avec la base de données :

• API JDBC
• Gestionnaire de pilotes JDBC
• Suite de tests JDBC
• Pilotes de pont JDBC-ODBC

190. Qu'est-ce que le pilote JDBC ?

Pilote JDBC est un composant logiciel utilisé pour permettre à une application Java d'interagir avec la base de données. JDBC fournit l'implémentation de l'API JDBC pour un système de gestion de base de données spécifique, ce qui lui permet de connecter la base de données, d'exécuter des instructions SQL et de récupérer des données. Il existe quatre types de pilotes JDBC :

• Pilote de pont JDBC-ODBC
• Pilote API natif
• Pilote de protocole réseau
• Conducteur mince

191. Quelles sont les étapes pour se connecter à la base de données en Java ?

Il existe certaines étapes pour connecter la base de données et le programme Java, comme mentionné ci-dessous :

• Importer les packages
• Chargez les pilotes en utilisant la méthode forName()
• Enregistrez les pilotes à l'aide de DriverManager
• Établir une connexion à l'aide de l'objet de classe Connection
• Créer une déclaration
• Exécuter la requête
• Fermer les connexions

192. Quels sont les composants de l'API JDBC ?

Les composants de l'API JDBC fournissent diverses méthodes et interfaces pour une communication facile avec les bases de données. Ils fournissent également des packages tels que Java Se et Java EE qui offrent la possibilité d'écrire une fois exécuté n'importe où (WORA).

Syntaxe:

java.sql.*;>

193. Qu'est-ce que l'interface de connexion JDBC ?

L'interface de connectivité de base de données Java (JDBC) est un composant logiciel qui permet aux applications Java d'interagir avec les bases de données. Pour améliorer la connexion, JDBC nécessite des pilotes pour chaque base de données.

194. Qu'est-ce que l'interface JDBC ResultSet ?

L'interface JDBC ResultSet est utilisée pour stocker les données de la base de données et les utiliser dans notre programme Java. Nous pouvons également utiliser ResultSet pour mettre à jour les données à l'aide des méthodes updateXXX(). L'objet ResultSet pointe le curseur avant la première ligne des données de résultat. En utilisant la méthode next(), nous pouvons parcourir le ResultSet.

195. Qu'est-ce que l'ensemble de lignes JDBC ?

Un JDBC RowSet fournit un moyen de stocker les données sous forme de tableau. RowSet est une interface en Java qui peut être utilisée dans le package java.sql. La connexion entre l'objet RowSet et la source de données est maintenue tout au long de son cycle de vie. Les RowSets sont classés en cinq catégories en fonction de l'implémentation mentionnée ci-dessous :

1. JdbcRowSet
2. CachedRowSet
3. WebRowSet
4. FilteredRowSet
5. JoinRowSet

196. Quel est le rôle de la classe JDBC DriverManager ?

La classe JDBC DriverManager agit comme une interface pour les utilisateurs et les pilotes. Il est utilisé de plusieurs manières, comme mentionné ci-dessous :

• Il est utilisé pour créer une connexion entre une application Java et la base de données.
• Aide à garder une trace des pilotes disponibles.
• Cela peut aider à établir une connexion entre une base de données et les pilotes appropriés.
• Il contient toutes les méthodes permettant d'enregistrer et de désenregistrer les classes de pilotes de base de données.
• La méthode DriverManager.registerDriver() peut conserver la liste des classes de pilotes qui se sont elles-mêmes enregistrées.

Questions d'entretien sur les différences Java

197. Faites la différence entre Iterable et Iterator.

198. Faites la différence entre Liste et Ensemble.

199. Faites la différence entre liste et carte.

200. Faites la différence entre la file d'attente et la pile.

201. Différencier PriorityQueue et TreeSet.

202. Faites la différence entre la liste à chaînage unique et la liste à double chaînage.

203. Faites la différence entre Failfast et Failsafe.

204. Différencier HashMap et TreeMap.

205. Faites la différence entre Queue et Deque.

206. Différencier HashSet et TreeSet.

Questions d'entretien Java - FAQ

T1. Quel est le salaire d’un développeur Java en Inde ?

Selon diverses sources, le salaire moyen d'un développeur Java Backend est supérieur à 14 lakhs par an, soit 30 % de plus que tout autre rôle de développeur . Ici, vous pouvez également consulter notre dernier cours sur Portail de pratique GeekforGeeks peut également être utile.

Q5. Comment puis-je me démarquer lors d’un entretien Java ?

Pour vous démarquer lors d'un entretien Java, démontrez une compréhension approfondie des concepts Java et des applications pratiques. Présentez vos compétences en résolution de problèmes en expliquant votre approche des scénarios complexes et en proposant des solutions efficaces. De plus, mettez en évidence tous les projets ou contributions pertinents que vous avez apportés à la communauté Java. Faire preuve d’enthousiasme, d’une bonne communication et d’une volonté d’apprendre peut également laisser une impression positive.