Java

Notification de cookies

Nous utilisons des cookies pour améliorer votre expérience. En poursuivant votre navigation sur ce site, vous acceptez l'utilisation de cookies. Plus d'informations

Classes abstraites en Java

Une classe concrète est une classe à partir de laquelle vous pouvez instancier des objets. Parfois, une classe est si générale que vous n’avez jamais l’intention de créer des instances spécifiques de la classe. 

Par exemple, vous pouvez avoir l’intention de ne jamais créer d’objet «uniquement» Forme; chaque Forme est plus spécifiquement un Cercle ou Rectangle. Une classe telle que Forme que vous créez uniquement pour l'héritage n'est pas une classe concrète; c'est une classe abstraite.

Le seul but de la création de classes abstraites est de permettre à d’autres classes de les hériter. Si vous essayez d'instancier un objet à partir d'une classe abstraite, vous recevez un message d'erreur du compilateur indiquant que vous avez commis une erreur InstantiationError. Vous utilisez le mot-clé abstract lorsque vous déclarez une classe abstraite.

Les classes abstraites peuvent inclure deux types de méthodes:

  • Les méthodes non abstraites, comme celles que vous pouvez créer dans n'importe quelle classe, sont implémentées dans la classe abstraite et sont simplement héritées par ses enfants.
  • les méthodes abstraites n'ont pas de corps (pas d'accolades ni de déclarations) et elles doivent être implémentées (corps donnés) dans des classes enfant.

Les classes abstraites contiennent généralement au moins une méthode abstraite. Lorsque vous créez une méthode abstraite, vous fournissez le mot clé abstract et le reste de l'en-tête de la méthode, y compris le type, le nom et les paramètres de la méthode. Cependant, la déclaration se termine là. Vous ne fournissez aucune accolade ni aucune instruction dans la méthode, mais seulement un point-virgule à la fin de la déclaration. Si vous créez une méthode vide dans une classe abstraite, la méthode est abstraite même si vous n'utilisez pas explicitement le mot clé abstract lors de la définition de la méthode, bien que les programmeurs l'incluent souvent par souci de clarté.

                                public abstract afficher();
                            
  • Si vous déclarez une classe abstraite, chacune de ses méthodes peut être abstraite ou non.
  • Si vous déclarez une méthode abstraite, vous devez également déclarer sa classe abstraite.

Lorsque vous créez une sous-classe qui hérite une méthode abstraite, vous écrivez une méthode avec la même signature. Vous devez implémenter une méthode de sous-classe pour redéfinir chaque méthode de superclasse abstraite, vide héritée.
Soit la méthode de classe enfant doit être elle-même abstraite, soit vous devez fournir un corps ou une implémentation pour la méthode héritée.

Exemple 1 :

Le type de base est "Forme" et chaque forme a une couleur, une taille, etc. À partir de cela, des types spécifiques de formes sont dérivés (hérités) - cercle, rectangle, triangle, etc. - chacune pouvant avoir des caractéristiques et des comportements supplémentaires. Par exemple, certaines formes peuvent être inversées. Certains comportements peuvent être différents, par exemple lorsque vous souhaitez calculer la surface d'une forme.

                                    abstract class Forme {
                                        String couleur;
                                    
                                        // méthode abstraite
                                        abstract double surface();
                                    
                                        // constructeur
                                        public Forme(String couleur) {
                                            System.out.println("Constructeur Forme");
                                            this.couleur = couleur;
                                        }
                                    
                                        // méthode concréte
                                        public String getCouleur() {
                                            return couleur;
                                        }
                                    }
                                    
                                    class Cercle extends Forme {
                                        double rayon;
                                    
                                        public Cercle(String couleur, double rayon) {
                                    
                                            // appler le constructeur de la classe mère Forme
                                            super(couleur);
                                    
                                            System.out.println("Constructeur Cercle");
                                            this.rayon = rayon;
                                        }
                                    
                                        @Override
                                        double surface() {
                                            return Math.PI * Math.pow(rayon, 2);
                                        }
                                    
                                    }
                                    
                                    class Rectangle extends Forme {
                                    
                                        double hauteur;
                                        double largeur;
                                    
                                        public Rectangle(String couleur, double hauteur, double largeur) {
                                    
                                            // appler le constructeur de la classe mère Forme
                                            super(couleur);
                                            System.out.println("Constructeur Rectangle");
                                            this.hauteur = hauteur;
                                            this.largeur = largeur;
                                        }
                                    
                                        @Override
                                        double surface() {
                                            return hauteur * largeur;
                                        }
                                    
                                    }
                                    
                                    public class Test {
                                    
                                        public static void main(String args[]) {
                                            Forme f1 = new Cercle("Rouge", 2.2);
                                            System.out.println("Surface : " + f1.surface());
                                    
                                            System.out.println("---------------------------------");
                                            
                                            Forme f2 = new Rectangle("Vert", 2, 4);
                                            System.out.println("Surface : " + f2.surface());
                                        }
                                    }
                            
Constructeur Forme
Constructeur Cercle
Surface : 15.205308443374602
---------------------------------
Constructeur Forme
Constructeur Rectangle
Surface : 8.0

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :