Une classe abstraite Java n'a pas besoin d'implémenter toutes les méthodes de mise en œuvre de l'interface. Pourquoi?

Regardons le simple bout de code suivant dans Java.

interface Sum
{
    abstract public void showSum();
}

interface Mul
{
    abstract public void showMul();
}

abstract class Super implements Sum
{
    protected int x;
    protected int y;

    public Super(int x, int y)
    {
        this.x=x;
        this.y=y;
    }

    //No error, though the method showSum() of the implementing iterface Sum is commented. Why?

    /*public void showSum()
    {
        System.out.println("Sum = "+(x+y));
    }*/
}

final class Calculation extends Super implements Mul
{
    public Calculation(int x, int y)
    {
        super(x,y);
    }

    public void showSum()
    {
        System.out.println("Summation = "+(x+y));
    }

    //If showMul() is commented , it would issue a compile-time error. Why?
    public void showMul()
    {
        System.out.println("Multiplication = "+(x*y));
    }   
}

final public class Main
{
    public static void main(String[] args) throws IOException
    {
        Scanner s=new Scanner(System.in);

        System.out.print("\nEnter a number : ");
        int x=s.nextInt();

        System.out.print("\nEnter another number : ");
        int y=s.nextInt();

        Calculation c=new Calculation(x,y);
        c.showSum();
        c.showMul();
    }
}

Depuis l'interface Somme ne contenant qu'une seule méthode showSum(); est mis en œuvre par la classe abstraite Super , il devrait être nécessaire pour la classe abstraite Super à mettre en œuvre que la méthode showSum();. Le compilateur ne se plaignent pas du tout, et le programme fonctionne bien avec aucun problème du tout. Pourquoi?

De même, la non-abstraite, finale de la classe Calcul est la mise en œuvre de la Mul interface et contient la mise en œuvre effective de la méthode showMul(); présenté dans la mise en œuvre de l'interface. Dans le cas, si cette méthode showMul() dans la classe Calcul est commenté, il génère une erreur de compilation. Pourquoi la même chose n'est pas applicable à cette classe abstraite Super?

OriginalL'auteur Bhavesh | 2011-11-06

java

La abstract classe n'est pas mise en œuvre réelle de la classe. Il peut contenir des abstract méthodes et n'est pas besoin de implement les méthodes de la interface. La préoccupation de la RÉELLE mise en œuvre de la classe de définir l'abstrait/méthodes d'interface.

Voir cette différence entre l'abstrait classe et d'interface

Interface:
public interface InterfaceClass {
    void interfaceMethod();
    //no method definition
}


//Abstract Class implementing InterfaceClass
abstract class AbsClass implements InterfaceClass{
    abstract void abstractMethod();
    public void doSomethingCommon() {
        System.out.println("Abstract class may contain method definition");
    }
    //no need to implement methods of InterfaceClass because AbsClass is abstract
}

Et ici est réel classe qui étend la classe AbsClass: Son devoir de RealClass de définir toutes les méthodes abstraites et les méthodes d'interface. En outre, il peut override les méthodes définies dans abstract classe.

public class RealClass extends AbsClass{
    @Override
    public void interfaceMethod() {
        //implement interface method here
    }
    @Override
    void abstractMethod() {
    }
    //you may override the doSomethingCommon() of AbsClass too
    @Override
    public void doSomethingCommon() {
        //TODO Auto-generated method stub
        super.doSomethingCommon();
    }
}

Pourquoi il n'y a pas d'erreur de compilation sur AbsClass:
Nous ne pouvons pas créer des instances de la classe abstraite. C'est pourquoi il n'y a pas de sens de l'affichage d'erreur au moment de la compilation.

OriginalL'auteur gtiwari333

4

Les classes abstraites comportement ressemble à des interfaces dans ce cas.

De la Java Tutoriel: ...les classes abstraites sont similaires aux interfaces, à l'exception de ce qu'ils prévoient une mise en œuvre partielle, laissant le soin à des sous-classes pour compléter la mise en œuvre. Si une classe abstraite contient uniquement résumé des déclarations de méthode, elle doit être déclarée comme une interface au lieu

Vous ne mettez pas en œuvre des méthodes dans une interface qui étend une autre interface. Et vous n'AVEZ pas à mettre en œuvre des méthodes abstraites de la classe qui implémente une interface.

OriginalL'auteur Oleg Mikheev
3

Parce qu'elle est abstraite. Une classe abstraite est une classe qui est autorisé à déclarer certaines méthodes, sans apporter de mise en œuvre de ces méthodes, forçant les sous-classes concrètes de le faire. Vous pouvez ajouter la méthode
```
@Override
public abstract void showSum();
```
de la classe abstraite, mais ce serait redondante avec la méthode déjà déclarées dans l'interface.

OriginalL'auteur JB Nizet
0

Cela devrait être le commentaire de JB Nizet réponse, mais je ne peux pas poster de commentaires pour l'instant 🙁
Notez que vous pourrait fournir la mise en oeuvre de la showSum() dans votre classe abstraite, et toujours avoir la classe restent abstraites sans aucun problème. Une classe abstraite peut avoir toutes les méthodes mises en œuvre et encore abstrait!

OriginalL'auteur Zavior

Vous devez vous connecter pour publier un commentaire.