Abstrakt klasse og grensesnitt brukes begge til å definere kontrakter i objektorientert programmering, men det er noen viktige forskjeller mellom dem.

Forskjellen mellom abstrakt klasse og grensesnitt: -

Definisjon: En abstrakt klasse er en klasse som ikke kan instansieres og kan inneholde både abstrakte og ikke-abstrakte metoder. Et grensesnitt er derimot en kontrakt som spesifiserer et sett med metoder som en klasse må implementere.

Metodeimplementering: I en abstrakt klasse kan noen metoder implementeres, mens andre etterlates abstrakte, noe som betyr at de ikke har noen implementering og må overstyres av konkrete underklasser. Derimot er alle metoder i et grensesnitt som standard abstrakte og må implementeres av enhver klasse som implementerer grensesnittet.

Arv: En klasse kan arve fra bare én abstrakt klasse, men den kan implementere flere grensesnitt. Dette er fordi en abstrakt klasse representerer en type objekt, mens et grensesnitt representerer et sett med atferd.

Tilgangsmodifikatorer: Abstrakte klasser kan ha tilgangsmodifikatorer som offentlig, beskyttet og privat for sine metoder og egenskaper, mens grensesnitt bare kan ha offentlig tilgang.

Variabler: En abstrakt klasse kan ha medlemsvariabler, mens et grensesnitt ikke kan.

Oppsummert brukes abstrakte klasser for å gi en basisklasse for konkrete underklasser å arve fra, mens grensesnitt brukes til å definere et sett med metoder som en klasse må implementere. Abstrakte klasser kan ha implementerte og abstrakte metoder, mens grensesnitt bare kan ha abstrakte metoder. Klasser kan arve fra bare én abstrakt klasse, men kan implementere flere grensesnitt.

Som vi vet refererer abstraksjon til å skjule den interne implementeringen av funksjonen og bare vise funksjonaliteten til brukerne. dvs. viser bare de nødvendige funksjonene, og skjuler hvordan disse funksjonene implementeres bak scenen. Mens et grensesnitt er en annen måte å oppnå abstraksjon i java. Både abstrakt klasse og grensesnitt brukes til abstraksjon, heretter er grensesnitt og abstrakt klasse obligatoriske forutsetninger.

Abstrakt klasse vs grensesnitt

• Type metoder: Grensesnitt kan bare ha abstrakte metoder. Mens en abstrakt klasse kan ha abstrakt metode og konkrete metoder. Fra Java 8 kan den også ha standard og statiske metoder. Fra Java 9 kan den også ha private konkrete metoder.

• Merk: Konkrete metoder er de metodene som har sin fullstendige definisjon, men de kan også overstyres i den arvede klassen. Men hvis vi gjør den konkrete metoden som ENDELIG den kan ikke overstyres i den arvede klassen fordi å erklære en metode som endelig betyr - implementeringen er fullført .

• Endelige variabler: Variabler deklarert i et Java-grensesnitt er som standard endelige. En abstrakt klasse kan inneholde ikke-endelige variabler.
• Type variabler: Abstrakt klasse kan ha endelige, ikke-finale, statiske og ikke-statiske variabler. Grensesnittet har kun statiske og endelige variabler.
• Gjennomføring: Abstrakt klasse kan gi implementeringen av grensesnittet. Grensesnitt kan ikke gi implementering av en abstrakt klasse.
• Arv vs abstraksjon: Et Java-grensesnitt kan implementeres ved å bruke nøkkelordet redskaper og en abstrakt klasse kan utvides ved å bruke nøkkelordet strekker .
• Flere implementeringer: Et grensesnitt kan utvide ett eller flere Java-grensesnitt; en abstrakt klasse kan utvide en annen Java-klasse og implementere flere Java-grensesnitt.
• Multippel arv: Multippel arv kan delvis oppnås ved bruk av grensesnitt, mens det samme ikke kan gjøres ved bruk av abstrakte klasser. Fordi i Java kan en klasse implementere flere grensesnitt, men en klasse kan ikke strekke seg fra flere andre klasser fordi det bare ikke er mulig i java, da det ville føre til diamantproblemet.
• Tilgjengelighet for datamedlemmer: Medlemmer (variabler) av et Java-grensesnitt er endelige som standard. En abstrakt Java-klasse kan ha klassemedlemmer som private, beskyttede osv.

Funksjoner av abstrakt klasse: -

