Gibt es eine Möglichkeit zu machen, eine Methode, die nicht Abstrakt, sondern muss überschrieben werden?

Wie andere haben darauf hingewiesen, können Sie dies nicht direkt.

Aber ein Weg dies zu tun ist die Verwendung der Strategie-Muster, etwa so:

public class Base {
    private final Strategy impl;

    //Public factory method uses DefaultStrategy
    //You could also use a public constructor here, but then subclasses would
    //be able to use that public constructor instead of the protected one
    public static Base newInstance() {
        return new Base(new DefaultStrategy());
    }

    //Subclasses must provide a Strategy implementation
    protected Base(Strategy impl) {
        this.impl = impl;
    }

    //Method is final: subclasses can "override" by providing a different
    //implementation of the Strategy interface
    public final void foo() {
        impl.foo();
    }

    //A subclass must provide an object that implements this interface
    public interface Strategy {
        void foo();
    }

    //This implementation is private, so subclasses cannot access it
    //It could also be made protected if you prefer
    private static DefaultStrategy implements Strategy {
        @Override
        public void foo() {
            //Default foo() implementation goes here
        }
    }
}

Ich denke, die einfachste Möglichkeit ist das erstellen einer abstrakten Klasse erbt von der Basis-Klasse:

public class Base {
    public void foo() {
        //original method
    }
}

abstract class BaseToInheritFrom extends Base {
    @Override
    public abstract void foo();
}

class RealBaseImpl extends BaseToInheritFrom {
    @Override
    public void foo() {
        //real impl
    }
}

Wie etwa dieser: in der default-Implementierung der Methode, reflektion verwenden, um die genaue Klasse des Objekts. Wenn die Klasse nicht mit Ihren Basis-Klasse genau das werfen einer RuntimeException oder gleichwertig.

public class Parent {

    public void defaultImpl(){
        if(this.getClass() != Parent.class){
            throw new RuntimeException();
        }
    }

}

Antwort wäre keine. Sie können die redesign-mit Vorlage-design-Muster. Es kann Ihnen dabei helfen.

Alternativ, Sie können Ihr Kind-Klassen implementieren eine Schnittstelle. Das interface kann oder kann nicht umgesetzt werden, durch die super-Klasse.

Ich wird Spiegel der anderen Antworten und sagen, dass es keine compiler-durchgesetzt zwingen, die abgeleiteten Klassen zu überschreiben einer nicht-abstrakten Methode. Der ganze Sinn machen, eine Methode Abstrakt ist, zu definieren, dass eine Methode mit dieser Signatur muss vorhanden sein, aber kann nicht angegeben werden, auf dem Basis-level und muss daher angegeben werden, bei der eine abgeleitete Ebene. Wenn es eine funktionierende, nicht-triviale Implementierung (wie in es nicht leer ist und nicht nur eine Ausnahme werfen, oder zeigen Sie eine Nachricht), der eine Methode auf der Basis-Ebene, dann ist dies nicht unbedingt erforderlich ist, um für einen Aufruf der Methode, die von einem Verbraucher der abgeleiteten Klasse um erfolgreich zu sein. So, der compiler nicht haben durchsetzen überschreiben einer Methode, die ausgeführt werden können, die Recht erfolgreich auf entweder die Basis-oder abgeleiteten Ebenen.

In Situationen, In denen Sie möchten, einer abgeleiteten Klasse zu überschreiben Ihrer Umsetzung arbeiten, es sollte ziemlich offensichtlich, dass die Basis-Implementierung nicht tun, was der abgeleiteten Klasse werden die Verbraucher wollen; die Basisklasse entweder nicht genug die Umsetzung, oder die falsche. In diesen Fällen müssen Sie darauf Vertrauen, dass ein Programmierer die sich aus Ihrer Klasse wissen, was er tut, und er somit weiß, dass die Methode muss überschrieben werden, weil Sie nicht produzieren die richtige Antwort im Zusammenhang mit seiner neuen Objekt.

Ich denken kann, eine Sache, die Sie tun konnte. Es würde eine abstrakte Basisklasse, mit einem geschlossenen (final für die Javaheads) "default" - Implementierung. So, es ist eine grundlegende Implementierung der Methode, die leicht verfügbar sind zu verwenden, als ob es eine "Basis" - Klasse, aber um zu definieren, eine andere Klasse für ein neues Szenario, müssen Sie gehen Sie zurück zu der abstrakten Klasse, und sind daher gezwungen, implementieren Sie die Methode. Diese Methode könnte sein, die nur abstrakte Sache auf die Klasse, also noch so dass Sie machen verwenden von basic-Implementierungen von anderen Methoden:

public abstract class BaseClass
{
   public abstract void MethodYouMustAlwaysOverride();

   public virtual void MethodWithBasicImplementation() { ... }
}

public final class DefaultClass:BaseClass
{
   public override void MethodYouMustAlwaysOverride() { ... }

   //the base implementation of MethodWithBasicImplementation 
   //doesn't have to be overridden
}

...

public class DerivedClass:BaseClass
{
   //Because DefaultClass is final, we must go back to BaseClass,
   //which means we must reimplement the abstract method
   public override void MethodYouMustAlwaysOverride() { ... }

   //again, we can still use MethodWithBasicImplementation, 
   //or we can extend/override it
   public override void MethodWithBasicImplementation() { ... }
}

Dies hat jedoch zwei Nachteile. Erstens, weil Sie keinen Zugang zu DefaultClass Implementierung durch Vererbung, Sie kann nicht erweitert DefaultClass der Umsetzung, was bedeutet, dass zu tun, was DefaultClass tut, plus ein wenig mehr, Sie müssen schreiben Sie den code aus DefaultClass, verletzen TROCKNEN. Zweitens, das funktioniert nur für eine Ebene der Vererbung, da kann man nicht erzwingen überschreiben, wenn Sie erlauben die Vererbung von DerivedClass.

ok, lasst uns lernen, es auf diese Weise. Ich bin java-Stil-Richtlinien und verwenden java-syntax. So wird davon ausgegangen, dass mehrere erbschaft-und C++ - Vorlagen sind nicht verfügbar.

machen die übergeordnete Klasse Methode abstract ist nicht ein muss,
in OOP verwenden Sie das Konzept des Polymorphismus. Sie können dieselbe Methode verwenden, die in zwei oder mehr verschiedene Arten.
Dies wird als Methode überschreiben.

nehmen wir ein Beispiel.

    public class Animal{
       public void makeSound(){
          System.out.println("Animal doesn't know how to make sound");
       }

    }

    public class PussyCat extends Animal{
        public void makeSound(){

           System.out.println("meowwww !!!");
        }

        public static void main(String args[]){
           PussyCat aCat=new PussyCat();
           aCat.makeSound(); 
        }
    }

diese wird print "meowww !!!" auf dem Bildschirm.

aber dies bedeutet nicht, dass die Methode makeSound muss überschrieben werden in der Kind-Klasse.

Wenn Sie die Kind-Klasse gezwungen werden, überschreiben die Methoden, die Sie besser implementieren einer Schnittstelle durch die Klasse.

      public Interface audible{
         public void makeSound();

      }

      public class pussyCat implements audible{
          //now you must implement the body of makeSound method here
          public void makeSound(){
            System.out.println("meowwww !!!"); 
          }

          public static void main(String args[]){
           PussyCat aCat=new PussyCat();
           aCat.makeSound(); 
        }
      }

wird diese auch " drucken "meowwww !!!" auf dem Bildschirm