logo

TechCodeview

Abstractie op Java

Abstractie op Java is het proces waarbij we alleen essentiële details/functionaliteit aan de gebruiker tonen. De niet-essentiële implementatiedetails worden niet aan de gebruiker getoond.

In dit artikel zullen we leren over abstractie en wat abstract betekent.



Eenvoudig voorbeeld om abstractie te begrijpen:

Afstandsbediening voor televisie is een uitstekend voorbeeld van abstractie . Het vereenvoudigt de interactie met een tv door de complexiteit achter eenvoudige knoppen en symbolen te verbergen, waardoor het gemakkelijk wordt zonder dat u de technische details van de werking van de tv hoeft te begrijpen.

Wat is abstractie op Java?

In Java wordt abstractie bereikt door interfaces En abstracte klassen . Met behulp van interfaces kunnen we 100% abstractie bereiken.

Dataabstractie kan ook worden gedefinieerd als het proces waarbij alleen de vereiste kenmerken van een object worden geïdentificeerd, waarbij de irrelevante details worden genegeerd. De eigenschappen en het gedrag van een object onderscheiden het van andere objecten van een vergelijkbaar type en helpen ook bij het classificeren/groeperen van de objecten.



Abstractievoorbeeld uit de praktijk:

Beschouw eens een voorbeeld uit de praktijk van een man die een auto bestuurt. De man weet alleen dat het indrukken van het gaspedaal de snelheid van een auto zal verhogen en dat het remmen de auto tot stilstand zal brengen, maar hij weet niet hoe de snelheid daadwerkelijk toeneemt als hij het gaspedaal indrukt. Hij kent het innerlijke mechanisme van de auto niet. of de implementatie van het gaspedaal, de remmen etc. in de auto. Dit is wat abstractie is.

Java Abstract-klassen en Java Abstract-methoden

  1. Een abstracte klasse is een klasse die wordt gedeclareerd met een abstract trefwoord.
  2. Een abstracte methode is een methode die zonder implementatie wordt gedeclareerd.
  3. Een abstracte klasse kan al dan niet over alle abstracte methoden beschikken. Sommigen daarvan kunnen concrete methoden zijn
  4. Een door een methode gedefinieerde samenvatting moet altijd opnieuw worden gedefinieerd in de subklasse, waardoor overheersend verplicht of maak de subklasse zelf abstract.
  5. Elke klasse die een of meer abstracte methoden bevat, moet ook worden gedeclareerd met een abstract trefwoord.
  6. Er kan geen object van een abstracte klasse bestaan. Dat wil zeggen dat een abstracte klasse niet rechtstreeks kan worden geïnstantieerd met de nieuwe exploitant .
  7. Een abstracte klasse kan geparametriseerde constructors hebben en de standaardconstructor is altijd aanwezig in een abstracte klasse.

Algoritme om abstractie in Java te implementeren

  1. Bepaal de klassen of interfaces die deel zullen uitmaken van de abstractie.
  2. Maak een abstracte klasse of interface die het gemeenschappelijke gedrag en de eigenschappen van deze klassen definieert.
  3. Definieer abstracte methoden binnen de abstracte klasse of interface die geen implementatiedetails hebben.
  4. Implementeer concrete klassen die de abstracte klasse uitbreiden of implementeer de interface.
  5. Overschrijf de abstracte methoden in de concrete klassen om hun specifieke implementaties te bieden.
  6. Gebruik de concrete klassen om de programmalogica te implementeren.

Wanneer abstracte klassen en abstracte methoden gebruiken?

Er zijn situaties waarin we een superklasse willen definiëren die de structuur van een bepaalde abstractie declareert zonder een volledige implementatie van elke methode te bieden. Soms willen we een superklasse maken die alleen een generalisatievorm definieert die door alle subklassen wordt gedeeld, waarbij het aan elke subklasse wordt overgelaten om de details in te vullen.

