Scala中的通用工厂（？）模式

Question

I have a generic class:

class SomeValue[T](private val value: T) {
  override def toString = value.toString
}

In my application, I'm going to be using a particular construction of this class a lot:

val five = new SomeValue[Int](5) // doing this a lot
assert(five.toString == "5")

This is pretty verbose and prone to typos (for example setting it to 6 by accident). To solve this, I'd like to create a class that masks this pattern:

class Five { ... }

So that I can now do this:

val five = new Five
assert(five.toString == "5")

Kind of a dumb example I know, but hope you get the picture!

Answer 1

It seems like you are building constants, hence I would suggest using Scala objects .

eg

object Main extends App {
  assert(Five.toString == "5")
  assert(Hello.toString == "hello")
}

class SomeValue[T](private val value: T) {
  override def toString = value.toString
}

object Five extends SomeValue[Int](5)
object Hello extends SomeValue[String]("hello")

Answer 2

Why not just define a method instead of a whole new class?

class SomeValue[T](private val value: T) { ... }
object SomeValue {
  // since the class appears to be immutable, it could also be a val
  def five = new SomeValue(5)
}

// elsewhere
SomeValue.five

Naturally, this method can have arguments and type arguments if desired (eg to fix only some of constructor arguments).

Answer 3

Came up with this right after posting my question.

class Five extends SomeValue[Int](value = 5) {}

Seems right, but can anyone confirm?