Abstrakt klasse og interface bruges begge til at definere kontrakter i objektorienteret programmering, men der er nogle vigtige forskelle mellem dem.

Forskellen mellem abstrakt klasse og grænseflade: -

Definition: En abstrakt klasse er en klasse, der ikke kan instansieres og kan indeholde både abstrakte og ikke-abstrakte metoder. En grænseflade er på den anden side en kontrakt, der specificerer et sæt metoder, som en klasse skal implementere.

Metodeimplementering: I en abstrakt klasse kan nogle metoder implementeres, mens andre efterlades abstrakte, hvilket betyder, at de ikke har nogen implementering og skal tilsidesættes af konkrete underklasser. I modsætning hertil er alle metoder i en grænseflade som standard abstrakte og skal implementeres af enhver klasse, der implementerer grænsefladen.

Arv: En klasse kan kun arve fra én abstrakt klasse, men den kan implementere flere grænseflader. Dette skyldes, at en abstrakt klasse repræsenterer en type objekt, mens en grænseflade repræsenterer et sæt adfærd.

Adgangsmodifikatorer: Abstrakte klasser kan have adgangsmodifikatorer såsom offentlig, beskyttet og privat for deres metoder og egenskaber, mens grænseflader kun kan have offentlig adgang.

Variabler: En abstrakt klasse kan have medlemsvariabler, mens en grænseflade ikke kan.

Sammenfattende bruges abstrakte klasser til at give en basisklasse for konkrete underklasser at arve fra, mens grænseflader bruges til at definere et sæt metoder, som en klasse skal implementere. Abstrakte klasser kan have implementerede og abstrakte metoder, mens grænseflader kun kan have abstrakte metoder. Klasser kan kun arve fra én abstrakt klasse, men kan implementere flere grænseflader.

Som vi ved, refererer abstraktion til at skjule den interne implementering af funktionen og kun vise funktionaliteten til brugerne. det vil sige kun at vise de nødvendige funktioner og skjule, hvordan disse funktioner implementeres bag scenen. Hvorimod en grænseflade er en anden måde at opnå abstraktion i java. Begge abstrakt klasse og interface bruges til abstraktion, fremover kræves grænseflade og abstrakt klasse.

Abstrakt klasse vs grænseflade

• Typer af metoder: Interface kan kun have abstrakte metoder. Hvorimod en abstrakt klasse kan have abstrakt metode og konkrete metoder. Fra Java 8 kan den også have standard og statiske metoder. Fra Java 9 kan den også have private konkrete metoder.

• Bemærk: Konkrete metoder er de metoder, som har deres fuldstændige definition, men de kan også tilsidesættes i den nedarvede klasse. Men hvis vi laver den konkrete metode som ENDELIG det kan ikke tilsidesættes i den nedarvede klasse, fordi at erklære en metode som endelig betyder - dens implementering er afsluttet .

• Endelige variabler: Variabler deklareret i en Java-grænseflade er som standard endelige. En abstrakt klasse kan indeholde ikke-endelige variabler.
• Typer af variabler: Abstrakt klasse kan have endelige, ikke-endelige, statiske og ikke-statiske variabler. Grænsefladen har kun statiske og endelige variabler.
• Implementering: Abstrakt klasse kan give implementeringen af ​​grænsefladen. Interface kan ikke levere implementeringen af ​​en abstrakt klasse.
• Arv vs abstraktion: En Java-grænseflade kan implementeres ved hjælp af nøgleordet redskaber og en abstrakt klasse kan udvides ved hjælp af nøgleordet strækker sig .
• Flere implementeringer: En grænseflade kan udvide en eller flere Java-grænseflader; en abstrakt klasse kan udvide en anden Java-klasse og implementere flere Java-grænseflader.
• Multipel arv: Multipel nedarvning kan delvist opnås ved brug af grænseflader, hvorimod det samme ikke kan gøres ved brug af abstrakte klasser. For i Java kan en klasse implementere flere grænseflader, men en klasse kan ikke strække sig fra flere andre klasser, fordi det bare ikke er muligt i java, da det ville føre til diamantproblemet.
• Tilgængelighed for datamedlemmer: Medlemmer (variabler) af en Java-grænseflade er endelige som standard. En abstrakt Java-klasse kan have klassemedlemmer som private, beskyttede osv.

Funktioner af abstrakt klasse: -

hej verden med java

En abstrakt klasse er en speciel type klasse i objektorienteret programmering, som ikke kan instansieres direkte. I stedet fungerer den som en plan eller skabelon for andre klasser, der kan udledes af. En abstrakt klasse:

1. Kan ikke instansieres : Abstrakte klasser kan ikke instantieres direkte, hvilket betyder, at du ikke kan oprette objekter af en abstrakt klasse.
2. Indeholder mindst én ren virtuel funktion : Abstrakte klasser skal indeholde mindst én ren virtuel funktion, hvilket betyder, at funktionen ikke har nogen implementering og skal implementeres af eventuelle afledte klasser.
3. Kan indeholde både abstrakte og ikke-abstrakte metoder : Abstrakte klasser kan have både abstrakte og ikke-abstrakte metoder. Ikke-abstrakte metoder har en komplet implementering og kan kaldes direkte.
4. Kan have konstruktører og destruktorer : Abstrakte klasser kan have konstruktører og destruktorer som enhver anden klasse.
5. Kan have medlemsvariabler : Abstrakte klasser kan have medlemsvariabler, som er variabler, der hører til et objekt i klassen.
6. Kan bruges som basisklasse : Abstrakte klasser kan bruges som basisklasse for andre klasser, hvilket betyder, at de kan nedarves af andre klasser.

Overordnet set bruges abstrakte klasser til at definere en fælles grænseflade eller adfærd, der kan deles af flere relaterede klasser, men med specifikke implementeringer i hver afledt klasse.

Eksempel 1: (For abstrakt klasse)

abstract class sunstar {    abstract void printInfo(); } class employee extends sunstar {  void printInfo()  {  String name = 'avinash';  int age = 21;  float salary = 222.2F;  System.out.println(name);  System.out.println(age);  System.out.println(salary);  } } class base {  public static void main(String args[])  {  sunstar s = new employee();  s.printInfo();  } }>

avinash 21 222.2>

Eksempel 2: (For abstrakt klasse)

// Java Program to Illustrate Concept of // Abstract Class // Importing required classes import java.io.*; // Class 1 // Helper abstract class abstract class Shape {  // Declare fields  String objectName = ' ';  // Constructor of this class  Shape(String name) { this.objectName = name; }  // Method  // Non-abstract methods  // Having as default implementation  public void moveTo(int x, int y)  {  System.out.println(this.objectName + ' '  + 'has been moved to'  + ' x = ' + x + ' and y = ' + y);  }  // Method 2  // Abstract methods which will be  // implemented by its subclass(es)  abstract public double area();  abstract public void draw(); } // Class 2 // Helper class extending Class 1 class Rectangle extends Shape {  // Attributes of rectangle  int length, width;  // Constructor  Rectangle(int length, int width, String name)  {  // Super keyword refers to current instance itself  super(name);  // this keyword refers to current instance itself  this.length = length;  this.width = width;  }  // Method 1  // To draw rectangle  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  // Method 2  // To compute rectangle area  @Override public double area()  {  // Length * Breadth  return (double)(length * width);  } } // Class 3 // Helper class extending Class 1 class Circle extends Shape {  // Attributes of a Circle  double pi = 3.14;  int radius;  // Constructor  Circle(int radius, String name)  {  // Super keyword refers to parent class  super(name);  // This keyword refers to current instance itself  this.radius = radius;  }  // Method 1  // To draw circle  @Override public void draw()  {  // Print statement  System.out.println('Circle has been drawn ');  }  // Method 2  // To compute circle area  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 4 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape class reference.  Shape rect = new Rectangle(2, 3, 'Rectangle');  System.out.println('Area of rectangle: '  + rect.area());  rect.moveTo(1, 2);  System.out.println(' ');  // Creating the Objects of circle class  Shape circle = new Circle(2, 'Circle');  System.out.println('Area of circle: '  + circle.area());  circle.moveTo(2, 4);  } }>

Area of rectangle: 6.0 Rectangle has been moved to x = 1 and y = 2 Area of circle: 12.56 Circle has been moved to x = 2 and y = 4>

Hvad hvis vi ikke har nogen fælles kode mellem rektangel og cirkel, så gå med grænsefladen.

Interface:

Funktioner af interface:

En grænseflade:

1. Definerer et sæt metoder og egenskaber: En grænseflade definerer et sæt metoder og egenskaber, der skal implementeres af enhver klasse eller struktur, der implementerer grænsefladen.
2. Giver en fælles protokol: Grænseflader giver en fælles protokol, der tillader forskellige softwarekomponenter at kommunikere med hinanden.
3. Understøtter polymorfi: En grænseflade kan bruges til at opnå polymorfi, hvilket betyder, at objekter af forskellige klasser kan behandles, som om de tilhører samme type, så længe de implementerer den samme grænseflade.
4. Muliggør adskillelse af bekymringer: Interfaces muliggør adskillelse af bekymringer, hvilket betyder, at forskellige dele af et softwaresystem kan udvikles uafhængigt af hinanden, så længe de overholder grænsefladespecifikationerne.
5. Forbedrer kodegenanvendelighed: Interfaces forbedrer kodegenanvendeligheden ved at tillade forskellige softwarekomponenter at genbruge den samme kodebase, så længe de implementerer den samme grænseflade.
6. Håndhæver designmønstre: Interfaces kan bruges til at håndhæve designmønstre, såsom Adapter-mønsteret, ved at kræve, at visse metoder eller egenskaber implementeres af de implementerende klasser.
7. Letter test: Grænseflader letter testning ved at tillade softwarekomponenter at blive testet uafhængigt af hinanden ved hjælp af falske objekter, der implementerer grænsefladen.

Eksempel 1: Til grænseflade

// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

Eksempel 2: For Interface

// Java Program to Illustrate Concept of Interface // Importing I/O classes import java.io.*; // Interface interface Shape {  // Abstract method  void draw();  double area(); } // Class 1 // Helper class class Rectangle implements Shape {  int length, width;  // constructor  Rectangle(int length, int width)  {  this.length = length;  this.width = width;  }  @Override public void draw()  {  System.out.println('Rectangle has been drawn ');  }  @Override public double area()  {  return (double)(length * width);  } } // Class 2 // Helper class class Circle implements Shape {  double pi = 3.14;  int radius;  // constructor  Circle(int radius) { this.radius = radius; }  @Override public void draw()  {  System.out.println('Circle has been drawn ');  }  @Override public double area()  {  return (double)((pi * radius * radius));  } } // Class 3 // Main class class GFG {  // Main driver method  public static void main(String[] args)  {  // Creating the Object of Rectangle class  // and using shape interface reference.  Shape rect = new Rectangle(2, 3);  System.out.println('Area of rectangle: '  + rect.area());  // Creating the Objects of circle class  Shape circle = new Circle(2);  System.out.println('Area of circle: '  + circle.area());  } }>

Area of rectangle: 6.0 Area of circle: 12.56>

Hvornår skal man bruge hvad?

Overvej at bruge abstrakte klasser, hvis nogen af ​​disse udsagn gælder for din situation:

• I Java-applikationen er der nogle relaterede klasser, der skal dele nogle kodelinjer, så kan du placere disse kodelinjer i den abstrakte klasse, og denne abstrakte klasse skal udvides med alle disse relaterede klasser.
• Du kan definere det eller de ikke-statiske eller ikke-endelige felter i abstraktklassen, så du via en metode kan få adgang til og ændre tilstanden for det objekt, som de tilhører.
• Du kan forvente, at de klasser, der udvider en abstrakt klasse, har mange almindelige metoder eller felter eller kræver andre adgangsmodifikatorer end offentlige (såsom beskyttet og privat).

Overvej at bruge grænseflader, hvis nogen af ​​disse udsagn gælder for din situation:

• Det er en total abstraktion, alle metoder, der er erklæret i en grænseflade, skal implementeres af den eller de klasse(r), der implementerer denne grænseflade.
• En klasse kan implementere mere end én grænseflade. Det kaldes multiple arv.
• Du ønsker at angive adfærden for en bestemt datatype, men er ikke bekymret over, hvem der implementerer dens adfærd.