Vragen en antwoorden over Java SE 8 (Deel 2)

Handleidingen
Java

In mijn vorige bericht heb ik enkele belangrijke Java SE 8 Interviewvragen en antwoorden besproken. In dit bericht gaan we enkele andere Java SE 8 Interviewvragen en antwoorden bespreken. Voordat je dit bericht leest, ga alsjeblieft door mijn vorige bericht op: “Java SE 8 Interviewvragen (Deel 1)“.

Java SE 8 Interviewvragen

  1. Wat is Interne Iteratie in Java SE 8?
  2. Verschillen tussen Externe Iteratie en Interne Iteratie?
  3. Wat zijn de belangrijkste nadelen van Externe Iteratie?
  4. Wat zijn de belangrijkste voordelen van Interne Iteratie ten opzichte van Externe Iteratie?
  5. Wat is het belangrijkste nadeel van Interne Iteratie ten opzichte van Externe Iteratie?
  6. Wat is het belangrijkste voordeel van Externe Iteratie ten opzichte van Interne Iteratie?
  7. Wanneer moeten we Interne Iteratie gebruiken? Wanneer moeten we Externe Iteratie gebruiken?
  8. Verschillen tussen Intermediaire Bewerkingen en Terminale Bewerkingen van Java 8’s Stream API?
  9. Is het mogelijk om methodimplementaties te leveren in Java Interfaces? Zo ja, hoe doen we dat?
  10. Wat is een Standaardmethode? Waarom hebben we Standaardmethoden nodig in Java 8 Interfaces?
  11. Wat is een Statische Methode? Waarom hebben we Statische methoden nodig in Java 8 Interfaces?
  12. differences tussen Functioneel Programmeren en Objectgeoriënteerd Programmeren?
  13. Leg de problemen uit van de oude Java Date API. Wat zijn de voordelen van de Java 8 Date and Time API ten opzichte van de oude Date API en Joda Time API?
  14. Waarom hebben we een nieuwe Date and Time API nodig in Java SE 8? Leg uit hoe de Java SE 8 Date and Time API de problemen van de oude Java Date API oplost.
  15. Wat zijn de verschillen tussen de oude Java Date API en de Java 8 Date and Time API?
  16. Wat is Meervoudige Erfenis? Hoe ondersteunt Java 8 Meervoudige Erfenis?
  17. Wat is het Diamantprobleem in interfaces als gevolg van standaardmethoden? Hoe lost Java 8 dit probleem op?

Java SE 8 Interviewvragen en Antwoorden

Wat is Interne Iteratie in Java SE 8?

Vóór Java 8 hadden we geen concept van Interne Iteratie. Java 8 heeft een nieuwe functie geïntroduceerd die bekend staat als “Interne Iteratie”. Vóór Java 8 had de Java-taal alleen Externe Iteratie om elementen van een geaggregeerd object zoals collecties, arrays, enzovoort te doorlopen. Interne Iteratie betekent “Het itereren van de elementen van een geaggregeerd object één voor één intern door de Java API”. In plaats van dat de Java-toepassing extern itereert, vragen we de Java API om deze taak intern uit te voeren.

Verschillen tussen Externe Iteratie en Interne Iteratie?

S.No. External Iteration Internal Iteration
1. Available before Java 8 too. It is introduced in Java SE 8
2. Iterating an Aggregated Object elements externally. Iterating an Aggregated Object elements internally (background).
3. Iterate elements by using for-each loop and Iterators like Enumeration, Iterator, ListIterator. Iterate elements by using Java API like “forEach” method.
4. Iterating elements in Sequential and In-Order only. Not required to iterate elements in Sequential order.
5. It follows OOP approach that is Imperative Style. It follows Functional Programming approach that is Declarative Style.
6. It does NOT separate responsibilities properly that is, it defines both “What is to be done” and “How it is to be done”. It defines only “What is to be done”. No need to worry about “How it is to be done”. Java API takes care about “How to do”.
7. Less Readable Code. More Readable code.

