Java is een van de populairste programmeertalen ter wereld en staat bekend om zijn veelzijdigheid, draagbaarheid en brede scala aan toepassingen. Java is de meest gebruikte taal bij topbedrijven zoals Uber, Airbnb, Google, Netflix, Instagram, Spotify, Amazon en nog veel meer vanwege de functies en prestaties.

In dit artikel zullen we bieden 200+ kernvragen over Java-interviews op maat gemaakt voor zowel eerstejaars als ervaren professionals met 3, 5 en 8 jaar ervaring. Hier behandelen we alles, inclusief kern-Java-concepten, Object-Oriented Programming (OOP), multithreading, afhandeling van uitzonderingen, ontwerppatronen, Java-collecties en meer, die u zeker zullen helpen Java-interviews te kraken.

Inhoudsopgave

• Java-interviewvragen voor eerstejaarsstudenten
• Java tussentijdse sollicitatievragen
• Java-interviewvragen voor ervaren
• Interviewvragen over Java-verschillen

Java-interviewvragen voor eerstejaarsstudenten

1. Is het Java-platform onafhankelijk en hoe?

Ja, Java is een platformonafhankelijke taal. In tegenstelling tot veel andere programmeertalen compileert de javac-compiler het programma om een ​​bytecode- of .class-bestand te vormen. Dit bestand is onafhankelijk van de actieve software of hardware, maar heeft een JVM-bestand (Java Virtual Machine) nodig dat vooraf in het besturingssysteem is geïnstalleerd voor verdere uitvoering van de bytecode.

Hoewel JVM is platformafhankelijk , kan de bytecode op elk systeem worden aangemaakt en op elk ander systeem worden uitgevoerd, ondanks dat er hardware of software wordt gebruikt, waardoor het Java-platform onafhankelijk is.

2. Wat zijn de belangrijkste Java-functies?

Java is een van de bekendste en meest gebruikte talen in de echte wereld. Er zijn veel functies in Java die het beter maken dan welke andere taal dan ook. Enkele daarvan worden hieronder vermeld:

• Eenvoudig : Java is vrij eenvoudig te begrijpen en de syntaxis
• Platformonafhankelijk: Java is platformonafhankelijk, wat betekent dat we hetzelfde programma op elke software en hardware kunnen uitvoeren en hetzelfde resultaat zullen behalen.
• geïnterpreteerd : Java wordt zowel geïnterpreteerd als een op compilers gebaseerde taal.
• Robuust : functies zoals Garbage collection, exception handling, enz. die de taal robuust maken.
• Objectgericht : Java is een objectgeoriënteerde taal die de concepten van klasse, objecten, vier pijlers van OOPS, enz. ondersteunt.
• Beveiligd : Omdat we een applicatie rechtstreeks met de gebruiker kunnen delen zonder het eigenlijke programma te delen, is Java een veilige taal.
• Hoge performantie: sneller dan andere traditioneel geïnterpreteerde programmeertalen.
• Dynamisch : ondersteunt dynamisch laden van klassen en interfaces.
• Gedistribueerd : functie van Java geeft ons toegang tot bestanden door de methoden aan te roepen vanaf elke aangesloten machine.
• Meerdradig : behandel meerdere taken tegelijk door meerdere threads te definiëren
• Architectuur Neutraal : het is niet afhankelijk van de architectuur.

3. Wat is JVM?

JVM staat voor Java Virtual Machine en is een Java-interpreter. Het is verantwoordelijk voor het laden, verifiëren en uitvoeren van de bytecode die in Java is gemaakt.

Hoewel het platformafhankelijk is, wat betekent dat de software van JVM verschillend is voor verschillende besturingssystemen, speelt het een cruciale rol bij het onafhankelijk maken van het Java-platform.

Voor meer informatie over het onderwerp verwijzen wij u naar JVM in Java .

4. Wat is JIT?

JIT staat voor (Just-in-Time) compiler en is een onderdeel van JRE (Java Runtime Environment), het wordt gebruikt voor betere prestaties van de Java-applicaties tijdens runtime. Het gebruik van JIT wordt vermeld in het onderstaande stapsgewijze proces:

1. De broncode is gecompileerd met Javac compiler om bytecode te vormen
2. Bytecode wordt verder doorgegeven aan JVM
3. JIT is een onderdeel van JVM, JIT is verantwoordelijk voor het compileren van bytecode in native machinecode tijdens runtime.
4. De JIT-compiler is overal ingeschakeld, maar wordt geactiveerd wanneer een methode wordt aangeroepen. Voor een gecompileerde methode roept de JVM de gecompileerde code rechtstreeks aan, in plaats van deze te interpreteren.
5. Terwijl JVM de gecompileerde code aanroept, verhoogt dit de prestaties en snelheid van de uitvoering.

Voor meer informatie over het onderwerp verwijzen wij u naar JIT op Java .

5. Welke geheugenopslag is beschikbaar met JVM?

JVM bestaat uit een aantal geheugenopslagplaatsen, zoals hieronder vermeld:

1. Class(Method) Area: slaat gegevens op klasseniveau op van elke klasse, zoals de runtime-constantepool, veld- en methodegegevens en de code voor methoden.
2. Heap: Er worden objecten gemaakt of objecten opgeslagen. Het wordt gebruikt om geheugen toe te wijzen aan objecten tijdens runtime.
3. Stack: slaat gegevens en gedeeltelijke resultaten op die nodig zijn bij het retourneren van waarde voor de methode en het uitvoeren van dynamische koppelingen
4. Program Counter Register: slaat het adres op van de Java virtuele machine-instructie die momenteel wordt uitgevoerd.
5. Native Method Stack: slaat alle native methoden op die in de applicatie worden gebruikt.

Voor meer informatie over het onderwerp verwijzen wij u naar JVM-geheugenopslag .

6. Wat is een klassenlader?

Classloader is het onderdeel van JRE (Java Runtime Environment). Tijdens de uitvoering van de bytecode of het gemaakte .class-bestand is de classloader verantwoordelijk voor het dynamisch laden van de Java-klassen en interfaces naar JVM (Java Virtual Machine). Vanwege classloaders hoeft het Java-runtimesysteem geen kennis te hebben van bestanden en bestandssystemen.

Voor meer informatie over het onderwerp verwijzen wij u naar ClassLoader in Java.

7. Verschil tussen JVM, JRE en JDK.

JVM : JVM, ook bekend als Java Virtual Machine, is een onderdeel van JRE. JVM is een type tolk dat verantwoordelijk is voor het omzetten van bytecode in machinaal leesbare code. JVM zelf is platformafhankelijk, maar interpreteert de bytecode, wat de platformonafhankelijke reden is waarom Java platformonafhankelijk is.

JRE : JRE staat voor Java Runtime Environment, het is een installatiepakket dat een omgeving biedt waarin het Java-programma of de Java-applicatie op elke machine kan worden uitgevoerd.

JDK : JDK staat voor Java Development Kit en biedt de omgeving voor het ontwikkelen en uitvoeren van Java-programma's. JDK is een pakket dat twee dingen bevat: Development Tools om een ​​omgeving te bieden waarin u uw Java-programma's kunt ontwikkelen, en JRE om Java-programma's of -applicaties uit te voeren.

Voor meer informatie over het onderwerp verwijzen wij u naar de Verschillen tussen JVM, JRE en JDK .

8. Wat zijn de verschillen tussen Java en C++?

9. Leg public static void main(String args[]) in Java uit.

In tegenstelling tot andere programmeertalen zoals C, C++, enz. In Java hebben we de hoofdfunctie gedeclareerd als een openbare statische lege hoofdfunctie (String args[]). De betekenis van de termen vindt u hieronder:

1. openbaar : het publiek is de toegangsmodificator die verantwoordelijk is voor het vermelden wie toegang heeft tot het element of de methode en wat de limiet is. Het is verantwoordelijk voor het wereldwijd beschikbaar maken van de hoofdfunctie. Het wordt openbaar gemaakt zodat JVM het van buiten de klasse kan aanroepen, aangezien het niet aanwezig is in de huidige klasse.
2. statisch : statisch is een trefwoord dat wordt gebruikt zodat we het element kunnen gebruiken zonder de klasse te initiëren, om onnodige toewijzing van geheugen te voorkomen.
3. leegte : void is een trefwoord en wordt gebruikt om aan te geven dat een methode niets retourneert. Omdat de hoofdfunctie niets retourneert, gebruiken we void.
4. voornaamst : main geeft aan dat de gedeclareerde functie de hoofdfunctie is. Het helpt JVM te identificeren dat de gedeclareerde functie de hoofdfunctie is.
5. Tekenreeksargumenten[] : Het slaat Java-opdrachtregelargumenten op en is een array van het type java.lang.String.

10. Wat is Java String Pool?

Een Java String Pool is een plaats in het heap-geheugen waar alle strings die in het programma zijn gedefinieerd, worden opgeslagen. Een aparte plaats in een stapel is de plaats waar de variabele waarin de string is opgeslagen, wordt opgeslagen. Telkens wanneer we een nieuw stringobject maken, controleert JVM de aanwezigheid van het object in de String-pool. Als String beschikbaar is in de pool, wordt dezelfde objectreferentie gedeeld met de variabele, anders wordt er een nieuw object gemaakt.

Voorbeeld:

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

11. Wat zal er gebeuren als we verklaren dat de hoofdstroom niet statisch is?

We kunnen de hoofdmethode declareren zonder statisch te gebruiken en zonder fouten te krijgen. Maar de hoofdmethode wordt niet behandeld als toegangspunt tot de applicatie of het programma.

12. Wat zijn pakketten in Java?

Pakketten in Java kunnen worden gedefinieerd als de groepering van gerelateerde typen klassen, interfaces, enz. die toegang bieden tot bescherming en naamruimtebeheer.

13. Waarom worden pakketten gebruikt?

Pakketten worden in Java gebruikt om naamgevingsconflicten te voorkomen, de toegang te controleren en het zoeken/lokaliseren en gebruiken van klassen, interfaces, enz. eenvoudiger te maken.

14. Wat zijn de voordelen van pakketten in Java?

Er zijn verschillende voordelen verbonden aan het definiëren van pakketten in Java.

• Pakketten vermijden naamconflicten.
• Het pakket biedt eenvoudiger toegangscontrole.
• We kunnen ook de verborgen klassen hebben die buiten niet zichtbaar zijn en door het pakket worden gebruikt.
• Het is gemakkelijker om de gerelateerde klassen te vinden.

15. Hoeveel soorten pakketten zijn er in Java?

Er zijn twee soorten pakketten in Java

• Door de gebruiker gedefinieerde pakketten
• Inbouwpakketten

16. Verschillende gegevenstypen in Java uitleggen.

Er zijn 2 soorten gegevenstypen in Java, zoals hieronder vermeld:

1. Primitief gegevenstype
2. Niet-primitief gegevenstype of objectgegevenstype

Primitief gegevenstype: Primitieve gegevens zijn enkele waarden zonder speciale mogelijkheden. Er zijn 8 primitieve gegevenstypen:

• Booleaans : slaat waarde waar of onwaar op
• byte : slaat een 8-bit ondertekend twee-complement geheel getal op
• verkoold : slaat een enkel 16-bits Unicode-teken op
• kort : slaat een 16-bits geheel getal met twee complementaire tekens op
• int : slaat een 32-bits geheel getal met twee complementaire tekens op
• lang : slaat een 64-bits geheel getal met twee complementen op
• vlot : slaat een 32-bits IEEE 754 drijvende komma met enkele precisie op
• dubbele : slaat een 64-bits IEEE 754 drijvende komma met dubbele precisie op

Niet-primitief gegevenstype: Referentiegegevenstypen bevatten een geheugenadres van de waarden van de variabele, omdat deze de waarden niet rechtstreeks in het geheugen kunnen opslaan. Soorten niet-primitieve worden hieronder vermeld:

• Snaren
• Array
• Klas
• Voorwerp
• Koppel

17. Wanneer wordt een byte-datatype gebruikt?

Een byte is een 8-bits geheel getal met twee complementen. De minimumwaarde die door bytes wordt ondersteund is -128 en 127 is de maximumwaarde. Het wordt gebruikt in omstandigheden waarin we geheugen moeten besparen en de limiet van het benodigde aantal getallen tussen -128 en 127 ligt.

18. Kunnen we Pointer declareren in Java?

Nee, Java biedt geen ondersteuning van Pointer. Omdat Java veiliger moest zijn, omdat welke functie van de pointer niet in Java aanwezig is.

19. Wat is de standaardwaarde van byte datatype in Java?

De standaardwaarde van het bytegegevenstype in Java is 0.

20. Wat is de standaardwaarde van float en double datatype in Java?

De standaardwaarde van de float is 0.0f en van double is 0.0d in Java.

21. Wat is de Wrapper-klasse in Java?

Wrapper wordt in het algemeen verwezen naar een grotere entiteit die een kleinere entiteit inkapselt. Hier in Java is de wrapper-klasse een objectklasse die de primitieve gegevenstypen inkapselt.

De primitieve gegevenstypen zijn de gegevenstypen waaruit verdere gegevenstypen kunnen worden gemaakt. Gehele getallen kunnen bijvoorbeeld verder leiden tot de constructie van long, byte, short, enz. Aan de andere kant kan de string dat niet, en daarom is deze niet primitief.