hei verden med java

En abstrakt klasse er en spesiell type klasse i objektorientert programmering som ikke kan instansieres direkte. I stedet fungerer den som en blåkopi eller mal for andre klasser som kan avledes fra. En abstrakt klasse:

1. Kan ikke instansieres : Abstrakte klasser kan ikke instansieres direkte, noe som betyr at du ikke kan lage objekter av en abstrakt klasse.
2. Inneholder minst én ren virtuell funksjon : Abstrakte klasser må inneholde minst én ren virtuell funksjon, noe som betyr at funksjonen ikke har noen implementering og må implementeres av eventuelle avledede klasser.
3. Kan inneholde både abstrakte og ikke-abstrakte metoder : Abstrakte klasser kan ha både abstrakte og ikke-abstrakte metoder. Ikke-abstrakte metoder har en fullstendig implementering og kan kalles direkte.
4. Kan ha konstruktører og destruktorer : Abstrakte klasser kan ha konstruktører og destruktorer som alle andre klasser.
5. Kan ha medlemsvariabler : Abstrakte klasser kan ha medlemsvariabler, som er variabler som tilhører et objekt i klassen.
6. Kan brukes som basisklasse : Abstrakte klasser kan brukes som basisklasse for andre klasser, noe som betyr at de kan arves av andre klasser.

Totalt sett brukes abstrakte klasser til å definere et felles grensesnitt eller atferd som kan deles av flere relaterte klasser, men med spesifikke implementeringer i hver avledet 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>

Hva om vi ikke har noen felles kode mellom rektangel og sirkel, så gå med grensesnittet.

Grensesnitt:

Funksjoner i grensesnittet:

Et grensesnitt:

1. Definerer et sett med metoder og egenskaper: Et grensesnitt definerer et sett med metoder og egenskaper som må implementeres av enhver klasse eller struktur som implementerer grensesnittet.
2. Gir en felles protokoll: Grensesnitt gir en felles protokoll som lar ulike programvarekomponenter kommunisere med hverandre.
3. Støtter polymorfisme: Et grensesnitt kan brukes for å oppnå polymorfisme, som betyr at objekter av forskjellige klasser kan behandles som om de tilhører samme type, så lenge de implementerer samme grensesnitt.
4. Gjør det mulig å separere bekymringer: Grensesnitt muliggjør separasjon av bekymringer, noe som betyr at ulike deler av et programvaresystem kan utvikles uavhengig av hverandre, så lenge de overholder grensesnittspesifikasjonene.
5. Forbedrer kodegjenbrukbarhet: Grensesnitt forbedrer kodegjenbrukbarheten ved å la ulike programvarekomponenter gjenbruke den samme kodebasen, så lenge de implementerer det samme grensesnittet.
6. Håndhever designmønstre: Grensesnitt kan brukes til å håndheve designmønstre, for eksempel adaptermønsteret, ved å kreve at visse metoder eller egenskaper implementeres av implementeringsklassene.
7. Forenkler testing: Grensesnitt forenkler testing ved å tillate at programvarekomponenter testes uavhengig av hverandre, ved å bruke falske objekter som implementerer grensesnittet.

Eksempel 1: For grensesnitt

// 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 grensesnitt

// 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>

Når skal man bruke hva?

Vurder å bruke abstrakte klasser hvis noen av disse utsagnene gjelder for din situasjon:

• I Java-applikasjonen er det noen relaterte klasser som trenger å dele noen kodelinjer, så kan du legge disse kodelinjene i abstraktklassen og denne abstrakte klassen bør utvides med alle disse relaterte klassene.
• Du kan definere ikke-statiske eller ikke-endelige felt(er) i abstraktklassen slik at du via en metode kan få tilgang til og endre tilstanden til objektet de tilhører.
• Du kan forvente at klassene som utvider en abstrakt klasse har mange vanlige metoder eller felt, eller krever andre tilgangsmodifikatorer enn offentlige (som beskyttet og privat).

Vurder å bruke grensesnitt hvis noen av disse utsagnene gjelder for din situasjon:

• Det er en total abstraksjon, alle metoder som er deklarert i et grensesnitt må implementeres av klassen(e) som implementerer dette grensesnittet.
• En klasse kan implementere mer enn ett grensesnitt. Det kalles multiple arv.
• Du vil spesifisere atferden til en bestemt datatype, men er ikke bekymret for hvem som implementerer dens oppførsel.