Wat zijn de belangrijkste nadelen van Externe Iteratie?

Externe Iteratie heeft de volgende nadelen:

  • We moeten code schrijven in een imperatieve stijl.
  • Er is geen duidelijke scheiding van verantwoordelijkheden. Sterke koppeling tussen de code voor “Wat moet er worden gedaan” en “Hoe het moet worden gedaan”.
  • Minder leesbare code.
  • Meer uitgebreide en overbodige code.
  • We moeten elementen in sequentiële volgorde doorlopen.
  • Het ondersteunt Concurrency en Parallelisme niet goed.

Wat zijn de belangrijkste voordelen van Interne Iteratie ten opzichte van Externe Iteratie?

Vergeleken met Externe Iteratie heeft Interne Iteratie de volgende voordelen:

  • Omdat het de Functionele Programmeerstijl volgt, kunnen we Declaratieve Code schrijven.
  • Meer leesbare en beknopte code.
  • Vermijdt het schrijven van omslachtige en overbodige code.
  • Geen noodzaak om elementen in opeenvolgende volgorde te doorlopen.
  • Het ondersteunt Concurrency en Parallelisme op de juiste manier.
  • We kunnen parallelle code schrijven om de prestaties van de toepassing te verbeteren.
  • Duidelijke scheiding van verantwoordelijkheden. Losse koppeling tussen code van “Wat moet er gedaan worden” en “Hoe het gedaan moet worden”.
  • We hoeven alleen code te schrijven over “Wat er gedaan moet worden” en de Java API zorgt voor de code van “Hoe het gedaan moet worden”.

Wat is het belangrijkste nadeel van Interne Iteratie ten opzichte van Externe Iteratie?

Vergeleken met Externe Iteratie heeft Interne Iteratie één groot nadeel:

  • In Interne Iteratie, aangezien de Java API zorgt voor het intern doorlopen van elementen, hebben we GEEN controle over Iteratie.

Wat is het belangrijkste voordeel van Externe Iteratie ten opzichte van Interne Iteratie?

Vergeleken met Interne Iteratie heeft Externe Iteratie één belangrijk voordeel:

  • Bij Externe Iteratie hebben we veel controle over Iteratie, omdat de Java API NIET zorgt voor het doorlopen van elementen.

Wanneer moeten we Interne Iteratie gebruiken? Wanneer moeten we Externe Iteratie gebruiken?

We moeten begrijpen in welke situaties we Interne Iteratie of Externe Iteratie moeten gebruiken.

  • Als we meer controle nodig hebben over Iteratie, kunnen we Externe Iteratie gebruiken.
  • Als we GEEN extra controle nodig hebben over Iteratie, kunnen we Interne Iteratie gebruiken.
  • Als we zeer gelijktijdige en parallelle toepassingen moeten ontwikkelen en we , moeten we Interne Iteratie gebruiken.

Verschillen tussen Intermediate Operations en Terminal Operations van de Java 8 Stream API?

S.No. Stream Intermediate Operations Stream Terminal Operations
1. Stream Intermediate operations are not evaluated until we chain it with Stream Terminal Operation. Stream Terminal Operations are evaluated on it’s own. No need other operations help.
2. The output of Intermediate Operations is another Stream. The output of Intermediate Operations is Not a Stream. Something else other than a Stream.
3. Intermediate Operations are evaluated Lazily. Terminal Operations are evaluated Eagerly.
4. We can chain any number of Stream Intermediate Operations. We can NOT chain Stream Terminal Operations.
5. We can use any number of Stream Intermediate Operations per Statement. We can use only one Stream Terminal Operation per Statement.

Is het mogelijk om methoden te implementeren in Java Interfaces? Zo ja, hoe doen we dat?

In Java 7 of eerder was het niet mogelijk om methoden te implementeren in Interfaces. Vanaf Java 8 is dit wel mogelijk. In Java SE 8 kunnen we methoden implementeren in Interfaces door gebruik te maken van de volgende twee nieuwe concepten:

  • Default-methoden
  • Statische methoden