Terugkomend op de wrapperklasse: Java bevat 8 wrapperklassen. Dit zijn Boolean, Byte, Short, Integer, Character, Long, Float en Double. Verder kunnen er ook aangepaste wrapper-klassen worden gemaakt in Java, wat vergelijkbaar is met het concept van Structuur in de programmeertaal C. We creëren onze eigen wrapperklasse met de vereiste gegevenstypen.

22. Waarom hebben we wrapperklassen nodig?

De wrapper-klasse is een objectklasse die de primitieve gegevenstypen inkapselt, en we hebben ze om de volgende redenen nodig:

1. Wrapper-klassen zijn definitief en onveranderlijk
2. Biedt methoden zoals valueOf(), parseInt(), enz.
3. Het biedt de functie van autoboxing en unboxing.

23. Maak onderscheid tussen instantievariabelen en lokale variabelen.

24. Wat zijn de standaardwaarden die aan variabelen en instanties in Java worden toegewezen?

In Java Als we de instantievariabelen niet hebben geïnitialiseerd, initialiseert de compiler ze met standaardwaarden. De standaardwaarden voor instanties en variabelen zijn afhankelijk van hun gegevenstypen. Enkele veel voorkomende typen standaardgegevenstypen zijn:

• De standaardwaarde voor numerieke typen (byte, short, int, long, float en double) is 0.
• De standaardwaarde voor het Booleaanse type is false.
• De standaardwaarde voor objecttypen (klassen, interfaces en arrays) is nul.
• Het null-teken, u0000, is de standaardwaarde voor het char-type.

Voorbeeld:

// 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. Wat is een klassevariabele?

In Java is een klassevariabele (ook wel een statische variabele genoemd) een variabele die binnen een klasse wordt gedeclareerd, maar buiten elke methode, constructor of blok. Klassevariabelen worden gedeclareerd met het statische trefwoord en worden gedeeld door alle instanties (objecten) van de klasse, evenals door de klasse zelf. Ongeacht hoeveel objecten er van een klasse zijn afgeleid, elke klassevariabele zou maar één keer bestaan.

Voorbeeld:

// 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. Wat is de standaardwaarde die is opgeslagen in Lokale variabelen?

Er is geen standaardwaarde opgeslagen bij lokale variabelen. Bovendien hebben primitieve variabelen en objecten geen standaardwaarden.

27. Leg het verschil uit tussen een instantievariabele en een klassevariabele.

Instantievariabele: Een klassevariabele zonder een statische modificator, bekend als een instantievariabele, wordt doorgaans gedeeld door alle instanties van de klasse. Deze variabelen kunnen verschillende waarden hebben voor verschillende objecten. De inhoud van een instantievariabele is volledig onafhankelijk van de ene objectinstantie van de andere, omdat ze gerelateerd zijn aan een specifieke objectinstantie van de klasse.

Voorbeeld:

// 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>

Klassevariabele: Klasse Variabele variabele kan overal op klasseniveau worden gedeclareerd met behulp van het trefwoord static. Deze variabelen kunnen slechts één waarde hebben wanneer ze op verschillende objecten worden toegepast. Deze variabelen kunnen door alle klasseleden worden gedeeld, aangezien ze niet verbonden zijn met een specifiek object van de klasse.

Voorbeeld:

// 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. Wat is een statische variabele?

Het statische sleutelwoord wordt gebruikt om dezelfde variabele of methode van een bepaalde klasse te delen. Statische variabelen zijn de variabelen die, zodra ze zijn gedeclareerd, een enkele kopie van de variabele maken en delen met alle objecten op klasseniveau.

29. Wat is het verschil tussen System.out, System.err en System.in?

Systeemuit – Het is een PrintStream die wordt gebruikt voor het schrijven van tekens of kan worden gezegd dat deze de gegevens kan uitvoeren die we willen schrijven op de console/terminal van de opdrachtregelinterface.

Voorbeeld:

// 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('');  } }>

Systeemfout – Het wordt gebruikt om foutmeldingen weer te geven.

Voorbeeld:

// 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');  } }>

Uitgang:

This is how we throw error with System.err>

Hoewel System.err veel overeenkomsten heeft, hebben ze allebei ook behoorlijk wat verschillen, laten we ze eens bekijken.

Systeem.in – Het is een InputStream die wordt gebruikt om invoer van het terminalvenster te lezen. We kunnen System.in niet rechtstreeks gebruiken, dus gebruiken we de Scanner-klasse voor het opnemen van invoer met system.in.

Voorbeeld:

// 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);  } }>

Uitgang:

3 4 Addition: 7>

30. Wat versta je onder een IO-stream?

Java brengt met zijn I/O-pakket verschillende Streams mee die de gebruiker helpen alle input-output-bewerkingen uit te voeren. Deze stromen ondersteunen alle soorten objecten, gegevenstypen, tekens, bestanden, enz. om de I/O-bewerkingen volledig uit te voeren.

31. Wat is het verschil tussen de klassenhiërarchie Reader/Writer en de klassenhiërarchie InputStream/OutputStream?

Het belangrijkste verschil tussen beide is dat bytestroomgegevens worden gelezen en geschreven door invoer-/uitvoerstroomklassen. Tekens worden afgehandeld door de klassen Reader en Writer. In tegenstelling tot Reader/Writer-klassen, die karakterarrays als parameters accepteren, accepteren invoer-/uitvoerstroomklassemethoden byte-arrays. In vergelijking met invoer-/uitvoerstromen zijn de Reader/Writer-klassen efficiënter, verwerken ze alle Unicode-tekens en zijn ze nuttig voor internalisatie. Gebruik Reader/Writer-klassen in plaats van binaire gegevens, zoals afbeeldingen, tenzij u dat doet.

Voorbeeld:

// 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. Wat zijn de supermeeste klassen voor alle streams?

Alle streamklassen kunnen worden onderverdeeld in twee soorten klassen: ByteStream-klassen en CharacterStream-klassen. De ByteStream-klassen zijn verder onderverdeeld in InputStream-klassen en OutputStream-klassen. CharacterStream-klassen zijn ook onderverdeeld in Reader-klassen en Writer-klassen. De SuperMost-klassen voor alle InputStream-klassen is java.io.InputStream en voor alle outputstream-klassen is java.io.OutPutStream. Op dezelfde manier is voor alle reader-klassen de superklasse java.io.Reader, en voor alle writer-klassen java.io.Writer.

33. Wat zijn FileInputStream en FileOutputStream?

Om gegevens te lezen en te schrijven biedt Java I/O-streams. Een Stream vertegenwoordigt een invoerbron of een uitvoerbestemming, wat een bestand, een i/o-apparaat, een ander programma, enz. kan zijn. FileInputStream in Java wordt gebruikt om gegevens uit een bestand te lezen als een stroom bytes. Het wordt meestal gebruikt voor het lezen van binaire gegevens zoals afbeeldingen, audiobestanden of geserialiseerde objecten.

Voorbeeld:

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

Op Java is de FileOutputStream functie wordt gebruikt om gegevens byte voor byte naar een bepaald bestand of bestandsdescriptor te schrijven. Meestal worden onbewerkte bytegegevens, zoals afbeeldingen, naar een bestand geschreven met behulp van FileOutputStream.

Voorbeeld:

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

34. Wat is het doel van het gebruik van de klassen BufferedInputStream en BufferedOutputStream?

Wanneer we met de bestanden of stream werken, moeten we de klassen BufferedInputStream en BufferedOutputStream gebruiken om de Input/Output-prestaties van het programma te verbeteren. Deze beide klassen bieden de mogelijkheid tot bufferen, wat betekent dat de gegevens in een buffer worden opgeslagen voordat ze naar een bestand worden geschreven of uit een stream worden gelezen. Het vermindert ook het aantal keren dat ons besturingssysteem moet communiceren met het netwerk of de schijf. Door te bufferen kunnen programma's een grote hoeveelheid gegevens schrijven in plaats van deze in kleine stukjes te schrijven. Dit vermindert ook de overhead van toegang tot het netwerk of de schijf.

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. Wat zijn FilterStreams?

Streamfilter of Filterstreams retourneert een stroom die bestaat uit de elementen van deze stroom die overeenkomen met het gegeven predikaat. Terwijl filter() werkt, wordt er niet daadwerkelijk gefilterd, maar wordt in plaats daarvan een nieuwe stroom gemaakt die, wanneer deze wordt doorlopen, de elementen van de initiële stromen bevat die overeenkomen met het gegeven predikaat.

Voorbeeld:

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

36. Wat is een I/O-filter?

Een I/O-filter, ook wel een Input Output-filter genoemd, is een object dat uit één stream leest en gegevens naar invoer- en uitvoerbronnen schrijft. Er werd gebruik gemaakt van het java.io-pakket om dit filter te gebruiken.

37. Op hoeveel manieren kunt u input van de console ontvangen?

Er zijn twee methoden om invoer van de hieronder genoemde console in Java te ontvangen:

1. Gebruik van een opdrachtregelargument
2. Gebufferde lezerklasse gebruiken
3. Consoleklasse gebruiken
4. Scannerklasse gebruiken

Het programma dat het gebruik van elke methode demonstreert, wordt hieronder gegeven.

Voorbeeld:

// 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);  } }>

Uitgang:

techcodeview.com>

38. Verschil in het gebruik van print, println en printf.

print, println en printf worden allemaal gebruikt voor het afdrukken van de elementen, maar print drukt alle elementen af ​​en de cursor blijft op dezelfde regel. println verplaatst de cursor naar de volgende regel. En met printf kunnen we ook formaat-ID's gebruiken.

39. Wat zijn operatoren?

Operators zijn de speciale typen symbolen die worden gebruikt voor het uitvoeren van bepaalde bewerkingen op variabelen en waarden.

40. Hoeveel soorten operators zijn er beschikbaar in Java?

Hieronder worden alle soorten operators in Java vermeld:

1. Rekenkundige operatoren
2. Unaire operators
3. Opdracht Operator
4. Relationele operators
5. Logische operatoren
6. Ternaire operator
7. Bitwise-operatoren
8. Shift-operatoren
9. exemplaar van operator

Postfix-operatoren worden beschouwd als de hoogste prioriteit volgens de prioriteit van Java-operatoren.

41. Leg het verschil uit tussen>> en>>> operatoren.

Operators als>> en>>> lijken hetzelfde, maar gedragen zich iets anders.>> operator verschuift de tekenbits en de>>> operator wordt gebruikt bij het verschuiven van de met nul gevulde bits.

Voorbeeld:

// Java Program to demostrate //>> en>>> operators importeren java.io.*; // Driverklasse GFG {public static void main(String[] args) { int a = -16, b = 1;  // Gebruik van>> System.out.println(a >> b);  a = -17;  b = 1;  // Gebruik van>>> System.out.println(a >>> b);  } }>

-8 2147483639>

42. Welke Java-operator is juist associatief?

Er is slechts één operator die rechtsassociatief is, namelijk = operator.

43. Wat is een puntoperator?

De Dot-operator in Java wordt gebruikt om toegang te krijgen tot de instantievariabelen en methoden van klasseobjecten. Het wordt ook gebruikt om toegang te krijgen tot klassen en subpakketten uit het pakket.

44. Wat is een covariant rendementstype?

Het covariante retourtype specificeert dat het retourtype in dezelfde richting mag variëren als de subklasse. Het is mogelijk om verschillende retourneringstypen te hebben voor een overschrijvende methode in de onderliggende klasse, maar het retourneringstype van het kind moet een subtype zijn van het retourneringstype van de ouder en wordt daardoor een variant ten opzichte van het retourneringstype.

We gebruiken het covariante retourtype vanwege de volgende redenen:

• Voorkomt verwarrende typecasts in de klassenhiërarchie en maakt de code leesbaar, bruikbaar en onderhoudbaar.
• Geeft de vrijheid om specifiekere retourtypen te hebben bij het overschrijven van methoden.
• Hulp bij het voorkomen van runtime ClassCastExceptions bij retourzendingen.

45. Wat is het tijdelijke trefwoord?

Het transient trefwoord wordt gebruikt op het moment van serialisatie als we de waarde van een bepaalde variabele niet in een bestand willen opslaan. Wanneer JVM een tijdelijk trefwoord tegenkomt, negeert het de oorspronkelijke waarde van de variabele en slaat het de standaardwaarde van dat variabele gegevenstype op.

46. ​​Wat is het verschil tussen de methoden sleep() en wait()?

47. Wat zijn de verschillen tussen String en StringBuffer?

48. Wat zijn de verschillen tussen StringBuffer en StringBuilder?

49. Welke String of String Buffer verdient de voorkeur als er veel updates in de gegevens moeten worden uitgevoerd?

De string heeft de voorkeur boven StringBuffer omdat StringBuilder sneller is dan StringBuffer, maar StringBuffer-objecten hebben de voorkeur boven omdat het meer threadveiligheid biedt.

50. Waarom wordt StringBuffer veranderlijk genoemd?