Beschouw een voorbeeld van een klassieke vorm, misschien gebruikt in een computerondersteund ontwerpsysteem of spelsimulatie. Het basistype is vorm en elke vorm heeft een kleur, grootte, enzovoort. Hieruit worden specifieke soorten vormen afgeleid (overerfd) – cirkel, vierkant, driehoek, enzovoort – die elk aanvullende kenmerken en gedragingen kunnen hebben. Bepaalde vormen kunnen bijvoorbeeld worden omgedraaid. Sommige gedragingen kunnen afwijken, bijvoorbeeld wanneer u de oppervlakte van een vorm wilt berekenen. De typehiërarchie belichaamt zowel de overeenkomsten als de verschillen tussen de vormen.



Abstracte klasse in Java

Voorbeeld van Java-abstractie

Voorbeeld 1:

Java


weergaven en tabellen



// Java program to illustrate the> // concept of Abstraction> abstract> class> Shape {> >String color;> > >// these are abstract methods> >abstract> double> area();> >public> abstract> String toString();> > >// abstract class can have the constructor> >public> Shape(String color)> >{> >System.out.println(>'Shape constructor called'>);> >this>.color = color;> >}> > >// this is a concrete method> >public> String getColor() {>return> color; }> }> class> Circle>extends> Shape {> >double> radius;> > >public> Circle(String color,>double> radius)> >{> > >// calling Shape constructor> >super>(color);> >System.out.println(>'Circle constructor called'>);> >this>.radius = radius;> >}> > >@Override> double> area()> >{> >return> Math.PI * Math.pow(radius,>2>);> >}> > >@Override> public> String toString()> >{> >return> 'Circle color is '> +>super>.getColor()> >+>'and area is : '> + area();> >}> }> class> Rectangle>extends> Shape {> > >double> length;> >double> width;> > >public> Rectangle(String color,>double> length,> >double> width)> >{> >// calling Shape constructor> >super>(color);> >System.out.println(>'Rectangle constructor called'>);> >this>.length = length;> >this>.width = width;> >}> > >@Override> double> area() {>return> length * width; }> > >@Override> public> String toString()> >{> >return> 'Rectangle color is '> +>super>.getColor()> >+>'and area is : '> + area();> >}> }> public> class> Test {> >public> static> void> main(String[] args)> >{> >Shape s1 =>new> Circle(>'Red'>,>2.2>);> >Shape s2 =>new> Rectangle(>'Yellow'>,>2>,>4>);> > >System.out.println(s1.toString());> >System.out.println(s2.toString());> >}> }> 

>

bellen sorteren in algoritme 
>

Uitvoer 

Shape constructor called Circle constructor called Shape constructor called Rectangle constructor called Circle color is Redand area is : 15.205308443374602 Rectangle color is Yellowand area is : 8.0>

Voorbeeld 2:

Java




// Java Program to implement> // Java Abstraction> > // Abstract Class declared> abstract> class> Animal {> >private> String name;> > >public> Animal(String name) {>this>.name = name; }> > >public> abstract> void> makeSound();> > >public> String getName() {>return> name; }> }> > // Abstracted class> class> Dog>extends> Animal {> >public> Dog(String name) {>super>(name); }> > >public> void> makeSound()> >{> >System.out.println(getName() +>' barks'>);> >}> }> > // Abstracted class> class> Cat>extends> Animal {> >public> Cat(String name) {>super>(name); }> > >public> void> makeSound()> >{> >System.out.println(getName() +>' meows'>);> >}> }> > // Driver Class> public> class> AbstractionExample {> >// Main Function> >public> static> void> main(String[] args)> >{> >Animal myDog =>new> Dog(>'Buddy'>);> >Animal myCat =>new> Cat(>'Fluffy'>);> > >myDog.makeSound();> >myCat.makeSound();> >}> }> 

>

>

Uitvoer 

Buddy barks Fluffy meows>

Uitleg van het bovenstaande Java-programma:

Deze code definieert een Animal abstracte klasse met een abstracte methode makeSound(). De klassen Dog en Cat breiden Animal uit en implementeren de methode makeSound(). De methode main() maakt instanties van Dog en Cat en roept daarop de methode makeSound() aan.

Dit demonstreert het abstractieconcept in Java, waarbij we een sjabloon voor een klasse definiëren (in dit geval Animal), maar de implementatie van bepaalde methoden laten definiëren door subklassen (in dit geval makeSound()).

Koppel

