Java >> Java Program >  >> Java

Abstraktion i Java – Lär dig med dess typer och verkliga exempel

Java

I vilken utsträckning en modul döljer sina interna data och andra implementeringsdetaljer från de andra modulerna är den viktigaste faktorn som skiljer en väldesignad objektorienterad modul från andra moduler.

En väldesignad modul döljer alla dess implementeringsdetaljer och separerar rent gränssnittet från dess implementering. Dessa moduler kommunicerar sedan endast med varandra via gränssnitten. Detta koncept stöds med hjälp av abstraktion i Java.

Betydelsen av ordet "abstraktion", i allmänna ordalag, är processen att arbeta med idéer snarare än deras genomförande.

Tänk till exempel exemplet med ett e-postmeddelande, användaren känner inte till de komplexa detaljerna som vad som händer precis efter att ha skickat ett e-postmeddelande, vilket protokoll som används av servern för att skicka meddelandet.

Därför behöver vi bara nämna adressen till mottagaren, skriv innehållet och klicka på skicka-knappen.

Detta kallas i grunden abstraktion där de komplexa detaljerna döljs för användarna.

På samma sätt, i objektorienterad programmering, är abstraktion en process för att tillhandahålla funktionalitet till användarna genom att dölja dess implementeringsdetaljer för dem. Med andra ord kommer användaren bara ha kunskapen om vad en enhet gör istället för dess interna arbete.

Idag kommer vi att diskutera det mycket viktiga konceptet med objektorienterad programmering, som är abstraktion.

Håll dig uppdaterad med de senaste tekniktrenderna, Gå med i TechVidvan på Telegram

Abstraktion i Java

En abstraktion är en process för att avslöja alla nödvändiga detaljer och dölja resten. I Java, Dataabstraktion definieras som processen att reducera objektet till dess essens så att endast de nödvändiga egenskaperna exponeras för användarna.

Abstraktion definierar ett objekt i termer av dess egenskaper (attribut), beteende (metoder) och gränssnitt (medel för att kommunicera med andra objekt).

Exempel från verkligheten för Java-abstraktion

Om vi ​​vill bearbeta något från den verkliga världen måste vi extrahera de väsentliga egenskaperna hos det objektet. Betrakta exemplet som visas i figuren nedan.

Här kan du se att en Ägare är intresserad av detaljer som bilbeskrivning, servicehistorik, etc; Garagepersonal är intresserade av detaljer som licens, arbetsbeskrivning, räkning, ägare, etc; och Registreringskontoret intresserad av detaljer som fordonets identifieringsnummer, nuvarande ägare, registreringsskylt, etc.

Det betyder att varje applikation identifierar de detaljer som är viktiga för den.

Abstraktion kan ses som tekniken att filtrera bort de onödiga detaljerna i ett objekt så att det bara finns kvar de användbara egenskaperna som definierar det. Abstraktion fokuserar på det upplevda beteendet hos entiteten. Det ger en extern bild av enheten.

Hur uppnår man abstraktion i Java?

I Java kan vi uppnå dataabstraktion med abstrakta klasser och gränssnitt .
Gränssnitt tillåter 100 % abstraktion (fullständig abstraktion). Gränssnitt låter dig abstrahera implementeringen helt.

Abstrakta klasser tillåter 0 till 100 % abstraktion (partiell till fullständig abstraktion) eftersom abstrakta klasser kan innehålla konkreta metoder som har den implementering som resulterar i en partiell abstraktion.

Abstrakta klasser i Java

  • En abstrakt class är en klass vars objekt inte kan skapas. En abstrakt klass skapas med hjälp av abstrakt nyckelord. Det används för att representera ett begrepp.
  • En abstrakt klass kan ha abstrakta metoder (metoder utan kropp) såväl som icke-abstrakta metoder eller konkreta metoder (metoder med kroppen). En icke-abstrakt klass kan inte ha abstrakta metoder.
  • Klassen måste deklareras som abstrakt om den innehåller minst en abstrakt metod.
  • En abstrakt klass tillåter dig inte att skapa objekt av dess typ. I det här fallet kan vi bara använda objekten i dess underklass.
  • Genom att använda en abstrakt klass kan vi uppnå 0 till 100 % abstraktion.
  • Det finns alltid en standardkonstruktor i en abstrakt klass, den kan också ha en parametriserad konstruktor.
  • Den abstrakta klassen kan också innehålla slutliga och statiska metoder.

Lär veta mer om klasser i Java i detalj med Techvidvan.

Syntax för att deklarera en abstrakt klass:

För att deklarera en abstrakt klass använder vi nyckelordet abstrakt . Syntaxen anges nedan:

abstract class ClassName
{
//class body
}

Obs! Vi kan inte instansiera abstrakta klasser, dvs. vi kan inte skapa objekt eller instanser från de abstrakta klasserna .