De klasse StringBuffer in Java wordt gebruikt om een ​​veranderlijke reeks tekens weer te geven. Het biedt een alternatief voor de onveranderlijke klasse String, doordat u de inhoud van een string kunt wijzigen zonder voortdurend nieuwe objecten te maken. Veranderbare (aanpasbare) tekenreeksen worden gemaakt met behulp van de klasse StringBuffer. De klasse StringBuffer in Java is identiek aan de klasse String, behalve dat deze veranderlijk is.

Voorbeeld:

// 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. Hoe verschilt de creatie van een String met new() van die van een letterlijke?

String die new() gebruikt, verschilt van de letterlijke zin, omdat wanneer we string declareren, deze de elementen in het stapelgeheugen opslaat, terwijl wanneer deze wordt gedeclareerd met new() het een dynamisch geheugen in het heap-geheugen toewijst. Het object wordt in het heap-geheugen gemaakt, zelfs als hetzelfde inhoudsobject aanwezig is.

Syntaxis:

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

52. Wat is een array in Java?

Een array in Java is een gegevensstructuur die wordt gebruikt om een ​​reeks elementen van hetzelfde type met een vaste grootte op te slaan. Elementen van een array zijn toegankelijk via hun index, die begint bij 0 en oploopt tot een lengte van min 1. Arraydeclaratie in Java gebeurt met behulp van vierkante haakjes en de grootte wordt ook gespecificeerd tijdens de declaratie.

Syntaxis:

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

53. Op welke geheugenarrays worden in Java gemaakt?

Arrays in Java worden gemaakt in heap-geheugen. Wanneer een array wordt gemaakt met behulp van een nieuw trefwoord, wordt er geheugen toegewezen in de heap om de elementen van de array op te slaan. In Java wordt het heapgeheugen beheerd door de Java Virtual Machine (JVM) en wordt het ook gedeeld tussen alle threads van het Java-programma. Het geheugen dat niet langer door het programma wordt gebruikt, JVM gebruikt een garbage collector om het geheugen terug te winnen. Arrays in Java worden dynamisch gemaakt, wat betekent dat de grootte van de array wordt bepaald tijdens de runtime van het programma. De grootte van de array wordt gespecificeerd tijdens het declareren van de array en kan niet meer worden gewijzigd nadat de array is gemaakt.

54. Wat zijn de typen arrays?

Er zijn twee soorten arrays, namelijk primitieve arrays en referentiearrays.

• Enkeldimensionale arrays: Arrays die slechts één dimensie hebben, dat wil zeggen een array van gehele getallen of een array van strings, staan ​​bekend als eendimensionale arrays.

Syntaxis:

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

• Multidimensionale arrays: Arrays met twee of meer dimensies, zoals tweedimensionale of driedimensionale arrays.

55. Waarom begint de Java-array-index met 0?

De index van een array geeft de afstand vanaf het begin van de array aan. Het eerste element heeft dus een afstand van 0, daarom is de startindex 0.

Syntaxis:

[Base Address + (index * no_of_bytes)]>

56. Wat is het verschil tussen int array[] en int[] array?

Zowel int array[] als int[] array worden gebruikt om een ​​array van gehele getallen in Java te declareren. Het enige verschil tussen hen is dat er qua syntaxis geen functionaliteitsverschil tussen hen bestaat.

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

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

Het wordt echter over het algemeen aanbevolen om een ​​syntaxis in Java-stijl te gebruiken om een ​​array te declareren. Omdat het gemakkelijk te lezen en te begrijpen is, is het ook consistenter met andere Java-taalconstructies.

57. Hoe kopieer ik een array in Java?

In Java zijn er meerdere manieren om een ​​array te kopiëren op basis van de vereisten.

• clone()-methode in Java: Deze methode in Java wordt gebruikt om een ​​ondiepe kopie van de gegeven array te maken, wat betekent dat de nieuwe array hetzelfde geheugen zal delen als de originele array.

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

• arraycopy() methode: Om een ​​diepe kopie van de array te maken, kunnen we deze methode gebruiken, waarmee een nieuwe array wordt gemaakt met dezelfde waarden als de originele array.

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

• copyOf() methode: Deze methode wordt gebruikt om een ​​nieuwe array met een specifieke lengte te maken en de inhoud van de originele array naar de nieuwe array te kopiëren.

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

• copyOfRange() methode: Deze methode lijkt sterk op de methode copyOf() in Java, maar met deze methode kunnen we ook het bereik specificeren van de elementen die uit de originele array moeten worden gekopieerd.

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

58. Wat versta je onder de gekartelde array?

Een gekartelde array in Java is slechts een tweedimensionale array waarin elke rij van de array een andere lengte kan hebben. Omdat alle rijen in een 2-d-array dezelfde lengte hebben, biedt een gekartelde array meer flexibiliteit in de grootte van elke rij. Deze functie is erg handig in omstandigheden waarin de gegevens verschillende lengtes hebben of wanneer het geheugengebruik moet worden geoptimaliseerd.

Syntaxis:

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

59. Is het mogelijk om een ​​array vluchtig te maken?

Op Java is het niet mogelijk om een ​​vluchtig bestand te maken. Vluchtige trefwoorden in Java kunnen alleen worden toegepast op individuele variabelen, maar niet op arrays of verzamelingen. De waarde van de variabele wordt altijd gelezen van en geschreven naar het hoofdgeheugen wanneer deze als vluchtig is gedefinieerd, in plaats van te worden opgeslagen in het lokale geheugen van een thread. Dit maakt het gemakkelijker om ervoor te zorgen dat alle threads die toegang hebben tot de variabele de aangebrachte wijzigingen kunnen zien.

60. Wat zijn de voor- en nadelen van een array?

De voordelen van Arrays zijn:

• Directe en effectieve toegang tot elk element in de collectie wordt mogelijk gemaakt door arrays. De elementen van een array zijn toegankelijk via een O(1)-bewerking, wat betekent dat de hoeveelheid tijd die daarvoor nodig is constant is en onafhankelijk van de grootte van de array.
• Gegevens kunnen effectief in het geheugen worden opgeslagen met behulp van arrays. De grootte van een array is tijdens het compileren bekend, aangezien de elementen ervan in aangrenzende geheugengebieden worden opgeslagen.
• Omdat de gegevens in aaneengesloten geheugengebieden worden opgeslagen, zorgen arrays ervoor dat gegevens snel kunnen worden opgehaald.
• Arrays zijn gemakkelijk te implementeren en te begrijpen, waardoor ze een ideale keuze zijn voor beginners die computerprogrammering leren.

Nadelen van arrays zijn:

• Er worden arrays gemaakt met een vooraf bepaalde grootte die op dat moment wordt gekozen. Dit betekent dat als de omvang van de array moet worden uitgebreid, er een nieuwe array moet worden gemaakt en dat de gegevens van de oude array naar de nieuwe array moeten worden gekopieerd, wat veel tijd en geheugen kan kosten.
• Er kan ongebruikte geheugenruimte in de geheugenruimte van een array aanwezig zijn als de array niet volledig bezet is. Als u een slechte herinnering heeft, kan dit een probleem zijn.
• Vergeleken met andere datastructuren zoals gekoppelde lijsten en bomen, kunnen arrays rigide zijn vanwege hun vaste grootte en beperkte ondersteuning voor geavanceerde gegevenstypen.
• Omdat de elementen van een array allemaal van hetzelfde gegevenstype moeten zijn, ondersteunt deze geen complexe gegevenstypen zoals objecten en structuren.

61. Wat is een objectgeoriënteerd paradigma?

Paradigma betekent letterlijk een patroon of een methode. Programmeerparadigma's zijn de methoden om een ​​programma op te lossen dat uit vier typen bestaat, namelijk imperatief, logisch, functioneel en objectgeoriënteerd. Wanneer objecten worden gebruikt als basisentiteiten waarop de methoden worden toegepast, en inkapselings- of overervingsfunctionaliteiten worden uitgevoerd, staat dit bekend als een objectgeoriënteerd paradigma.

62. Wat zijn de belangrijkste concepten van OOP's in Java?

De belangrijkste concepten van OOP's in Java worden hieronder vermeld:

• Erfenis
• Polymorfisme
• Abstractie
• Inkapseling

63. Wat is het verschil tussen een objectgeoriënteerde programmeertaal en een objectgebaseerde programmeertaal?

64. Waarin verschilt de ‘new’ operator van de ‘newInstance()’ operator in Java?

de nieuwe operator wordt gebruikt om objecten te maken, maar als we willen beslissen welk type object tijdens runtime moet worden gemaakt, kunnen we de nieuwe operator op geen enkele manier gebruiken. In dit geval moeten we de newInstance()-methode .

65. Wat zijn klassen in Java?

In Java zijn klassen de verzameling objecten die vergelijkbare kenmerken en attributen delen. Klassen vertegenwoordigen de blauwdruk of sjabloon waaruit objecten worden gemaakt. Klassen zijn geen entiteiten uit de echte wereld, maar helpen ons objecten te creëren die entiteiten uit de echte wereld zijn.

66. Wat is het verschil tussen de statische (klasse)methode en de instancemethode?

67. Wat is dit trefwoord in Java?

‘dit’ is een trefwoord dat wordt gebruikt om te verwijzen naar een variabele die verwijst naar het huidige object.

68. Wat zijn korte toegangsspecificaties en soorten toegangsspecificaties?

Toegangsspecificaties in Java helpen de reikwijdte van een klasse, constructor, variabele, methode of gegevenslid te beperken. Er zijn vier soorten toegangsspecificaties in Java die hieronder worden genoemd:

1. Openbaar
2. Privaat
3. Beschermd
4. Standaard

69. Wat zal de initiële waarde zijn van een objectreferentie die is gedefinieerd als een instantievariabele?

De initiële waarde van een objectreferentie die is gedefinieerd als een instantievariabele is een NULL-waarde.

70. Wat is een voorwerp?

Het object is een levensechte entiteit waaraan bepaalde eigenschappen en methoden zijn gekoppeld. Het object wordt ook gedefinieerd als de instantie van een klasse. Een object kan worden gedeclareerd met een nieuw trefwoord.

71. Wat zijn de verschillende manieren om objecten in Java te maken?

Methoden om objecten in Java te maken worden hieronder vermeld:

1. Nieuw zoekwoord gebruiken
2. Nieuw exemplaar gebruiken
3. Met behulp van de clone()-methode
4. Deserialisatie gebruiken
5. De methode newInstance() van de klasse Constructor gebruiken

Raadpleeg voor meer informatie over methoden om objecten in Java te maken Dit artikel .

72. Wat zijn de voor- en nadelen van het klonen van objecten?

Er zijn veel voor- en nadelen verbonden aan het klonen van objecten, zoals hieronder vermeld:

Voordelen:

• In Java kan de toewijzingsoperator ‘=’ niet worden gebruikt voor klonen, omdat deze eenvoudigweg een kopie van referentievariabelen maakt. Om een ​​dergelijke discrepantie te overwinnen, kan de clone()-methode van de Object-klasse worden gebruikt via de toewijzingsoperator.
• De clone()-methode is een beschermde methode van de klasse Object, wat betekent dat alleen de klasse Employee Employee-objecten kan klonen. Dit betekent dat geen enkele andere klasse dan Employee Employee-objecten kan klonen, omdat deze de attributen van de Employee-klasse niet kent.
• De codegrootte neemt af naarmate de herhaling afneemt.
• Maakt replicatie mogelijk (een soort prototypepatroon). Door elk veld handmatig te initialiseren, ontstaat er grote code als het object complex is, het gaat sneller met klonen.

Nadelen:

• Omdat de methode Object.clone() beschermd is, moeten we onze eigen kloon() opgeven en er indirect Object.clone() van aanroepen.
• Als we geen methoden hebben, moeten we een kloonbare interface bieden, omdat we JVM-informatie moeten verstrekken zodat we een kloon() op ons object kunnen uitvoeren. Als dat niet het geval is, kunnen we de kloon niet klonen, maar een ondiepe kopie van velden als we retourneer gewoon super.clone() van de kloonmethode die problematisch kan zijn.

73. Wat zijn de voordelen als je dit in een methode doorgeeft in plaats van in het huidige klassenobject zelf?

Er zijn een paar voordelen als je dit in een methode doorgeeft in plaats van in het huidige klasseobject zelf, namelijk:

• dit is de laatste variabele waardoor deze niet aan een nieuwe waarde kan worden toegewezen, terwijl het huidige klasseobject mogelijk niet definitief is en kan worden gewijzigd.
• dit kan worden gebruikt in het gesynchroniseerde blok.

74. Wat is de constructeur?

Constructor is een speciale methode die wordt gebruikt om objecten te initialiseren. Constructor wordt aangeroepen wanneer een object wordt gemaakt. De naam van de constructor is dezelfde als die van de klasse.

Voorbeeld:

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

75. Wat gebeurt er als je geen constructor in een klasse opgeeft?

Als u geen constructor in een klasse in Java opgeeft, genereert de compiler automatisch een standaardconstructor zonder argumenten en zonder bewerking, wat een standaardconstructor is.

76. Hoeveel soorten constructors worden er in Java gebruikt?

Er zijn twee soorten constructors in Java, zoals hieronder vermeld:

1. Standaardconstructeur
2. Geparametriseerde constructor

Standaardconstructor: dit is het type dat geen enkele parameterwaarde accepteert. Het wordt gebruikt om initiële waarden voor objectattributen in te stellen.

