blocks|key|224057|text|我不知道您是否可以进行以下更改，但您想要的效果可以通过引入一个额外的特征(我称之为Repr)并在Abstract特征中使用abstract+override来实现：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|224058|trait+Repr+{
++++def+userRepr:+String
}

abstract+class+Result+extends+Repr+{
++++def+userRepr:+String+=+"wtv"
}

case+class+ValDefResult(name:+String)+extends+Result+{
++++override+def+userRepr+=+name
}

trait+Abstract+extends+Repr+{+self:+Result+=>
++++abstract+override+def+userRepr+=+"abstract-"+%2B+super.userRepr+//+'super.'+works+now
}|code-block|syntax|javascript|224059|您的示例用法现在提供：|224060|scala>+val+a+=+new+ValDefResult("asd")+with+Abstract
a:+ValDefResult+with+Abstract+=+ValDefResult(asd)

scala>+a.userRepr
res3:+String+=+abstract-asd|224061|entityMap^0|15|4|1C|8|1P|H|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]|$9|V|A|W|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|X|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|Y|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|10|8|@]|D|@]|E|$]]]|P|$]]

I don't know if you are in a position to make the following changes, but the effect you want can be achieved by introducing an extra trait (I'll call it <code>Repr</code>), and using <code>abstract override</code> in the <code>Abstract</code> trait:

<pre><code>trait Repr {
 def userRepr: String
}

abstract class Result extends Repr {
 def userRepr: String = "wtv"
}

case class ValDefResult(name: String) extends Result {
 override def userRepr = name
}

trait Abstract extends Repr { self: Result =&gt;
 abstract override def userRepr = "abstract-" + super.userRepr // 'super.' works now
}
</code></pre>

Your example usage now gives:

<pre><code>scala&gt; val a = new ValDefResult("asd") with Abstract
a: ValDefResult with Abstract = ValDefResult(asd)

scala&gt; a.userRepr
res3: String = abstract-asd
</code></pre>

blocks|key|7500|text|这就是我要找的答案。感谢您使用Scala的abstract+override特性为我指明了正确的方向。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|7501|trait+Abstract+extends+Result+{
++++abstract+override+def+userRepr+=+"abstract+"+%2B+super.userRepr
}

abstract+class+Result+{
++++def+userRepr:+String+=+"wtv"
}

case+class+ValDefResult(name:+String)+extends+Result+{
++++override+def+userRepr+=+name
}

val+a+=+new+ValDefResult("asd")+with+Abstract
a.userRepr|code-block|syntax|javascript|7502|这里提供了实时代码：http://www.scalakata.com/52536cc2e4b0b1a1c4daa4a4|7503|对于令人困惑的示例代码，很抱歉，我正在编写一个处理Scala+AST的库，并且没有足够的灵感来更改名称。|7504|entityMap|0|LINK|mutability|MUTABLE|url|http://www.scalakata.com/52536cc2e4b0b1a1c4daa4a4^0|L|H|0|0|A|1D|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@$9|X|A|Y|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|Z|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|10|8|@]|D|@$9|11|A|12|1|13]]|E|$]]|$1|M|3|N|5|6|7|14|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|15|8|@]|D|@]|E|$]]]|P|$Q|$5|R|S|T|E|$U|V]]]]

Here is the answer I was looking for. Thank you Shadowlands for pointing me in the right direction with Scala's <code>abstract override</code> feature.

<pre><code>trait Abstract extends Result {
 abstract override def userRepr = "abstract " + super.userRepr
}

abstract class Result {
 def userRepr: String = "wtv"
}

case class ValDefResult(name: String) extends Result {
 override def userRepr = name
}

val a = new ValDefResult("asd") with Abstract
a.userRepr
</code></pre>

Live code is available here: <a href="http://www.scalakata.com/52536cc2e4b0b1a1c4daa4a4">http://www.scalakata.com/52536cc2e4b0b1a1c4daa4a4</a>

Sorry for the confusing example code, I am writing a library that deals with the Scala AST and was not inspired enough to change the names.

blocks|key|224145|text|abstract+override是一种机制，也就是可堆叠的特征。值得一提的是，线性化很重要，因为线性化决定了super的含义。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|224146|这个问题是the+canonical+Q&A+on+self-type+vs+extension的一个很好的补充。|224147|继承对于self类型是不明确的：|224148|scala>+trait+Bar+{+def+f:+String+=+"bar"+}
defined+trait+Bar

scala>+trait+Foo+{+_:+Bar+=>+override+def+f+=+"foo"+}
defined+trait+Foo

