标签: abstract-methods

有没有办法强制子类覆盖超类的非抽象方法？

我需要能够创建父类的实例,但是如果一个类扩展了这个类,它必须给出它自己的一些方法的定义.

我有一些关于抽象类/方法的基本问题.我知道抽象类的基本用法是为将来的类创建模板.但他们有没有更多的用途？什么时候你应该更喜欢它们而不是接口？抽象方法何时有用？

我读过有关抽象基类的python文档:

从这里:

abc.abstractmethod(function) 指示抽象方法的装饰员.

使用这个装饰器需要该类的元类是ABCMeta从它派生的.ABCMeta 除非所有抽象方法和属性都被覆盖,否则无法实例化具有派生自元类的类.

而在这里

您可以将@abstractmethod装饰器应用于必须实现的draw()等方法; 然后,Python将为未定义该方法的类引发异常.请注意,只有在您实际尝试创建缺少该方法的子类的实例时才会引发该异常.

我已经用这段代码测试了一下:

import abc

class AbstractClass(object):
  __metaclass__ = abc.ABCMeta

  @abc.abstractmethod
  def abstractMethod(self):
    return

class ConcreteClass(AbstractClass):
  def __init__(self):
    self.me = "me"

c = ConcreteClass()
c.abstractMethod()

代码很好,所以我不明白.如果我输入c.abstractMethod我得到:

<bound method ConcreteClass.abstractMethod of <__main__.ConcreteClass object at 0x7f694da1c3d0>>

我在这里缺少什么？ConcreteClass 必须实现抽象方法,但我也不例外.

我正在阅读包的代码,time然后我想知道它是如何func After(d Duration) <-chan Time工作的.

我发现代码如下:

func After(d Duration) <-chan Time {
    return NewTimer(d).C
}

func NewTimer(d Duration) *Timer {
    c := make(chan Time, 1)
    t := &Timer{
        C: c,
        r: runtimeTimer{
            when: nano() + int64(d),
            f:    sendTime,
            arg:  c,
        },
    }
    startTimer(&t.r)
    return t
}

所以我找到了startTimer- 函数startTimer没有函数体这么奇怪.

func startTimer(*runtimeTimer)

我想知道:

1. 真正的代码在哪里？ startTimer
2. 为什么这里可以存在"抽象方法"
3. 为什么Go的作者这样写了

谢谢!

将方法的默认实现放在超类中更好,并在子类想要偏离它时重写它,或者你应该只留下超类方法摘要,并在许多子类中重复正常实现？

例如,我参与的项目有一个类,用于指定它应该停止的条件.抽象类如下:

public abstract class HaltingCondition{
    public abstract boolean isFinished(State s);
}

一个简单的实现可能是:

public class AlwaysHaltingCondition extends HaltingCondition{
    public boolean isFinished(State s){
        return true;
    }
}

我们用对象做这个的原因是我们可以随意组合这些对象.例如:

public class ConjunctionHaltingCondition extends HaltingCondition{
    private Set<HaltingCondition> conditions;

    public void isFinished(State s){
        boolean finished = true;
        Iterator<HaltingCondition> it = conditions.iterator();
        while(it.hasNext()){
            finished = finished && it.next().isFinished(s);
        }
        return finished;
    }
}

但是,我们有一些暂停条件需要通知事件已经发生.例如:

public class HaltAfterAnyEventHaltingCondition extends HaltingCondition{
    private boolean eventHasOccurred = false;

    public void eventHasOccurred(Event e){
        eventHasOccurred = true;
    }

    public boolean isFinished(State …

抽象类是否有必要至少有一个抽象方法？

我知道在抽象类中,方法既可以是抽象的,也可以不是抽象的.但为什么我不能在"普通"非抽象类中创建抽象方法呢？

在此先感谢任何解释!

为什么我们需要Java中的抽象类？如果你永远不会把它变成一个物体,那为什么要把它放在一起呢？你如何使用它？为什么会这样？我用抽象方法想知道同样的事情.我发现这似乎是一个类似的概念,有一个没有子类的超级类可能无关紧要.

为什么抽象方法需要new/override,虚拟方法不需要？

样本1:

abstract class ShapesClass
{
    abstract public int Area(); // abstract!
}

class Square : ShapesClass
{
    int x, y;

    public int Area() // Error: missing 'override' or 'new'
    {
        return x * y;
    }
}

编译器将显示此错误: 要使当前成员覆盖该实现,请添加override关键字.否则添加新关键字

样本2:

class ShapesClass
{
    virtual public int Area() { return 0; } // it is virtual now!
}

class Square : ShapesClass
{
    int x, y;

    public int Area() // no explicit 'override' or 'new' required
    {
        return x * y; …

关于为什么没有抽象的静态方法/字段,已经有几个SO问题,但我想知道如何实现以下伪代码:

class Animal {
    abstract static int getNumberOfLegs(); // not possible
}

class Chicken inherits Animal {
    static int getNumberOfLegs() { return 2; }


class Dog inherits Animal {
    static int getNumberOfLegs() { return 4; }

这是问题:假设我想确保每个继承的类Animal都包含getNumberOfLegs()方法(即几乎像一个接口,除了我确实希望抽象类实现所有子类共有的几个方法,因此纯接口不会在这里工作).getNumberOfLegs()显然应该是一个静态的方法(假设在一个完美的世界中,我们不会使鸡和狗瘫痪,因此getNumberOfLegs不依赖于实例).

如果没有"抽象静态"方法/字段,可以将方法从Animal类中删除,然后存在某些子类没有该方法的风险.或者可以制作getNumberOfLegs一个实例方法,但是必须实例化一个类以找出动物有多少腿 - 即使它没有必要.

人们通常如何实施这种情况？

编辑:我在这里如何使用它.假设(现在这很荒谬,但无论如何......)每只动物的腿数是独一无二的,所以我可能有类似的东西:

Animal getModelAnimal(int numberOfLegs) {
   if (numberOfLegs == Chicken.getNumberOfLegs()) return new Chicken();
   else if (numberOfLegs == Dog.getNumberOfLegs()) return new Dog();
}