Zarówno klasa abstrakcyjna, jak i interfejs są używane do definiowania kontraktów w programowaniu obiektowym, ale istnieją między nimi pewne kluczowe różnice.

Różnica między klasą abstrakcyjną a interfejsem: -

Definicja: Klasa abstrakcyjna to klasa, której nie można utworzyć instancji i która może zawierać zarówno metody abstrakcyjne, jak i nieabstrakcyjne. Z drugiej strony interfejs to kontrakt określający zestaw metod, które klasa musi zaimplementować.

Implementacja metod: W klasie abstrakcyjnej niektóre metody można zaimplementować, podczas gdy inne pozostają abstrakcyjne, co oznacza, że ​​nie mają implementacji i muszą zostać zastąpione konkretnymi podklasami. Natomiast wszystkie metody w interfejsie są domyślnie abstrakcyjne i muszą zostać zaimplementowane przez dowolną klasę, która implementuje interfejs.

mysql pokaż użytkownikom

Dziedziczenie: Klasa może dziedziczyć tylko z jednej klasy abstrakcyjnej, ale może implementować wiele interfejsów. Dzieje się tak, ponieważ klasa abstrakcyjna reprezentuje typ obiektu, podczas gdy interfejs reprezentuje zestaw zachowań.

Modyfikatory dostępu: Klasy abstrakcyjne mogą mieć modyfikatory dostępu, takie jak publiczny, chroniony i prywatny dla swoich metod i właściwości, podczas gdy interfejsy mogą mieć dostęp tylko publiczny.

narzędzie do wycinania w Ubuntu

Zmienne: Klasa abstrakcyjna może zawierać zmienne składowe, natomiast interfejs nie.

Podsumowując, klasy abstrakcyjne służą do zapewnienia klasy bazowej, z której mogą dziedziczyć konkretne podklasy, podczas gdy interfejsy służą do definiowania zestawu metod, które klasa musi implementować. Klasy abstrakcyjne mogą mieć metody zaimplementowane i abstrakcyjne, podczas gdy interfejsy mogą mieć tylko metody abstrakcyjne. Klasy mogą dziedziczyć tylko z jednej klasy abstrakcyjnej, ale mogą implementować wiele interfejsów.

Jak wiemy, abstrakcja odnosi się do ukrywania wewnętrznej implementacji funkcji i pokazywania jej użytkownikom jedynie. tj. pokazywanie tylko wymaganych funkcji i ukrywanie sposobu, w jaki te funkcje są implementowane za sceną. Natomiast interfejs to kolejny sposób na osiągnięcie abstrakcji w Javie. Obydwa klasa abstrakcyjna I interfejs są używane do abstrakcji, odtąd interfejs i klasa abstrakcyjna są wymaganymi warunkami wstępnymi.

Klasa abstrakcyjna a interfejs

• Rodzaj metod: Interfejs może posiadać wyłącznie metody abstrakcyjne. Natomiast klasa abstrakcyjna może mieć metodę abstrakcyjną i metody konkretne. Od wersji Java 8 może mieć również metody domyślne i statyczne. Od wersji Java 9 może mieć również prywatne metody konkretne.

• Uwaga: Metody konkretne to te metody, które mają pełną definicję, ale można je również zastąpić w klasie dziedziczonej. Jeśli jednak zastosujemy metodę konkretną jako FINAŁ nie można jej przesłonić w klasie dziedziczonej, ponieważ zadeklarowanie metody jako ostatecznej oznacza – jego realizacja została zakończona .

• Zmienne końcowe: Zmienne zadeklarowane w interfejsie Java są domyślnie finalne. Klasa abstrakcyjna może zawierać zmienne inne niż końcowe.
• Typ zmiennych: Klasa abstrakcyjna może mieć zmienne końcowe, niekońcowe, statyczne i niestatyczne. Interfejs zawiera tylko zmienne statyczne i końcowe.
• Realizacja: Klasa abstrakcyjna może zapewnić implementację interfejsu. Interfejs nie może zapewnić implementacji klasy abstrakcyjnej.
• Dziedziczenie a abstrakcja: Interfejs Java można zaimplementować za pomocą słowa kluczowego przybory a klasę abstrakcyjną można rozszerzyć za pomocą słowa kluczowego rozciąga się .
• Wiele implementacji: Interfejs może rozszerzać jeden lub więcej interfejsów Java; klasa abstrakcyjna może rozszerzać inną klasę Java i implementować wiele interfejsów Java.
• Dziedziczenie wielokrotne: Dziedziczenie wielokrotne można częściowo osiągnąć za pomocą interfejsów, podczas gdy tego samego nie da się osiągnąć za pomocą klas abstrakcyjnych. Ponieważ w Javie jedna klasa może implementować wiele interfejsów, ale jedna klasa nie może rozciągać się od wielu innych klas, ponieważ w Javie nie jest to możliwe, ponieważ prowadziłoby to do problemu z diamentem.
• Dostępność członków danych: Domyślnie elementy (zmienne) interfejsu Java są ostateczne. Klasa abstrakcyjna Java może mieć członków klasy, takich jak private,protected itp.

Cechy klasy abstrakcyjnej: -

Klasa abstrakcyjna to specjalny typ klasy w programowaniu obiektowym, którego instancji nie można bezpośrednio utworzyć. Zamiast tego służy jako plan lub szablon, z którego można wyprowadzić inne klasy. Klasa abstrakcyjna:

1. Nie można utworzyć instancji : Nie można bezpośrednio tworzyć instancji klas abstrakcyjnych, co oznacza, że ​​nie można tworzyć obiektów klasy abstrakcyjnej.
2. Zawiera co najmniej jedną czystą funkcję wirtualną : Klasy abstrakcyjne muszą zawierać co najmniej jedną czystą funkcję wirtualną, co oznacza, że ​​funkcja ta nie ma implementacji i musi być implementowana przez dowolne klasy pochodne.
3. Może zawierać zarówno metody abstrakcyjne, jak i nieabstrakcyjne : Klasy abstrakcyjne mogą mieć zarówno metody abstrakcyjne, jak i nieabstrakcyjne. Metody nieabstrakcyjne mają kompletną implementację i można je wywoływać bezpośrednio.
4. Może mieć konstruktory i destruktory : Klasy abstrakcyjne mogą mieć konstruktory i destruktory, jak każda inna klasa.
5. Może mieć zmienne członkowskie : Klasy abstrakcyjne mogą mieć zmienne składowe, które są zmiennymi należącymi do obiektu klasy.
6. Może być używany jako klasa bazowa : Klasy abstrakcyjne mogą służyć jako klasy bazowe dla innych klas, co oznacza, że ​​mogą być dziedziczone przez inne klasy.

Ogólnie rzecz biorąc, klasy abstrakcyjne służą do definiowania wspólnego interfejsu lub zachowania, które może być współużytkowane przez wiele powiązanych klas, ale z określonymi implementacjami w każdej klasie pochodnej.

algorytm „bankiera”

Przykład 1: (dla klasy abstrakcyjnej)

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>

Przykład 2: (dla klasy abstrakcyjnej)

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

A jeśli nie mamy żadnego wspólnego kodu pomiędzy prostokątem i okręgiem, to przejdźmy do interfejsu.

Interfejs:

Funkcje interfejsu:

Interfejs:

1. Definiuje zestaw metod i właściwości: Interfejs definiuje zestaw metod i właściwości, które muszą być zaimplementowane przez dowolną klasę lub strukturę implementującą interfejs.
2. Zapewnia wspólny protokół: Interfejsy zapewniają wspólny protokół, który umożliwia komunikację między różnymi składnikami oprogramowania.
3. Obsługuje polimorfizm: Interfejs może służyć do osiągnięcia polimorfizmu, co oznacza, że ​​obiekty różnych klas mogą być traktowane tak, jakby należały do ​​tego samego typu, o ile implementują ten sam interfejs.
4. Umożliwia oddzielenie obaw: Interfejsy umożliwiają rozdzielenie zagadnień, co oznacza, że ​​różne części systemu oprogramowania mogą być tworzone niezależnie od siebie, o ile są zgodne ze specyfikacjami interfejsu.
5. Poprawia możliwość ponownego użycia kodu: Interfejsy poprawiają możliwość ponownego wykorzystania kodu, umożliwiając różnym komponentom oprogramowania ponowne wykorzystanie tej samej bazy kodu, o ile implementują ten sam interfejs.
6. Egzekwuje wzorce projektowe: Interfejsów można używać do wymuszania wzorców projektowych, takich jak wzorzec Adapter, poprzez wymaganie implementacji określonych metod lub właściwości przez klasy implementujące.
7. Ułatwia testowanie: Interfejsy ułatwiają testowanie, umożliwiając niezależne testowanie komponentów oprogramowania przy użyciu próbnych obiektów implementujących interfejs.

Przykład 1: Dla interfejsu

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

Przykład 2: Dla interfejsu

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

Kiedy czego używać?

lista tablic sortowania Java

Rozważ użycie klas abstrakcyjnych, jeśli którekolwiek z poniższych stwierdzeń ma zastosowanie w Twojej sytuacji:

• W aplikacji Java istnieje kilka powiązanych klas, które muszą współdzielić kilka linii kodu. Można je umieścić w klasie abstrakcyjnej i ta klasa abstrakcyjna powinna zostać rozszerzona o wszystkie powiązane klasy.
• Możesz zdefiniować niestatyczne lub niekońcowe pola w klasie abstrakcyjnej, dzięki czemu za pomocą metody będziesz mógł uzyskać dostęp do stanu obiektu, do którego one należą, i modyfikować go.
• Można się spodziewać, że klasy rozszerzające klasę abstrakcyjną mają wiele wspólnych metod lub pól albo wymagają modyfikatorów dostępu innych niż publiczne (takich jak chronione i prywatne).

Rozważ użycie interfejsów, jeśli którekolwiek z poniższych stwierdzeń ma zastosowanie w Twojej sytuacji:

• Jest to całkowita abstrakcja, wszystkie metody zadeklarowane w interfejsie muszą zostać zaimplementowane przez klasę(y), która implementuje ten interfejs.
• Klasa może implementować więcej niż jeden interfejs. Nazywa się to dziedziczeniem wielokrotnym.
• Chcesz określić zachowanie określonego typu danych, ale nie interesuje Cię, kto implementuje jego zachowanie.