Forskellen mellem abstrakt klasse og grænseflade

class

Før vi begynder med forskellene mellem en abstrakt klasse og grænseflade i java, er det vigtigt at forstå betydningen af begrebet abstraktion. Abstraktion vedrører at skjule de interne implementeringsspecifikke træk ved objekter og fremvise kun funktionaliteten for brugerne. Abstrakt klasse og interface bruges begge med henblik på abstraktion. Et vigtigt og ofte stillet interviewspørgsmål, forskellen mellem interface og abstrakt klasse udgør en kernekomponent i java-programmeringssproget. Så hvis du som Java-programmør har spekuleret på, om du skulle vælge abstrakt klasse eller interface, så er det følgende noget for dig.

Grænseflade vs abstrakt klasse

Forskellene mellem abstrakt klasse og grænseflade er som følger:

Abstrakt klasse	Grænseflade
På ethvert givet tidspunkt er en abstrakt klasse kun i stand til at udvide én klasse eller en enkelt abstrakt klasse.	En grænseflade er designet til at udvide flere grænseflader på ethvert givet tidspunkt.
Abstrakte klasser er i stand til at udvide andre konkrete (almindelige) klasser og/eller abstrakte klasser.	Interfaces er kun i stand til at udvide andre grænseflader.
En abstrakt klasse omfatter både konkrete og abstrakte metoder.	Kun abstrakte metoder er til stede i en grænseflade.
Søgeordet "abstrakt" bruges til at erklære enhver metode som en abstrakt metode. Det er obligatorisk.	Søgeordet "abstrakt" er ikke obligatorisk med det formål at erklære abstrakte metoder.
En abstrakt klasse kan bestå af både beskyttede og offentlige abstrakte metoder.	Grænseflader i java består kun af offentlige abstrakte metoder.
Abstrakte klasser er i stand til at have endelige, statiske, endelige og/eller statiske finalvariabler ved brug af adgangsspecifikationer.	Kun offentlige statiske slutvariabler er mulige med grænseflader i java.
Nøgleordet 'abstrakt' bruges både til at definere en abstrakt klasse og metode.	Nøgleordet 'interface' bruges kun til at definere en grænseflade. Det kan ikke bruges til metodedeklaration.
Nøgleordet 'extends' bruges af en underklasse til at udvide en abstrakt klasse. Implementering af alle erklærede metoder, der findes i den abstrakte klasse, skal tilvejebringes, hvis underklassen ikke er en abstrakt klasse.	Nøgleordet 'implementer' bruges af en underklasse til implementering af en grænseflade. Alle metoder, der findes i grænsefladen, skal være forsynet med korrekt implementering for at koden kan kompileres.
Abstrakte klasser kan have metoder til implementering.	Java-grænseflader tilbyder absolut abstraktion. Det er ikke muligt at have metodeimplementeringer i dem.
Abstrakte klasser har konstruktører.	Grænseflader har ikke konstruktører.
Abstrakt klasse indeholder funktionerne i enhver normal java-klasse, men disse funktioner kan ikke instansieres.	Grænseflader består af en anden type og består af offentlige statiske slutmetodedeklarationer og konstanter.
Abstrakt klasse kan fås til at køre, hvis de indeholder themain()-metoden.	En grænseflade kan ikke fås til at køre, da den ikke indeholder hovedmetodeimplementeringen.
En abstrakt klasse definerer også kontrakt sammen med at give andre metodeimplementeringer til brug af underklasser.	Interface i java bruges til at definere kontrakten for underklasser.
Abstrakte klasser kan bestå af ikke-finalevariabler.	Variabler deklareret i enhver Java-grænseflade er som standardfinale.
Abstrakte klasser er hurtigere end grænseflader i Java.	Java-grænseflader er langsommere end abstrakte klasser, da de kræver ekstra indirekte.

Abstrakt klasse i Java

Abstract klasse i Java tjener til at ligne interface med den undtagelse, at den kan bruges til at indeholde standardmetodeimplementering.