class_Name(); // Default constructor called>

Geparametriseerde constructor: Het is het type constructor dat parameters als argumenten accepteert. Deze worden gebruikt om waarden toe te wijzen aan instantievariabelen tijdens de initialisatie van objecten.

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

77. Wat is het doel van een standaardconstructor?

Constructors helpen bij het maken van instanties van een klasse, of er kan worden gezegd dat ze objecten van een klasse creëren. Constructor wordt aangeroepen tijdens de initialisatie van objecten. Een standaardconstructor is een type constructor dat geen enkele parameter accepteert. Elke waarde die aan de eigenschappen van de objecten wordt toegewezen, wordt dus als standaardwaarden beschouwd.

78. Wat versta je onder kopieerconstructor in Java?

De kopieconstructor is het type constructor waarin we een ander object als parameter doorgeven, omdat welke eigenschappen van beide objecten hetzelfde lijken, daarom lijkt het alsof constructors een kopie van een object maken.

79. Waar en hoe kunt u een particuliere aannemer inschakelen?

Een privéconstructor wordt gebruikt als u niet wilt dat een andere klasse het object instantieert om subklassen te voorkomen. Het gebruik van een private constructor kan worden gezien zoals geïmplementeerd in het voorbeeld.

Voorbeeld:

// 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. Wat zijn de verschillen tussen de constructors en methoden?

Java-constructors worden gebruikt voor het initialiseren van objecten. Tijdens het maken worden constructors opgeroepen om attributen voor objecten in te stellen, afgezien van deze paar fundamentele verschillen tussen hen:

1. Constructors worden alleen aangeroepen als het object is gemaakt, maar andere methoden kunnen tijdens de levensduur van een object meerdere keren worden aangeroepen.
2. Constructors retourneren niets, terwijl andere methoden alles kunnen retourneren.
3. Constructors worden gebruikt om de beginstatus in te stellen, maar methoden worden gebruikt om specifieke acties uit te voeren.

81. Wat is een interface?

Een interface in Java is een verzameling statische eindvariabelen en abstracte methoden die het contract of de overeenkomst voor een reeks gekoppelde klassen definiëren. Elke klasse die een interface implementeert, moet een specifieke set methoden implementeren. Het specificeert het gedrag dat een klasse moet vertonen, maar niet de details van hoe deze moet worden geïmplementeerd.

Syntaxis:

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

Voorbeeld:

// 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. Geef enkele kenmerken van de interface.

Een interface in de Java-programmeertaal wordt gedefinieerd als een abstract type dat wordt gebruikt om het gedrag van een klasse te specificeren. Een interface in Java is een blauwdruk van gedrag. Een Java-interface bevat statische constanten en abstracte methoden.

Kenmerken van de interface worden hieronder vermeld:

• De interface kan helpen om totale abstractie te bereiken.
• Hiermee kunnen we meerdere overervingen in Java gebruiken.
• Elke klasse kan meerdere interfaces implementeren, zelfs als één klasse slechts één klasse kan uitbreiden.
• Het wordt ook gebruikt om losse koppeling te bereiken.

83. Wat is een markerinterface?

Een interface wordt herkend als een lege interface (geen veld of methoden). Het wordt een markerinterface genoemd. Voorbeelden van markeerinterfaces zijn serialiseerbare, kloonbare en externe interfaces.

84. Wat zijn de verschillen tussen abstracte klasse en interface?

85. Wat bedoel je met gegevensinkapseling?

Data Encapsulation is het concept van OOPS-eigenschappen en kenmerken van de klassen die aan elkaar zijn gekoppeld. Kortom, het bundelt gegevens en methoden die op die gegevens werken binnen één eenheid. Inkapseling wordt bereikt door de instantievariabelen van een klasse als privé te declareren, wat betekent dat ze alleen toegankelijk zijn binnen de klasse.

86. Wat zijn de voordelen van inkapseling op Java?

De voordelen van Encapsulation in Java worden hieronder vermeld:

1. Gegevens verbergen: het is een manier om de toegang van onze gegevensleden te beperken door de implementatiedetails te verbergen. Inkapseling biedt ook een manier om gegevens te verbergen. De gebruiker heeft geen idee van de innerlijke implementatie van de klasse.
2. Verhoogde flexibiliteit: We kunnen de variabelen van de klasse alleen-lezen of alleen-schrijven maken, afhankelijk van onze vereisten.
3. Herbruikbaarheid: Inkapseling verbetert ook de herbruikbaarheid en is gemakkelijk te veranderen bij nieuwe eisen.
4. Code testen is eenvoudig: Code is eenvoudig te testen voor unit-testen.

87. Wat is het belangrijkste voordeel van inkapseling?

Het belangrijkste voordeel van Encapsulation in Java is het vermogen om de interne status van een object te beschermen tegen externe wijziging of toegang. Het is een manier om de implementatiedetails van een klasse te verbergen voor toegang van buitenaf en alleen een openbare interface bloot te leggen die kan worden gebruikt voor interactie met de klasse. Het belangrijkste voordeel is dat het een manier biedt om de toestand en het gedrag van een object te controleren en te beheren en het tegelijkertijd te beschermen tegen wijziging en ongeoorloofde toegang.

Voorbeeld:

// 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. Wat bedoel je met aggregatie?

Aggregatie is een term die betrekking heeft op de relatie tussen twee klassen die het best kan worden omschreven als een heeft-een-relatie. Dit soort is de meest gespecialiseerde versie van associatie. Het is een unidirectionele associatie, wat betekent dat het een eenrichtingsrelatie is. Het bevat de verwijzing naar een andere klasse en er wordt gezegd dat het eigenaar is van die klasse.

89. Wat is de ‘IS-A’-relatie in OOPs Java?

‘IS-A’ is een type relatie in OOPs Java waarbij de ene klasse een andere klasse erft.

90. Definieer erfelijkheid.

Wanneer een object dat tot een subklasse behoort, alle eigenschappen en gedrag verkrijgt van een ouderobject dat uit de superklasse komt, staat dit bekend als overerving. Een klasse binnen een klasse wordt de subklasse genoemd en deze laatste de superklasse. Er wordt gezegd dat de subklasse of de kindklasse specifiek is, terwijl de superklasse of de ouderklasse generiek is. Overerving zorgt voor herbruikbaarheid van code.

91. Wat zijn de verschillende soorten overerving op Java?

Overerving is de methode waarmee de klasse Child de kenmerken van de klasse Super of Parent kan overnemen. In Java bestaat er vier soorten overerving:

• Enkele erfenis: Wanneer een kind- of subklasse slechts één superklasse uitbreidt, is het bekend dat er sprake is van een enkele overerving. Eigenschappen van eenouderklasse worden doorgegeven aan de onderliggende klasse.
• Overerving op meerdere niveaus: Wanneer een kind of subklasse een andere subklasse uitbreidt, ontstaat er een overervingshiërarchie die bekend staat als overerving op meerdere niveaus. Met andere woorden: de ene subklasse wordt de ouderklasse van een andere.
• Hiërarchische erfenis: Wanneer meerdere subklassen voortkomen uit dezelfde bovenliggende klasse, staat dit bekend als hiërarchische overerving. Met andere woorden: een klasse met één ouder heeft veel subklassen.
• Meervoudige erfenis: Wanneer een onderliggende klasse erft van meerdere bovenliggende klassen, wordt dit meervoudige overerving genoemd. In Java ondersteunt het alleen meervoudige overerving van interfaces, geen klassen.

92. Wat is meervoudige overerving? Wordt het ondersteund door Java?

Een onderdeel van het objectgeoriënteerde begrip dat bekend staat als meerdere overervingen, stelt een klasse in staat eigenschappen van veel bovenliggende klassen te erven. Wanneer methoden met dezelfde signatuur aanwezig zijn in zowel superklassen als subklassen, ontstaat er een probleem. De aanroeper van de methode kan niet aan de compiler specificeren welke klassemethode moet worden aangeroepen of zelfs welke klassemethode voorrang moet krijgen.

Opmerking: Java ondersteunt geen meervoudige overerving

Voorbeeld:

// 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. Hoe verschilt overerving in C++ van Java?

94. Zijn er beperkingen aan het gebruik van erfenis?

Ja, er is een beperking bij het gebruik van overerving in Java, omdat je door overerving alles kunt erven van superklasse en interface, waardoor de subklasse te geclusterd is en soms foutgevoelig wanneer in bepaalde situaties dynamische overschrijving of dynamische overbelasting wordt uitgevoerd.

95. Hoewel overerving een populair OOP-concept is, is het minder voordelig dan samenstelling. Uitleggen.

Overerving is een populair concept van Object-Oriented Programming (OOP), waarbij een klasse de eigenschappen en methoden van elke andere klasse kan erven, ook wel een Parent- of superklasse genoemd. Aan de andere kant kan een klasse in Composition een instantie van een andere klasse bevatten als lidvariabele, waarnaar vaak wordt verwezen als onderdeel of component. Hieronder staan ​​enkele redenen waarom samenstelling voordeliger is dan overerving:

• Strakke koppeling: Wanneer er wijzigingen worden aangebracht in de superklasse, kunnen deze wijzigingen het gedrag van alle onderliggende klassen of subklassen beïnvloeden. Dit probleem maakt de code minder flexibel en zorgt ook voor problemen tijdens het onderhoud. Dit probleem leidt ook tot de nauwe koppeling tussen de klassen.
• Kwetsbaar basisklasseprobleem: Wanneer de wijzigingen in de basisklasse de functionaliteit van de afgeleide klassen kunnen verstoren. Dit probleem kan het moeilijk maken om nieuwe functies toe te voegen of de bestaande te wijzigen. Dit probleem staat bekend als het Fragile Base-klasseprobleem.
• Beperkt hergebruik: Overerving in Java kan leiden tot beperkt hergebruik van code en tot duplicatie van code. Omdat een subklasse alle eigenschappen en methoden van zijn superklasse erft, kan het soms eindigen met onnodige code die niet nodig is. Dit leidt tot een minder onderhoudbare codebase.

96. Wat is een associatie?

De associatie is een relatie tussen twee afzonderlijke klassen, tot stand gebracht via hun objecten. Het vertegenwoordigt de relatie van Has-A.

97. Wat bedoel je met aggregatie?

Compositie is een beperkte vorm van aggregatie waarbij twee entiteiten sterk van elkaar afhankelijk zijn. Het vertegenwoordigt deel van de relatie.

98. Wat is de samenstelling van Java?

Compositie impliceert een relatie waarbij het kind betrokken is kan niet zelfstandig bestaan van de ouder. Het menselijk hart bestaat bijvoorbeeld niet los van een mens.

99. Geef het verschil aan tussen Samenstelling en Aggregatie.

100. Kan de constructor worden geërfd?

Nee, we kunnen een constructor niet erven.

101. Wat is polymorfisme?

Polymorfisme wordt gedefinieerd als het vermogen om meer dan één vorm aan te nemen. Er zijn twee soorten, namelijk compileertijdpolymorfisme of overbelasting van methoden - een functie die wordt aangeroepen tijdens het compileren. Neem bijvoorbeeld een klasse ‘gebied’. Op basis van het aantal parameters kan het de oppervlakte van een vierkant, driehoek of cirkel berekenen. Runtime-polymorfisme of methode-overschrijving - koppelingen tijdens runtime. De methode binnen een klasse overschrijft de methode van de bovenliggende klasse.

102. Wat is runtime-polymorfisme of dynamische methodeverzending?

Dynamische methodeverzending is een oplossingsmechanisme voor het overschrijven van methoden tijdens de runtime. Methode overschrijven is degene waarbij de methode in een subklasse dezelfde naam, parameters en retourtype heeft als een methode in de superklasse. Wanneer de overschreven methode wordt aangeroepen via een superklassereferentie, bepaalt Java welke versie (superklasse of subklasse) van die methode moet worden uitgevoerd op basis van het type object waarnaar wordt verwezen op het moment dat de aanroep plaatsvindt. De beslissing wordt dus tijdens runtime genomen. Dit wordt dynamische methodeverzending genoemd.

103. Wat is methodeoverschrijving?

Methode-overschrijving, ook wel runtime-polymorfisme genoemd, is er een waarbij de onderliggende klasse dezelfde methode bevat als de bovenliggende klasse. We hebben bijvoorbeeld een methode met de naam ‘gfg()’ in de bovenliggende klasse. In de subklasse wordt opnieuw een methode gfg() gedefinieerd. Dus wanneer gfg() wordt aangeroepen in de subklasse, wordt de methode binnen de klasse-id uitgevoerd. Hier heeft gfg() binnen de klasse de methode daarbuiten overschreven.

104. Wat is overbelasting van methoden?

Methode-overschrijving is een methode om Runtime-polymorfisme in Java te bereiken. Methode overschrijven is een functie waarmee een onderliggende klasse een specifieke implementatie kan bieden van een methode die al door een van de bovenliggende klassen wordt aangeboden. Wanneer een methode in een onderliggende klasse dezelfde naam, dezelfde parameters of handtekening en hetzelfde retourtype (of subtype) heeft als een methode in de bovenliggende klasse, dan zou de methode in de subklasse de methode overschrijven. de superklasse.

105. Kunnen we de statische methode terzijde schuiven?

