通过上面的abstract override def doAction {}语句来覆盖虚方法。具体来说这当中的super.doAction是关键，他调用了TAction的doAction方法。其原理是，由于doAction是虚方法，所以实际被执行的是被调用的实体类中所定义的方法。
那么将实际执行的实体类RealAction作为TAction的子类来实现吧。
- class RealAction extends TAction {
- def doAction = { println("** real action done!! **") }
- }
|
接着就执行一下。
- scala> val act1 = new RealAction with TBeforeAfter
- act1: RealAction with TBeforeAfter = $anon$1@3bce70
- scala> act1.doAction
- /entry before-action
- ** real action done!! **
- /exit after-action
|
仅仅这样还不好玩，接着为他定义一下别的方面，然后将这些方面加入到同一对象的方法中。接着定义一个将源方法执行两遍的方面。
- trait TTwiceAction extends TAction {
- abstract override def doAction {
- for ( i <- 1 to 2 ) {
- super.doAction
- println( " ==> No." + i )
- }
- }
- }
|
下面，将TBeforeAfter和TtwiceAction混合在一起后执行一下。
- scala> val act2 = new RealAction with TBeforeAfter with TTwiceAction
- act2: RealAction with TBeforeAfter with TTwiceAction = $anon$1@1fcbac1
- scala> act2.doAction
- /entry before-action
- ** real action done!! **
- /exit after-action
- ==> No.1
- /entry before-action
- ** real action done!! **
- /exit after-action
- ==> No.2
|
伴随着原来方法的before/after动作一起各自执行了两次。接着将混入顺序颠倒后再试一下。
- scala> val act3 = new RealAction with TTwiceAction with TBeforeAfter
- act3: RealAction with TTwiceAction with TBeforeAfter = $anon$1@6af790
- scala> act3.doAction
- /entry before-action
- ** real action done!! **
- ==> No.1
- ** real action done!! **
- ==> No.2
- /exit after-action
|
这样执行后，原来的实现方法被循环执行了两次，但是before/after则在循环以外整体只执行了一次。这是根据with语句定义的顺序来执行的，知道了这原理之后也就没有什么奇怪的了。Scala特性的如此混入顺序是和AspectJ的方面以及Spring的interceptor相同的。
这样不仅是before和after动作，只要更改了特征的实现就可以将各种方面动态地加入到原来的对象中去了，读者自己也可以尝试一下各种其他情况。
在Java中通过Decorator或Template Method模式来想尽办法实现的功能，在Scala中只要通过特征就可以轻松到手了。从这还可以延展开来，通过在原来的方法中插入挂钩的方法，即所谓的拦截者式面向方面的方法，就可以轻松地将各个方面通过特征来组件化了。
