blocks|key|535567|text|不，这是抽象方法的全部意义所在。你的用例是什么？也许我们可以根据潜在的需求来考虑它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535568|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

No, that's the whole point of an abstract method. What is your use case? Perhaps we can think about it based on the underlying need.

blocks|key|535586|text|考虑使用此方法创建一个接口。类的后代将不得不实现它。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535587|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Consider making an interface with this method. Class descendants will have to implement it.

blocks|key|535630|text|答案是否定的。您可以使用模板设计模式进行重新设计。这可能会对你有帮助。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535631|或者，您可以使子类实现一个接口。接口可以由超类实现，也可以不由超类实现。|535632|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|F|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|G|8|@]|9|@]|A|$]]|$1|D|3|-4|5|6|7|H|8|@]|9|@]|A|$]]]|E|$]]

Answer would be a no. You can redesign using template design pattern. It may help you. 

Alternatively, you can make your child classes implement an interface. The interface may or may not be implemented by the super class.

blocks|key|535681|text|这样如何:在该方法的默认实现中，使用反射来获取对象的确切类。如果类与基类不完全匹配，则抛出RuntimeException或等效的类。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535682|public+class+Parent+{

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

}|code-block|syntax|javascript|535683|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

How about this: inside the default implementation of the method, use reflection to get the exact Class of the object. If the Class does not match your base class exactly, throw a RuntimeException or equivalent.

<pre><code>public class Parent {

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

}
</code></pre>

blocks|key|535769|text|你总是可以让基类有一个抛出异常的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535770|从技术上讲，基类已经定义了该方法，但如果不覆盖该方法，它将不可用。在这种情况下，我更喜欢运行时异常，因为它们不需要显式的throws语句。下面是一个例子|535771|public+class+Parent+{

++public+void+doStuff()+{
++++throw+new+RuntimeException("doStuff()+must+be+overridden");
++}

}

public+class+Child+extends+Parent+{

++@Override
++public+void+doStuff()+{
++++...+all+is+well+here+...
++}

}|code-block|syntax|javascript|535772|缺点是，这不会阻止创建Base对象；但是，任何试图使用“必须被覆盖”方法之一的人很快就会发现它们应该覆盖该类。|offset|length|style|CODE|535773|虽然此解决方案很好地满足了请求的描述，但您的应用程序可能会受益于不需要这样的解决方案。使用编译器检查来避免运行时崩溃要好得多，这正是抽象关键字所提供的。|535774|entityMap^0|0|0|0|B|4|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|Y|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

You can always make the base class have a method that throws an exception.

Technically the base class has defined the method, but it is not usable without overriding the method. In such a case, I prefer a runtime exception as they don't require an explicit throws statement. An example follows

<pre><code>public class Parent {

 public void doStuff() {
 throw new RuntimeException("doStuff() must be overridden");
 }

}

public class Child extends Parent {

 @Override
 public void doStuff() {
 ... all is well here ...
 }

}
</code></pre>

The downside is that this doesn't prevent creation of <code>Base</code> objects; however, anyone attempting to use one of the "must be overridden" methods will soon find that they should have overridden the class.

While this solution meets the description of the request well, your application would probably benefit from not requiring a solution like this one. It's much better to avoid runtime crashes with compiler checks, which is what the abstract keyword provides.

blocks|key|535839|text|好的，我们就这样学吧。我遵循java风格的指导方针，并使用java语法。因此，假设多重继承和C%2B%2B模板不可用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535840|让父类方法抽象并不是必须的，在OOP中你使用了多态性的概念。您可以以两种或更多不同的方式使用相同的方法。这称为方法重写。|535841|让我们举个例子。|535842|++++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();+
++++++++}
++++}|code-block|syntax|javascript|535843|这将打印"meowww！“在屏幕上。|535844|但这并不意味着方法makeSound必须在子类中被覆盖。|535845|如果需要强制子类重写方法，最好通过类实现一个接口。|535846|++++++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();+
++++++++}
++++++}|535847|这也将打印"meowwww！“在屏幕上|535848|entityMap^0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|X|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Y|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|Z|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|13|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|14|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

ok, let's learn it this way. I adhere to java style guidelines and use java syntax. So it is assumed that multiple inheritance and C++ templates are unavailable.

making the parent class method abstract is not a must,
in OOP you use the concept of polymorphism. you can use the same method in two or more different ways.
This is called method overriding.

let's take an example.

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

this will print "meowww !!!" on the screen. 

but this doesn't imply that the method makeSound must be overridden in the child class.

If you need the child class to be forced to override the methods, you better implement an interface by the class.

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

this will also print "meowwww !!!" on the screen

blocks|key|752419|text|我将镜像其他答案，并指出没有编译器强制的方法来强制派生类覆盖非抽象方法。使方法抽象的全部意义在于定义具有此签名的方法必须存在，但不能在基础级别指定，因此必须在派生级别指定。如果在基本级别上有一个有效的、非平凡的方法实现(如在中，它不是空的，并且不只是抛出异常或显示消息)，那么对于从派生类的使用者对该方法的调用成功来说，这并不是绝对必要的。因此，编译器不必强制重写可以在基级或派生级上成功运行的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|752420|在您希望派生类覆盖您的工作实现的情况下，很明显，基类的实现并不能满足派生类的使用者的需要；基类要么没有足够的实现，要么是错误的实现。在这些情况下，您必须相信从您的类派生的程序员将知道他在做什么，因此知道该方法需要被重写，因为它在使用新对象的上下文中不会产生正确的答案。|752421|我能想到一件你可以做的事。它需要一个抽象库，以及一个密封的(对于Javahead来说是最终的)“默认”实现。这样，就有了该方法的基本实现，可以像使用“基类”一样使用它，但为了为新场景定义不同的类，您必须返回到抽象类，并因此被迫重新实现该方法。这个方法可能是类中唯一抽象的东西，因此仍然允许您使用其他方法的基本实现：|752422|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()+{+...+}
}|code-block|syntax|javascript|752423|然而，这有两个缺点。首先，因为您不能通过继承访问DefaultClass的实现，所以不能扩展DefaultClass的实现，这意味着要做DefaultClass所做的事情，您必须从DefaultClass重写代码，这违反了DRY。其次，这只适用于一个级别的继承，因为如果允许从DerivedClass继承，则不能强制覆盖。|752424|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|R|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

I will mirror the other answers and say that there is no compiler-enforced way to force derived classes to override a non-abstract method. The whole point of making a method abstract is to define that a method with this signature must exist, but cannot be specified at the base level and therefore must be specified at a derived level. If there is a working, non-trivial implementation (as in it's not empty and doesn't just throw an exception or show a message) of a method at the base level, then this isn't strictly necessary in order for a call to the method from a consumer of the derived class to succeed. So, the compiler doesn't have to enforce overriding a method that can run quite successfully on either the base or derived levels. 

In situations where you would want a derived class to override your working implementation, it should be pretty obvious that the base implementation doesn't do what the derived class's consumers will want; the base class either doesn't have enough implementation, or the wrong one. In those cases, you have to trust that a programmer deriving from your class will know what he is doing and thus know that the method needs to be overridden because it does not produce the right answer in the context of using his new object.

I can think of one thing you could do. It would require an abstract base, with a sealed (final for the Javaheads) "default" implementation. That way, there is a basic implementation of the method that is readily available to use as if it were a "base" class, but in order to define a different class for a new scenario, you must go back to the abstract class, and are thus forced to reimplement the method. This method could be the only abstract thing on the class, thus still allowing you to make use of basic implementations of other methods:

<pre><code>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() { ... }
}
</code></pre>

However, this has two drawbacks. First, because you do not have access to DefaultClass's implementation through inheritance, you cannot extend DefaultClass's implementation, meaning that to do what DefaultClass does, plus a little more, you must rewrite the code from DefaultClass, violating DRY. Second, this only works for one level of inheritance, because you cannot force overriding if you allow inheritance from DerivedClass.

blocks|key|535959|text|也许这会有帮助：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|535960|class+SuperClass+{

++++void+doStuff(){

++++++++if(!this.getClass().equals(SuperClass.class)){

++++++++++++throw+new+RuntimeException("Child+class+must+implement+doStuff+Method");
++++++++}else{
++++++++++++//ok
++++++++++++//default+implementation
++++++++}
++++}
}

class+Child+extends+SuperClass{

++++@Override
++++void+doStuff()+{
++++++++//ok
++++}
}

class+Child2+extends+SuperClass{

}


+new+SuperClass().doStuff();+//ok
+new+Child().doStuff();+++++++++//ok
+new+Child2().doStuff();++++++++//error|code-block|syntax|javascript|535961|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

maybe this helps:

<pre><code>class SuperClass {

 void doStuff(){

 if(!this.getClass().equals(SuperClass.class)){

 throw new RuntimeException("Child class must implement doStuff Method");
 }else{
 //ok
 //default implementation
 }
 }
}

class Child extends SuperClass{

 @Override
 void doStuff() {
 //ok
 }
}

class Child2 extends SuperClass{

}


 new SuperClass().doStuff(); //ok
 new Child().doStuff(); //ok
 new Child2().doStuff(); //error
</code></pre>

blocks|key|752497|text|我认为最简单的方法是创建一个从基类继承的抽象类：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|752498|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
++++}
}|code-block|syntax|javascript|752499|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

I think the easiest way is to create an abstract class that inherits from the base class:

<pre><code>
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
 }
}
</code></pre>

blocks|key|752550|text|可能不推荐这样做，但您可以在方法实现中抛出异常(类似于MethodeMustBeOverRiddenExp)。当然，这是RunTime强制，但可能比什么都不做要好。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|752551|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It may not be recommended, but you can throw an exeption( something like MethodeMustBeOverRiddenExp) in your methode implementation.
Of course it is RunTime forcing but may be better than nuthing.

Is there any way of forcing child classes to override a non-abstract method of super class?

I need to be able to create instances of parent class, but if a class extends this class, it must give its own definition of some methods.

Is there a way to make a method which is not abstract but must be overridden?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

有没有办法强制子类覆盖超类的非抽象方法？我需要能够创建父类的实例，但是如果一个类扩展了这个类，它必须给出一些方法的自己的定义。

问有没有一种方法可以让方法不是抽象的，但必须被覆盖？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问有没有一种方法可以让方法不是抽象的，但必须被覆盖？EN