Scala：如何通过属性丰富课程

Question

I'm trying to enrich a class with a custom property:

class MyClass {

   def printNumber(n: Int) = {
     println(n)
   }
}

class MyClassWithName(myClass: MyClass, val name: String) {}

implicit def myClassWithName(myClass: MyClass, name: String) = new MyClassWithName(myClass, name)

Then I try to access custom property name like this...

val c = myClassWithName(new MyClass, "jonny")
c.printNumber(5)

... but it does not compile:

value printNumber is not a member of MyClassWithName.

Am I missing something? Tx.

Answer 1

You probably wanted the opposite:

class Wrapper(original: OriginalClass) {
  def printNumber(n: Int) = println(n)
  def printName = println(original.name) // I added this method to justify wrapping of original
}

class OriginalClass(val name: String)

implicit def toWrapper(original: OriginalClass) = new Wrapper(original)

val x = new OriginalClass("johny")
// x: OriginalClass = OriginalClass@21788153

x.printName
// johny

x.printNumber(1)
// 1

Note, that newer versions of scala has more concise syntax with implicit class combination

Answer 2

If you only want to add a name property and nothing else you could do it like this:

object MyClassPlus {
  private val map = scala.collection.mutable.Map.empty[MyClass,String]
}

implicit class MyClassPlus(val myClass: MyClass) extends AnyVal {

  def name = MyClassPlus.map(myClass) 

  def name_= (value: String) {
    MyClassPlus.map(myClass) = value
  }
}

You can then access name as if it's a member of MyClass :

scala> val c = new MyClass
c: MyClass = MyClass@78e312af

scala> c.name = "foo"
c.name: String = foo

scala> c.name
res4: String = foo

Note that with this approach the equals method of MyClass should test for reference equality. Otherwise the Map has to be changed to use reference equality instead.

---

If you want to be able to add many properties to an object at runtime and you can change the definition of the class you can extend Dynamic .

import scala.language.dynamics

class MyClass extends Dynamic {

  private val map = scala.collection.mutable.Map.empty[String,String]

  // the type of value doesn't necessarily have to be String
  def updateDynamic(name: String)(value: String) {
    map(name) = value
  }

  def selectDynamic(name: String) = map(name)
}

Then you can add and access properties like this:

scala> val c = new MyClass
c: MyClass = MyClass@50f85a5f

scala> c.name = "foo"
c.name: String = foo

scala> c.name
res6: String = foo

If you can't change the definition of the class, you could try to do some sort of implicit conversion like this:

object MyClassPlus {
  private val map = scala.collection.mutable.Map.empty[(MyClass,String),String]
}

implicit class MyClassPlus(val myClass: MyClass) extends AnyVal {

  def update(name: String, value: String) {
    MyClassPlus.map((myClass, name)) = value
  }

  def apply(name: String) = MyClassPlus.map((myClass, name))
}

Then you can add and access properties, but with a less intuitive syntax:

scala> val c1 = new MyClass
c1: MyClass = MyClass@635b4736

scala> val c2 = new MyClass
c2: MyClass = MyClass@1be2e9e5

scala> c1("name") = "foo"

scala> c2("name") = "bar"

scala> c1("name")
res2: String = foo

scala> c2("name")
res3: String = bar

Answer 3

Your wrapper class MyClassWithName contains myClass and name as its members. So, in order to access the printNumber function in the class MyClass , you need to access the object myClass first.

You can write a getter method, use @BeanProperty annotation or better yet, use a case class as follows:

case class MyClassWithName(myClass: MyClass, val name: String)

val c = myClassWithName(new MyClass, "jonny")
c.myClass.printNumber(5)

That would compile.