想象一下,我有一个名为Engine的类作为抽象基类.我也有ElectrictEngine和FuelEngine类来自它.

我想创建一种为引擎加油的方法.我应该将它作为基类级别的抽象方法,并将其命名为通用的fasion,例如fillUpEnergy？

问题是如果我有一个电动引擎,该方法所采用的参数数量与燃料引擎需要传递的参数数量不同.因此,该方法的签名是不同的.

另外,是否有任何智能方法可以为两个引擎使用泛型方法,但是将它包装在一个更具体的名称中？例如:对于燃料发动机,"加油",对于电动发动机,"chargeBattery"？同时隐藏用户的通用方法？

C++/CLI中以下C#代码的等价物是什么？

public abstract class SomeClass
{
    public abstract String SomeMethod();
}

假设我有以下类层次结构:

interface Collection<E>
{
    Collection<E> $plus(E element)
}

interface MutableCollection<E> extends Collection<E>
{
    @Override
    MutableCollection<E> $plus(E element)
}

interface Set<E> extends Collection<E>
{
    @Override
    Set<E> $plus(E element)
}

interface MutableSet<E> extends Set<E>, MutableCollection<E>
{
    @Override
    default MutableSet<E> $plus(E element)
    {
        // ... implementation
    }
}

abstract class AbstractArraySet<E> implements Set<E>
{
    // ... no $plus(...) implementation
}

class ArraySet<E> extends AbstractArraySet<E> implements MutableSet<E>
{
    // ... no $plus(...) implementation
}

如您所见,只有MutableSet该类提供了该$plus方法的实现.在测试用例中,我在类型的实例上调用此方法ArraySet.测试总是在CI环境中传递,而它总是AbstractMethodError在我的本地环境中失败.在这两种情况下,我都在使用Gradle(2.7).

错误: …

我有一个抽象类,Model有一些抽象方法,我应该在方法体中放入什么？

1. 回报

   class Model(metaclass=ABCMeta):
       @abstractmethod
       def foo(self): return
   

   Run Code Online (Sandbox Code Playgroud)

2. 通过

   class Model(metaclass=ABCMeta):
       @abstractmethod
       def foo(self): pass
   

   Run Code Online (Sandbox Code Playgroud)

3. 提出描述性错误

   class Model(metaclass=ABCMeta):
       @abstractmethod
       def foo(self):
           raise NotImplementedError("Class {class_name} doesn't implement {func_name} function"
                                 .format(class_name=self.__class__.__name__, func_name=self.foo.__name__))
   

   Run Code Online (Sandbox Code Playgroud)

通常我会实现方法3并引发错误,但是看起来它会是多余的,因为Python为我引发了一个错误:

>>> bar = module.Model()
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: Can't instantiate abstract class Model with abstract methods foo

在提出的选项之间,哪个是最佳实践？或者还有另一种方法我应该处理这个问题吗？

我试图在Android中设计一个抽象类和方法,并通过从我的父Activity类扩展类来调用这些方法,但我不知道如何调用我的抽象方法.

MyCode:

MainActivity.java

public class MainActivity extends MyActivity {

    @Override
    public void onTest() {

       Log.d("MyLog", "onTest");

    } }

MyActivity.java

public abstract class MyActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
         setContentView(R.layout.activity_main);

    }

public abstract void onTest(); }

所以这是上面的代码片段,请告诉我,如何在Android中使用Abstract,因为我之前从未这样做过.

我有一种情况,我需要修改超类方法以获得子类特定的逻辑,但方法逻辑对于所有其他子类是相同的.

我有两个选择:

1)使方法抽象,除了我有关的子类之外,重复相同的代码.

2)覆盖我想要改变逻辑的有关子类中的非抽象方法.

在Java中覆盖非抽象方法是一种很好的做法吗？什么是概念上b/w覆盖非抽象方法和抽象方法的区别.

好吧基本上我有以下问题:我试图让一个抽象类继承另一个抽象方法,但是我不想在其中任何一个中实现抽象方法,因为第三个类继承了他们:

public abstract class Command
{
      public abstract object execute();
}

public abstract class Binary : Command
{
     public abstract object execute(); //the issue is here
}

public class Multiply : Binary
{
     public override object execute()
     {
           //do stuff
     }
}

我正在尝试将二进制命令与一元命令分开,但不希望/不能实现任何一种执行方法.我想过让Binary覆盖抽象方法(因为它必须),然后只抛出一个未实现的异常事物.如果我覆盖它,那么我必须声明一个体,但如果我把它抽象,那么我就是"隐藏"继承的方法.

有什么想法吗？

嗨我有一个类"A"与抽象方法

protected abstract List<Contributor> GetContributors(List<SyndicationPerson> contributersList);

我想在以下条件下在派生类"B"中覆盖此方法

• 它应该是B类私人的.

编译器不允许我在派生类"B"中将此方法声明为私有什么是正确的语法？

我正在读凯瑟琳塞拉的SCJP.
我理解抽象和最终关键字不能一起使用,因为它们相互矛盾,正如书中所解释的那样.

但是,我不明白为什么strictfp和abstract关键字不能一起使用.
我不知道strictfp关键字在Java中是如何工作的.

在我的想法中,可以声明一个抽象的strictfp方法,有一个子类,并以"strictfp方式"实现该方法.

这些关键字不能很好地融合在一起的原因是什么？
编辑
我已经仔细检查了这本书,它肯定会说

因为接口方法是抽象的,所以它们不能标记为final,strictfp或native.

来自SCJP的Katherine Sierra.第21页.

我的IDE(Eclipse Juno)也说我不能同时使用abstract和strictfp关键字.
嗯,为什么不呢？

覆盖python抽象方法时，有没有办法在方法签名中使用额外的参数覆盖该方法？

例如

抽象类=

Agent(ABC):

    @abstractmethod
    def perceive_world(self, observation):
        pass

继承类：

Dumb_agent(Agent):

    def perceive_world(self, observation):
        print('I see %s' % observation)

在方法签名中使用额外参数继承类：

Clever_Agent(Agent):

    def perceive_world(self, observation, prediction):
        print('I see %s' % observation)
        print('I think I am going to see %s happen next' % prediction)