Abstrakta metoder i Java

  • Abstrakta metoder är metoder utan implementering och utan en metodkropp. De innehåller ingen metodsats.
  • En abstrakt metod deklareras med ett abstrakt nyckelord.
  • Deklarationen av en abstrakt metod måste sluta med semikolon ;
  • De underordnade klasserna som ärver den abstrakta klassen måste tillhandahålla implementeringen av dessa ärvda abstrakta metoder.

För en bättre förståelse, ta en djup inblick i konceptet Java-metoder.

Syntax för att deklarera abstrakta metoder: 

access-specifier abstract return-type method-name();

Exempel på abstrakt klass och abstrakt metoder 

package com.techvidvan.abstraction;
//parent class
abstract class BaseClass
{
  //abstract method
  abstract public void show1();

  //concrete method
  public void show2()
  {
    System.out.println("Concrete method of parent class");
  }
}
//child class
class ChildClass extends BaseClass
{
  // Must Override this method while extending the Parent class
  public void show1()
  {
    System.out.println("Overriding the abstract method of the parent class");
  }

  //Overriding concrete method is not compulsory
  public voidshow2()
  {
    System.out.println("Overriding concrete method of the parent class");
  }
}
public class AbstractionDemo
{
  public static void main(String[] args)
  {
    /* we can't create object of the parent class hence we are creating object of the child class */
    ChildClass obj = new ChildClass();
  obj.show1();
  obj.show 2();
  }
}

Utdata:

Åsidosättande abstrakt metod för överordnad klass
Åsidosättande konkret metod för överordnad klass

Varför behöver vi abstrakta klasser i Java?

Om vi ​​inte kan skapa ett objekt från abstrakta klasser och inte heller kan använda dem, vad är då behovet av abstrakta klasser?

För att svara på denna fråga, låt oss ta en situation där vi vill skapa en klass som bara deklarerar den allmänna formen eller strukturen eller riktlinjerna för en viss idé, utan att ge en fullständig implementering av varje metod.

Och vi vill att denna generaliserade form eller struktur för klassen kan användas av alla dess barnklasser, och barnklasserna kommer att införa dessa riktlinjer genom att uppfylla alla implementeringsdetaljer efter behov.

Det finns inget behov av att implementera metoden i den överordnade klassen, så vi kan deklarera dessa metoder som abstrakta i den överordnade klassen. Det vill säga, vi kommer inte att tillhandahålla någon metodtext eller implementering av dessa abstrakta metoder.

Att göra dessa metoder som abstrakta kommer att tvinga alla härledda klasser att implementera dessa abstrakta metoder, annars kommer det att bli ett kompileringsfel i din kod.

Kod för att förstå konceptet abstraktion i Java: 

package com.techvidvan.abstraction;
abstract class GeometricShapes
{
  String nameOfShape;
  //abstract methods
  abstract double calculateArea();
  public abstract String toString();
  //constructor
  public GeometricShapes(String nameOfShape)
  {
    System.out.println("Inside the Constructor of GeometricShapes class ");
    this.nameOfShape = nameOfShape;
  }
  //non-abstract method
  public String getNameOfShape()
  {
    return nameOfShape;
  }
}
class Circle extends GeometricShapes
{
  double radius;
  public Circle(String nameOfShape,double radius)
  {
    super(nameOfShape);
    System.out.println("Inside the Constructor of Circle class ");
    this.radius = radius;
  }
  //implementing the methods
  @Override
  double calculateArea()
  {
    return Math.PI * Math.pow(radius, 2);
  }
  @Override
  public String toString()
  {
    return "Name of the shape is " + super.nameOfShape +
        " and its area is: " + calculateArea();
  }
}
class Square extends GeometricShapes
{
  double length;
  public Square(String nameOfShape,double length)
  {
    //calling Shape constructor
    super(nameOfShape);
    System.out.println("Inside the Constructor of Square class ");
    this.length = length;
  }
  //implementing the methods
  @Override
  double calculateArea()
  {
    return length * length;
  }
  @Override
  public String toString()
  {
    return "Name of the Shape is " + super.nameOfShape +
        " and its area is: " + calculateArea();
  }
}
public class AbstractionDemo
{
  public static void main(String[] args)
  {
    GeometricShapes shapeObject1 = new Circle("Circle", 6.5);
    System.out.println(shapeObject1.toString());

    GeometricShapes shapeObject2 = new Square("Rectangle",8);
    System.out.println(shapeObject2.toString());
  }
}

Utdata:

Inuti klassen Constructor of GeometricShapes
Inside the Constructor of Circle-klassen
Namnet på formen är Circle och dess area är:132.73228961416876
Inside the Constructor of GeometricShapes-klassen
Inside the Constructor of Kvadratklass
Formens namn är rektangel och dess area är:64,0