Interfaces zijn een andere methode om abstractie in Java te implementeren. Het belangrijkste verschil is dat we, door interfaces te gebruiken, 100% abstractie in Java-klassen kunnen bereiken. In Java of een andere taal bevatten interfaces zowel methoden als variabelen, maar missen ze een methodebody. Naast abstractie kunnen interfaces ook worden gebruikt om interfaces in Java te implementeren.

Implementatie: Voor het implementeren van een koppel wij gebruiken het trefwoord implementeert met klasse.

Java


int naar char



ffilms
// Define an interface named Shape> interface> Shape {> >double> calculateArea();>// Abstract method for> >// calculating the area> }> > // Implement the interface in a class named Circle> class> Circle>implements> Shape {> >private> double> radius;> > >// Constructor for Circle> >public> Circle(>double> radius) {>this>.radius = radius; }> > >// Implementing the abstract method from the Shape> >// interface> >public> double> calculateArea()> >{> >return> Math.PI * radius * radius;> >}> }> > // Implement the interface in a class named Rectangle> class> Rectangle>implements> Shape {> >private> double> length;> >private> double> width;> > >// Constructor for Rectangle> >public> Rectangle(>double> length,>double> width)> >{> >this>.length = length;> >this>.width = width;> >}> > >// Implementing the abstract method from the Shape> >// interface> >public> double> calculateArea() {>return> length * width; }> }> > // Main class to test the program> public> class> Main {> >public> static> void> main(String[] args)> >{> >// Creating instances of Circle and Rectangle> >Circle myCircle =>new> Circle(>5.0>);> >Rectangle myRectangle =>new> Rectangle(>4.0>,>6.0>);> > >// Calculating and printing the areas> >System.out.println(>'Area of Circle: '> >+ myCircle.calculateArea());> >System.out.println(>'Area of Rectangle: '> >+ myRectangle.calculateArea());> >}> }> 

>

>

Uitvoer 

Area of Circle: 78.53981633974483 Area of Rectangle: 24.0>

Voordelen van abstractie

Hier zijn enkele voordelen van abstractie:

  1. Het vermindert de complexiteit van het bekijken van dingen.
  2. Voorkomt duplicatie van code en vergroot de herbruikbaarheid.
  3. Helpt de veiligheid van een applicatie of programma te vergroten, omdat alleen essentiële details aan de gebruiker worden verstrekt.
  4. Het verbetert de onderhoudbaarheid van de applicatie.
  5. Het verbetert de modulariteit van de applicatie.
  6. De verbetering zal zeer eenvoudig worden omdat we, zonder de eindgebruikers te beïnvloeden, elk type verandering in ons interne systeem kunnen doorvoeren.
  7. Verbetert de herbruikbaarheid en onderhoudbaarheid van code.
  8. Verbergt implementatiedetails en geeft alleen relevante informatie weer.
  9. Biedt een duidelijke en eenvoudige interface voor de gebruiker.
  10. Verhoogt de veiligheid door toegang tot interne lesgegevens te voorkomen.
  11. Ondersteunt modulariteit, omdat complexe systemen kunnen worden opgedeeld in kleinere en beter beheersbare delen.
  12. Abstractie biedt een manier om de complexiteit van implementatiedetails voor de gebruiker te verbergen, waardoor het gemakkelijker te begrijpen en te gebruiken is.
  13. Abstractie zorgt voor flexibiliteit bij de implementatie van een programma, omdat wijzigingen in de onderliggende implementatiedetails kunnen worden aangebracht zonder de gebruikersinterface te beïnvloeden.
  14. Abstractie maakt modulariteit en scheiding van aandachtspunten mogelijk, waardoor code beter onderhoudbaar en gemakkelijker te debuggen wordt.

Nadelen van abstractie op Java

Hier zijn de belangrijkste nadelen van abstractie in Java:

  1. Abstractie kan het moeilijker maken om te begrijpen hoe het systeem werkt.
  2. Het kan tot een grotere complexiteit leiden, vooral als het niet op de juiste manier wordt gebruikt.
  3. Dit kan de flexibiliteit van de implementatie beperken.
  4. Abstractie kan onnodige complexiteit toevoegen aan code als deze niet op de juiste manier wordt gebruikt, wat leidt tot meer ontwikkelingstijd en -inspanningen.
  5. Abstractie kan het moeilijker maken om code te debuggen en te begrijpen, vooral voor degenen die niet bekend zijn met de abstractielagen en implementatiedetails.
  6. Overmatig gebruik van abstractie kan resulteren in verminderde prestaties als gevolg van de extra codelagen en indirectheid.

