logo

TechCodeview

Abstraktion i Java

Abstraktion i Java är den process där vi endast visar väsentliga detaljer/funktioner för användaren. De icke väsentliga implementeringsdetaljerna visas inte för användaren.

I den här artikeln kommer vi att lära oss om abstraktion och vad abstrakt betyder.

Enkelt exempel för att förstå abstraktion:

TV fjärrkontroll är en utmärkt exempel på abstraktion . Det förenklar interaktionen med en TV genom att dölja komplexiteten bakom enkla knappar och symboler, vilket gör det enkelt utan att behöva förstå de tekniska detaljerna om hur TV:n fungerar.



Vad är abstraktion i Java?

I Java uppnås abstraktion genom gränssnitt och abstrakta klasser . Vi kan uppnå 100% abstraktion med hjälp av gränssnitt.

Dataabstraktion kan också definieras som processen att identifiera endast de erforderliga egenskaperna hos ett objekt och ignorera de irrelevanta detaljerna. Ett objekts egenskaper och beteenden skiljer det från andra objekt av liknande typ och hjälper också till att klassificera/gruppera objekten.

Abstraktionsexempel i verkligheten:

Tänk på ett verkligt exempel på en man som kör bil. Mannen vet bara att ett tryck på gaspedalen kommer att öka hastigheten på en bil eller att bromsa kommer att stoppa bilen, men han vet inte hur hastigheten faktiskt ökar när han trycker på gaspedalen, han vet inte om bilens inre mekanism eller implementeringen av gaspedalen, bromsarna etc i bilen. Detta är vad abstraktion är.

Java Abstract-klasser och Java Abstract-metoder

  1. En abstrakt klass är en klass som deklareras med ett abstrakt nyckelord.
  2. En abstrakt metod är en metod som deklareras utan implementering.
  3. En abstrakt klass kan ha alla abstrakta metoder eller inte. Några av dem kan vara konkreta metoder
  4. En metoddefinierad abstrakt måste alltid omdefinieras i underklassen, vilket gör åsidosättande obligatorisk eller göra själva underklassen abstrakt.
  5. Varje klass som innehåller en eller flera abstrakta metoder måste också deklareras med ett abstrakt nyckelord.
  6. Det kan inte finnas något objekt i en abstrakt klass. Det vill säga, en abstrakt klass kan inte direkt instansieras med ny operatör .
  7. En abstrakt klass kan ha parametriserade konstruktorer och standardkonstruktorn finns alltid i en abstrakt klass.

Algoritm för att implementera abstraktion i Java

  1. Bestäm de klasser eller gränssnitt som kommer att ingå i abstraktionen.
  2. Skapa en abstrakt klass eller gränssnitt som definierar de vanliga beteendena och egenskaperna för dessa klasser.
  3. Definiera abstrakta metoder inom den abstrakta klassen eller gränssnittet som inte har några implementeringsdetaljer.
  4. Implementera konkreta klasser som utökar den abstrakta klassen eller implementerar gränssnittet.
  5. Åsidosätt de abstrakta metoderna i de konkreta klasserna för att tillhandahålla deras specifika implementeringar.
  6. Använd de konkreta klasserna för att implementera programlogiken.

När ska man använda abstrakta klasser och abstrakta metoder?

Det finns situationer där vi kommer att vilja definiera en superklass som deklarerar strukturen för en given abstraktion utan att tillhandahålla en fullständig implementering av varje metod. Ibland vill vi skapa en superklass som bara definierar en generaliseringsform som kommer att delas av alla dess underklasser, och lämnar det till varje underklass att fylla i detaljerna.

Tänk på ett klassiskt formexempel, kanske använt i ett datorstödt designsystem eller spelsimulering. Bastypen är form och varje form har en färg, storlek och så vidare. Från detta härleds specifika typer av former (ärvda) - cirkel, kvadrat, triangel och så vidare - som var och en kan ha ytterligare egenskaper och beteenden. Till exempel kan vissa former vändas. Vissa beteenden kan vara annorlunda, till exempel när du vill beräkna arean av en form. Typhierarkin förkroppsligar både likheterna och skillnaderna mellan formerna.

Abstrakt klass i Java

Exempel på Javaabstraktion

Exempel 1:

Java


vad är kataloginlämning



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

>

sträng till tecken 
>

Produktion 

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>

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

>

>

Produktion 

Buddy barks Fluffy meows>

Förklaring av ovanstående Java-program:

kat timpf nettoförmögenhet

Denna kod definierar en Animal abstrakt klass med en abstrakt metod makeSound(). Klasserna Hund och Katt utökar Animal och implementerar metoden makeSound(). Main()-metoden skapar instanser av Dog and Cat och anropar makeSound()-metoden på dem.

Detta demonstrerar abstraktionskonceptet i Java, där vi definierar en mall för en klass (i detta fall Animal), men låter implementeringen av vissa metoder definieras av underklasser (i detta fall makeSound()).

Gränssnitt

Gränssnitt är en annan metod för att implementera abstraktion i Java. Den viktigaste skillnaden är att genom att använda gränssnitt kan vi uppnå 100% abstraktion i Java-klasser. I Java eller något annat språk innehåller gränssnitt både metoder och variabler men saknar en metodkropp. Förutom abstraktion kan gränssnitt också användas för att implementera gränssnitt i Java.

Genomförande: Att implementera en gränssnitt vi använder nyckelordet redskap med klass.

Java




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

linux byta namn på mapp 

>

>

Produktion 

Area of Circle: 78.53981633974483 Area of Rectangle: 24.0>

Fördelar med abstraktion

Här är några fördelar med abstraktion:

  1. Det minskar komplexiteten i att se saker.
  2. Undviker kodduplicering och ökar återanvändbarheten.
  3. Hjälper till att öka säkerheten för en applikation eller ett program eftersom endast väsentliga detaljer ges till användaren.
  4. Det förbättrar applikationens underhållsbarhet.
  5. Det förbättrar modulariteten i applikationen.
  6. Förbättringen kommer att bli mycket enkel eftersom vi utan att påverka slutanvändarna kan utföra alla typer av ändringar i vårt interna system.
  7. Förbättrar kodåteranvändbarhet och underhållsbarhet.
  8. Döljer implementeringsdetaljer och visar endast relevant information.
  9. Ger ett tydligt och enkelt gränssnitt till användaren.
  10. Ökar säkerheten genom att förhindra åtkomst till interna klassdetaljer.
  11. Stöder modularitet, eftersom komplexa system kan delas upp i mindre och mer hanterbara delar.
  12. Abstraktion ger ett sätt att dölja komplexiteten i implementeringsdetaljer för användaren, vilket gör det lättare att förstå och använda.
  13. Abstraktion möjliggör flexibilitet i implementeringen av ett program, eftersom ändringar av de underliggande implementeringsdetaljerna kan göras utan att det påverkar användargränssnittet.
  14. Abstraktion möjliggör modularitet och separation av problem, vilket gör koden mer underhållbar och lättare att felsöka.

Nackdelar med abstraktion i Java

Här är de största nackdelarna med abstraktion i Java:

  1. Abstraktion kan göra det svårare att förstå hur systemet fungerar.
  2. Det kan leda till ökad komplexitet, särskilt om det inte används på rätt sätt.
  3. Detta kan begränsa implementeringens flexibilitet.
  4. Abstraktion kan lägga till onödig komplexitet till koden om den inte används på rätt sätt, vilket leder till ökad utvecklingstid och ansträngning.
  5. Abstraktion kan göra det svårare att felsöka och förstå kod, särskilt för de som inte är bekanta med abstraktionsskikten och implementeringsdetaljerna.
  6. Överanvändning av abstraktion kan resultera i minskad prestanda på grund av de ytterligare lagren av kod och inriktning.

Läs också:

Abstraktion i Java – Vanliga frågor

Q1. Varför använder vi abstrakt?

En viktig anledning till att vi använder abstrakta begrepp är att förenkla komplexiteten. Föreställ dig att försöka förklara hela universum med varenda atom och stjärna! Abstracts låter oss zooma ut, ta tag i huvudidéerna som tyngdkraft och energi, och förstå det hela utan att gå vilse i detaljerna.

Här är några andra anledningar till varför vi använder abstrakt i Java:

1. Abstraktion : Abstrakta klasser används för att definiera en generisk mall för andra klasser att följa. De definierar en uppsättning regler och riktlinjer som deras underklasser måste följa. Genom att tillhandahålla en abstrakt klass kan vi säkerställa att klasserna som utökar den har en konsekvent struktur och beteende. Detta gör koden mer organiserad och lättare att underhålla.

2. Polymorfism : Abstrakta klasser och metoder möjliggör polymorfism i Java. Polymorfism är förmågan hos ett objekt att anta många former. Detta betyder att en variabel av en abstrakt typ kan innehålla objekt av vilken konkret underklass som helst av den abstrakta klassen. Detta gör koden mer flexibel och anpassningsbar till olika situationer.

3. Ramar och API:er: Java har många ramverk och API:er som använder abstrakta klasser. Genom att använda abstrakta klasser kan utvecklare spara tid och ansträngning genom att bygga på befintlig kod och fokusera på de aspekter som är specifika för deras applikationer.

Q2. Vad är skillnaden mellan Inkapsling och dataabstraktion?

Här är några viktiga skillnader i svartvit inkapsling och abstrering:

Inkapsling

Abstraktion
Inkapsling är att dölja data (informationsgömma) Abstraktion är detaljerad gömning (gömning av implementering).
Inkapsling grupperar data och metoder som verkar på datan Dataabstraktion handlar om att exponera gränssnittet för användaren och dölja detaljerna i implementeringen
Inkapslade klasser är Java-klasser som följer datadöljning och abstraktion Implementering av abstraktion görs med hjälp av abstrakta klasser och gränssnitt
Inkapsling är en procedur som sker på implementeringsnivå abstraktion är en process på designnivå

Q3. Vad är ett verkligt exempel på dataabstraktion?

TV fjärrkontroll är ett utmärkt verkligt exempel på abstraktion. Det förenklar interaktionen med en TV genom att dölja komplexiteten bakom enkla knappar och symboler, vilket gör det enkelt utan att behöva förstå de tekniska detaljerna om hur TV:n fungerar.

Q4. Vad är skillnaden mellan abstrakta klasser och gränssnitt i Java?

Här är några viktiga skillnader i svartvitt abstrakta klasser och gränssnitt i Java:

Abstrakt klass

java arraylist metoder

Gränssnitt
Abstrakta klasser stöder abstrakta och icke-abstrakta metoder Gränssnittsstöd har endast abstrakta metoder.
Stöder inte multipla arv Stöder multipla arv
Abstrakta klasser kan utökas med Java-klasser och flera gränssnitt Gränssnittet kan endast utökas med Java-gränssnitt.
Abstrakta klassmedlemmar i Java kan vara privata, skyddade osv. Gränssnitt är offentliga som standard.

Exempel:

offentlig abstrakt klass Vechicle{
public abstract void drive()
}

Exempel:

offentligt gränssnitt Animal{
void tala();
}