Varför kan vi inte skapa ett objekt av en abstrakt klass?

Du kanske undrar varför vi inte kan instansiera en abstrakt klass eller skapa ett objekt från den? Antag, om Java tillåter dig att skapa ett objekt av den abstrakta klassen och använda detta objekt.

Om någon anropar den abstrakta metoden genom objektet för den abstrakta klassen, vad skulle då hända? Det skulle inte finnas någon faktisk implementering av den anropade metoden.

En abstrakt klass är också som en riktlinje eller en mall som måste utökas med sina underordnade klasser för implementeringen.

Kod för att illustrera att objektskapandet av en abstrakt klass är ogiltig:

Som diskuterats ovan kan vi inte instansiera en abstrakt klass. Detta program ger ett kompileringsfel.

package com.techvidvan.abstraction;
//Parent class
abstract class ParentClass
{
  //Abstract method
  abstract public void showDetails();
}
//Child class
class ChildClass extends ParentClass
{
  public void showDetails()
  {
    System.out.print("Overriding Abstract method of the parent class ");
  }
}
public class AbstractionDemo
{
  public static void main(String args[])
  {
    //error: You can't create object of an abstract class
    ParentClass obj = new ParentClass();
    obj.showDetails();
  }
}

Utdata:

Undantag i tråden "main" java.lang.Error:Olöst kompileringsproblem:
Kan inte instansiera typen ParentClass

Typer av abstraktion i Java

Abstraktion kan vara av två typer:

1. Dataabstraktion

Dataabstraktion är den vanligaste typen av abstraktion där vi skapar komplexa datatyper som HashMap eller HashSet, och döljer dess implementeringsdetaljer för användarna och visar endast de meningsfulla operationerna för att interagera med datatypen.

Fördelen med detta tillvägagångssätt löser prestandaproblemen och förbättrar implementeringen över tid. Eventuella förändringar som inträffar samtidigt som prestandan förbättras, återspeglas inte på koden som finns på klientsidan.

2. Kontrollabstraktion

Kontrollabstraktion är processen att fastställa alla sådana uttalanden som är lika och upprepas många gånger och exponera dem som en enda arbetsenhet. Vi använder normalt denna typ av abstraktion när vi vill skapa en funktion för att utföra en given uppgift.

Fördelar med abstraktion i Java

  • Det minskar komplexiteten i att se saker.
  • Ökar återanvändning av programvara och undviker kodduplicering:Löst kopplade klasser visar sig ofta vara användbara i andra sammanhang.
  • Det hjälper till att öka säkerheten och sekretessen för en applikation eftersom endast nödvändiga detaljer exponeras för användaren.
  • Lättar underhållsbördan – Klasser kan förstås snabbare och felsökas med liten rädsla för att skada andra moduler.

Datainkapsling vs dataabstraktion i Java

  • Inkapsling är ett steg bortom abstraktion.
  • Datainkapsling döljer data eller information medan abstraktion döljer implementeringsdetaljerna.
  • Inkapsling binder samman datamedlemmarna och metoderna medan dataabstraktion handlar om att visa en enhets externa detaljer för användaren och dölja detaljerna om dess implementering.
  • Abstraktion ger åtkomst till en specifik del av data medan inkapsling döljer data.

Saker att komma ihåg

  • I Java kan du inte skapa ett objekt från den abstrakta klassen med den nya operatorn. Om du försöker instansiera en abstrakt klass kommer den att ge ett kompileringsfel.
  • En abstrakt klass kan ha en konstruktor.
  • Den kan innehålla både abstrakta och konkreta metoder. En abstrakt metod har bara deklarationen men inte vilken metod som helst.
  • I Java kan endast klasser eller metoder deklareras som abstrakta, vi kan inte deklarera en variabel som abstrakt.
  • Vi använder nyckelordet abstrakt för att deklarera både klass och metod som abstrakt.
  • Om vi ​​deklarerar någon metod som abstrakt måste klassen automatiskt bli en abstrakt klass.

Sammanfattning

Genom Data Abstraction kan vi reducera en verklig enhet till dess väsentliga definierande funktioner och bara visa vad som är nödvändigt för användarna. Konceptet med dataabstraktion är helt baserat på abstrakta klasser i Java.

Här kommer vi till slutet av vår Java-artikel. Låt oss nu titta på vad vi har lärt oss. I den här artikeln har vi diskuterat vikten av abstraktion i Java med verkliga exempel.

Vi täckte också den detaljerade beskrivningen av abstrakta klasser och abstrakta metoder i Java med deras syntax och exempel. Nu kanske du har förstått vikten av abstraktion i OOPs och även hur du implementerar det i dina koder.

Tack för att du läser vår artikel. Dela den här Java-artikeln på sociala medier.

Lycka till med lärandet 🙂


Java-tagg