Nee, omdat statische methoden deel uitmaken van de klasse en niet van het object, kunnen we ze niet overschrijven.

106. Kunnen we de overbelaste methode terzijde schuiven?

Ja, aangezien de overbelaste methode in de ogen van de compiler een heel andere methode is. Overschrijven is helemaal niet hetzelfde. De beslissing welke methode moet worden aangeroepen, wordt uitgesteld tot runtime.

107. Kunnen we de methode main() overbelasten?

Ja, in Java kunnen we de hoofdmethode overbelasten om de hoofdmethode aan te roepen met behulp van de vooraf gedefinieerde aanroepmethode.

108. Wat zijn methode-overbelasting en methode-overschrijving?

Methode Overbelasting: Het is ook bekend als Compile Time Polymorphism. Bij overbelasting van methoden worden twee of meer methoden gedeeld in dezelfde klasse met een verschillende handtekening.

Voorbeeld:

// 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>

Methode overschrijven: Methode-overschrijving vindt plaats wanneer een subklasse de implementatie kan bieden van een methode die al is gedefinieerd in de bovenliggende klasse of superklasse. Het retourtype, de naam en de argumenten moeten vergelijkbaar zijn met de methoden in de superklasse.

Voorbeeld:

// 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. Kunnen we de privémethoden terzijde schuiven?

Het is niet mogelijk om de privémethoden in Java te overschrijven. Bij het overschrijven van methoden wordt de methode in de subklasse geïmplementeerd in plaats van de methode uit de bovenliggende klasse. De private methoden zijn alleen toegankelijk binnen de klasse waarin deze is gedeclareerd. Omdat deze methode niet zichtbaar is voor andere klassen en niet toegankelijk is, kan deze niet worden overschreven.

110. Kunnen we de reikwijdte van de overschreven methode in de subklasse wijzigen?

In Java is het niet mogelijk om het bereik van de overschreven methode te wijzigen. Het bereik van de subklassemethode moet gelijk zijn aan of groter zijn dan het bereik van de overschreven methode van de Superklassemethode. De overschreven methode in de subklasse kan bijvoorbeeld een openbaar bereik hebben of een meer toegankelijk bereik, zoals protected of default, als de overschreven methode in de superklasse een openbaar bereik heeft. Het kan echter geen exclusievere reikwijdte hebben dan privé.

111. Kunnen we de throws-clausule van de superklassemethode wijzigen terwijl we deze in de subklasse overschrijven?

We kunnen de throws-clausule van de Superclass-methode met enkele beperkingen wijzigen. We kunnen de throws-clausule van de superclass-methode wijzigen terwijl deze in de subklasse wordt overschreven. De subklasse-overschreven methode kan alleen niet-gecontroleerde uitzonderingen specificeren als de superklasse-methode geen uitzonderingen declareert. Als de superklassemethode een uitzondering declareert, kan de subklassemethode dezelfde uitzondering, een subklasse-uitzondering of helemaal geen uitzondering declareren. De subklassemethode kan echter geen ouderuitzondering declareren die breder is dan de uitzonderingen die in de superklassemethode zijn gedeclareerd.

112. Kun je virtuele functies hebben in Java?

Ja, Java ondersteunt virtuele functies. Functies zijn standaard virtueel en kunnen niet-virtueel worden gemaakt met behulp van het laatste trefwoord.

113. Wat is abstractie?

Abstractie verwijst naar de handeling waarbij essentiële kenmerken worden weergegeven zonder achtergronddetails op te nemen. De gedetailleerde informatie of de implementatie is verborgen. Het meest voorkomende voorbeeld van abstractie is een auto, we weten hoe we de motor moeten aanzetten, accelereren en bewegen, maar de manier waarop de motor werkt, en de interne componenten ervan zijn complexe logica die verborgen is voor de algemene gebruikers. Dit wordt meestal gedaan om met de complexiteit om te gaan.

114. Wat is abstracte klasse?

Een klasse die als abstract is gedeclareerd, kan niet worden geïnstantieerd, dat wil zeggen dat het object niet kan worden gemaakt. Het kan wel of geen abstracte methoden bevatten, maar als een klasse ten minste één abstracte methode heeft, moet deze abstract worden verklaard.

Voorbeeld van een abstracte klasse met abstracte methode:

// 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. Wanneer worden abstracte methoden gebruikt?

Een abstracte methode wordt gebruikt wanneer we een methode willen gebruiken, maar onderliggende klassen willen hebben om de implementatie te bepalen. In dat geval gebruiken we abstracte methoden met de bovenliggende klassen.

116. Hoe kun je serialisatie in de onderliggende klasse vermijden als de basisklasse de serialiseerbare interface implementeert?

Serialisatie in de onderliggende klasse als de basisklasse de Serializable-interface implementeert, kunnen we dit vermijden door de writeObject() -methode te definiëren en NotSerializableException() te genereren.

117. Wat is het verzamelframework in Java?

Verzamelingen zijn eenheden van objecten in Java. Het verzamelingsframework is een reeks interfaces en klassen in Java die worden gebruikt om verzamelingen objecten op verschillende manieren weer te geven en te manipuleren. Het verzamelraamwerk bevat klassen (ArrayList, Vector, LinkedList, PriorityQueue, TreeSet) en meerdere interfaces (Set, List, Queue, Deque) waarbij elke interface wordt gebruikt om een ​​specifiek type gegevens op te slaan.

118. Leg verschillende interfaces uit die in het Collection-framework worden gebruikt.

Verzamelingsraamwerk implementeert

1. Collectie-interface
2. Lijstinterface
3. Interface instellen
4. Wachtrij-interface
5. En de interface
6. Kaartinterface

Verzamelinterface: Collection is de primaire beschikbare interface die kan worden geïmporteerd met java.util.Collection.

Syntaxis:

public interface Collection extends iterable>

119. Hoe kunt u een ArrayList in Java synchroniseren?

Een ArrayList kan worden gesynchroniseerd met behulp van de twee hieronder genoemde methoden:

1. Collections.synchronizedList() gebruiken
2. CopyOnWriteArrayList gebruiken

Collections.synchronizedList() gebruiken:

public static List synchronizedList(List list)>

CopyOnWriteArrayList gebruiken:

1. Maak een lege lijst.
2. Het implementeert de Lijst-interface
3. Het is een thread-safe variant van ArrayList
4. T staat voor generiek

120. Waarom hebben we een gesynchroniseerde ArrayList nodig als we vectoren hebben (die gesynchroniseerd zijn) in Java?

ArrayList heeft om bepaalde redenen zelfs behoefte aan vectoren:

1. ArrayList is sneller dan vectoren.
2. ArrayList ondersteunt multithreading, terwijl Vectoren alleen gebruik van één thread ondersteunen.
3. ArrayList is veiliger in gebruik, omdat vectoren afzonderlijke threads ondersteunen en individuele bewerkingen minder veilig zijn en langer duren om te synchroniseren.
4. Vectoren worden op Java als verouderd beschouwd vanwege hun gesynchroniseerde karakter.

121. Waarom kunnen we geen generieke array maken?

Generieke arrays kunnen niet worden gemaakt omdat een reeks draagt typ informatie over de elementen tijdens runtime, waardoor het tijdens runtime ‘ArrayStoreException’ gooit als het type van de elementen niet vergelijkbaar is. Omdat informatie over het generieke type tijdens het compileren wordt gewist door Type Erasure, zou de array-opslagcontrole zijn geslaagd waar deze had moeten mislukken.

122. Aaneengesloten geheugenlocaties worden gewoonlijk gebruikt voor het opslaan van feitelijke waarden in een array, maar niet in ArrayList. Uitleggen.

De elementen van een array worden opgeslagen op aaneengesloten geheugenlocaties, wat betekent dat elk element wordt opgeslagen in een afzonderlijk blok op basis van het element dat zich in de array bevindt. Omdat de elementen van de array op aaneengesloten locaties zijn opgeslagen, kan het relatief eenvoudig zijn om toegang te krijgen tot elk element via de index, aangezien het elementadres kan worden berekend op basis van de locatie van het element. Maar Java implementeert ArrayLists als dynamische arrays, wat betekent dat de grootte kan veranderen als elementen worden verwijderd of toegevoegd. ArrayList-elementen worden niet opgeslagen op aaneengesloten geheugenlocaties om tegemoet te komen aan dit dynamische karakter. In plaats daarvan maakt de ArrayList gebruik van een methode die bekend staat als een uitbreidbare array, waarbij de onderliggende array indien nodig naar een groter formaat wordt uitgebreid en de elementen vervolgens naar de nieuwe locatie worden gekopieerd. In tegenstelling tot een ArrayList, die een dynamische grootte heeft en de elementen niet op aaneengesloten geheugenlocaties opslaat, heeft een array een vaste grootte en worden de elementen daar opgeslagen.

123. Leg de methode uit om ArrayList naar Array en Array naar ArrayList te converteren.

Conversie van lijst naar ArrayList

Er zijn meerdere methoden om Lijst naar ArrayList te converteren

Programmeurs kunnen een Array naar ArrayList converteren met behulp van de asList()-methode van de klasse Arrays. Het is een statische methode van de klasse Arrays die het List-object accepteert.

Syntaxis:

Arrays.asList(item)>

Voorbeeld:

// 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]>

Conversie van ArrayList naar Array

Java-programmeurs kunnen ArrayList converteren naar

Syntaxis:

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

Voorbeeld:

// 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. Hoe groeit de omvang van ArrayList dynamisch? En geef ook aan hoe het intern wordt geïmplementeerd.

Vanwege het array-gebaseerde karakter van ArrayLists groeit het dynamisch in omvang, waardoor er altijd voldoende ruimte is voor elementen. Wanneer een ArrayList-element voor het eerst wordt gemaakt, bedraagt ​​de standaardcapaciteit ongeveer 10-16 elementen, wat in principe afhankelijk is van de Java-versie. ArrayList-elementen worden van de originele array naar de nieuwe array gekopieerd wanneer de capaciteit van de originele array vol is. Naarmate de ArrayList-grootte dynamisch toeneemt, creëert de klasse een nieuwe array met grotere formaten en kopieert alle elementen van de oude array naar de nieuwe array. Nu wordt de referentie van de nieuwe array intern gebruikt. Dit proces van het dynamisch laten groeien van een array staat bekend als het wijzigen van de grootte.

125. Wat is een vector op Java?

Vectoren in Java zijn vergelijkbaar en kunnen meerdere elementen erin opslaan. Vectoren volgen bepaalde regels die hieronder worden vermeld:

1. Vector kan worden geïmporteerd met Java.util.Vector.
2. Vector wordt geïmplementeerd met behulp van een dynamische array naarmate de grootte van de vector toeneemt en afneemt, afhankelijk van de elementen die erin zijn ingevoegd.
3. Elementen van de vector met indexnummers.
4. Vectoren zijn van nature gesynchroniseerd, wat betekent dat ze slechts één enkele thread gebruikten (er wordt slechts één proces op een bepaald tijdstip uitgevoerd).
5. De vector bevat veel methoden die geen deel uitmaken van het verzamelingsframework.

Syntaxis:

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

126. Hoe maak ik Java ArrayList alleen-lezen?

Een ArrayList kan alleen gereed worden gemaakt met behulp van de methode van Collections met behulp van de Collections.unmodifiableList() -methode.

Syntaxis:

array_readonly = Collections.unmodifiableList(ArrayList);>

Voorbeeld:

// 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. Wat is een prioriteitswachtrij in Java?

Een prioriteitswachtrij is een abstract gegevenstype dat lijkt op een reguliere wachtrij of stapelgegevensstructuur. Elementen die in elementen zijn opgeslagen, zijn afhankelijk van de prioriteit die is gedefinieerd van laag naar hoog. De PriorityQueue is gebaseerd op de prioriteitsheap.

Syntaxis:

// 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. Leg de klasse LinkedList uit.

De LinkedList-klasse is Java die een dubbel gekoppelde lijst gebruikt om elementen op te slaan. Het erft de klasse AbstractList en implementeert List- en Deque-interfaces. Eigenschappen van de LinkedList-klasse worden hieronder vermeld:

1. LinkedList-klassen zijn niet-gesynchroniseerd.
2. Houdt de invoegvolgorde bij.
3. Het kan worden gebruikt als lijst, stapel of wachtrij.

Syntaxis:

LinkedList list_name=new LinkedList();>

129. Wat is de Stack-klasse in Java en welke verschillende methoden worden erdoor geboden?

Een Stack-klasse in Java is een LIFO-datastructuur die de Last In First Out-datastructuur implementeert. Het is afgeleid van een Vector-klasse, maar heeft functies die specifiek zijn voor stapels. De Stack-klasse in Java biedt de volgende methoden:

• kijkje(): geeft het bovenste item van de stapel terug zonder het te verwijderen
• leeg(): retourneert true als de stapel leeg is en anders false
• duw(): duwt een item naar de bovenkant van de stapel
• knal(): verwijdert het bovenste item van de stapel en legt het terug
• zoekopdracht(): retourneert de 1, gebaseerde positie van het object vanaf de bovenkant van de stapel. Als het object zich niet in de stapel bevindt, retourneert het -1

130. Wat is ingesteld in het Java Collections-framework en somt de verschillende implementaties ervan op?