Abstrakte klasser kan indeholde den abstrakte metode uden at have en krop; også kan de indeholde metoder sammen med implementering.
Nøgleordet 'abstrakt' bruges til at skabe en abstrakt klasse og/eller metode.
Det er ikke muligt at starte en abstrakt klasse i Java.
Den abstrakte klasse bruges generelt til at give en base for en underklasse til at implementere og udvide og implementere abstrakte metoder. Det bruges også til at tilsidesætte/bruge de implementerede metoder i en given abstrakt klasse.
Hvis en klasse indeholder abstrakte metoder, så skal den defineres som abstrakt ved at bruge nøgleordet 'abstrakt'; ellers vil den ikke kunne kompilere.
Det er valgfrit at have en abstrakt klasse for at en klasse skal indeholde den abstrakte metode. En klasse er i stand til at blive markeret som abstrakt, selvom den ikke erklærer abstrakte metoder.
Da Java ikke understøtter multiple class nedarvning, er det at foretrække at bruge grænsefladen, hvis der ikke er nogen metodeimplementering i den abstrakte klasse.
I Java-koder skal underklassen af enhver abstrakt klasse implementere alle abstrakte metoder, medmindre den specifikke underklasse tilfældigvis også er en abstrakt klasse.
Abstrakte klasser i Java kan køres som alle andre klasser, hvis de har main()-metoden.
Java Abstract class leverer fælles metodeimplementeringer for underklasser for at give standardimplementering.
Java abstrakte klasser kan implementere grænseflader selv uden levering/implementering af grænseflademetoder.

Eksempel på Java abstrakt klasseprogram

For begyndere

//Simple program for Abstract Class

//Abstract Class of the program
abstract class Employee {
    public void get(){
        System.out.println("I am a employee");
    }
}

//Admin Class extends the features of Employee Class
class Admin extends Employee {
    //Admin Class Method
}

//Admin Engineers extends the features of Employee Class
class Engineers extends Employee {
    //Engineers class method
}

//Main Class of the program
public class Main{
    //Main method of the program
    public static void main(String []args) {
        //Creating the an object for Admin Class
        Admin a1 = new Admin();
        //Creating the an object for Engineer Class
        Engineers e1 = new Engineers();
        //Calling Abstract Class method using Admin Class object
        a1.get();
        //Calling Abstract Class method using Engineers Class object
        e1.get();
    }
}

OUTPUT

I am a employee                                                                                                                
I am a employee

For øvede

//Example for abstract class in java

//importing the Scanner class of util package
import java.util.Scanner;

//Abstract Class of the program
abstract class BankName{
    //Abstract method of the Abstract Class
    abstract int getRateofInterest();
}

//BOI CLASS extends the abstract class of the program
class BOI extends BankName{
    //Implementation of the abstract method of the abstract method
    int getRateofInterest(){
        //returning the rate of interest
        return 6;
    }
}

//BOI CLASS extends the abstract class of the program
class PNB extends BankName{
    //Implementation of the abstract method of the abstract method
    int getRateofInterest(){
        //returning the rate of interest
        return 7;
    }
}
//kodek CLASS extends the abstract class of the program
class kodek extends BankName{
    //Implementation of the abstract method of the abstract method
    int getRateofInterest(){
        //returning the rate of interest
        return 8;
    }
}
//Main Class of the program
public class Main{
    //Main Method of the program
    public static void main (String[] args) {
        //Creating a object for Scanner Class
        Scanner input = new Scanner(System.in);
        System.out.println("Enter the Principal Amount : ");
        //Taking Principal Amount value from user
        float principalAmount = input.nextFloat();
        System.out.println("Enter the time period (in years) : ");
        //Taking Time Period value from user
        float timePeriod = input.nextFloat();

        BankName x;
        //Creating the object for BOI Class to access it's components
        x = new BOI();
        //Calculating the Simple Interest and Storing value in variable
        float SimpleInterestfromBOI = ( principalAmount * timePeriod * x.getRateofInterest()) / 100;
        //Printing Output for BOI CLASS
        System.out.println("Interest form BOI is : "+SimpleInterestfromBOI);

        //Creating the object for PNB Class to access it's components
        x = new PNB();
        //Calculating the Simple Interest and Storing value in variable
        float SimpleInterestfromPNB = ( principalAmount * timePeriod * x.getRateofInterest()) / 100;
        //Printing Output for PNB CLASS
        System.out.println("Interest form PNB is : "+SimpleInterestfromPNB);

        //Creating the object for kodek Class to access it's components
        x = new kodek();
        //Calculating the Simple Interest and Storing value in variable
        float SimpleInterestfromKodek = ( principalAmount * timePeriod * x.getRateofInterest()) / 100;
        //Printing Output for KODEK CLASS
        System.out.println("Interest form kodek is : "+SimpleInterestfromKodek);
    }
}