Wat is een Default-methode? Waarom hebben we Default-methoden nodig in Java 8 Interfaces?

A Default Method is a method which is implemented in an interface with “default” keyword. It’s new featured introduced in Java SE 8. We need Default Methods because of the following reasons:

  • Het stelt ons in staat om de implementatie van methoden in Interfaces te voorzien.
  • Om nieuwe functionaliteit aan een Interface toe te voegen zonder de Klassen te breken die die Interface implementeren.
  • Om een elegante functionaliteit voor Achterwaartse Compatibiliteit te bieden.
  • Om het gemak van het uitbreiden van de bestaande functionaliteit te vergemakkelijken.
  • Om het gemak van het onderhouden van de bestaande functionaliteit te vergemakkelijken.

Wat is een Statische Methode? Waarom hebben we Statische methoden nodig in Java 8 Interfaces?

A Static Method is an Utility method or Helper method, which is associated to a class (or interface). It is not associated to any object. We need Static Methods because of the following reasons:

  • We kunnen Hulp- of Hulpprogramma-methoden die specifiek zijn voor een interface in dezelfde interface houden in plaats van in een aparte Hulpprogramma-klasse.
  • We hebben geen aparte Hulpprogramma-klassen nodig zoals Collections, Arrays, etc., om Hulpprogramma-methoden te behouden.
  • Duidelijke scheiding van Verantwoordelijkheden. Dat wil zeggen dat we niet één Hulpprogramma-klasse nodig hebben om alle Hulpprogramma-methoden van Collection API zoals Collections, etc., te behouden.
  • Gemakkelijk uit te breiden van de API.
  • Gemakkelijk te onderhouden van de API.

Verschillen tussen Functioneel Programmeren en Objectgeoriënteerd Programmeren?

Functional Programming OOP
Does not exist State Exists State
Uses Immutable data Uses Mutable data
It follows Declarative Programming Model It follows Imperative Programming Model
Stateless Programming Model Stateful Programming Model
Main Fcous on: “What you are doing” Main focus on “How you are doing”
Good for Parallel (Concurrency) Programming Poor for Parallel (Concurrency) Programming
Good for BigData processing and analysis NOT Good for BigData processing and analysis
Supports pure Encapsulation It breaks Encapsulation concept
Functions with No-Side Effects Methods with Side Effects
Functions are first-class citizens Objects are first-class citizens
Primary Manipulation Unit is “Function” Primary Manipulation Unit is Objects(Instances of Classes)
Flow Controls: Function calls, Function Calls with Recursion Flow Controls: Loops, Conditional Statements
It uses “Recursion” concept to iterate Collection Data. It uses “Loop” concept to iterate Collection Data. For example:-For-each loop in Java
Order of execution is less importance. Order of execution is must and very important.
Supports both “Abstraction over Data” and “Abstraction over Behavior”. Supports only “Abstraction over Data”.
We use FP when we have few Things with more operations. We use OOP when we have few Operations with more Things. For example: Things are classes and Operations are Methods in Java.

Let op: Voor meer informatie over FP, IP en OOP-vergelijkingen, ga naar mijn vorige bericht op: “Vergelijk FP, OOP (IP)“

Leg de problemen van de oude Java Date API uit. Wat zijn de voordelen van de Date en Time API van Java 8 ten opzichte van de oude Date API en Joda Time API?

De OUDE Java Date API van Java verwijst naar de Date API die beschikbaar was vóór Java SE 8, dat wil zeggen Date, Calendar, SimpleDateFormat enzovoort. De oude Date API van Java heeft de volgende problemen of nadelen in vergelijking met de Date en Time API van Java 8 en de Joda Time API.

  • De meeste API’s zijn verouderd.
  • Minder leesbaarheid.
  • java.util.Date is aanpasbaar en niet thread-safe.
  • java.text.SimpleDateFormat is niet thread-safe.
  • Minder prestaties.

