Mot-clé : Abstrait-Extensions,Interface-Outils

Mot-clé abstrait Java

Le mot-clé abstract est utilisé pour réaliser l'abstraction en Java. Il s'agit d'un modificateur de non-accès qui est utilisé pour créer une classe et une méthode abstraites.

Le rôle d'une classe abstraite est de contenir des méthodes abstraites. Cependant, il peut également contenir des méthodes non abstraites. La méthode déclarée avec le mot-clé abstract et qui n'a aucune implémentation est connue sous le nom de méthode abstraite.

Syntaxe :-

    abstract class Employee  
    {  
    abstract void work();  
    }   

Remarque - Nous ne pouvons pas déclarer de méthodes abstraites dans une classe non abstraite.

Règles du mot-clé abstrait
À ne pas faire

Un mot-clé abstrait ne peut pas être utilisé avec des variables et des constructeurs.
Si une classe est abstraite, elle ne peut pas être instanciée.
Si une méthode est abstraite, elle ne contient pas le corps.
Nous ne pouvons pas utiliser le mot-clé abstract avec le final.
Nous ne pouvons pas déclarer les méthodes abstraites comme privées.
Nous ne pouvons pas déclarer les méthodes abstraites comme statiques.
Une méthode abstraite ne peut pas être synchronisée.

À faire(À déterminer)

Un mot-clé abstrait ne peut être utilisé qu'avec une classe et une méthode.
Une classe abstraite peut contenir des constructeurs et des méthodes statiques.
Si une classe étend la classe abstraite, elle doit également implémenter au moins une des méthodes abstraites.
Une classe abstraite peut contenir la méthode principale et la méthode finale.
Une classe abstraite peut contenir des méthodes abstraites surchargées.
Nous pouvons déclarer la classe interne locale comme abstraite.
Nous pouvons déclarer la méthode abstraite avec une clause throw.

Qu'est-ce que la classe abstraite :

Une classe abstraite est une classe déclarée abstraite : elle peut inclure ou non des méthodes abstraites. Les classes abstraites ne peuvent pas être instanciées, mais elles peuvent être sous-classées.

Qu'est-ce que la méthode abstraite :

Une méthode abstraite est une méthode déclarée sans implémentation (sans accolades et suivie d'un point-virgule), comme ceci :
abstract void moveTo(double deltaX, double deltaY);

*abstraction : *

Son objectif principal est de gérer la complexité en cachant les détails inutiles à l'utilisateur.

Afficher uniquement les données nécessaires et masquer les détails indésirables de l'utilisateur.

Pour un cours abstrait, nous avons un cours enfant. Cette classe enfant peut-elle aussi être une classe abstraite ?
Oui, dans ce cas, la classe Child ne peut pas être instanciée.

Référence :https://www.javatpoint.com/abstract-keyword-in-java

package chennai.velachery;

public abstract class Parent {

    abstract void getJob();

    void studyWell()
    {
        System.out.println("Focus On Maths, Science"); 
    }
    static void display()
    {
        System.out.println("Hi");
    }
    public static void main(String[] args) {
        Parent.display();
//      Parent pp = new Parent(); 
//      pp.display();
//      pp.studyWell(); 
//      pp.getJob();

    }



}

package chennai.velachery;

public class Child extends Parent {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Child ch = new Child(); 
        ch.getJob();
        ch.studyWell();
        Child.display();
    }

    @Override //Annotation : Metadata
    //Data about data
    void getJob() {
        // TODO Auto-generated method stub

    }


}

Exemple 2 :

package chennai.velachery;

public abstract class Parent1 {

    public void watch_tv()
    {
        System.out.println("Watching TV");
    }
    public void chat_with_friends()
    {
        System.out.println("Chatting with neighbours");
    }
    public abstract void cook(); 

}

---

package chennai.velachery;

public class Child1 extends Parent1{

    public static void main(String[] args) {
//      Child1 ch = new Child1(); 
//      ch.cook();
//      ch.chat_with_friends(); 
//      ch.watch_tv();
//      ch.work();

        Child1 ch = new Child1(); 
        //Dynamic Binding 
        //Parent Class Reference points to Child class Memory
        Parent1 parent = new Child1();  

        parent.watch_tv();
        parent.chat_with_friends();
        parent.cook();
        //parent.work(); 
    }
    public void watch_tv()
    { //Runtime Polymorphism
        System.out.println("Watching OTT");
    }

    @Override
    public void cook() {
        // TODO Auto-generated method stub
        System.out.println("Cooking");

    }

    public void work()
    {
        System.out.println("Java Projects");
    }

}

Interface en Java

Une interface en Java est un modèle de classe. Il a des constantes statiques et des méthodes abstraites.

L'interface en Java est un mécanisme permettant de réaliser l'abstraction. Il ne peut y avoir que des méthodes abstraites dans l'interface Java, pas de corps de méthode. Il est utilisé pour réaliser l'abstraction et l'héritage multiple en Java.

En d’autres termes, on peut dire que les interfaces peuvent avoir des méthodes et des variables abstraites. Il ne peut pas avoir de corps de méthode.

L'interface Java représente également la relation IS-A.

Elle ne peut pas être instanciée comme la classe abstraite.

Pourquoi utiliser l'interface Java ?

Il y a principalement trois raisons d'utiliser l'interface. Ils sont donnés ci-dessous.

Comment déclarer une interface ?

Une interface est déclarée en utilisant le mot-clé interface. Il fournit une abstraction totale ; signifie que toutes les méthodes d'une interface sont déclarées avec le corps vide et que tous les champs sont publics, statiques et finaux par défaut. Une classe qui implémente une interface doit implémenter toutes les méthodes déclarées dans l'interface.

*INTERFACE : *

une interface est un groupe de méthodes liées avec des corps vides
100% Abstraction :

Syntaxe :

    abstract class Employee  
    {  
    abstract void work();  
    }   

Exemple :

package chennai.velachery;

public abstract class Parent {

    abstract void getJob();

    void studyWell()
    {
        System.out.println("Focus On Maths, Science"); 
    }
    static void display()
    {
        System.out.println("Hi");
    }
    public static void main(String[] args) {
        Parent.display();
//      Parent pp = new Parent(); 
//      pp.display();
//      pp.studyWell(); 
//      pp.getJob();

    }



}

Référence :https://www.javatpoint.com/interface-in-java

Extend vs Implémente en Java :

En Java, le mot-clé extends est utilisé pour hériter de toutes les propriétés et méthodes de la classe parent tandis que le mot-clé Implements est utilisé pour implémenter la méthode définie dans une interface.

**
Différence entre étendre et implémenter le mot-clé**

Mot clé « étend » en Java

En Java, le mot-clé extends est utilisé pour indiquer que la classe en cours de définition est dérivée de la classe de base en utilisant l'héritage. Donc, fondamentalement, le mot-clé extends est utilisé pour étendre les fonctionnalités de la classe parent à la sous-classe. En Java, les héritages multiples ne sont pas autorisés en raison d'ambiguïté. Par conséquent, une classe ne peut étendre qu’une seule classe pour éviter toute ambiguïté.

package chennai.velachery;

public class Child extends Parent {


    public static void main(String[] args) {
        // TODO Auto-generated method stub
        Child ch = new Child(); 
        ch.getJob();
        ch.studyWell();
        Child.display();
    }

    @Override //Annotation : Metadata
    //Data about data
    void getJob() {
        // TODO Auto-generated method stub

    }


}

Mot clé «implémente» en Java

En Java, le mot-clé Implements est utilisé pour implémenter une interface. Une interface est un type spécial de classe qui implémente une abstraction complète et ne contient que des méthodes abstraites. Pour accéder aux méthodes de l'interface, l'interface doit être « implémentée » par une autre classe avec le mot-clé Implements et les méthodes doivent être implémentées dans la classe qui hérite des propriétés de l'interface. Puisqu'une interface n'a pas l'implémentation des méthodes, une classe peut implémenter n'importe quel nombre d'interfaces à la fois.

/

package chennai.velachery;

public abstract class Parent1 {

    public void watch_tv()
    {
        System.out.println("Watching TV");
    }
    public void chat_with_friends()
    {
        System.out.println("Chatting with neighbours");
    }
    public abstract void cook(); 

}

Référence :https://www.geeksforgeeks.org/extends-vs-implements-in-java/

Exemple :

    abstract class Employee  
    {  
    abstract void work();  
    }   

---

package chennai.velachery;

public abstract class Parent {

    abstract void getJob();

    void studyWell()
    {
        System.out.println("Focus On Maths, Science"); 
    }
    static void display()
    {
        System.out.println("Hi");
    }
    public static void main(String[] args) {
        Parent.display();
//      Parent pp = new Parent(); 
//      pp.display();
//      pp.studyWell(); 
//      pp.getJob();

    }



}

Cours abstrait u>
0 à 100% d'abstraction

mot-clé abstrait

variables non statiques

peut être présent

* *vs Interface 100% Abstraction
Pas de mot-clé abstrait
toutes les variables sont statiques,
finale et publique

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!