Question

在传统的面向对象语言（例如Java）中，可以扩展＆＃34;通过从重写版本中的超类调用原始方法，继承类中的方法的功能，例如：

class A {
    public void method() {
        System.out.println("I am doing some serious stuff!");
    }
}

class B extends A {
    @Override
    public void method() {
        super.method(); // here we call the original version
        System.out.println("And I'm doing something more!");
    }
}

正如您所看到的，在Java中，我可以使用super关键字从超类中调用原始版本。我能够获得继承特征的等效行为，但在实现结构的特征时却没有。

trait Foo {
    fn method(&self) {
        println!("default implementation");
    }
}

trait Boo: Foo {
    fn method(&self) {
        // this is overriding the default implementation
        Foo::method(self);  // here, we successfully call the original
                            // this is tested to work properly
        println!("I am doing something more.");
    }
}

struct Bar;

impl Foo for Bar {
    fn method(&self) {
        // this is overriding the default implementation as well
        Foo::method(self);  // this apparently calls this overridden
                            // version, because it overflows the stack
        println!("Hey, I'm doing something entirely different!");
        println!("Actually, I never get to this point, 'cause I crash.");
    }
}

fn main() {
    let b = Bar;
    b.method();     // results in "thread '<main>' has overflowed its stack"
}

因此，在继承traits的情况下，调用原始默认实现是没有问题的，但是，在实现结构时使用相同的语法表现出不同的行为。这是Rust内的一个问题吗？有办法解决吗？或者我错过了什么？

Answer 1

现在不可能直接这样做。

但是，RFC 1210: impl specialization包含使这种行为有效的各个方面，例如，这样的事情应该有效：

trait Foo {
    fn method(&self) { println!("default implementation"); }
}
trait Bar: Foo { ... }

partial impl<T: Bar> Foo for T {
    default fn method(&self) { println!("Bar default"); }
}

super电话被明确提及为an extension，因此不一定会立即显示，但可能会在将来出现。

同时，通常使用的方法是为默认行为定义一个单独的函数，并在默认方法中调用它，然后用户可以通过直接调用该函数来模拟super::...调用：< / p>

trait Foo {
    fn method(&self) { do_method(self) }
}

fn do_method<T: Foo>(_x: &T) {
    println!("default implementation");
}

impl Foo for Bar {
    fn method(&self) {
        do_method(self);
        println!("more");
    }
}

也就是说，Rust更喜欢构图而不是继承：在Java中运行良好的设计不能也不应该被强制一对一地生成Rust。

    Foo::method(self);  // this apparently calls this overridden
                        // version, because it overflows the stack

限定路径语法Trait::method(value)是<Type as Trait>::method(value)的糖，其中Type是value的类型（或者，可能是取消引用某些次数后的类型）。也就是说，它正在您发现的特定类型上调用方法。

Answer 2

这是Rust内的一个问题吗？

不，这是按预期工作的

有办法吗？

您可以将方法移动到自由函数，然后直接调用它，从默认方法调用一次，从“重写”方法调用一次。

fn the_default() {
    println!("default implementation");
}

trait Foo {
    fn method(&self) {
        the_default()    
    }
}

struct Bar;

impl Foo for Bar {
    fn method(&self) {
        the_default();
        println!("Hey, I'm doing something entirely different!");
    }
}

fn main() {
    let b = Bar;
    b.method();
}

或者我错过了什么？

~~Rust不是面向对象的语言，~~ Rust可能是一种面向对象的语言，但并非所有的OO语言都是相同的。 Rust可能不太适合您期望的传统范例。

即，在运行时不存在特征。只有当它们应用于结构并与结构一起使用时，才会生成可调用的代码。当您创建自己的方法实现时，它将取代默认实现;存在默认方法实现的任何地方。

通常，您的代码可以以不同的方式编写。也许真正的共享代码应该作为新结构的方法提取，或者你可以为方法提供一个闭包来定制行为。

Answer 3

另一种实现此目的的方法是将覆盖方法放在struct impl块中

trait A {
    fn a(&self) {
        println!("trait default method");
    }
}

struct B;

impl B {
    fn a(&self) {
        println!("overridden method");
        // call default method here
        A::a(self);
    }
}

impl A for B {}

fn main() {
    let a = B;
    a.a();
}

playground

是否可以在结构中扩展特征的默认方法实现？

3 个答案: