使用Scala的Java中的C＃扩展方法

Question

I need to create some extension methods in my Java code. I've read some posts here in SO and people suggest XTend or Scala in order to achieve this.

Now, my question would be.. if i write kind of an Adapter layer in Scala (adding there my extension methods) and then using that project as a dependency for my own Java project, are those extended methods available for me to use, or they are defined just for the 'scope of Scala project' and then the JVM output cannot provide those new methods to the other project using it?

EDIT: What i need to do is to extend a full hierarchy of classes in a given library and give some new functionality. As for Java's first approach I should extend every class in that hierarchy creating my own hierarchy of extended classes adding the new method there. I would like to avoid this and give the final user the sense of native functionality in the original hierarchy.

Regards.

Answer 1

As mentioned above in the comments, it is very close to C# but not exactly there because of the type erasure. For example, this works fine:

object myLibExtensions {
    implicit class TypeXExtension( val obj: TypeX ) extends AnyRef {
        def myCustomFunction( a: String ): String = {
            obj.someMethod(a)
        }
    }
}

It will act somewhat similar to C# extension methods, ie create static method wrappers in reasonable cases ( but not always ).

The only thing I am missing in Scala is that you can't (or at least I couldn't figure out how to) return the values of the types being extended. For example, assume I want to have something like an extension method "withMeta" that works as follows:

class TypeY extends TypeX { def methodOfY(...) ...}

var y: TypeY = ....

y.withMeta(...).methodOfY(...)

The following didn't work for me:

object myLibExtensions {
    private val something = ....
    implicit class Extension[T<:TypeX]( val obj: T ) extends AnyRef {
        def withMeta( meta: Meta[T] ): T = {
            something.associateMeta(obj,meta)
            val
        }
    }
} 

... because T is being erased to TypeX. So effectively you will have to write extensions for all specific leaf classes of the hierarchy in this case, which is sad.