设计原则：请重新审视“多重继承”，找机会拥抱一下“掺入（Mixin）”

名称解释

多重继承：我没有使用多重继承的经验，因此这里不多说，大学学的C++，可惜没有学好。

Mixin：一个Mixin是一个方法和属性的集合，不同的语言提供的实现机制不一样。类型定义的时候可以声明他想包含的Mixin（可以是多个），这些Mixin包含的方法会成为类型的一部分。

使用动机

代码复用 AND 运行时不改变。

Mixin是推论，MixinTarget是定理。如：C#的IEnumerable（MixinTarget）只包含一个方法，根据这个方法（定理）Enumerable（Mixin）扩展了N个方法（推论）。

示例（ExtJs4.2）

/// <reference path="../ext-all-debug-w-comments.js" />
 Ext.define('Enjoyable', {
     play: function () {
         console.log(this.getName() + '-play');
     }
 });
 
 Ext.define('Workable', {
     work: function () {
         console.log(this.getName() + '-work');
     }
 });
 
 Ext.define('User', {
     mixins: {
         'enjoyable': 'Enjoyable',
         'workable': 'Workable'
     },
     config: { name: 'unknow' },
 
     constructor: function () {
         var me = this;
 
         me.initConfig(arguments);
     },
 
     eat: function () {
         for (var i = 0; i < arguments.length; i++) {
             console.log(arguments[i]);
         }
     }
 });
 
 var user = Ext.create('User');
 
 user.setName('段光伟');
 
 user.play();
 user.work();

示例（C#扩展方法）

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 namespace MixinDemo
 {
     public class User
     {
         public string Name { get; set; }
     }
 
     public static class Enjoyable
     {
         public static void Play(this User user)
         {
             Console.WriteLine(user.Name + "-play");
         }
     }
 
     public static class Workable
     {
         public static void Work(this User user)
         {
             Console.WriteLine(user.Name + "-work");
         }
     }
 }

示例（C#动态代理）

using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
 using Castle.DynamicProxy;
 using Castle.DynamicProxy.Generators;
 
 namespace MixinStudy
 {
     class Program
     {
         static void Main(string[] args)
         {
             var proxy = Factory.Create<User>();
             proxy.Id = Guid.NewGuid();
             proxy.Name = "段光伟";
 
             (proxy as ITeacher).Teach();
             (proxy as IFather).Play();
         }
     }
 
     [Mixin(typeof(Teacher))]
     [Mixin(typeof(Father))]
     public class User
     {
         public virtual Guid Id { get; set; }
         public virtual string Name { get; set; }
     }
 
     public interface ITeacher
     {
         User User { get; set; }
 
         void Teach();
     }
 
     public class Teacher : ITeacher
     {
         [MixinTarget]
         public User User { get; set; }
 
         public void Teach()
         {
             Console.WriteLine("我教你读书吧：" + this.User.Name);
         }
     }
 
     public interface IFather
     {
         User User { get; set; }
 
         void Play();
     }
 
     public class Father : IFather
     {
         [MixinTarget]
         public User User { get; set; }
 
         public void Play()
         {
             Console.WriteLine("我陪你玩吧：" + this.User.Name);
         }
     }
 
     public static class Factory
     {
         public static T Create<T>(params object[] args)
             where T : class
         {
             var generator = new ProxyGenerator();
 
             var options = new ProxyGenerationOptions();
 
             foreach (MixinAttribute attribute in typeof(User).GetCustomAttributes(true))
             {
                 var mixin = Activator.CreateInstance(attribute.MixinType);
 
                 options.AddMixinInstance(mixin);
             }
 
             var target = Activator.CreateInstance(typeof(T), args) as T;
 
             var proxy = generator.CreateClassProxyWithTarget(target, options);
 
             foreach (var mixin in options.MixinsAsArray())
             {
                 foreach (var property in mixin.GetType().GetProperties())
                 {
                     if (property.GetCustomAttributes(typeof(MixinTargetAttribute), true).Any())
                     {
                         property.SetValue(mixin, target);
                     }
                 }
             }
 
             return proxy;
         }
     }
 
     [AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
     public class MixinAttribute : Attribute
     {
         public MixinAttribute(Type mixinType)
         {
             this.MixinType = mixinType;
         }
 
         public Type MixinType { get; set; }
     }
 
     public class MixinTargetAttribute : Attribute
     {
     }
 }

示例（C++）

class Enjoyable
 {
 public:
     Enjoyable(void);
     ~Enjoyable(void);
     void Play();
     virtual string GetName() = 0;
 };
 
 class Workable
 {
 public:
     Workable(void);
     ~Workable(void);
     void Work();
     virtual string GetName() = 0;
 };
 
 class User: public Enjoyable, public Workable
 {
 public:
     User(void);
     ~User(void);
 
 private:
     string name;
 
 public: 
     string GetName();
     void SetName(string name);
 };
 
 User::User(void)
 {
 }
 
 User::~User(void)
 {
 }
 
 string User::GetName()
 {
     return this->name;
 }
 
 void User::SetName(string name)
 {
     this->name = name;
 }
 
 void Enjoyable::Play(){
     cout << ( this->GetName() + "play");
 }
 
 void Workable::Work(){
     cout << ( this->GetName() + "work");
 }

示例（Ruby）

module Enjoyable
     def play
         puts(self.name + "-play")
     end
 end
 
 module Workable
     def work
         puts(self.name + "-work")
     end
 end
 
 class User
     include Enjoyable, Workable
 
     attr_accessor :name
 end
 
 user = User.new
 user.name = "段光伟"
 user.play
 user.work

 代码示例（Java的Qi4j）

示例地址：http://qi4j.org/latest/two-minutes-intro.html

 代码示例（Python）

user.py

class User():
        def __init__(self):
                self.name = "unkwnow"

        from Enjoyable import play
        from Workable import work

        def getName(self):
                return self.name

        def setName(self, name):
                self.name = name

user = User()
user.setName("段光伟")
user.play()
user.work()
        

Enjoyable.py

def play(self):
	print(self.name + "-play")

Workable.py

def work(self):
	print(self.name + "-work")

备注

在学习一门语言的时候，如何模拟Mixin是我必须思考的一个东西。