抽象方法和虚拟方法有什么区别?在哪些情况下,建议使用抽象方法或虚拟方法?哪一种是最好的方法?


当前回答

抽象函数没有实现,只能在抽象类上声明。这迫使派生类提供实现。

虚拟函数提供默认实现,它可以存在于抽象类或非抽象类上。

例如:

public abstract class myBase
{
    //If you derive from this class you must implement this method. notice we have no method body here either
    public abstract void YouMustImplement();

    //If you derive from this class you can change the behavior but are not required to
    public virtual void YouCanOverride()
    { 
    }
}

public class MyBase
{
   //This will not compile because you cannot have an abstract method in a non-abstract class
    public abstract void YouMustImplement();
}

其他回答

抽象方法:当类包含抽象方法时,该类必须声明为抽象的。抽象方法没有实现,因此派生自该抽象类的类必须为该抽象方法提供实现。

虚拟方法:类可以具有虚拟方法。虚拟方法有一个实现。当从具有虚拟方法的类继承时,可以重写虚拟方法并提供额外的逻辑,或者用自己的实现替换逻辑。

何时使用什么:在某些情况下,您知道某些类型应该有一个特定的方法,但您不知道该方法应该有什么实现。在这种情况下,您可以创建包含具有此签名的方法的接口。然而,如果您有这样的情况,但您知道该接口的实现者也将有另一个通用方法(您已经可以为其提供实现),那么您可以创建一个抽象类。然后,这个抽象类包含抽象方法(必须重写)和另一个包含“公共”逻辑的方法。

如果您有一个可以直接使用的类,但您希望继承者能够更改某些行为,则应使用虚拟方法,尽管这不是强制性的。

虚拟方法:

虚拟意味着我们可以超越它。虚拟函数有一个实现。当我们继承类时可以重写虚拟函数并提供我们自己的逻辑。我们可以在实现子类中的函数(可以说是阴影)。

抽象方法

抽象意味着我们必须重写它。抽象函数没有实现,必须在抽象类中。它只能声明。这迫使派生类提供它的实现。抽象成员是隐式虚拟的。在某些语言中,抽象可以称为纯虚拟。公共抽象类BaseClass{ 受保护的抽象void xAbstractMethod();公共虚拟void xVirtualMethod(){变量x=3+4;}}

在这里,我写了一些示例代码,希望这可能是一个非常实际的例子,可以从非常基本的层面上看到接口、抽象类和普通类的行为。如果您想将其用作演示,也可以在github中找到此代码作为项目:https://github.com/usavas/JavaAbstractAndInterfaceDemo

public interface ExampleInterface {

//    public void MethodBodyInInterfaceNotPossible(){
//    }
    void MethodInInterface();

}

public abstract class AbstractClass {
    public abstract void AbstractMethod();

    //    public abstract void AbstractMethodWithBodyNotPossible(){
    //
    //    };

    //Standard Method CAN be declared in AbstractClass
    public void StandardMethod(){
        System.out.println("Standard Method in AbstractClass (super) runs");
    }
}

public class ConcreteClass
    extends AbstractClass
    implements ExampleInterface{

    //Abstract Method HAS TO be IMPLEMENTED in child class. Implemented by ConcreteClass
    @Override
    public void AbstractMethod() {
        System.out.println("AbstractMethod overridden runs");
    }

    //Standard Method CAN be OVERRIDDEN.
    @Override
    public void StandardMethod() {
        super.StandardMethod();
        System.out.println("StandardMethod overridden in ConcreteClass runs");
    }

    public void ConcreteMethod(){
        System.out.println("Concrete method runs");
    }

    //A method in interface HAS TO be IMPLEMENTED in implementer class.
    @Override
    public void MethodInInterface() {
        System.out.println("MethodInInterface Implemented by ConcreteClass runs");

    //    Cannot declare abstract method in a concrete class
    //    public abstract void AbstractMethodDeclarationInConcreteClassNotPossible(){
    //
    //    }
    }
}

只有抽象类才能有抽象成员。从抽象类继承的非抽象类必须重写其抽象成员。抽象成员是隐式虚拟的。抽象成员不能提供任何实现(抽象在某些语言中称为纯虚拟)。

答案已经提供了很多次,但关于何时使用每一个的问题是设计时的决定。我认为,尝试将通用方法定义捆绑到不同的接口中,并将它们拉到适当抽象级别的类中是一种很好的做法。当最好定义一个实现一组简洁接口的非抽象类时,将一组通用的抽象和虚拟方法定义转储到一个类中会使该类不可实例化。一如既往,这取决于什么最适合您的应用程序特定需求。