标签: abstract-methods

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

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

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

• 它应该是B类私人的.

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

覆盖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)

问:如果要在未链接到接口的抽象类中创建抽象方法,您是否仍遵循Program to the Interface的原则？

我已经为我创建的所有UI类使用了一个接口; 但是,鉴于接口的原因,我没有看到与我想要创建的抽象方法和现有接口的直接关联.

通常,我只是创建抽象方法并完成; 但是,我想知道我是否违反了程序到接口的设计原则.

问:我应该为此创建另一个接口还是坚持使用抽象方法？

注意:这不是接口与抽象类问题.

public abstract class BaseClass extends Clazz implements Interface {

    // 1 out of 4 interface methods are implemented here
    CustomObj getMode() { ... }

    // I am actually also thinking of taking that 1 method - getMode() - out of the 
    //     interface and implementing it as an implemented method without an interface. 

    // Method that made me ask this question!!
    abstract …

在 django 抽象类中似乎可以使用：

class Meta:
    abstract = True

但是我不知道如何在这些类中声明不包含任何逻辑的抽象方法/函数，例如

class AbstractClass(models.Model):

    def abstractFunction():

    class Meta:
    abstract = True

库 abc 的符号 @abstractmethod 似乎不适用于此处，还是我错了？

我在Java中有以下界面

public interface IFoo
{
    public abstract void foo();
    public void bar();
}

foo()和bar()有什么区别？我什么时候应该使用抽象？

除非我遗漏了一些微妙的东西,否则两者似乎都能实现我的目标？

更新重复为什么将Java接口方法声明为抽象？

我想知道两个约定之间的区别:

1. 使用抽象方法创建抽象基类,稍后将在派生类上实现该抽象基类.
2. 在没有抽象方法的情况下创建抽象基类,
   但稍后在派生类的级别上添加相关方法.

有什么不同？

我发现将抽象方法分成两个方法似乎很有用,一个用于公共接口,另一个用于子类重写.

通过这种方式,您可以为输入和输出添加前置条件/​​后置条件检查,从而可以抵御人为错误.

但我在这里关心的是它是否是蟒蛇可接受的,因为在我的小经验中我从来没有见过像这样的代码.

正常多态性

import abc

class Shape:
    """Abstract base class for shapes"""
    __metaclass__ = abc.ABCMeta

    @abc.abstractmethod
    def get_area(self, scale):
        """Calculates the area of the shape, scaled by a factor.
        Do not blame for a silly example.
        """
        pass

class Rectangle(Shape):
    def __init__(self, left, top, width, height):
        self.left = left
        self.top = top
        self.width = width
        self.height = height

    def get_area(self, scale):
        return scale * self.width * self.height

print(Rectangle(10, 10, 40, 40).get_area(3))

# Gosh!... gets tons of 3's
print(Rectangle(10, 10, …

我试图在抽象方法中使用通用的EnumMap作为参数.我的问题是,当我使用EnumMap的现有枚举实现抽象方法时,编译器告诉我必须删除Override Annotation并实现super方法.

这是我的抽象类:

    import java.util.EnumMap;
    import java.util.HashMap;

    public abstract class AbstractClazz {

        // The methode I tried to define
        public abstract <K extends Enum<K>> boolean isVisible(EnumMap<K, Object> visibleConditions);

        // second test
        public abstract <K> boolean isVisible2(HashMap<K, Object> visibleConditions);

        // third test
        public abstract boolean isVisible3(EnumMap<?, Object> visibleConditions);
    }

而实施班:

    import java.util.EnumMap;
    import java.util.HashMap;

    public class Clazz extends AbstractClazz {

        public enum Numbers {
            ONE, TWO, THREE
        }

        // Error: The method isVisible(EnumMap<Clazz.Numbers,Object>) of type Clazz must override or implement a …

Python 3.4 中抽象类方法 abc.py 的实现如下所示：

class abstractclassmethod(classmethod):

    __isabstractmethod__ = True

    def __init__(self, callable):
        callable.__isabstractmethod__ = True
        super().__init__(callable)

Python 2.7 Combine abc.abstractmethod and classmethod的答案就是基于这个实现。

为什么需要在可调用对象上设置 __isabstractmethod__？设置类abstractclassmethod 的类变量__isabstractmethod__ 还不够吗？如果整个 __init__() 定义将被删除（如抽象属性中），哪个用例将不起作用？

我正在阅读python官方文档。

在提到的链接中，第二行指出：

使用此装饰器要求该类的元类为ABCMeta或从其派生。

但是，我能够成功定义以下给定的类。

from abc import abstractmethod

class A(object):
    def __init__(self):
        self.a = 5
    @abstractmethod
    def f(self):
        return self.a

a = A()
a.f()

因此，上面的代码工作正常。而且，我能够创建一个子类

class B(A):
    def __init__(self):
        super(B, self).__init__() 

b = B()
b.f()

在不覆盖上面定义的抽象方法的情况下。

因此，基本上，这是否意味着如果我的基类metaclass不是ABCMeta（或从其派生的），即使我具有抽象方法，该类的行为也不会像抽象类一样？

这意味着文档需要更清晰吗？

或者，这种行为在某种程度上有用吗？我错过了重点。