我一直在读this post之类的东西，解释Flutter为什么更喜欢组合而不是继承。虽然我部分理解了其中的原因，但我怀疑在这种做法变得冗长的情况下该怎么办。另外，在Flutter的内部代码中，内置组件到处都是继承。所以从哲学上讲，一定有这样的情况。
考虑这个例子（基于我制作的真实Widget）：

class MyFadingAnimation extends StatefulWidget {
    final bool activated;
    final Duration duration;
    final Curve curve;
    final Offset transformOffsetStart;
    final Offset transformOffsetEnd;
    final void Function()? onEnd;
    final Widget? child;

    const MyFadingAnimation({
        super.key,
        required this.activated,
        this.duration = const Duration(milliseconds: 500),
        this.curve = Curves.easeOut,
        required this.transformOffsetStart,
        this.transformOffsetEnd = const Offset(0, 0),
        this.onEnd,
        this.child,
    });

    @override
    State<MyFadingAnimation> createState() => _MyFadingAnimationBuilder();
}

class _MyFadingAnimationBuilder extends State<MyFadingAnimation> {
    @override
    Widget build(BuildContext context) {
        return AnimatedContainer(
            duration: widget.duration,
            curve: widget.curve,
            transform: Transform.translate(
                offset: widget.activated ?
                    widget.transformOffsetStart : widget.transformOffsetEnd,
            ).transform,
            onEnd: widget.onEnd,
            child: AnimatedOpacity(
                duration: widget.duration,
                curve: widget.curve,
                opacity: widget.activated ? 1 : 0,
                child: widget.child
            ),
        );
    }
}

MyFadingAnimation的目标是在Widget上同时执行平移和不透明度动画。太棒了！
现在，假设我想为这个小部件创建一些“快捷方式”或“别名”，比如水平淡入的MyHorizontalAnimation，或者垂直淡入的MyVerticalAnimation。

class MyHorizontalAnimation extends StatelessWidget {
    final bool activated;
    final Duration duration;
    final Curve curve;
    final double offsetStart;
    final void Function()? onEnd;
    final Widget? child;

    const MyHorizontalAnimation({
        super.key,
        required this.activated,
        this.duration = const Duration(milliseconds: 500),
        this.curve = Curves.easeOut,
        required this.offsetStart,
        this.onEnd,
        this.child,
    });

    @override
    Widget build(BuildContext context) {
        return MyFadingAnimation(
            activated: activated,
            duration: duration,
            curve: curve,
            transformOffsetStart: Offset(offsetStart, 0),
            onEnd: onEnd,
            child: child,
        );
    }
}

这对我来说似乎...非常冗长。所以我最初的想法是“好吧，也许我无论如何都应该试着扩展这个类...”

class MyHorizontalAnimation extends MyFadingAnimation {
    final double offsetStart;

    MyHorizontalAnimation({
        super.key,
        required super.activated,
        super.duration,
        super.curve,
        this.offsetStart,
        super.onEnd,
        super.child,
    }) : super(
        transformOffsetStart: Offset(offsetStart, 0),
    );
}

对我来说，这看起来更干净。另外，它还带来了额外的好处，如果我向MyFadingAnimation添加功能/道具，它 * 几乎 * 会自动集成到MyHorizontalAnimation中（除了必须添加super.newProp）。使用组合方法，我必须添加一个新属性，可能要复制/维护一个默认值，将其添加到构造函数中，等我做完的时候感觉就像是个苦差事。
我使用继承的主要问题是（这可能真的很小），除了我的基本部件MyFadingAnimation之外，我不能为任何东西使用const构造函数。这一点，再加上继承的 * 强烈 * 阻碍，让我觉得有更好的方法。
所以，总结一下，我有两个问题：
1.我应该如何组织上面的代码，使constWidget重定向到其他“基”Widget？
1.什么时候可以使用继承而不是组合？对此是否有一个好的经验法则？