blocks|key|1974051|text|您可以只在继承的类中使用虚拟名称：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1974052|case+class+SomeHypothesis(anotherArg:+SomeType,+rq:+Boolean+=+false,+odays:+Seq[Int]+=+Nil)
extends+Hypothesis(rq,+odays)|code-block|syntax|javascript|1974053|但您确实需要重复默认值。不需要覆盖val。|offset|length|style|CODE|1974054|编辑：|1974055|请注意，您的抽象类不应该是case类。扩展case类现在是deprecated。您应该为您的抽象类使用extractor：|1974056|abstract+class+SomeHypothesis(val+request:+Boolean)

object+SomeHypothesis+{
++def+unapply(o:+Any):+Option[Boolean]+=+o+match+{
++++case+sh:+SomeHypothesis+=>+Some(sh.request)
++++case+_+=>+None
++}
}|1974057|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/6002725/which-things-around-case-classes-will-be-removed-after-scala-2-9-exactly|1|http://www.scala-lang.org/node/112^0|0|0|H|3|0|0|T|A|0|1F|9|1|0|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@$I|15|J|16|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|17|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|18|8|@]|9|@$I|19|J|1A|1|1B]|$I|1C|J|1D|1|1E]]|A|$]]|$1|Q|3|R|5|D|7|1F|8|@]|9|@]|A|$E|F]]|$1|S|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|T|$U|$5|V|W|X|A|$Y|Z]]|10|$5|V|W|X|A|$Y|11]]]]

You can just use a dummy name in the inherited class:

<pre><code>case class SomeHypothesis(anotherArg: SomeType, rq: Boolean = false, odays: Seq[Int] = Nil)
extends Hypothesis(rq, odays)
</code></pre>

but you do have to repeat the default values. There is no need to override a <code>val</code>.

EDIT:

Note that your abstract class should not be a case class. Extending case classes is now <a href="https://stackoverflow.com/questions/6002725/which-things-around-case-classes-will-be-removed-after-scala-2-9-exactly">deprecated</a>. You should use an <a href="http://www.scala-lang.org/node/112" rel="nofollow noreferrer">extractor</a> for you abstract class instead:

<pre><code>abstract class SomeHypothesis(val request: Boolean)

object SomeHypothesis {
 def unapply(o: Any): Option[Boolean] = o match {
 case sh: SomeHypothesis =&gt; Some(sh.request)
 case _ =&gt; None
 }
}
</code></pre>

blocks|key|1974144|text|如果假设是一个抽象类，那么我就没有它的构造器。我将这些参数设置为抽象类的抽象属性。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1974145|但是，在这种情况下，您确实需要override修饰符。|offset|length|style|CODE|1974146|entityMap^0|0|F|8|0^^$0|@$1|2|3|4|5|6|7|J|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|K|8|@$D|L|E|M|F|G]]|9|@]|A|$]]|$1|H|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|I|$]]

If Hypothesis is an abstract class, then I'd not have a constructor for it. I'd
set those parameters as abstract attributes of the abstract class.

But then, in this case you do need the <code>override</code> modifier.

blocks|key|1760638|text|在我看来，默认值的策略不属于基类，而应该放在具体的类中。相反，我会执行以下操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1760639|trait+Hypothesis+{
++def+requirement:+Boolean
++def+onlyDays:+Seq[Int]
++/*+other+common+attributes+as+necessary+*/
}

case+class+SomeHypothesis(anotherArg:+SomeType,
++++++++++++++++++++++++++requirement:+Boolean+=+false,
++++++++++++++++++++++++++onlyDays:+Seq[Int]+=+Nil)
++extends+Hypothesis|code-block|syntax|javascript|1760640|SomeHypothesis的case类字段将满足假设特征的要求。|offset|length|style|CODE|1760641|正如其他人所说，您仍然可以使用提取器对常见部分进行模式匹配：|1760642|object+Hypothesis+{
++def+unapply(h:+Hypothesis):+(Boolean,+Seq[Int])+=+(h.requirement,+h.onlyDays)
}|1760643|entityMap^0|0|0|0|E|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@$I|V|J|W|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

In my mind the policy of default values doesn't belong in the base class but should go on the concrete classes. I'd instead do the following:

<pre><code>trait Hypothesis {
 def requirement: Boolean
 def onlyDays: Seq[Int]
 /* other common attributes as necessary */
}

case class SomeHypothesis(anotherArg: SomeType,
 requirement: Boolean = false,
 onlyDays: Seq[Int] = Nil)
 extends Hypothesis
</code></pre>

The case class fields of <code>SomeHypothesis</code> will fulfill the requirements of the Hypothesis trait.

As others have said, you can still use an extractor for pattern matching on the common parts:

<pre><code>object Hypothesis {
 def unapply(h: Hypothesis): (Boolean, Seq[Int]) = (h.requirement, h.onlyDays)
}
</code></pre>