OUTPUT

Enter the Principal Amount :
25000
Enter the time period (in years) :
7
Interest form BOI is : 10500.0
Interest form PNB is : 12250.0
Interest form kodek is : 14000.0

Grænseflade i java

Interface er en referencetype, der ligner en klasse i Java . Den indeholder en gruppe abstrakte metoder. En grænseflade og de abstrakte metoder, som grænsefladen indeholder, nedarves af Java-klasser. Ud over de abstrakte metoder kan java-grænsefladen også omfatte standardmetoder, konstanter, statiske metoder samt indlejrede typer.

Metodeteksterne er kun til stede for statiske metoder og standardmetoder.
Kodningen af en grænseflade er beslægtet med skrivning af java-klasser. Men mens en klasse afbilder objekters adfærd og attributter, består grænsefladen af adfærden implementeret af en klasse.
Hvis klassen, der implementerer grænsefladen, ikke er abstrakt, skal de metoder, som grænsefladen indeholder, defineres i klassen.
Nøgleordet 'interface' bruges til erklæringen af en grænseflade.
En grænseflade er som standard abstrakt. Derfor behøver det abstrakte nøgleord ikke at blive brugt, mens der erklæres en grænseflade.
Alle metoder indeholdt i en grænseflade er implicit abstrakte, så det er ikke nødvendigt at bruge det abstrakte søgeord.
Metoder indeholdt i java-grænsefladen er implicit offentlige.
En grænseflade kan fås til at udvide i en anden grænseflade på en måde, der ligner en klasse, der kan udvides til en anden klasse. For at udvide en grænseflade bruger programmører i java nøgleordet 'extends'. Når grænsefladen er udvidet, vil den underordnede grænseflade arve de metoder, der er afbildet af den overordnede grænseflade.

Java Interface Class Program Eksempel

//Java program for Interface

//Creating an interface for Addition
interface arithmeticAdd{
    //By default it is looks like public abstract void add ()
    void add();
}

//Creating an interface for Multiplication
interface arithmeticMul{
    //By default it is looks like public abstract void multiply ()
    void multiply();
}

//Creating a class and which inherit the all methods of arithmeticAdd Interface
class addOperation implements arithmeticAdd {
    //implementing the add function of the arithmeticAdd Interface
    public void add(){
        int x = 50;
        int y = 60;
        int z = x+y;
        //Printing the output
        System.out.println("Addition is : "+z);
    }
}

//Creating a class and which inherit the all methods of arithmeticMul Interface
class mulOperation implements arithmeticMul {
    //implementing the add function of the arithmeticMul Interface
    public void multiply(){
        int x = 50;
        int y = 60;
        int z = x*y;
        //Printing the output
        System.out.println("Multiplication is : "+z);
    }
}

//Main Class of the program
public class Main{
    //Main method of the program
    public static void main(String[] args){
        //Creating the object of addOperation Class
        arithmeticAdd addObject = new addOperation();
        //Accessing the function of addOperation Class
        addObject.add();

        //Creating the object of addOperation Class
        arithmeticMul mulObject = new mulOperation();
        //Accessing the function of mulOperation Class
        mulObject.multiply();
    }
}

Output:

Addition is : 110
Multiplication is : 3000