Sets zijn verzamelingen die geen dubbele elementen opslaan. Ze houden geen enkele volgorde van de elementen aan. Het Java Collections-framework biedt verschillende implementaties van de Set-interface, waaronder:

• HashSet: HashSet in Java slaat de elementen op in een has-tabel, wat snellere zoekopdrachten en snellere invoeging mogelijk maakt. HashSet is niet besteld.
• GekoppeldeHashSet: LinkedHashSet is een implementatie van HashSet die de invoegvolgorde van de elementen behoudt.
• BoomSet: TreeSet slaat de elementen op in een gesorteerde volgorde die wordt bepaald door de natuurlijke volgorde van de elementen of door een aangepaste vergelijker die werd verstrekt op het moment van creatie.

131. Wat is de HashSet-klasse in Java en hoe slaat deze elementen op?

De HashSet-klasse implementeert de Set-interface in het Java Collections Framework en is lid van de HashSet-klasse. In tegenstelling tot dubbele waarden slaat het een verzameling afzonderlijke elementen op. In deze implementatie wordt elk element toegewezen aan een index in een array met behulp van een hash-functie, en wordt de index gebruikt om snel toegang te krijgen tot het element. Het produceert een index voor het element in de array waar het is opgeslagen op basis van het invoerelement. Ervan uitgaande dat de hashfunctie de elementen op de juiste manier over de buckets verdeelt, biedt de klasse HashSet constante prestaties voor basisbewerkingen (toevoegen, verwijderen, bevatten en vergroten).

132. Wat is LinkedHashSet in het Java Collections Framework?

De LinkedHashSet is een geordende versie van Hashset die wordt onderhouden door een dubbel gekoppelde lijst voor alle elementen. Het is erg handig als er een iteratievolgorde nodig is. Tijdens Iteratie in LinkedHashSet worden elementen geretourneerd in dezelfde volgorde waarin ze zijn ingevoegd.

Syntaxis:

LinkedHashSet hs = new LinkedHashSet();>

Voorbeeld:

// 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. Wat is een kaartinterface in Java?

De kaartinterface is aanwezig in de Java-collectie en kan worden gebruikt met het Java.util-pakket. Een kaartinterface wordt gebruikt voor het in kaart brengen van waarden in de vorm van een sleutelwaardeformulier. De kaart bevat alle unieke sleutels. Het biedt ook methoden die eraan zijn gekoppeld, zoals containKey(), bevat waarde (), enz.

Er zijn meerdere soorten kaarten in de kaartinterface, zoals hieronder vermeld:

1. Gesorteerde kaart
2. Boomkaart
3. Hash kaart
4. GelinkteHashMap

134. Treemap in Java uitleggen

TreeMap is een type kaart waarin gegevens worden opgeslagen in de vorm van een sleutel-waardepaar. Het wordt geïmplementeerd met behulp van de rood-zwarte boom. Kenmerken van TreeMap zijn:

1. Het bevat alleen unieke elementen.
2. Het kan geen NULL-sleutel hebben
3. Het kan meerdere NULL-waarden hebben.
4. Het is niet-gesynchroniseerd.
5. Het handhaaft de oplopende volgorde.

135. Wat is EnumSet?

EnumSet is een gespecialiseerde implementatie van de Set-interface voor gebruik met het opsommingstype. Een paar kenmerken van EnumSet zijn:

1. Het is niet-gesynchroniseerd.
2. Sneller dan HashSet.
3. Alle elementen in een EnumSet moeten afkomstig zijn van één enkel opsommingstype.
4. Het staat geen null-objecten toe en genereert NullPointerException voor uitzonderingen.
5. Het maakt gebruik van een fail-safe iterator.

Syntaxis:

public abstract class EnumSet>

Parameter: E specificeert de elementen.

136. Wat is BlockingQueue?

Een blokkerende wachtrij is een wachtrij die de bewerkingen ondersteunt die wachten tot de wachtrij niet leeg is tijdens het ophalen en verwijderen van het element, en wachten tot er ruimte vrijkomt in de wachtrij terwijl het element wordt toegevoegd.

Syntaxis:

public interface BlockingQueue extends Queue>

Parameters: E is het type elementen dat in de collectie is opgeslagen

137. Wat is de ConcurrentHashMap in Java en implementeert u deze?

ConcurrentHashMap wordt geïmplementeerd met behulp van Hashtable.

Syntaxis:

public class ConcurrentHashMap  extends AbstractMap  implements ConcurrentMap, Serializable>

Parameters : K is het sleutelobjecttype en V is de waarde Objecttype

138. Kun je elke klasse als kaartsleutel gebruiken?

Ja, we kunnen elke klasse als kaartsleutel gebruiken als deze bepaalde vooraf gedefinieerde regels volgt die hieronder worden vermeld:

1. De klasse die de methode equals() overschrijft, moet ook de methode hashCode() overschrijven
2. De klasse concurrentHashMap is thread-safe.
3. Het standaard gelijktijdigheidsniveau van ConcurrentHashMap is 16.
4. Het invoegen van nulobjecten in ConcurrentHashMap is niet mogelijk als sleutel of als waarde.

139. Wat is een iterator?

De Iterator-interface biedt methoden om elke verzameling in Java te herhalen. Iterator is de vervanging van Enumeration in het Java Collections Framework. Het kan een iteratorinstantie uit een verzameling ophalen met behulp van de methode _iterator()_. Het stelt de aanroeper ook in staat om tijdens de iteratie elementen uit de onderliggende verzameling te verwijderen.

140. Wat is een opsomming?

Opsomming is een door de gebruiker gedefinieerd gegevenstype. Het wordt voornamelijk gebruikt om namen toe te kennen aan integrale constanten; de namen maken een programma gemakkelijk te lezen en te onderhouden. Het hoofddoel van de enum is het definiëren van door de gebruiker gedefinieerde gegevenstypen.

Voorbeeld:

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

141. Wat is het verschil tussen verzameling en verzamelingen?

142. Maak onderscheid tussen Array en ArrayList in Java.

143. Wat is het verschil tussen Array en Collection in Java?

144. Verschil tussen ArrayList en LinkedList.

145. Maak onderscheid tussen ArrayList en Vector in Java.

146. Wat is het verschil tussen Iterator en ListIterator?

147. Maak onderscheid tussen HashMap en HashTable.

148. Wat is het verschil tussen Iterator en Opsomming?

149. Wat is het verschil tussen Vergelijkbaar en Vergelijker?

150. Wat is het verschil tussen Set en Kaart?

Java tussentijdse sollicitatievragen

151. Leg de FailFast-iterator en FailSafe-iterator uit, samen met voorbeelden voor elk.

Een FailFast-iterator is een iterator die a gooit ConcurrentModificationException als het detecteert dat de onderliggende verzameling is gewijzigd terwijl de iterator wordt gebruikt. Dit is het standaardgedrag van iterators in het Java Collections Framework. De iterator voor een HashMap is bijvoorbeeld FailFast.

Voorbeeld:

// 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);  }  }  } }>

Uitgang:

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

Een FailSafe-iterator gooit geen a ConcurrentModificationException als de onderliggende verzameling wordt gewijzigd terwijl de iterator wordt gebruikt. Als alternatief kan er een momentopname van de collectie worden gemaakt op het moment dat de iterator wordt gemaakt, en wordt de momentopname herhaald. De iterator voor een ConcurrentHashMap is bijvoorbeeld FailSafe.

Voorbeeld:

// 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. Wat is de afhandeling van uitzonderingen?

Een Uitzondering is een gebeurtenis die de normale stroom van het programma onderbreekt en speciale verwerking vereist. Tijdens de uitvoering van een programma kunnen fouten en ongeplande gebeurtenissen worden afgehandeld met behulp van het Java Exception Handling-mechanisme. Hieronder staan ​​enkele redenen waarom er uitzonderingen voorkomen in Java:

• Apparaatfout
• Verlies van netwerkverbinding
• Codefouten
• Een niet-beschikbaar bestand openen
• Ongeldige gebruikersinvoer
• Fysieke beperkingen (onvoldoende schijfgeheugen)

153. Hoeveel soorten uitzonderingen kunnen er voorkomen in een Java-programma?

Er zijn over het algemeen twee soorten uitzonderingen in Java:

• Ingebouwde uitzonderingen: Ingebouwde uitzonderingen in Java worden geleverd door de Java-bibliotheken. Deze uitzonderingen kunnen verder worden onderverdeeld in twee subcategorieën, namelijk aangevinkte en niet-aangevinkte uitzonderingen. Hieronder staan ​​enkele van de ingebouwde uitzonderingen in Java:
  • ArrayIndexOutOfBoundsExceptions
  • ClassNotFoundException
  • FileNotFoundException
  • IOUitzondering
  • NullPointerException
  • Rekenkundige uitzondering
  • OnderbrokenUitzondering
  • RuntimeException
• Door de gebruiker gedefinieerde uitzonderingen: Door de gebruiker gedefinieerde uitzonderingen worden door de programmeurs zelf gedefinieerd om bepaalde specifieke situaties of fouten af ​​te handelen die niet onder de ingebouwde uitzonderingen vallen. Om door de gebruiker gedefinieerde uitzonderingen te definiëren, moet een nieuwe klasse worden gedefinieerd die de juiste uitzonderingsklasse uitbreidt. Door de gebruiker gedefinieerde uitzonderingen in Java worden gebruikt wanneer de ingebouwde uitzonderingen zich in Java bevinden.

154. Verschil tussen een fout en een uitzondering.

155. Leg de hiërarchie van Java Exception-klassen uit.

Alle uitzonderings- en fouttypen in Java zijn subklassen van de klasse die kan worden gegooid, wat de basisklasse van de hiërarchie is. Deze klasse wordt vervolgens gebruikt voor uitzonderlijke omstandigheden die gebruikersprogramma's moeten opvangen. NullPointerException is een voorbeeld van een dergelijke uitzondering. Een andere tak, fout, wordt door het Java-runtimesysteem gebruikt om fouten aan te geven die te maken hebben met de JRE. StackOverflowError is een voorbeeld van een dergelijke fout.

156. Leg runtime-uitzonderingen uit.

Runtime-uitzonderingen zijn uitzonderingen die optreden tijdens de uitvoering van een code, in tegenstelling tot uitzonderingen tijdens het compileren die optreden tijdens het compileren. Runtime-uitzonderingen zijn niet-gecontroleerde uitzonderingen, omdat er geen rekening mee wordt gehouden door de JVM.

Voorbeelden van runtime-uitzonderingen in Java zijn:

• NullPointerException: Dit gebeurt wanneer een toepassing probeert een null-objectreferentie te gebruiken.
• ArrayIndexOutOfBoundsException: Dit gebeurt wanneer een toepassing probeert toegang te krijgen tot een array-index die zich buiten het bereik bevindt.
• ArithmeticException: Dit gebeurt wanneer een toepassing probeert te delen door nul.
• IllegalArgumentException: Dit gebeurt wanneer een methode wordt doorgegeven op basis van een illegaal of ongepast argument.

In tegenstelling tot gecontroleerde uitzonderingen vereisen runtime-uitzonderingen geen declaratie in de throws-clausule of capture in een try-catch-blok. Het is echter aan te raden om runtime-uitzonderingen af ​​te handelen om betekenisvolle foutmeldingen te geven en een systeemcrash te voorkomen. Omdat runtime-uitzonderingen meer specifieke informatie over het probleem bieden dan gecontroleerde uitzonderingen, stellen ze ontwikkelaars in staat programmeerfouten gemakkelijker en sneller op te sporen en te corrigeren.

157. Wat is NullPointerException?

Het is een type runtime-uitzondering die wordt gegenereerd wanneer het programma probeert een objectreferentie te gebruiken die een nulwaarde heeft. Het belangrijkste gebruik van NullPointerException is om aan te geven dat er geen waarde is toegewezen aan een referentievariabele. Het wordt ook gebruikt voor het implementeren van datastructuren zoals gekoppelde lijsten en bomen.

158. Wanneer wordt de ArrayStoreException gegenereerd?

ArrayStoreException wordt gegenereerd wanneer wordt geprobeerd het verkeerde type object in een array met objecten op te slaan.

Voorbeeld:

// 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);  } }>

Voorbeeld:

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

159. Wat is het verschil tussen een gecontroleerde uitzondering en een niet-gecontroleerde uitzondering?

Gecontroleerde uitzondering:

Gecontroleerde uitzonderingen zijn de uitzonderingen die worden gecontroleerd tijdens het compileren van een programma. Als in een programma code binnen een methode een gecontroleerde uitzondering genereert, moet de methode de uitzondering afhandelen of de uitzondering specificeren met behulp van het sleutelwoord throws.

Er zijn twee soorten gecontroleerde uitzonderingen:

• Volledig gecontroleerde uitzonderingen: alle onderliggende klassen worden ook gecontroleerd, zoals IOException en InterruptedException.
• Gedeeltelijk gecontroleerde uitzonderingen: sommige van de onderliggende klassen zijn uitgeschakeld, zoals een uitzondering.

Niet-aangevinkte uitzondering:

Niet aangevinkt zijn de uitzonderingen die niet worden gecontroleerd tijdens het compileren van een programma. Uitzonderingen onder de klassen Error en RuntimeException zijn niet-aangevinkte uitzonderingen, al het andere onder throwable is aangevinkt.