blocks|key|1974436|text|我已经花了几天的时间在办公桌上敲打我的头，试图理解为什么命名的params不会进入扩展课程。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1974437|我尝试了特征，copy()，你能想到的--我和编译器总是不一致，当事情确实编译的时候，值永远不会被传递。|1974438|所以要清楚的是如果你有课程|1974439|class+A(someInt:Int+=+0,+someString:+String+="xyz",+someOtherString:+String+=+"zyx")++|code-block|syntax|javascript|1974440|你想要扩展它：|1974441|class+B+extends+A+//+does+NOT+compile+

class+B(someInt:+Int,+someString:+String,+someOtherString:+String)+extends+A+//+compiles+but+does+not+work+as+expected+|1974442|您可能认为对B的调用如下所示：|1974443|case+object+X+=+B(someInt=4,+someString="Boo",+someOtherString="Who")+|1974444|实际上要么不编译(遗憾的是它编译了)，要么实际工作了(它不编译)|1974445|相反，你需要创建B，如下所示(是的，这是上面答案的重复，但当google引导我到这里时，它一开始并不明显……)|1974446|class+B(someInt:+Int,+someString:+String,+someOtherString:+String)+extends+A(someInt,+someString,+someOtherString)+|1974447|而现在|1974448|case+object+X+=+B(someInt=4,+someString="Boo",+someOtherString="Who")+|1974449|同时进行编译和工作|1974450|我还没有计算出可以在B类构造函数中放置默认值的内容/时间和位置的所有组合和排列，但我非常确定可以在B类的定义中指定具有“预期”结果的默认值。|1974451|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|18|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|19|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1A|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|1B|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|1C|8|@]|9|@]|A|$]]|$1|M|3|N|5|H|7|1D|8|@]|9|@]|A|$I|J]]|$1|O|3|P|5|6|7|1E|8|@]|9|@]|A|$]]|$1|Q|3|R|5|H|7|1F|8|@]|9|@]|A|$I|J]]|$1|S|3|T|5|6|7|1G|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1H|8|@]|9|@]|A|$]]|$1|W|3|X|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|Y|3|Z|5|6|7|1J|8|@]|9|@]|A|$]]|$1|10|3|11|5|H|7|1K|8|@]|9|@]|A|$I|J]]|$1|12|3|13|5|6|7|1L|8|@]|9|@]|A|$]]|$1|14|3|15|5|6|7|1M|8|@]|9|@]|A|$]]|$1|16|3|-4|5|6|7|1N|8|@]|9|@]|A|$]]]|17|$]]

I've spend DAYS bashing my head on the desk trying to understand why named params were not going into an extended class.

I tried traits, copy() you name it - me and the compiler were always at odds and when things did compile the values never got passed. 

So to be clear if you have class 

<pre><code>class A(someInt:Int = 0, someString: String ="xyz", someOtherString: String = "zyx") 
</code></pre>

And you want to extend it: 

<pre><code>class B extends A // does NOT compile 

class B(someInt: Int, someString: String, someOtherString: String) extends A // compiles but does not work as expected 
</code></pre>

You would think that a call to B like so: 

<pre><code>case object X = B(someInt=4, someString="Boo", someOtherString="Who") 
</code></pre>

Would in fact either NOT compile (sadly it does) or actually work (it does NOT)

Instead you need to create B as follows (yes this is a repeat of an above answer but it wasn't obvious at first when google led me here...) 

<pre><code>class B(someInt: Int, someString: String, someOtherString: String) extends A(someInt, someString, someOtherString) 
</code></pre>

and now 

<pre><code>case object X = B(someInt=4, someString="Boo", someOtherString="Who") 
</code></pre>

Both COMPILES and WORKS 

I have not yet worked out all the combinations and permutations of what/when and where you can put default values in the class B constructor but I'm pretty sure that defaults can be specified in the definition of class B with "expected" results.

I have an abstract base class with several optional parameters:

<pre><code>abstract case class Hypothesis(
 requirement: Boolean = false,
 onlyDays: Seq[Int] = Nil,
 …
) extends Something {…}
</code></pre>

Do i really need to explicitly repeat all parameters with the additional keywords <code>override val</code> on top‽

<pre><code>case class SomeHypothesis(
 anotherArg: SomeType,
 override val requirement: Boolean = false,
 override val onlyDays: Seq[Int] = Nil,
 …
) extends Hypothesis(
 requirement,
 onlyDays,
 …
) {…}
</code></pre>

Or is there a syntax like

<pre><code>case class SomeHypothesis(anotherArg: SomeType, **) extends Hypothesis(**) {…}
</code></pre>

I don’t even need <code>anotherArg</code>, just a way to pass all keyword args to the super constructor.

<hr>

I really like Scala’s idea about constructors, but if there isn’t a syntax for that one, I’ll be disappoint :(

Scala inherit parameterized constructor

编译器

我有一个带有几个可选参数的抽象基类：abstract case class Hypothesis(    requirement: Boolean = false,    onlyDays:   Seq[Int] = Nil,    …) extends Something {…}我真的需要在顶部‽上显式地重复所有带有...

问Scala继承参数化构造函数
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala继承参数化构造函数EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Scala继承参数化构造函数
EN