what is abstraction java learn with examples
Deze tutorial legt uit wat Abstraction in Java is, samen met programmeervoorbeelden. Je leert ook wat een abstracte les is en waarom deze wordt gebruikt:
In deze JAVA-serie bespreken we de belangrijke kenmerken van objectgeoriënteerd programmeren (OOP) die ook bekend staan als vier pijlers, namelijk abstractie, inkapseling, overerving en polymorfisme.
De eerste pijler van OOP is 'Abstraction'. 'Abstractie is het proces waarbij gegevens worden geselecteerd om alleen de relevante informatie aan de gebruiker te tonen.'
Bekijk hier de Java-beginnershandleiding.
Wat je leert:
- Abstractie in OOP
- Wat is abstractie in Java
- Verschil tussen abstractie en inkapseling
- Gevolgtrekking
Abstractie in OOP
Eenvoudig gezegd: abstractie 'toont' alleen de relevante attributen van objecten en 'verbergt' de onnodige details.
Bijvoorbeeld, als we autorijden, zijn we alleen bezorgd over het besturen van de auto, zoals het starten / stoppen van de auto, accelereren / remmen, enz. We maken ons geen zorgen over hoe het eigenlijke start / stop-mechanisme of het acceleratie- / remproces intern werkt. We zijn gewoon niet geïnteresseerd in die details.
Waar we ons zorgen over maken, is de 'abstracte' kijk op deze operaties die ons zullen helpen de auto vooruit te rijden en onze bestemming te bereiken. Dit is een eenvoudig voorbeeld van abstractie.
De auto beschikt dus over alle mechanismen en processen, maar vanuit het perspectief van de eindgebruiker, d.w.z. het perspectief van de automobilist, zal hij / zij alleen geïnteresseerd zijn in de abstracte kijk op deze processen.
Abstractie vermindert de programmeerinspanningen en daarmee de complexiteit. Een eindgebruiker die de applicatie gebruikt, hoeft zich geen zorgen te maken over hoe een bepaalde functie wordt geïmplementeerd. Hij / zij kan de functies gewoon gebruiken zoals vereist.
Dus in abstractie hebben we te maken met ideeën en niet met de gebeurtenissen. Dit betekent dat we de implementatiedetails voor de gebruiker verbergen en alleen de functionaliteit aan de eindgebruiker tonen. Daardoor weet de gebruiker alleen “wat het doet” in plaats van “hoe het doet”.
Abstractie in OOP kan van twee soorten zijn.
# 1) Gegevens-abstractie
Bij data-abstractie creëren we meestal complexe datatypes en verbergen we hun implementatie. We stellen alleen de bewerkingen bloot om deze gegevenstypen te manipuleren zonder in te gaan op de details van hun implementatie.
Een voordeel van deze aanpak is dat we de implementatie op elk moment kunnen wijzigen zonder het gedrag dat wordt blootgesteld aan de gebruiker te veranderen.
# 2) Controle over abstractie
Controle-abstractie verzamelt alle controleverklaringen die deel uitmaken van de applicatie en stelt ze als een eenheid bloot. Deze functie wordt gebruikt wanneer we een werkende functie moeten uitvoeren met deze besturingseenheid.
Controle-abstractie vormt de belangrijkste eenheid van gestructureerd programmeren en met behulp van controle-abstractie kunnen we eenvoudige functies definiëren voor complexe kaders.
Wat is abstractie in Java
Omdat Java een OOP-taal is, kan abstractie worden gezien als een van de belangrijke kenmerken en bouwstenen van de Java-taal. In Java wordt abstractie geïmplementeerd met behulp van een abstracte klasse en interface.
Dus hoe implementeren we abstractie in Java? Java biedt een non-access modifier 'abstract' voor het implementeren van abstractie. Deze abstracte modifier kan worden gebruikt met klassen en methoden, maar niet met variabelen.
De interface biedt volledige abstractie, d.w.z. het biedt alleen methode-prototypes en niet hun implementatie. Een abstracte klasse biedt gedeeltelijke abstractie waarbij ten minste één methode niet moet worden geïmplementeerd.
In deze tutorial zullen we abstractie met abstracte klassen in detail bespreken. We zullen interfaces in detail onderzoeken in onze volgende tutorials.
Voorbeeld van Java-abstractie
Laten we het onderstaande voorbeeld eens bekijken.
Uitgang:
Het eenvoudige abstractievoorbeeld dat hierboven is gegeven, heeft een klasse Auto. In deze klasse Auto hebben we een abstracte methode om te accelereren (). Dan erven we deze klasse in de Suzuki klasse. Binnen de Suzuki-klasse implementeren we de accelerate-methode.
Het bovenstaande voorbeeld toont eenvoudig de manier waarop een abstracte klasse wordt gedefinieerd, geërfd en vervolgens in het programma wordt gebruikt.
Wat is Java Abstract Class
We hebben al gezegd dat Java abstractie implementeert met behulp van abstracte klassen en interfaces. Laten we eerst alles bekijken over de abstracte les.
Een abstracte klasse kan worden gedefinieerd als een klasse die is gedeclareerd met het trefwoord 'abstract' en heeft een beperking dat deze niet kan worden geïnstantieerd.
Een abstracte klasse kan al dan niet een abstracte methode hebben (een methode zonder implementatie). Wat JVM betreft, is een abstracte klasse een onvolledige klasse die geen volledig gedrag vertoont.
De algemene syntaxis van een abstracte klasse wordt hieronder gegeven:
Zoals getoond in de syntaxis van de bovenstaande abstracte klasse, kunnen we zowel abstracte als niet-abstracte methoden in een abstracte klasse hebben. Het trefwoord ‘abstract’ gaat vooraf aan de klasseverklaring.
In een notendop kan een abstracte klasse worden beschreven zoals hieronder weergegeven.
Abstracte methode in Java
Een abstracte methode is een methode die wordt voorafgegaan door een ‘abstract’ zoekwoord zonder enige implementatie. Een abstracte methode wordt gedeclareerd binnen een abstracte klasse.
Een abstracte methode is de methode die een klasse onvolledig maakt omdat deze geen implementatie heeft. Dus als we een abstracte methode in de klas opnemen, wordt de klas natuurlijk onvolledig.
We kunnen de abstracte methode gebruiken door deze in een subklasse te implementeren, d.w.z. een klasse erft de abstracte klasse en implementeert of levert vervolgens de code voor alle abstracte methoden die in de abstracte klasse zijn gedeclareerd door ze te overschrijven.
Zo wordt het verplicht om de abstracte methode in de subklasse te overschrijven. Als de abstracte methode ook niet in de subklasse is geïmplementeerd, moeten we de subklasse ook als 'abstract' declareren.
De algemene verklaring van de abstracte methode is:
abstract leegte methodName (parameter_lijst);
Bij het schrijven van de abstracte methode moeten we de volgende regels onthouden:
- Een klasse die een of meer abstracte methoden bevat, is een abstracte klasse.
- Bepaalde andere trefwoorden mogen niet worden gebruikt met het abstracte trefwoord.
De volgende combinaties zijn dus illegaal in Java.
- laatste
- abstract native
- abstract statisch
- abstract privé
- abstract gesynchroniseerd
- abstracte strictfp
Laten we een voorbeeld van een abstracte klasse en een abstracte methode implementeren.
Uitgang:
In het bovenstaande voorbeeld hebben we een klasse Bank. In deze klasse hebben we een abstracte methode, getInterestRate (). Vervolgens declareren we twee klassen: ICICI en BOI die erven van de klasse Bank. Beide klassen implementeren de methode getInterestRate () door hun respectieve rentetarieven te retourneren.
Vervolgens maken we in de hoofdmethode een bankobject. Ten eerste bevat het bankobject een object van de ICICI-klasse en geeft het de rentevoet weer. Vervolgens wordt het BOI-object gemaakt en wordt het rentepercentage weergegeven.
We kunnen dus aannemen dat de klasse Bank een soort schets of structuur is waarmee we een rentetarief kunnen krijgen. Vanuit deze structuur kunnen we zoveel concrete klassen maken als we willen, en dan kunnen we de respectievelijke rentetarieven voor elk bankobject krijgen (dit wordt getoond in de hoofdmethode).
Wat is het gebruik van een abstracte klasse in Java
Waarom gebruiken we een abstracte klasse terwijl deze in werkelijkheid geen eigen implementatie heeft?
Samen met het antwoord op de bovenstaande vraag, zullen we ook illustreren hoe je een abstracte klasse kunt gebruiken in het voorbeeld dat volgt.
Laten we eens kijken naar een voorbeeld van voertuigen. We weten dat voertuigen van vele soorten kunnen zijn. We kunnen auto's, scooters, fietsen, bromfietsen, bussen enz. Hebben. Hoewel er veel soorten voertuigen zijn, hebben ze een aantal eigenschappen of attributen die gemeenschappelijk zijn voor alle voertuigen, ongeacht hun type.
Bijvoorbeeld, elk voertuig heeft een model, chassisnummer, kleur, enz. Elk van hen heeft functies zoals starten, stoppen, accelereren, remmen, enz. Nu heeft elk voertuig de bovenstaande eigenschappen en methoden die ook voor de anderen gemeenschappelijk zijn. Op hetzelfde moment als een voertuiggebruiker zijn we misschien niet geïnteresseerd in sommige aspecten.
Bijvoorbeeld, als een persoon een auto bestuurt, zal hij / zij alleen geïnteresseerd zijn in het starten en stoppen van het voertuig of het versnellen of remmen van het voertuig. Hij / zij zal niet willen weten hoe het voertuig start of stopt. We zijn alleen geïnteresseerd in de abstracte werking van de functies en niet in hun details.
Als we het bovenstaande voorbeeldsysteem nu in een softwaretoepassing willen weergeven, hoe ontwerpen we het dan? Allereerst zullen we enige abstractie doorvoeren. Nu weten we dat sommige functies gebruikelijk zijn, maar afhankelijk van elk model zal de implementatie van deze functies anders zijn.
Om te beginnen verklaren we een abstracte klasse 'Voertuig'.
We hebben dit systeem hieronder laten zien:
We zullen dus een abstracte klasse Voertuig hebben en er zal een betonnen klasse zijn die elk model van het voertuig vertegenwoordigt. Ter illustratie hebben we slechts drie modellen gebruikt, namelijk auto, fiets en scooter.
Hieronder is de klassenhiërarchie van het bovenstaande systeem weergegeven.
We hebben dus een abstracte klasse voertuig en drie klassen auto, fiets en scooter. Elk van deze klassen zal de voertuigklasse uitbreiden en elk van de abstracte methoden overschrijven.
Dus in het algemeen, wanneer we een dergelijk systeem moeten vertegenwoordigen dat gemeenschappelijke methoden of bewerkingen heeft om te vertegenwoordigen, en om alleen het uiterlijke perspectief aan de gebruiker te presenteren, gaan we voor abstractie. Het resultaat is dat we de gebruikelijke methoden verwijderen en deze als abstracte methoden voorstellen en deze abstracte methoden verzamelen in een gemeenschappelijke abstracte klasse.
Zodra we de omtrek van een systeem hebben weergegeven als een abstracte klasse en de bewerkingen als abstracte methoden, kunnen we een willekeurig aantal klassen afleiden uit de gegeven abstracte klasse en de abstracte methoden overschrijven om deze bewerkingen voor elke klasse te implementeren.
Op deze manier wordt het handig om een systeem te ontwerpen.
Abstracte klasse en interface
We hebben de abstracte klasse hierboven gezien. Interfaces zijn weer andere bouwstenen die abstractie implementeren. Interfaces zijn contracten en klassen die de interface implementeren, moeten deze contracten nakomen.
Contracten in interfaces zijn niets anders dan methoden die niet worden geïmplementeerd. Binnen interfaces zullen we alleen prototypes van methoden hebben. Er zal geen enkele implementatie van methoden binnen interfaces zijn.
Als we als volgt een interface-verklaring hebben:
Elke klasse die de interfaceA implementeert, moet de ‘myInterfaceMethod’ overschrijven.
Als we de methode in een klas helemaal niet overschrijven, wordt die klasse als abstract weergegeven.
We zullen later een aparte tutorial over de interface hebben.
Laten we vervolgens enkele verschillen bespreken tussen abstracte klassen en interfaces in Java.
Verschil tussen abstracte klasse en interface
| Abstracte klasse | Koppel |
|---|---|
| Een abstracte klasse kan privé- of beschermde gegevensleden hebben, behalve openbare leden. | Interface-leden zijn standaard openbaar. |
| Een abstracte klasse kan abstracte en / of niet-abstracte methoden hebben. | Een interface kan alleen abstracte methoden hebben. |
| De samenvatting kan al dan niet de laatste variabelen bevatten. | Interfaces kunnen uiteindelijke variabelen zijn als standaardvariabelen. |
| Een abstracte klasse kan definitieve, statische of niet-statische of niet-definitieve variabelen hebben. | Interfaces kunnen alleen definitieve en statische variabelen hebben. |
| Een abstracte klasse kan interface-implementatie bieden. | Interfaces kunnen geen abstracte klasse implementeren. |
| Een abstracte klasse wordt overgeërfd met behulp van het trefwoord 'extends'. | De interface wordt geïmplementeerd met behulp van het sleutelwoord 'implements'. |
| Een abstracte klasse kan andere klassen uitbreiden of meerdere interfaces implementeren. | De interface kan alleen een andere interface implementeren. |
Wanneer abstracte klasse en interface in Java gebruiken
De beslissing over wanneer abstracte klassen moeten worden gebruikt en wanneer interfaces in Java-toepassingen moeten worden gebruikt, moet op intelligente wijze worden genomen na grondig begrip van het probleem bij de hand. Er zijn twee aspecten waarmee we rekening moeten houden, zoals hieronder weergegeven.
Abstracte lessen met gedeeltelijk gedrag
We weten dat abstracte klassen mogelijk niet volledig worden geïmplementeerd. Ze kunnen gedeeltelijk gedrag vertonen. Aan de andere kant hebben interfaces geen enkele implementatie. Dus als we moeten kiezen tussen een abstracte klasse en een implementatie, dan moeten we dit aspect van onze applicatie in overweging nemen.
Dit betekent dat we eerst moeten beslissen of de applicatie die we ontwerpen een gemeenschappelijke gedeeltelijke implementatie heeft die we kunnen scheiden in een abstracte klasse.
Bijvoorbeeld, bedenk dat we een webapplicatie ontwerpen. Hiervoor zullen we enige webtechnologie moeten gebruiken, zoals Servlet, REST API, enz. Nu heeft elk van deze webtechnologieën een aantal technieken of stappen die geïmplementeerd moeten worden, ongeacht de applicatie die we aan het ontwikkelen zijn. Vervolgens bouwen we onze applicatie op maat.
normalisatie in database met voorbeeldtabellen
Dus in dit geval kan de definitieve code die de webtechnologie moet uitvoeren in een abstracte klasse worden geplaatst. Kunnen we hiervoor een interface hebben? Nee. Dit komt omdat de interface geen implementatie kan hebben.
Contract Only Interfaces
We weten dat interfaces contracten of methoden hebben die er deel van uitmaken. Deze methoden zijn slechts prototypes. We moeten deze interfaces in een klasse implementeren en vervolgens de methoden overschrijven.
Overweeg nu de kaartinterface van Java Collections Framework. Veel klassen zoals HashMap, TreeMap en HashTable, enz. Implementeren deze interface. Elk van deze klassen heeft een andere implementatie. Ze hebben geen gemeenschappelijk gedrag dat kan worden weergegeven in de abstracte klasse.
Dus wat we doen is dat we een interface ontwerpen met prototypes van methoden en vervolgens elk van de klassen implementeren.
Op deze manier moeten we elke factor goed afwegen voordat we kiezen tussen een abstracte klasse en een interface.
Verschil tussen abstractie en inkapseling
Laten we enkele van de verschillen bespreken tussen abstractie en nog een belangrijk kenmerk van OOP, namelijk inkapseling.
| Abstractie | Inkapseling |
|---|---|
| Proces van het verkrijgen en abstraheren van de informatie | Proces om de informatie te binden. |
| De abstractietechniek is op ontwerp- of interfaceniveau. | Het inkapselingsmechanisme bevindt zich op het implementatieniveau. |
| Abstractie verbergt de details. | Inkapseling bindt de informatie in één eenheid en zorgt zo voor informatiebeveiliging. |
| Abstractie wordt geïmplementeerd met behulp van abstracte klassen en interfaces. | Toegangsmodificatoren, namelijk openbaar, privé en beschermd, en standaard spelen een rol bij inkapseling. |
| In abstractie wordt de enige abstracte weergave aan de gebruiker gepresenteerd, terwijl complexe en gedetailleerde gegevens voor de gebruiker verborgen blijven. | Bij inkapseling worden gegevens als een eenheid gebundeld en kunnen ze worden beschermd of toegankelijk gemaakt met behulp van toegangsmodificatoren en getter- en setter-methoden. |
Veel Gestelde Vragen
Vraag 1) Is het verbergen van abstractie en gegevens hetzelfde?
Antwoord: Nee, abstractie en gegevens verbergen is niet hetzelfde. Maar beide zijn belangrijke kenmerken van objectgeoriënteerd programmeren. Terwijl abstractie een proces is waarbij de achtergronddetails worden verborgen, is het verbergen van gegevens een techniek om de gegevens te isoleren van directe toegang.
Vraag 2) Wat zijn de voordelen van abstractie?
Antwoord: Enkele voordelen van abstractie worden hieronder gegeven:
- Door de achtergronddetails te verbergen en alleen de abstracte weergave aan de gebruiker bloot te stellen, maakt abstractie code eenvoudiger en leesbaarder.
- Omdat abstractie onnodige details afschermt, wordt de code kleiner.
- Codeonderhoud kan complex en moeilijk worden zonder abstractie.
Vraag 3) Waarom is abstractie zo belangrijk?
Antwoord: Door abstractie kunnen we achtergronddetails verbergen die belangrijk zijn en tot chaos kunnen leiden als ze naar de wereld worden gelekt. Door de achtergronddetails te verbergen en alleen de vereiste interface aan de gebruiker bloot te stellen, maakt abstractie toepassingen eenvoudiger.
Vraag 4) Leg abstractie uit met een real-time voorbeeld.
Antwoord: Er zijn veel real-time voorbeelden van abstractie, inclusief geometrische vormen, voertuigen, etc. Nog een ander voorbeeld is de ATM (Automated Teller Machine). De geldautomaat ondersteunt operaties zoals het opnemen van contant geld, het controleren van het saldo, het overboeken van geld, enz. Maar we weten niet hoe deze operaties intern werken.
We krijgen alleen een monitor met een gebruikersinterface om de vereiste bewerkingen te selecteren en uit te voeren.
V # 5) Kunnen we abstractie bereiken zonder inkapseling?
Antwoord: Abstractie schermt de implementatiedetails af en inkapseling verbergt de objectdetails. Het object is de abstracte vorm van de echte wereld en de details zijn verborgen door middel van inkapseling. Inkapseling is dus vereist voor abstractie.
Gevolgtrekking
In deze tutorial hebben we abstractie in Java in detail besproken. Abstractie is een techniek om onnodige details voor de gebruiker te verbergen. De gebruiker krijgt alleen toegang tot de gegevens die relevant zijn. Voertuigoperaties of geldautomaten zijn klassieke voorbeelden van abstracties in de echte wereld.
Wanneer we ATM gebruiken, zijn we alleen geïnteresseerd in het uitvoeren van operaties zoals geldopname, enz. Zonder dat we de details hoeven te weten over hoe die operatie intern precies wordt uitgevoerd.
Java biedt abstractie door middel van abstracte klassen en interfaces. Hoewel interfaces 100% abstractie bieden, bieden abstracte klassen een gedeeltelijke abstractie. De keuze tussen interfaces en abstracte klassen moet worden gemaakt afhankelijk van de te ontwikkelen applicatie en ook welke informatie aan de gebruiker moet worden blootgesteld.
We hebben ook de abstracte methoden in deze tutorial besproken, samen met de verschillen tussen abstracte klassen en interfaces.
Bekijk hier ALLE Java-tutorials.
Aanbevolen literatuur
- Java-interface en abstracte les met voorbeelden
- Java Integer en Java BigInteger-klasse met voorbeelden
- Zelfstudie voor Java-scannerklassen met voorbeelden
- Wat is Java-vector | Java Vector Class-zelfstudie met voorbeelden
- Java Enum: zelfstudie over Java-opsomming met voorbeelden
- Java Basics: Java Syntax, Java Class en Core Java Concepts
- JAVA-zelfstudie voor beginners: 100+ praktische Java-videotutorials
- Java Iterator: leer iterators te gebruiken in Java met voorbeelden