Différence entre la classe abstraite et l'interface

Avant de commencer avec les différences entre une classe abstraite et une interface en Java, il est important de comprendre la signification du terme abstraction. L'abstraction consiste à dissimuler les caractéristiques spécifiques à l'implémentation interne des objets et à ne présenter que la fonctionnalité aux utilisateurs. La classe abstraite et l'interface sont toutes deux utilisées à des fins d'abstraction. Une question d'entrevue importante et fréquemment posée, la différence entre l'interface et la classe abstraite constitue un élément central du langage de programmation Java. Donc, en tant que programmeur Java, si vous vous demandez s'il faut choisir une classe abstraite ou une interface, alors ce qui suit est pour vous.

Interface vs classe abstraite

Les différences entre la classe abstraite et l'interface sont les suivantes :

Classe abstraite	Interface
À tout moment, une classe abstraite est capable d'étendre une seule classe ou une classe abstraite singulière.	Une interface est conçue pour étendre plusieurs interfaces à tout moment.
Les classes abstraites sont capables d'étendre d'autres classes concrètes (régulières) et/ou classes abstraites.	Les interfaces sont capables d'étendre d'autres interfaces uniquement.
Une classe abstraite comprend à la fois des méthodes concrètes et abstraites.	Seules les méthodes abstraites sont présentes dans une interface.
Le mot-clé « abstrait » est utilisé pour déclarer n'importe quelle méthode en tant que méthode abstraite. C'est obligatoire.	Le mot-clé « abstrait » n'est pas obligatoire pour déclarer des méthodes abstraites.
Une classe abstraite peut comprendre à la fois des méthodes abstraites protégées et publiques.	Les interfaces en Java comprennent uniquement des méthodes abstraites publiques.
Les classes abstraites sont capables d'avoir des variables finales finales, statiques, finales et/ou statiques avec l'utilisation de spécificateurs d'accès.	Seules les variables finales statiques publiques sont possibles avec les interfaces en java.
Le mot clé "abstract" est utilisé pour définir une classe et une méthode abstraites.	Le mot clé 'interface' est utilisé pour définir une interface uniquement. Il ne peut pas être utilisé pour la déclaration de méthode.
Le mot clé 'extends' est utilisé par une sous-classe pour étendre une classe abstraite. L'implémentation de toutes les méthodes déclarées présentes dans la classe abstraite doit être fournie dans le cas où la sous-classe n'est pas une classe abstraite.	Le mot clé 'impléments' est utilisé par une sous-classe pour l'implémentation d'une interface. Toutes les méthodes présentes dans l'interface doivent être fournies avec une implémentation correcte pour que le code puisse être compilé.
Les classes abstraites peuvent avoir des méthodes avec implémentation.	Les interfaces Java offrent une abstraction absolue. Il n'est pas possible d'y inclure des implémentations de méthode.
Les classes abstraites possèdent des constructeurs.	Les interfaces ne possèdent pas de constructeurs.
La classe abstraite contient les fonctionnalités de n'importe quelle classe Java normale, mais ces fonctionnalités ne peuvent pas être instanciées.	Les interfaces sont d'un type différent et comprennent des déclarations de méthode finale statiques publiques et des constantes.
Les classes abstraites peuvent être exécutées si elles contiennent la méthode main().	Une interface ne peut pas être exécutée car elle ne contient pas l'implémentation de la méthode principale.
Une classe abstraite définit également le contrat tout en fournissant d'autres implémentations de méthodes à utiliser par les sous-classes.	L'interface en Java est utilisée pour définir le contrat des sous-classes.
Les classes abstraites peuvent comprendre des variables non finales.	Les variables déclarées dans n'importe quelle interface Java sont par défaut final.
Les classes abstraites sont plus rapides que les interfaces en Java.	Les interfaces Java sont plus lentes que les classes abstraites car elles nécessitent une indirection supplémentaire.

Classe abstraite en Java

La classe abstraite en Java est similaire à l'interface, à l'exception qu'elle peut être utilisée pour contenir l'implémentation de la méthode par défaut.

• Les classes abstraites peuvent contenir la méthode abstraite sans avoir de corps ; également, ils peuvent contenir des méthodes avec la mise en œuvre.
• Le mot clé "abstract" est utilisé pour la création d'une classe et/ou d'une méthode abstraite.
• Il n'est pas possible d'initier une classe abstraite en Java.
• La classe abstraite est généralement utilisée pour fournir une base à une sous-classe pour implémenter, étendre et implémenter des méthodes abstraites. Il est également utilisé pour remplacer/utiliser les méthodes implémentées dans une classe abstraite donnée.
• Si une classe contient des méthodes abstraites, alors elle doit être définie comme abstraite en utilisant le mot clé 'abstract' ; sinon, la compilation échouera.
• Il est facultatif d'avoir une classe abstraite pour qu'une classe contienne la méthode abstraite. Une classe peut être marquée comme abstraite même si elle ne parvient pas à déclarer des méthodes abstraites.
• Comme Java ne prend pas en charge l'héritage de plusieurs classes, il est préférable d'utiliser l'interface au cas où il n'y aurait pas d'implémentation de méthode dans la classe abstraite.
• Dans les codes Java, la sous-classe de toute classe abstraite doit implémenter toutes les méthodes abstraites à moins que la sous-classe spécifique ne soit également une classe abstraite.
• Les classes abstraites en Java peuvent être exécutées comme toutes les autres classes si elles possèdent la méthode main().
• La classe Java Abstract fournit des implémentations de méthodes communes pour les sous-classes afin de fournir une implémentation par défaut.
• Les classes abstraites Java peuvent implémenter des interfaces même sans fourniture/implémentation de méthodes d'interface.

Exemple de programme de classe abstraite Java

Pour les débutants

//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();
    }
} 

SORTIE

I am a employee                                                                                                                
I am a employee

Pour expérimenté

//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);
    }
} 

SORTIE

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 

Interface en java

L'interface est un type de référence, qui est similaire à une classe en Java . Il contient un groupe de méthodes abstraites. Une interface et les méthodes abstraites contenues par l'interface sont héritées par les classes Java. En plus des méthodes abstraites, l'interface Java peut également comprendre des méthodes par défaut, des constantes, des méthodes statiques ainsi que des types imbriqués.

• Les corps de méthode ne sont présents que pour les méthodes statiques et les méthodes par défaut.
• Le codage d'une interface s'apparente à l'écriture de classes Java. Cependant, alors qu'une classe décrit le comportement et les attributs des objets, l'interface comprend le comportement implémenté par une classe.
• Dans le cas où la classe implémentant l'interface n'est pas abstraite, les méthodes contenues par l'interface doivent être définies dans la classe.
• Le mot clé 'interface' est utilisé pour la déclaration d'une interface.
• Une interface est abstraite par défaut. Par conséquent, le mot-clé abstrait n'a pas besoin d'être utilisé lors de la déclaration d'une interface.
• Toutes les méthodes contenues dans une interface sont implicitement abstraites, il n'est donc pas nécessaire d'utiliser le mot clé abstract.
• Les méthodes contenues dans l'interface Java sont implicitement publiques.
• Une interface peut être conçue pour s'étendre dans une autre interface d'une manière similaire à une classe extensible dans une autre classe. Pour étendre une interface, les programmeurs en java utilisent le mot clé 'extends'. Une fois l'interface étendue, l'interface enfant héritera des méthodes décrites par l'interface parent.

Exemple de programme de classe d'interface Java

//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();
    }
}

Sortie :

Addition is : 110
Multiplication is : 3000