scala>+new+Foo+with+Bar+{+}
<console>:44:+error:+<$anon:+Foo+with+Bar>+inherits+conflicting+members:
++method+f+in+trait+Foo+of+type+=>+String++and
++method+f+in+trait+Bar+of+type+=>+String
(Note:+this+can+be+resolved+by+declaring+an+override+in+<$anon:+Foo+with+Bar>.)
++++++++++++++new+Foo+with+Bar+{+}
++++++++++++++++++%5E|code-block|syntax|javascript|224149|很明显，你可以选择：|224150|scala>+new+Foo+with+Bar+{+override+def+f+=+super.f+}
res5:+Foo+with+Bar+=+$anon$1@57a68215

scala>+.f
res6:+String+=+bar

scala>+new+Foo+with+Bar+{+override+def+f+=+super[Foo].f+}
res7:+Foo+with+Bar+=+$anon$1@17c40621

scala>+.f
res8:+String+=+foo|224151|或|224152|scala>+new+Bar+with+Foo+{}
res9:+Bar+with+Foo+=+$anon$1@374d9299

scala>+.f
res10:+String+=+foo|224153|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/q/1990948/1296806^0|0|H|1J|5|0|5|17|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|14|8|@$9|15|A|16|B|C]|$9|17|A|18|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|19|8|@]|D|@$9|1A|A|1B|1|1C]]|E|$]]|$1|H|3|I|5|6|7|1D|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1E|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1F|8|@]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1G|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1H|8|@]|D|@]|E|$]]|$1|U|3|V|5|L|7|1I|8|@]|D|@]|E|$M|N]]|$1|W|3|-4|5|6|7|1J|8|@]|D|@]|E|$]]]|X|$Y|$5|Z|10|11|E|$12|13]]]]

<code>abstract override</code> is the mechanism, aka stackable traits. It's worth adding that linearization counts, because that's what determines what <code>super</code> means.

This question is a great addendum to <a href="https://stackoverflow.com/q/1990948/1296806">the canonical Q&amp;A on self-type vs extension</a>.

Where the inheritance is ambiguous with self-types:

<pre><code>scala&gt; trait Bar { def f: String = "bar" }
defined trait Bar

scala&gt; trait Foo { _: Bar =&gt; override def f = "foo" }
defined trait Foo

scala&gt; new Foo with Bar { }
&lt;console&gt;:44: error: &lt;$anon: Foo with Bar&gt; inherits conflicting members:
 method f in trait Foo of type =&gt; String and
 method f in trait Bar of type =&gt; String
(Note: this can be resolved by declaring an override in &lt;$anon: Foo with Bar&gt;.)
 new Foo with Bar { }
 ^
</code></pre>

Then obviously, you can choose:

<pre><code>scala&gt; new Foo with Bar { override def f = super.f }
res5: Foo with Bar = $anon$1@57a68215

scala&gt; .f
res6: String = bar

scala&gt; new Foo with Bar { override def f = super[Foo].f }
res7: Foo with Bar = $anon$1@17c40621

scala&gt; .f
res8: String = foo
</code></pre>

or

<pre><code>scala&gt; new Bar with Foo {}
res9: Bar with Foo = $anon$1@374d9299

scala&gt; .f
res10: String = foo
</code></pre>

It would appear that it is possible to change the implementation of a method on a class with a trait such as follows:

<pre><code>trait Abstract { self: Result =&gt;
 override def userRepr = "abstract"
}

abstract class Result {
 def userRepr: String = "wtv"
}

case class ValDefResult(name: String) extends Result {
 override def userRepr = name
}

val a = new ValDefResult("asd") with Abstract
a.userRepr
</code></pre>

Live code is available here: <a href="http://www.scalakata.com/52534e2fe4b0b1a1c4daa436">http://www.scalakata.com/52534e2fe4b0b1a1c4daa436</a>

But now I would like to call the previous or super implementation of the function such as follows:

<pre><code>trait Abstract { self: Result =&gt;
 override def userRepr = "abstract" + self.userRepr
}
</code></pre>

or

<pre><code>trait Abstract { self: Result =&gt;
 override def userRepr = "abstract" + super.userRepr
}
</code></pre>

However, none of these alternatives compile. Any idea how this could be accomplished?

How to call super method when overriding a method through a trait

似乎可以更改具有如下特征的类上方法的实现：trait Abstract { self: Result =>    override def userRepr = "abstract"}abstract class Result {    def userRepr: String = "wtv"}case class V...

问如何在通过特征重写方法时调用超方法
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在通过特征重写方法时调用超方法EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在通过特征重写方法时调用超方法
EN