160. Wat is de basisklasse voor Error en Exception?

Fout is een illegale handeling die door de gebruiker wordt uitgevoerd en die afwijkingen in het programma veroorzaakt. Uitzonderingen zijn de onverwachte gebeurtenissen of omstandigheden die zich voordoen tijdens het uitvoeren van het programma. Uitzonderingen verstoren de normale stroom van de programma-instructies.

Fouten en uitzonderingen hebben beide een gemeenschappelijke bovenliggende klasse, namelijk de klasse java.lang.Throwable.

161. Is het nodig dat elk try-blok gevolgd wordt door een catch-blok?

Nee, het is niet nodig om catch block na try block in Java te gebruiken, omdat we met final block een andere combinatie kunnen maken. Ten slotte is er het blok dat wordt uitgevoerd ondanks het feit dat de uitzondering wordt gegenereerd of niet.

162. Wat is de verspreiding van uitzonderingen?

Uitzonderingvoortplanting is een proces waarbij de uitzondering van boven naar onder in de stapel wordt verwijderd. Als de uitzondering niet één keer wordt opgevangen, valt de uitzondering weer terug naar de vorige methode, enzovoort totdat deze wordt opgevangen of helemaal onderaan de call-stack wordt bereikt.

163. Wat zal er gebeuren als u System.exit(0) op het try- of catch-blok zet? Zal het blok eindelijk worden uitgevoerd?

System.exit(int) heeft de mogelijkheid om SecurityException te genereren. Dus als in geval van veiligheid de uitzondering wordt gegenereerd, wordt het blok uiteindelijk uitgevoerd, anders wordt JVM gesloten tijdens het aanroepen van System. exit(0) waardoor het blok uiteindelijk niet zal worden uitgevoerd.

164. Wat versta je onder Object Cloning en hoe bereik je dit in Java?

Het is het proces waarbij van elk object een exacte kopie wordt gemaakt. Om dit te ondersteunen moet een Java-klasse de Cloneable-interface van het java.lang-pakket implementeren en de clone()-methode van de Object-klasse overschrijven, waarvan de syntaxis is:

Protected Object clone() genereert CloneNotSupportedException{ return (Object)super.clone();}In het geval dat de Cloneable-interface niet is geïmplementeerd en alleen de methode wordt overschreven, resulteert dit in CloneNotSupportedException in Java.

165. Welke invloed hebben uitzonderingen op het programma als het ze niet afhandelt?

Uitzonderingen zijn verantwoordelijk voor het abrupt beëindigen van de uitvoering van het programma tijdens de uitvoering en de code die wordt geschreven nadat de uitzondering zich heeft voorgedaan, wordt niet uitgevoerd.

166. Wat is het nut van het laatste zoekwoord?

Het laatste trefwoord wordt gebruikt om functies niet-virtueel te maken. Standaard zijn alle functies virtueel, dus om het niet-virtueel te maken gebruiken we het laatste trefwoord.

167. Welk doel dienen de trefwoorden final, final en finalize?

i). laatste:

final is dat een trefwoord wordt gebruikt met de variabele, methode of klasse, zodat deze niet kunnen worden overschreven.

Voorbeeld:

// 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;  } }>

Uitgang:

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

ii). Eindelijk

ten slotte is er een codeblok dat wordt gebruikt met try-catch bij het afhandelen van uitzonderingen. Code die uiteindelijk in blok wordt geschreven, wordt uitgevoerd ondanks het feit dat er een uitzondering wordt gegenereerd of niet.

Voorbeeld:

// 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). afronden

Het is een methode die wordt aangeroepen vlak voordat de objecten worden verwijderd/vernietigd die in aanmerking komen voor Garbage Collection om opruimactiviteiten uit te voeren.

Voorbeeld:

/*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. Wat is het verschil tussen this() en super() in Java?

169. Wat is multitasken?

Multitasking in Java verwijst naar het vermogen van een programma om meerdere taken tegelijk uit te voeren. Threads, dit zijn snelle bewerkingen binnen één enkel programma, kunnen dit doen. Het uitvoeren van meerdere dingen tegelijk staat bekend als multitasken.

Voorbeeld:

// 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. Wat bedoel je met een Multithreaded-programma?

Multithreaded-programma's in Java bevatten threads die gelijktijdig worden uitgevoerd in plaats van opeenvolgend. Een computer kan zijn hulpbronnen efficiënter gebruiken door meerdere taken tegelijk te combineren. Met elk programma met multithreading kan meer dan één gebruiker het programma tegelijkertijd gebruiken zonder meerdere kopieën uit te voeren. Een multithreaded programma is ontworpen om meerdere processen tegelijkertijd uit te voeren, wat de prestaties van een programma kan verbeteren en het programma in staat stelt meerdere processors te gebruiken en de algehele doorvoer verbetert.

171. Wat zijn de voordelen van multithreading?

Er zijn meerdere voordelen van het gebruik van multithreading, namelijk:

• Responsiviteit: De responsiviteit van gebruikers neemt toe omdat de multithreading interactieve applicatie het mogelijk maakt code uit te voeren, zelfs wanneer de sectie is geblokkeerd of een langdurig proces uitvoert.
• Het delen van bronnen: het proces kan het doorgeven van berichten en gedeeld geheugen uitvoeren vanwege multithreading.
• Economie: We kunnen geheugen delen, waardoor de processen economisch zijn.
• Schaalbaarheid: Multithreading op meerdere CPU-machines verhoogt het parallellisme.
• Betere communicatie: Thread-synchronisatiefuncties verbeteren de communicatie tussen processen.
• Gebruik van multiprocessor-architectuur
• Geminimaliseerd gebruik van systeembronnen

172. Wat zijn de twee manieren waarop Thread kan worden gemaakt?

Multithreading is een Java-functie die gelijktijdige uitvoering van twee of meer delen van een programma mogelijk maakt voor maximaal gebruik van de CPU. Over het algemeen zijn threads kleine, lichtgewicht processen met afzonderlijke uitvoeringspaden. Deze threads maken gebruik van gedeeld geheugen, maar ze werken onafhankelijk, dus als een thread mislukt, heeft dit geen invloed op de andere threads. Er zijn twee manieren om een ​​thread te maken:

• Door de Thread-klasse uit te breiden
• Door een Runnable-interface te implementeren.

Door de Thread-klasse uit te breiden

We maken een klasse die de java.lang.Thread-klasse . Deze klasse overschrijft de methode run() die beschikbaar is in de klasse Thread. Een thread begint zijn leven binnen de run() -methode.

Syntaxis:

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

Door de Runnable-interface te implementeren

We creëren een nieuwe klasse die implementeert java.lang.Uitvoerbaar interface en overschrijf de run() methode. Vervolgens instantiëren we een Thread-object en roepen we de start()-methode op dit object aan.

Syntaxis:

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

173. Wat is een draad?

Threads in Java zijn lichtgewicht subprocessen met de kleinste eenheid van processen en hebben ook afzonderlijke uitvoeringspaden. Deze threads maken gebruik van gedeeld geheugen, maar ze werken onafhankelijk, dus als er een uitzondering is in threads die de werking van andere threads niet beïnvloeden, ondanks dat ze hetzelfde geheugen delen. Een thread heeft zijn eigen programmateller, uitvoeringsstapel en lokale variabelen, maar deelt dezelfde geheugenruimte met andere threads in hetzelfde proces. Java biedt ingebouwde ondersteuning voor multithreading via de Uitvoerbare interface en de Draadklasse .

174. Onderscheid maken tussen proces en draad?

Een proces en een thread zijn beide uitvoeringseenheden in een computersysteem, maar ze verschillen op verschillende manieren:

175. Beschrijf de levenscyclus van de draad?

A draad in Java bestaat op elk moment in een van de volgende toestanden. Een draad bevindt zich op elk moment slechts in een van de weergegeven toestanden:

1. Nieuw: De thread is aangemaakt, maar nog niet gestart.
2. Uitvoerbaar: De thread is actief, voert zijn taak uit, of is klaar om te worden uitgevoerd als er geen andere threads met een hogere prioriteit zijn.
3. Geblokkeerd: De thread is tijdelijk opgeschort, in afwachting van een bron of een gebeurtenis.
4. Aan het wachten: De thread wacht totdat een andere thread een taak uitvoert of totdat een bepaalde tijd is verstreken.
5. Beëindigd: De thread heeft zijn taak voltooid of is beëindigd door een andere thread.

176. Leg de methode suspend() uit onder de klasse Thread.

De methode suspend() van de klasse Thread in Java schort tijdelijk de uitvoering van een thread op. Wanneer een thread wordt opgeschort, raakt deze in een geblokkeerde toestand en wordt deze niet gepland door het besturingssysteem, wat betekent dat deze zijn taak niet kan uitvoeren totdat deze wordt hervat. Er zijn veiliger en flexibelere alternatieven voor de suspend()-methoden in de moderne Java-programmeertaal. Deze methode retourneert geen enkele waarde.

Syntaxis:

  public final void   suspend();>

Voorbeeld:

// 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');  } }>

Uitgang:

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. Leg de hoofdthread uit onder Thread-klasse-uitvoering.

Java biedt ingebouwde ondersteuning voor multithreaded programmeren. De hoofdthread wordt beschouwd als de bovenliggende thread van alle andere threads die worden gemaakt tijdens de uitvoering van het programma. De hoofdthread wordt automatisch aangemaakt wanneer het programma start. Deze thread voert de hoofdmethode van het programma uit. Het is verantwoordelijk voor het uitvoeren van de hoofdlogica van het Java-programma en voor het afhandelen van de gebruikersinvoerbewerkingen. De hoofdthread dient als basisthread waaruit alle andere onderliggende threads voortkomen.

178. Wat is een daemonthread?

Een daemon-thread in Java is een thread met lage prioriteit die wordt gebruikt om achtergrondbewerkingen of taken uit te voeren die continu worden uitgevoerd. zoals Garbage collection, Signal dispatches, Action luisteraars, enz. Daemon-threads in Java hebben een lagere prioriteit dan gebruikersthreads, wat betekent dat ze alleen kunnen worden uitgevoerd als er geen gebruikersthreads actief zijn. Daemon-threads in Java zijn handige functies die nodig zijn voor achtergrondtaken waarvoor geen expliciete afsluiting of voltooiing vereist is. Het maakt een efficiënter gebruik van systeembronnen mogelijk en wordt gebruikt om bronnen te vereenvoudigen en langlopende taken te vereenvoudigen.

179. Op welke manieren kan een thread in de wachtstatus komen?

Thread is een lichtgewicht proces dat gelijktijdig met de andere thread binnen één proces wordt uitgevoerd. Elke thread kan een andere taak uitvoeren en de bronnen binnen één proces delen. Thread in Java kan op veel verschillende manieren in de wachtstatus komen:

• Sleep() methode Aanroep: De slaap () methode wordt gebruikt om de uitvoering van de thread voor een bepaalde tijd te onderbreken. Terwijl de thread is gepauzeerd, gaat deze naar de wachtstatus.
• Wacht() methode: Deze methode wordt gebruikt om een ​​thread te wachten totdat de andere thread aangeeft dat hij wakker moet worden. Thread gaat in de wachtstatus totdat het een melding ontvangt van een andere thread.
• Join()-methode: De methode Join() kan worden gebruikt om te wachten tot de uitvoering van de thread is voltooid. De aanroepende thread gaat in de wachtstatus totdat de doelthread is voltooid.
• Wachten op I/O-bewerkingen: Als de thread wacht tot de invoer-/uitvoerbewerking is voltooid, gaat deze in de wachtstatus totdat de bewerking is voltooid.
• Synchronisatieproblemen: Als er synchronisatieproblemen zijn in een toepassing met meerdere threads, kunnen threads in de wachtstatus terechtkomen totdat de synchronisatieproblemen zijn opgelost.

180. Hoe vindt multi-threading plaats op een computer met één CPU?

Java maakt gebruik van een techniek die time-sharing wordt genoemd, ook wel time-slicing genoemd, om multi-threading te implementeren op computers met één CPU. De schijn van parallelle uitvoering wordt gecreëerd doordat de CPU schakelt tussen actieve threads. Het besturingssysteem is verantwoordelijk voor het opeenvolgend toewijzen van CPU-tijd aan elke thread en het plannen van de threads.

Om te voorkomen dat threads met elkaar interageren en racesituaties of andere problemen veroorzaken, heeft Java een aantal manieren om het gedrag van threads te regelen, inclusief synchronisatie en vergrendeling. Het is haalbaar om multi-threaded programmeurs te maken die correct en effectief werken op een machine met een enkele CPU door de interactie tussen threads te reguleren en ervoor te zorgen dat cruciale codedelen worden gesynchroniseerd. In tegenstelling tot het uitvoeren van hetzelfde programma op een computer met meerdere CPU's of kernen, kan multi-threading op een enkele CPU slechts de schijn van parallelliteit wekken, en kunnen de werkelijke prestatieverbeteringen bescheiden zijn. Het besturingssysteem verdeelt de CPU-tijd die beschikbaar is wanneer er meerdere threads op één CPU draaien, in kleine tijdsegmenten en geeft elke thread een tijdsegment om uit te voeren. Door het snelle schakelen tussen de threads door het besturingssysteem ontstaat de schijn van parallelle uitvoering. Het schakelen tussen threads lijkt onmiddellijk te gebeuren, omdat de tijdsegmenten vaak erg klein zijn, in de orde van milliseconden of microseconden.

Java-interviewvragen voor ervaren

181. Wat zijn de verschillende soorten threadprioriteiten in Java? En wat is de standaardprioriteit van een thread toegewezen door JVM?

Prioriteiten in threads is een concept waarbij elke thread een prioriteit heeft. In lekentaal kan men zeggen dat elk object hier prioriteit heeft, wat wordt weergegeven door getallen variërend van 1 tot 10. Er zijn verschillende soorten thread-eigenschappen in Java die hieronder worden vermeld:

• MIN_PRIORITEIT
• MAX_PRIORITEIT
• NORM_PRIORITY

Standaard wordt aan de thread NORM_PRIORITY toegewezen.

182. Waarom is Garbage Collection nodig op Java?

Voor Java is het verzamelen van afval noodzakelijk om geheugenlekken te voorkomen, waardoor het programma kan crashen en instabiel kan worden. Er is geen manier om garbagecollection in Java te vermijden. In tegenstelling tot C++ helpt Garbage Collection in Java programmeurs zich te concentreren op de ontwikkeling van de applicatie, in plaats van op het beheren van geheugenbronnen en het zorgen maken over geheugenlekken. Java Virtual Machine (JVM) beheert het geheugen automatisch periodiek door een garbage collector uit te voeren die het ongebruikte geheugen in de applicatie vrijmaakt. Garbage collection maakt het Java-geheugen efficiënt omdat objecten zonder verwijzingen uit het heap-geheugen worden verwijderd.

183. Wat is het nadeel van Garbage Collection?

Naast vele voordelen heeft Garbage Collector ook enkele nadelen:

1. Het belangrijkste nadeel van Garbage Collection is dat het pauzes kan veroorzaken in de uitvoering van een applicatie, omdat het geheugen leegmaakt, wat de prestaties van de applicatie vertraagt.
2. Het proces van afvalinzameling is niet-deterministisch, wat het moeilijk maakt om te voorspellen wanneer afvalinzameling plaatsvindt, wat onvoorspelbaar gedrag in applicaties veroorzaakt. Als we bijvoorbeeld een programma schrijven, is het voor programmeurs moeilijk om te beslissen of het probleem wordt veroorzaakt door garbagecollection of door andere factoren in het programma.
3. Het verzamelen van afval kan ook het geheugengebruik verhogen als het programma veel objecten met een korte levensduur maakt en weggooit.

184. Leg het verschil uit tussen een kleine, grote en volledige afvalinzameling.

De Java Virtual Machine (JVM) verwijdert objecten die niet langer in gebruik zijn met behulp van een garbage collector die deze objecten periodiek controleert en verwijdert. Er zijn verschillende soorten garbagecollection in de JVM, elk met verschillende kenmerken en prestatie-implicaties. De belangrijkste vormen van afvalinzameling zijn:

• Kleine afvalinzameling: Dit type garbage collection, ook bekend als garbage collection van de jonge generatie, wordt gebruikt voor het verzamelen en terugwinnen van geheugen dat wordt gebruikt door objecten met een korte levensduur (objecten die snel worden gemaakt en weggegooid).
• Grote afvalinzameling: Dit type garbagecollection, ook bekend als garbage collection van de oude generatie, wordt gebruikt voor het verzamelen en terugwinnen van geheugen dat wordt gebruikt door objecten met een lange levensduur (objecten die meerdere kleine garbagecollections overleven en worden gepromoveerd naar de oude generatie).
• Volledige afvalinzameling: Tijdens de volledige afvalinzameling worden herinneringen van alle generaties verzameld en teruggewonnen, inclusief herinneringen van jong en oud. Het duurt normaal gesproken langer om een ​​volledige afvalinzameling te voltooien dan een kleine of grote afvalinzameling, waardoor de app tijdelijk wordt onderbroken.

185. Hoe identificeert u grote en kleine afvalinzamelingen op Java?

De grote afvalinzameling werkt op de overlevenderuimte en de kleine afvalinzameling werkt op de Eden-ruimte om een ​​markeer-en-veegroutine uit te voeren. En we kunnen ze allebei identificeren op basis van de uitvoer waarbij de kleine collectie GC afdrukt, terwijl de hoofdcollectie de volledige GC afdrukt voor het geval waarin het loggen van de garbage collection is ingeschakeld met -XX:PrintGCDetails of verbose:gc.

186. Wat is een geheugenlek en welke invloed heeft dit op de afvalinzameling?

In Java kunnen geheugenlekken worden veroorzaakt door verschillende factoren, zoals het niet correct afsluiten van bronnen, het langer vasthouden van objectreferenties dan nodig is, of het onnodig maken van te veel objecten. Er zijn situaties waarin de garbage collector geen objecten verzamelt omdat er een verwijzing naar die objecten is. In deze situaties waarin de applicatie veel objecten maakt en deze niet gebruikt en elk object een aantal geldige referenties heeft, kan een Garbage collector in Java de objecten niet vernietigen. Deze nutteloze objecten die geen enkele waarde aan het programma toevoegen, staan ​​bekend als geheugenlekken. Geheugenlekken kunnen een negatieve invloed hebben op de garbagecollection, omdat ze voorkomen dat de garbage collector ongebruikt geheugen terugwint. Dit gedrag zal leiden tot trage prestaties of soms tot systeemfouten. In een programma is het belangrijk om geheugenlekken te voorkomen door bronnen en objectreferenties op de juiste manier te beheren.

Voorbeeld:

// 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');  } }>

Uitgang:

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. Noem enkele klassen die aanwezig zijn in het pakket java.util.regex.

Reguliere expressies of Regex in Java is een API die wordt gebruikt voor het zoeken en manipuleren van tekenreeksen in Java. Het creëert String-patronen die de benodigde gegevens uit de strings kunnen extraheren of een patroon kunnen generaliseren.

Er zijn 3 klassen aanwezig in java.util.regex die hieronder worden vermeld:

• Patroonklasse: Kan patronen definiëren
• Matcher Class: Kan matchbewerkingen uitvoeren op tekst met behulp van patronen
• PatternSyntaxException-klasse: kan een syntaxisfout in een reguliere-expressiepatroon aangeven.

Naast het 3-klassenpakket bestaat het pakket uit een enkele interface MatchResult Interface die kan worden gebruikt voor het weergeven van het resultaat van een matchoperatie.

188. Schrijf een reguliere expressie om een ​​wachtwoord te valideren. Een wachtwoord moet beginnen met een alfabet en gevolgd worden door alfanumerieke tekens; De lengte moet tussen 8 en 20 liggen.

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

Uitleg:

• ^ gebruikt voor het startteken van de string.
• (?=.*[0-9]) dat voor een cijfer wordt gebruikt, moet minstens één keer voorkomen.
• (?=.*[a-z]) gebruikt voor een alfabet in kleine letters moet minstens één keer voorkomen.
• (?=.*[A-Z]) gebruikt voor een hoofdletteralfabet dat minstens één keer in de subtekenreeks moet voorkomen.
• (?=.*[@#$%^&-+=()] gebruikt voor een speciaal teken dat minstens één keer moet voorkomen.
• (?=S+$) spaties zijn niet toegestaan ​​in de gehele tekenreeks.
• .{8, 20} gebruikt voor minimaal 8 tekens en maximaal 20 tekens.
• $ gebruikt voor het einde van de string.

189. Wat is JDBC?

JDBC standaard API wordt gebruikt om Java-applicaties en relationele databases te koppelen. Het biedt een verzameling klassen en interfaces waarmee programmeurs de programmeertaal Java kunnen gebruiken om met de database te communiceren. Dankzij de klassen en interface van JDBC kan de applicatie verzoeken van gebruikers naar de opgegeven database sturen. Er zijn over het algemeen vier componenten van JDBC waarmee het samenwerkt met de database:

• JDBC-API
• JDBC-stuurprogrammabeheer
• JDBC-testsuite
• JDBC-ODBC Bridge-stuurprogramma's

190. Wat is JDBC-stuurprogramma?

JDBC-stuurprogramma is een softwarecomponent die wordt gebruikt om een ​​Java-applicatie in staat te stellen met de database te communiceren. JDBC verzorgt de implementatie van de JDBC API voor een specifiek databasemanagementsysteem, waarmee het de database kan verbinden, SQL-statements kan uitvoeren en data kan ophalen. Er zijn vier typen JDBC-stuurprogramma's:

• JDBC-ODBC Bridge-stuurprogramma
• Native-API-stuurprogramma
• Netwerkprotocol-stuurprogramma
• Dunne bestuurder

191. Wat zijn de stappen om verbinding te maken met de database in Java?

Er zijn bepaalde stappen om de database en het Java-programma te verbinden, zoals hieronder vermeld:

• Importeer de pakketten
• Laad de stuurprogramma's met behulp van de forName() -methode
• Registreer de chauffeurs met DriverManager
• Breng een verbinding tot stand met behulp van het klasseobject Connection
• Maak een verklaring
• Voer de query uit
• Sluit de verbindingen

192. Wat zijn de JDBC API-componenten?

JDBC API-componenten bieden verschillende methoden en interfaces voor eenvoudige communicatie met de databases. Het biedt ook pakketten zoals Java Se en Java EE, die de mogelijkheid bieden om 'write once run anywhere' (WORA) te gebruiken.

Syntaxis:

java.sql.*;>

193. Wat is de JDBC-verbindingsinterface?

Java Database Connectivity Interface (JDBC) is een softwarecomponent waarmee Java-applicaties kunnen communiceren met databases. Om de verbinding te verbeteren heeft JDBC stuurprogramma's nodig voor elke database.

194. Wat doet de JDBC ResultSet-interface?

De JDBC ResultSet-interface wordt gebruikt om de gegevens uit de database op te slaan en te gebruiken in ons Java-programma. We kunnen ResultSet ook gebruiken om de gegevens bij te werken met behulp van updateXXX() -methoden. Het ResultSet-object wijst de cursor vóór de eerste rij met resultaatgegevens. Met behulp van de next() methode kunnen we de ResultSet doorlopen.

195. Wat is de JDBC-rijset?

Een JDBC RowSet biedt een manier om de gegevens in tabelvorm op te slaan. RowSet is een interface in Java die kan worden gebruikt binnen het java.sql-pakket. De verbinding tussen het RowSet-object en de gegevensbron blijft gedurende de gehele levenscyclus behouden. RowSets worden ingedeeld in vijf categorieën op basis van de hieronder genoemde implementatie:

1. JdbcRijSet
2. In cache opgeslagen rijset
3. WebRijSet
4. GefilterdeRijSet
5. Sluit je aan bij RowSet

196. Wat is de rol van de klasse JDBC DriverManager?

De klasse JDBC DriverManager fungeert als interface voor gebruikers en stuurprogramma's. Het wordt op veel manieren gebruikt, zoals hieronder vermeld:

• Het wordt gebruikt om een ​​verbinding tot stand te brengen tussen een Java-applicatie en de database.
• Helpt bij het bijhouden van de beschikbare stuurprogramma's.
• Het kan helpen om een ​​verbinding tot stand te brengen tussen een database en de juiste stuurprogramma's.
• Het bevat alle methoden waarmee de databasestuurprogrammaklassen kunnen worden geregistreerd en gederegistreerd.
• De methode DriverManager.registerDriver() kan de lijst bijhouden van Driver-klassen die zichzelf hebben geregistreerd.

Interviewvragen over Java-verschillen

197. Maak onderscheid tussen itereerbaar en iterator.

198. Maak onderscheid tussen lijst en set.

199. Maak onderscheid tussen lijst en kaart.

200. Maak onderscheid tussen wachtrij en stapel.

201. Maak onderscheid tussen PriorityQueue en TreeSet.

202. Maak onderscheid tussen de enkelvoudig gekoppelde lijst en de dubbel gekoppelde lijst.

203. Maak onderscheid tussen failfast en failsafe.

204. Maak onderscheid tussen HashMap en TreeMap.

205. Maak onderscheid tussen wachtrij en deque.

206. Maak onderscheid tussen HashSet en TreeSet.

Java-interviewvragen – Veelgestelde vragen

Q1. Wat is het salaris van een Java-ontwikkelaar in India?

Volgens verschillende bronnen is het gemiddelde salaris van een Java Backend Developer meer dan 14 lakhs per jaar, wat 30% hoger is dan welke andere ontwikkelaarsrol dan ook . Hier kunt u ook onze nieuwste cursus bekijken GeekforGeeks oefenportaal kan ook nuttig zijn.

Vraag 5. Hoe kan ik opvallen in een Java-interview?

Om op te vallen in een Java-interview, moet u blijk geven van een diep begrip van Java-concepten en praktische toepassingen. Laat uw probleemoplossende vaardigheden zien door uw aanpak van complexe scenario's uit te leggen en efficiënte oplossingen te bieden. Markeer bovendien alle relevante projecten of bijdragen die u aan de Java-gemeenschap heeft geleverd. Ook enthousiasme, goede communicatie en leergierigheid kunnen een positieve indruk achterlaten.