在Scala中将依赖对象传递给父构造函数 [英] Passing dependent objects to a parent constructor in Scala

问题描述

假设我有以下类的父类：

  class A（）
 class B（a：A） 
 class C（b：B）
 
 class BaseClass（b：B，c：C）
  

现在我想实现一个BaseClass的子类，它被赋予A的一个实例，并构造B和C的实例，并传递给它的超类构造函数。

如果我可以使用任意表达式，我会这样做：

  b = new B（a）
c =新C（b）
 super（b，c）
  

因为父构造函数的第二个参数取决于第一个参数的值，所以我不能看到任何方法来做到这一点，而不使用工厂函数或无意的黑客，例如：

  class IntermediateSubclass（b：B）extends BaseClass（b，new C（b））
 class RealSubclass是否有干净的方法？
 
 
 
解决方案
处理这种情况的最佳方法是在您要写的BaseClass子类的随播对象中编写一个工厂方法
  class A（）
 class B（a：A）
 class C（b：B ）
 
 class BaseClass（b：B，c：C）
 
类SBC私有（a：A，b：B，c：C） （b，c）
 
对象SBC 
 {
 def 
 apply（a：A）：SBC = {
 val b = new B ）
 val c = new C（b）
 new SBC（a，b，c）
} 
} 
  
您可以将任何构造函数参数转换为字段而不影响任何内容（通过前缀 val 不熟悉该语法）：
  class A（）
 class B（val a：A）
类C（val b：B）
 
类BaseClass（val b：B，val c：C）
 
类SBC私有（val a：A，b： B，c：C）
 extends BaseClass（b，c）
 
对象SBC 
 {
 def 
 apply（a：A）：SBC = {
 val b = new B（a）
 val c = new C（b）
 new SBC（a，b，c）
} 
} 
  
现在可以创建 SBC 的新实例表达式的类型： SBC（aValue）（无论是否使用 val  b 
 $ b 
  scala> val a1 = new A 
 a1：A = A @ 14a8f44 
 
 scala> val sbc1 = SBC（a1）
 sbc1：SBC = SBC @ 7d8bb 
 
 scala> sbc1.a 
 res0：A = A @ 14a8f44 
 
 scala> sbc1.b 
 res1：B = B @ c7272 
 
 scala> sbc1.c 
 res2：C = C @ 178743b 
  
 
Suppose I have the following class heirarchy:
class A()
class B(a:A)
class C(b:B)

class BaseClass(b:B, c:C)
Now I want to implement a subclass of BaseClass, which is given an instance of A, and constructs instances of B and C, which it passes to its superclass constructor.

If I could use arbitrary expressions, I'd do something like this:
b = new B(a)
c = new C(b)
super(b, c)
Because the second argument to the parent constructor depends on the value of the first argument, though, I can't see any way to do this, without using a factory function, or a gratuitous hack, such as :
class IntermediateSubclass(b:B) extends BaseClass(b, new C(b))
class RealSubclass(a:A) extends IntermediateSubclass(new B(a))
Is there clean way to do this?
解决方案
Probably the best way to handle this sort of situation is by writing a factory method in the companion object for the subclass of BaseClass you want to write.
class A()
class B(a:A)
class C(b:B)

class BaseClass(b:B, c:C)

class SBC private (a: A, b: B, c: C)
extends BaseClass(b, c)

object SBC
{
    def
    apply(a: A): SBC = {
        val b = new B(a)
        val c = new C(b)
        new SBC(a, b, c)
    }
}
You can make any of those constructor parameters into fields without affecting anything (by prefixing with val, if you're not familiar with that syntax):
class A()
class B(val a: A)
class C(val b: B)

class BaseClass(val b: B, val c: C)

class SBC private (val a: A, b: B, c: C)
extends BaseClass(b, c)

object SBC
{
    def
    apply(a: A): SBC = {
        val b = new B(a)
        val c = new C(b)
        new SBC(a, b, c)
    }
}
Now new instances of SBC can be created with this sort of expression: SBC(aValue) (regardless of whether the vals are used).
scala> val a1 = new A
a1: A = A@14a8f44

scala> val sbc1 = SBC(a1)
sbc1: SBC = SBC@7d8bb

scala> sbc1.a
res0: A = A@14a8f44

scala> sbc1.b
res1: B = B@c7272

scala> sbc1.c
res2: C = C@178743b


                        
这篇关于在Scala中将依赖对象传递给父构造函数的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！