抽象课的适当层次结构

Question

我有下面定义的下一个代码。 该示例有2个架构问题：

1. 具体类POST有警告，因为没有实现（这是不可能的）某些抽象方法
2. 摘要类是混凝土类的继承者。

我知道一些解决方案，但它们都不是完美的：

1. 完全删除抽象课程。
2. 删除中间logica（post）类。
3. 为最终课程做出多个继承（可能没有帮助，但显然会减少损害）
4. 将此类分成大量的小班级。

为什么它们都不完美：

1. 类
2. 我
3. 抽象的
4. 需要 从6到〜（12-18，

常见的层次结构是：

基本抽象类Abstracta带有每个最终子类 - ＆gt;

concrete class logica（的继承者） Abstracta class）部分实现具有常见逻辑的方法，并且在

另一个Abstract类 中，＆gt;仅针对此类的特定抽象方法 - ＆gt;

）的特定方法仅用于此类的特定抽象方法

finalabtractb （logica > Finallogica（finalAbsTracta的继承者）

。

简而言之： 摘要 - ＆gt; logica-＆gt; （finalAbstracta - ＆gt; Finallogica + finalAbstractb - ＆gt; Finallogicb）

class AbstractPost(ABC):
    """Abstract Intermediate class with common methods for all inheritors"""
    @abstractmethod  # Method that has every final inheritor but not an intermediate
    def read(self):
        raise NotImplementedError

    @classmethod  # A common method for all subclasses
    def post_from_callback(cls, current_user: classes.users.User, callback: CallbackQuery) -> Post | None:
        raise NotImplementedError


class Post(AbstractPost):  # Warning on this line that not all abstract methods defined.
    """
    Implementation of intermediate class with common methods for all inheritors
    This class not supposing to has an instances, only type hint
    "read" function can't be implemented here because `post` instanse not defined in DB doesn't has. 
    "read" function has a common signature but should be impleneted in concrete class because has different sql queries.
    """
    @classmethod
    def post_from_callback(cls, current_user: classes.users.User, callback: CallbackQuery) -> Post | None:
        post = cls.read(user=current_user, post_id=abs(int(callback.data.split()[-1])))
        if post is not None and post.validate(data=int(callback.data.split()[-2])):
            return post


class AbstractPublicPost(Post):
    """Abstract class with some methods which has only this class"""
    @abstractmethod
    def public_post_method_only(self):
        raise NotImplementedError


class PublicPost(AbstractPublicPost):
    """Implementation of abstract class with some  methods which has only this class"""
    def public_post_method_only(self):
        ...


class AbstractPersonalPost(Post):
    """Abstract class with some methods which has only this class"""
    @abstractmethod
    def personal_post_method_only(self):
        raise NotImplementedError


class PersonalPost(AbstractPersonalPost):
    """Implementation of abstract class with some  methods which has only this class"""
    def personal_post_method_only(self):
        ...

Answer 1

看来您已经使这复杂化了。仅仅因为类是基类，并不意味着您无法实现一种方法，然后由其他类继承。

您可以将post_from_callback从发布 abractivepost没有任何问题，并且完全消除了post。

class AbstractPost(ABC):
    """Abstract Intermediate class with common methods for all inheritors"""
    @abstractmethod
    def read(self):
        pass

    @classmethod
    def post_from_callback(cls, current_user: classes.users.User, callback: CallbackQuery):
        post = cls().read(user=current_user, post_id=abs(int(callback.data.split()[-1])))
        if post is not None and post.validate(data=int(callback.data.split()[-2])):
            return post


class AbstractPublicPost(AbstractPost):
    """Abstract subclass for public posts"""
    @abstractmethod
    def public_post_method_only(self):
        raise NotImplementedError


class PublicPost(AbstractPublicPost):
    def public_post_method_only(self):
        ...


class AbstractPersonalPost(AbstractPost):
    """Abstract subclass for personal posts."""
    @abstractmethod
    def personal_post_method_only(self):
        pass


class PersonalPost(AbstractPersonalPost):
    def personal_post_method_only(self):
        ...