Lees ook:

Abstractie in Java – Veelgestelde vragen

Q1. Waarom gebruiken we abstract?

Een belangrijke reden waarom we abstracte concepten gebruiken, is om de complexiteit te vereenvoudigen. Stel je voor dat je probeert het hele universum te verklaren met elk afzonderlijk atoom en elke ster! Met samenvattingen kunnen we uitzoomen, de belangrijkste ideeën zoals zwaartekracht en energie vastleggen en er betekenis aan geven zonder ons te verliezen in de details.

Hier zijn enkele andere redenen waarom we abstract gebruiken in Java:

1. Abstractie : abstracte klassen worden gebruikt om een ​​generiek sjabloon te definiëren dat andere klassen kunnen volgen. Ze definiëren een reeks regels en richtlijnen die hun subklassen moeten volgen. Door een abstracte klasse aan te bieden, kunnen we ervoor zorgen dat de klassen die deze uitbreiden een consistente structuur en gedrag hebben. Dit maakt de code overzichtelijker en gemakkelijker te onderhouden.

2. Polymorfisme : Abstracte klassen en methoden maken polymorfisme in Java mogelijk. Polymorfisme is het vermogen van een object om vele vormen aan te nemen. Dit betekent dat een variabele van een abstract type objecten van elke concrete subklasse van die abstracte klasse kan bevatten. Dit maakt de code flexibeler en aanpasbaar aan verschillende situaties.

3. Frameworks en API's: Java heeft talloze raamwerken en API's die abstracte klassen gebruiken. Door abstracte klassen te gebruiken, kunnen ontwikkelaars tijd en moeite besparen door voort te bouwen op bestaande code en zich te concentreren op de aspecten die specifiek zijn voor hun toepassingen.

Vraag 2. Wat is het verschil tussen Inkapseling en data-abstractie?

Hier zijn enkele belangrijke verschillen tussen zwart-wit inkapseling en abstractie:

Inkapseling

Abstractie
Inkapseling is het verbergen van gegevens (informatie verbergen) Abstractie is gedetailleerd verbergen (implementatie verbergen).
Inkapseling groepeert gegevens en methoden die op de gegevens inwerken Data-abstractie houdt zich bezig met het blootstellen van de interface aan de gebruiker en het verbergen van de details van de implementatie
Ingekapselde klassen zijn Java-klassen die het verbergen en abstractie van gegevens volgen Implementatie van abstractie gebeurt met behulp van abstracte klassen en interface
Inkapseling is een procedure die plaatsvindt op implementatieniveau abstractie is een proces op ontwerpniveau

Q3. Wat is een praktijkvoorbeeld van data-abstractie?

Afstandsbediening voor televisie is een uitstekend, realistisch voorbeeld van abstractie. Het vereenvoudigt de interactie met een tv door de complexiteit achter eenvoudige knoppen en symbolen te verbergen, waardoor het gemakkelijk wordt zonder dat u de technische details van de werking van de tv hoeft te begrijpen.

Q4. Wat is het verschil tussen abstracte klassen en interfaces in Java?

Hier zijn enkele belangrijke verschillen tussen abstracte klassen en interfaces in Java:

Abstracte klasse

burak ozcivit

Interfaces
Abstracte klassen ondersteunen abstracte en niet-abstracte methoden Interface-ondersteuningen hebben alleen abstracte methoden.
Ondersteunt geen meervoudige overerving Ondersteunt meervoudige overerving
Abstracte klassen kunnen worden uitgebreid met Java-klassen en meerdere interfaces De interface kan alleen worden uitgebreid met een Java-interface.
Abstracte klasseleden in Java kunnen privé, beschermd, enz. zijn. Interfaces zijn standaard openbaar.

Voorbeeld:

openbare abstracte klasse Vechicle{
openbare abstracte leegte drive()
}

Voorbeeld:

openbare interface Dier{
leegte spreken();
}