传统的面向对象模型

传统程序的面向对象模型，即OOP思维，它的思路是线性的，假定你定义一个父类，然后定义一个子类继承一个父亲类。 伪代码：

class father {
func init () {}
}
class son extends father {
func init () { super() }
}

这样做的好处很显而易见：方便实现。并且，大部分程序也只需要用到线性的单继承即可。

那么问题来了，当你做游戏开发时，一般习惯是将玩家类、物件类和敌人类分开定义，但这时候你就会发现，有些方法，似乎是需要玩家类、物件类和敌人类同时实现的通用方法。比如说最常见的 move 、interact等方法。

传统的做法是将所有类继承同一个父类，但这样就意味着父类几乎没什么可以写的逻辑，也不够优雅。

为了实现这种需求，现代语言引入了一个新的语法特性，那就是接口。 接口简单来说就是一种方法类型的抽象，通过多个类实现同一个接口，从而补全面向对象模式中存在的类继承的问题。

当然，这样又引出了新的问题，那就是每个重复的方法必须重新实现接口，这方面除了复制粘贴同一个代码，或者写复杂的C++模板类型之外别无他法，但这样就会让语言的语法要素显得过于臃肿，关键字不断增多，心智负担也加重。

可以看出，这也是Algol系语言最大的弊端，要实现语法的扩展，必须不断地给自身添加各种复杂的新特性。

CLOS

那么有没有什么方式，不需要引入新的语法特性、不需要重复写代码和在几百个实现同一个接口的类之间复制粘贴同一份代码，也能优雅地实现游戏中常见的多类和多方法分派需求的呢？ 答案是：多继承和多重分派。 多继承和多重分派，这也就是CLOS，作为Common Lisp的面向对象系统最显著的一个特性。 请看下面这些代码及类定义：

(defclass interactable ())
(defclass moveable ())
(defclass player (interactable location moveable character listener)
(name :initform :player))
(defclass enemy (interactable location moveable character)
(name :initform :enemy)
(disabled :initform nil :accessor disabled))
(defmethod move ((m moveable))
(setf (location m) (v+ (vec 1 1 0 0) (location m))))
(defmethod move :before ((m moveable))
(print "before move"))
(defmethod move :after ((m moveable))
(print "after move"))
(defmethod move ((p player))
(call-next-method))
(defmethod move ((e enemy))
(setf (location e) (v- (vec 1 1 0 0) (location e))))
(defmethod move :before ((e enemy))
(print "before enemy move"))
(defmethod move :after ((e enemy))
(print "after enemy move"))
(defmethod move :around ((e enemy))
(unless (disabled e)
(call-next-method)))
(defmethod interact ((i interactable))
(print "interacted"))

上面这段代码，定义了四个类型，分别是interactable moveable player和enemy。 其中，player和enemy都继承了interactable和moveable，虽然还继承了其它的，不过都可以看作是多余的类型继承。

可以看到，这就是我们说的第一个特性，多继承，一个子类可以继承多个父类，有人会问，那么继承的父类怎么分派？

这就是多继承的重点了，为了解决如何分派，CommonLisp发明了一套专门用于解决多继承问题的算法，那就是C3线性化算法。

C3算法满足下列三个核心约束： -子类优先：如果 B 继承自 A，那么 B 永远排在 A 前面。 -局部顺序保留：如果定义时写的是 class D(B, C)，那么顺序必须是 B 在 C 前面。 -单调性：如果在类 C 的序列中 X 在 Y 前面，那么在 C 的任何子类序列中，X 也必须在 Y 前面。

接下来，大家可能会注意到，我定义方法的时候，并不是在类里面定义，而是将类型定义为方法的参数，这就是我们要讲的第二个特性：多重分派。

简单来讲，在Common Lisp中，方法本身是独立于类的，并且会根据传参的类型，自动将方法分派给使用的类型。

也就是说，在Common Lisp语言中，我们是根据方法思考它能匹配，默认匹配什么类型，而不是根据类型思考它拥有什么方法。

当然，值得注意的点是，CL中，方法都是固定参数数量的，也就是第一个defmethod的时候，方法的参数数量就固定了下来，当然你也可以在第一个defmethod后面加&key以及&rest 之类的关键字允许额外参数的传入。

当然，CommonLisp还提供了一个抽象通用方法的定义函数，就是defgeneric，通过defgeneric，可以规定一个方法的参数量和形式，第一个defmethod默认就是在没有defgeneric的时候会自动定义。

比方说，我给moveable定义了move的方法，因为player使用了call-next-method方法来调用父类的move，因此player会继承父类的move方法，当然你不调用move方法，默认也会继承move方法，而enemy调用的move方法，因为覆盖了原来的move方法，所以执行的move逻辑会不同于player和其它继承moveable类的move方法。

因此，interactable的调用结果，player和enemy都是一致的。

此外，大家可能还有注意到，一类带特殊关键字的方法形式，分别是 :before :after :around ，这类形式顾名思义，看着也很简单，分别是代表的在方法执行前执行、方法执行后执行和外包覆盖执行。

首先来讲 :before 和 :after ，这两个都是所有子类和父类的方法都会按C3算法顺序执行的，因为默认就是顺序执行，因此方法内部并不需要call-next-method调用，但是必须要有定义了主方法才能会执行，因为这两个都是随主方法执行一起执行的方法。

:before 在主方法之前执行，并会遵循从最具体到最不具体的类执行，它先跑完子类的逻辑才会跑父类的逻辑，只有当所有before跑完后，才会执行主方法。 而 :after 刚好相反，它会在主方法之后执行，并遵循从最不具体到最具体的类的顺序，也就是先跑完父类的逻辑才跑子类，所有after跑完后，方法才算执行结束。

因此上面的执行结果是，player会print出 before move 和after move，而enemy类，会依次把 before enemy move ，before move，after move ，after enemy move都print出来。

最后一个就是 :around ，这个非常有趣且特殊，它的作用是在外面包一层方法，简单来说，就是将整个方法包括主方法阶段、before阶段、after阶段的控制权，都封装在around的call-next-method里面执行，此外around是可以嵌套的。

在around里面，如果父方法没有实现around，那么call-next-method调用会从before阶段开始，将主方法执行一遍，再执行after，最后返回主方法的值，当然你也可以直接拿取call-next-method的结果做进一步操作，如果父方法有实现around，则call-next-method会执行父方法的around。

因此，我针对enemy写的这个around，意味着只要enemy的disable属性不为t，enemy就会进一步执行move方法的操作。

元对象协议

CommonLisp的对象系统，除了CLOS之外，还有另一个非常强大的特性，那就是元对象协议（MOP）。 MOP 是“代码即数据”和“自举性”在面向对象领域的终极体现。 它通过将类、方法、槽（Slots）本身也定义为对象（即元对象），让你可以通过 CLOS 的方式来重新定义 CLOS。

在具有 MOP 的 Common Lisp 中： - 类（Class）本身是一个对象，它是 standard-class 的一个实例。 - 槽（Slot，即成员变量）本身也是对象。 - 方法（Method）也是对象。

因为有这个强大的特性，你可以在运行时改动类的行为和继承关系、重定义类和槽的访问等。 这一块因为介绍起来比较麻烦，就不展开阐述了，不过最常用的元对象协议就是定义槽的存储和类的初始化的方法，当然除此之外MOP还有许多强大的和元对象协议接口，都可以通过定义函数和元类的方式拦截。