Abstraktia luokkaa ja käyttöliittymää käytetään molempien sopimusten määrittämiseen olioohjelmoinnissa, mutta niiden välillä on joitain keskeisiä eroja.

Ero abstraktin luokan ja käyttöliittymän välillä: -

Määritelmä: Abstrakti luokka on luokka, jota ei voi ilmentää ja joka voi sisältää sekä abstrakteja että ei-abstrakteja menetelmiä. Toisaalta rajapinta on sopimus, joka määrittelee joukon menetelmiä, jotka luokan on toteutettava.

Metodin toteutus: Abstraktissa luokassa jotkin menetelmät voidaan toteuttaa, kun taas toiset jätetään abstraktiksi, mikä tarkoittaa, että niillä ei ole toteutusta ja ne on ohitettava konkreettisilla alaluokilla. Sitä vastoin kaikki rajapinnan menetelmät ovat oletusarvoisesti abstrakteja, ja minkä tahansa liittymän toteuttavan luokan on toteutettava ne.

Periytys: Luokka voi periä vain yhdestä abstraktista luokasta, mutta se voi toteuttaa useita rajapintoja. Tämä johtuu siitä, että abstrakti luokka edustaa objektityyppiä, kun taas käyttöliittymä edustaa joukkoa käyttäytymistä.

Pääsyn muokkaajat: Abstrakteilla luokilla voi olla menetelmien ja ominaisuuksien käyttöoikeusmuutoksia, kuten julkinen, suojattu ja yksityinen, kun taas rajapinnoilla voi olla vain julkinen käyttöoikeus.

Muuttujat: Abstraktissa luokassa voi olla jäsenmuuttujia, kun taas käyttöliittymässä ei.

Yhteenvetona voidaan todeta, että abstrakteja luokkia käytetään antamaan perusluokka konkreettisille alaluokille, joista ne voidaan periä, kun taas rajapintoja käytetään määrittämään joukko menetelmiä, jotka luokan on toteutettava. Abstrakteilla luokilla voi olla toteutettuja ja abstrakteja menetelmiä, kun taas rajapinnoissa voi olla vain abstrakteja menetelmiä. Luokat voivat periä vain yhdestä abstraktista luokasta, mutta ne voivat toteuttaa useita rajapintoja.

Kuten tiedämme, abstraktiolla tarkoitetaan ominaisuuden sisäisen toteutuksen piilottamista ja vain toiminnallisuuden näyttämistä käyttäjille. eli näytetään vain vaaditut ominaisuudet ja piilotetaan, kuinka nämä ominaisuudet toteutetaan kulissien takana. Käyttöliittymä on toinen tapa saavuttaa abstraktio Javassa. Molemmat abstrakti luokka ja käyttöliittymä käytetään abstraktion, vastedes Interface ja Abstract Class ovat edellytyksiä.

java char kokonaisluvuksi

Abstrakti luokka vs. käyttöliittymä

• Menetelmien tyyppi: Käyttöliittymässä voi olla vain abstrakteja menetelmiä. Abstraktilla luokalla voi taas olla abstrakti menetelmä ja konkreettiset menetelmät. Java 8:sta lähtien sillä voi olla myös oletus- ja staattiset menetelmät. Java 9:stä lähtien sillä voi olla myös yksityisiä konkreettisia menetelmiä.

• Huomautus: Konkreettiset menetelmät ovat niitä menetelmiä, joilla on täydellinen määritelmä, mutta ne voidaan myös ohittaa perityssä luokassa. Jos kuitenkin teemme konkreettisen menetelmän kuten LOPULLINEN sitä ei voi ohittaa perityssä luokassa, koska metodin ilmoittaminen lopulliseksi keinoksi - sen täytäntöönpano on valmis .

• Lopulliset muuttujat: Java-rajapinnassa ilmoitetut muuttujat ovat oletuksena lopullisia. Abstrakti luokka voi sisältää ei-lopullisia muuttujia.
• Muuttujien tyyppi: Abstraktilla luokalla voi olla lopullisia, ei-lopullisia, staattisia ja ei-staattisia muuttujia. Käyttöliittymässä on vain staattiset ja lopulliset muuttujat.
• Toteutus: Abstrakti luokka voi tarjota käyttöliittymän toteuttamisen. Käyttöliittymä ei voi tarjota abstraktin luokan toteutusta.
• Perintö vs abstraktio: Java-rajapinta voidaan toteuttaa avainsanalla toteuttaa ja abstraktia luokkaa voidaan laajentaa avainsanalla ulottuu .
• Useita toteutuksia: Käyttöliittymä voi laajentaa yhtä tai useampaa Java-rajapintaa; abstrakti luokka voi laajentaa toista Java-luokkaa ja toteuttaa useita Java-rajapintoja.
• Moniperintö: Monikertainen periytyminen voidaan saavuttaa osittain käyttämällä rajapintoja, kun taas samaa ei voida tehdä käyttämällä abstrakteja luokkia. Koska Javassa yksi luokka voi toteuttaa useita käyttöliittymiä, mutta yksi luokka ei voi ulottua useista muista luokista, koska se ei vain ole mahdollista Javassa, koska se johtaisi timanttiongelmaan.
• Tietojen jäsenten saavutettavuus: Java-rajapinnan jäsenet (muuttujat) ovat oletuksena lopullisia. Abstraktissa Java-luokassa voi olla luokan jäseniä, kuten yksityinen, suojattu jne.

Abstraktin luokan ominaisuudet: -

Abstrakti luokka on olioohjelmoinnin erityinen luokka, jota ei voi ilmentää suoraan. Sen sijaan se toimii suunnitelmana tai mallina muille luokille, joista johdetaan. Abstrakti luokka:

1. Ei voida instantoida : Abstrakteja luokkia ei voi ilmentää suoraan, mikä tarkoittaa, että et voi luoda abstraktin luokan objekteja.
2. Sisältää vähintään yhden puhtaan virtuaalisen toiminnon : Abstraktien luokkien on sisällettävä vähintään yksi puhdas virtuaalinen funktio, mikä tarkoittaa, että funktiolla ei ole toteutusta ja se on toteutettava millä tahansa johdetuilla luokilla.
3. Voi sisältää sekä abstrakteja että ei-abstrakteja menetelmiä : Abstrakteilla luokilla voi olla sekä abstrakteja että ei-abstrakteja menetelmiä. Ei-abstrakteilla menetelmillä on täydellinen toteutus ja niitä voidaan kutsua suoraan.
4. Voi olla rakentajia ja tuhoajia : Abstrakteilla luokilla voi olla rakentajia ja tuhoajia, kuten kaikilla muillakin luokilla.
5. Voi sisältää jäsenmuuttujia : Abstrakteissa luokissa voi olla jäsenmuuttujia, jotka ovat muuttujia, jotka kuuluvat luokan objektiin.
6. Voidaan käyttää perusluokkana : Abstrakteja luokkia voidaan käyttää muiden luokkien perusluokkana, mikä tarkoittaa, että muut luokat voivat periä ne.

Kaiken kaikkiaan abstrakteja luokkia käytetään määrittelemään yhteinen käyttöliittymä tai käyttäytyminen, joka voidaan jakaa useiden toisiinsa liittyvien luokkien kanssa, mutta jokaisessa johdetussa luokassa on tietyt toteutukset.

Esimerkki 1 : (Abstract Class )

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>

Esimerkki 2 : (Abstract Class )

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

Entä jos meillä ei ole yhteistä koodia suorakulmion ja ympyrän välillä, siirry sitten käyttöliittymään.

Käyttöliittymä:

Käyttöliittymän ominaisuudet:

Käyttöliittymä:

1. Määrittää joukon menetelmiä ja ominaisuuksia: Liitäntä määrittelee joukon menetelmiä ja ominaisuuksia, jotka on toteutettava minkä tahansa luokan tai rakenteen kanssa, joka toteuttaa rajapinnan.
2. Tarjoaa yhteisen protokollan: Liitännät tarjoavat yhteisen protokollan, jonka avulla eri ohjelmistokomponentit voivat kommunikoida keskenään.
3. Tukee polymorfismia: Liitännällä voidaan saavuttaa polymorfismi, mikä tarkoittaa, että eri luokkiin kuuluvia objekteja voidaan käsitellä ikään kuin ne kuuluisivat samaan tyyppiin, kunhan ne toteuttavat saman rajapinnan.
4. Mahdollistaa huolenaiheiden erottamisen: Liitännät mahdollistavat huolenaiheiden erottamisen, mikä tarkoittaa, että ohjelmistojärjestelmän eri osia voidaan kehittää toisistaan ​​riippumatta, kunhan ne noudattavat rajapintamäärityksiä.
5. Parantaa koodin uudelleenkäytettävyyttä: Liitännät parantavat koodin uudelleenkäytettävyyttä sallimalla eri ohjelmistokomponenttien käyttää samaa koodipohjaa uudelleen, kunhan ne toteuttavat saman rajapinnan.
6. Vahvistaa suunnittelumalleja: Liitäntöjä voidaan käyttää toteuttamaan suunnittelumalleja, kuten sovitinkuviota, edellyttäen, että toteutusluokat toteuttavat tietyt menetelmät tai ominaisuudet.
7. Helpottaa testausta: Liitännät helpottavat testausta sallimalla ohjelmistokomponenttien testauksen toisistaan ​​riippumatta käyttämällä rajapinnan toteuttavia valeobjekteja.

Esimerkki 1: Liitännälle

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

Esimerkki 2: Liitännälle

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

Milloin käyttää mitä?

elokuvanäyttelijä Kajal

Harkitse abstraktien luokkien käyttöä, jos jokin seuraavista väitteistä koskee tilannettasi:

• Java-sovelluksessa on joitain toisiinsa liittyviä luokkia, joiden on jaettava joitain koodirivejä, jolloin voit laittaa nämä koodirivit abstraktiin luokkaan ja tätä abstraktia luokkaa tulisi laajentaa kaikilla näillä liittyvillä luokilla.
• Voit määrittää ei-staattiset tai ei-lopulliset kentät abstraktissa luokassa niin, että voit käyttää ja muokata sen kohteen tilaa menetelmän kautta, johon ne kuuluvat.
• Voit odottaa, että luokilla, jotka laajentavat abstraktia luokkaa, on monia yhteisiä menetelmiä tai kenttiä tai ne vaativat muita kuin julkisia käyttöoikeusmuutoksia (kuten suojattu ja yksityinen).

Harkitse käyttöliittymien käyttöä, jos jokin seuraavista väitteistä koskee tilannettasi:

• Se on täydellinen abstraktio, kaikki rajapinnassa ilmoitetut menetelmät on toteutettava tämän rajapinnan toteuttavien luokkien toimesta.
• Luokka voi toteuttaa useamman kuin yhden käyttöliittymän. Sitä kutsutaan moniperinnöiksi.
• Haluat määrittää tietyn tietotyypin toiminnan, mutta et ole kiinnostunut siitä, kuka sen toiminnan toteuttaa.