De Date en Time API van Java SE 8 heeft de volgende voordelen ten opzichte van de OUDE Date API van Java.

  • Zeer eenvoudig te gebruiken.
  • Leesbare syntaxis die menselijker is en meer leesbaarheid biedt.
  • Alle API’s zijn thread-safe.
  • Betere prestaties.

Waarom hebben we een nieuwe Date and Time API nodig in Java SE 8? Leg uit hoe de Java SE 8 Date and Time API de problemen van de oude Java Date API oplost.

We hebben de Date and Time API van Java 8 nodig om zeer prestatiegerichte, thread-safe en zeer schaalbare Java-applicaties te ontwikkelen. De Date and Time API van Java 8 lost alle problemen van de oude Java Date API op door de principes van onveranderlijkheid en thread-safe te volgen.

Wat zijn de verschillen tussen de oude Java Date API en de Date and Time API van Java 8?

Verschillen tussen de oude Java Date API en de Date and Time API van Java 8:

S.No. Java’s OLD Java Date API Java 8’s Date and Time API
1. Available before Java 8 too. It is introduced in Java SE 8
2. Not Thread Safe. Thread Safe.
3. Mutable API. Immutable API.
4. Less Performance. Better Performance.
5. Less Readability. More Readability.
6. It’s not recommended to use as its deprecated. It’s always recommended to use.
7. Not Extendable. Easy to Extend.
8. It defines months values from 0 to 11, that is January = 0. It defines months values from 1 to 12, that is January = 1.
9. It’s an old API. It’s a new API.

Wat is Meervoudige Erfenis? Hoe ondersteunt Java 8 Meervoudige Erfenis?

Meervoudige Erfenis betekent dat een klasse kenmerken en functies kan erven of uitbreiden van meer dan één ouderklasse. In Java 7 of eerder is Meervoudige Erfenis niet mogelijk omdat Java de regel volgt dat “een klasse slechts één enkele klasse of abstracte klasse moet uitbreiden”. Het is echter mogelijk om Meervoudige Implementatie-Erfenis te bieden met behulp van Interface omdat Java de regel volgt dat “een klasse een willekeurig aantal interfaces kan uitbreiden”. Echter, Java 8 ondersteunt “Implementeren van Methoden in Interfaces” door nieuwe functies te introduceren: Standaardmethoden in Interface. Vanwege deze functie ondersteunt Java 8 Meervoudige Erfenis met enkele beperkingen.

Wat is het Diamantprobleem in interfaces als gevolg van standaardmethoden? Hoe lost Java 8 dit probleem op?

Java 8 standaardmethoden kunnen een diamantprobleem introduceren wanneer een klasse meerdere interfaces implementeert. Het treedt op wanneer een klasse meer dan één interfaces uitbreidt met dezelfde methodenimplementaties (standaardmethode). Voorbeeld Java SE 8-code om het Diamantprobleem met interface standaardmethoden te laten zien.

interface A {
	default void display() {
		System.out.println("A");
	}
}

interface B extends A {
	default void display() {
		System.out.println("B");
	}
}

interface C extends A {
	default void display() {
		System.out.println("C");
	}
}

class D implements B, C {
}

In het bovenstaande codefragment geeft klasse D een compileerfout als “Duplicate default methods named display with the parameters () and () are inherited from the types C and B”. Dit komt doordat de Java-compiler in de war raakt over welke display() te gebruiken in klasse D. Klasse D erft de display() methode van zowel de interfaces B als C. Om dit probleem op te lossen, heeft Java 8 de volgende oplossing gegeven.

class D implements B, C {

	@Override
	public void display() {
		B.super.display();
	}
	
}

Dit B.super.display(); zal dit Diamantprobleem oplossen. Als je de standaardmethode van interface C wilt gebruiken, gebruik dan C.super.display();. Dat is alles over Java 8 Interviewvragen. We zullen wat meer Java SE 8 Interviewvragen bespreken in mijn komende berichten. Laat me alsjeblieft een reactie achter als je mijn bericht leuk vindt of als je problemen/suggesties hebt.

Source:
https://www.digitalocean.com/community/tutorials/javase8-interview-questions-part2