最好的方法，从不同类别

Question

我有这个类

public abstract class Foo { 
    def execute: Unit = ??? 
} 

public abstract class Bar { 
    def execute: Unit = ??? 
} 

public class FooFoo extends Foo { 
    def execute: Unit = ??? 
} 

public class BarBar extends Bar { 
    def execute: Unit = ??? 
} 

在某些运行常用的功能，我有这样的方法：

def executeSomething(body: => AnyRef) : = Try(body) match ... 

而且调用这个样子

x match { 
    case _: Foo => executeSomething(x.execute) 
    case _: Bar => executeSomething(x.execute) 
} 

有没有什么方法可以做到这一点（没有新班级）

val u = executeSomething(x) 

？

UPD

对不起，伙计们。这个m.b.真正的代码会更加清晰

import akka.actor.{Actor, ActorLogging, ActorRef, Props} 
import com.google.api.client.auth.oauth2.AuthorizationCodeTokenRequest 
import com.google.api.client.googleapis.json.GoogleJsonResponseException 
import com.google.api.services.analytics.Analytics 
import com.google.api.services.analyticsreporting.v4.AnalyticsReporting 
import com.my.lab.messages.{GRequest, GResponse} 
import scala.util.{Failure, Success, Try} 

class GQueueTask(req: GRequest, ref: ActorRef) extends Actor with ActorLogging { 

    def receive: Receive = { 
    case _ => 
    } 

    def execute(body: => AnyRef): Unit = { 
    Try(body) match { 
     case Success(r) => ref ! GResponse(req, response = Option(r)) 
     case Failure(f: GoogleJsonResponseException) => 
      f.printStackTrace() 
      ref ! GResponse(req, error = Option(f)) 
     case _ => ref ! GResponse(req, Option("unknown error")) 
    } 
    } 

    req match { 
    case GRequest(request, _) => request match { 
     case x: AnalyticsReporting#Reports#BatchGet => execute(x.execute()) // AbstractGoogleClientRequest 
     case x: Analytics#Data#Ga#Get => execute(x.execute()) // AbstractGoogleClientRequest 
     case x: Analytics#Management#Accounts#List => execute(x.execute()) // AbstractGoogleClientRequest 
     case x: Analytics#Management#Webproperties#List => execute(x.execute()) // AbstractGoogleClientRequest 
     case x: Analytics#Management#Profiles#List => execute(x.execute()) // AbstractGoogleClientRequest 
     case x: AuthorizationCodeTokenRequest => execute(x.execute()) // TokenRequest 
     case _ => ref ! GResponse(req) 
    } 
    } 

    context stop self 
} 

我试图简化 “的要求匹配” 块

Answer 1

虽然可以使用结构类型（鸭打字）实现它，它因为在运行时使用阶内省很大的开销。我认为实现它的最好方法是使用类型类。 Scala的Ordering就是一个例子。

A型类定义与“无关”类型相关联的功能。 你需要做的是在一个特点的形式定义类型类：

trait Executable[T] { 
    def execute(t: T): Unit 
} 

比你需要让你的类型的类型类的成员，例如：

implicit object FooFooExecutable extends Executable[FooFoo] { 
    override def execute(t: FooFoo): Unit = t.execute() 
} 

而且最后一件事是定义将您的类型类作为参数的方法。

def exec[T: Executable](t: T): Unit = { 
    implicitly[ExecTypeClass[T]].execute(t) 
} 

你可以阅读更多关于类型类here，here和here

Answer 2

我想这和它的工作：

object Dummy { 
    abstract class Foo { 
    def execute: Unit 
    } 

    abstract class Bar { 
    def execute: Unit 
    } 

    class FooFoo extends Foo { 
    def execute: Unit = { println("Foo") } 
    } 

    class BarBar extends Bar { 
    def execute: Unit = { println("Bar") } 
    } 

    def run(x: AnyRef): Unit = { 

    x match { 
     case f: Foo => f.execute 
     case b: Bar => b.execute 
     case _ => 
    } 
    } 

    def main(args: Array[String]): Unit = { 
    val any = new BarBar() 
    run(any) 
    } 
} 

它印刷

Bar 

Answer 3

这看起来像duck-typing的一个很好的用例。

Duck Typing更正式地称为Structural Types。

A Duck Type可以被认为只是所需的一组属性的specification。 Compile time reflection用于确保提供的参数的type与您的duck-type的specification兼容。所以它为您提供编译时类型安全性。

然后它使用run time reflection实际调用提供的实例上的各个方法。

所以，

比方说你有以下的抽象，

abstract class Foo { 
    def execute(): Unit 
} 

abstract class Bar { 
    def execute(): Unit 
} 

class FooFoo extends Foo { 
    override def execute(): Unit = { 
    println("FooFoo") 
    } 
} 

class BarBar extends Bar { 
    override def execute(): Unit = { 
    println("BarBar") 
    } 
} 

注::我已经加入()到所有Unit方法。这是Scala中的一个惯例，所有带副作用的方法应该有()。除了副作用之外，Unit方法不能做任何事情。

现在...你只需要定义一个duck-type的共享行为，

type HasExecuteMethod = { 
    def execute(): Unit 
} 

现在...让定义一个使用这种鸭式功能，

def doExecute(hasExecuteMethod: HasExecuteMethod): Unit = { 
    hasExecuteMethod.execute() 
} 

而且...在这里你有它。这个doExecute方法将接受任何具有def execute(): Unit成员的类的实例。