写的都是看到的——面向对象编程（二）

刺骨的言语ヽ痛彻心扉 2022-07-15 12:24 39阅读 0赞

# 传宗接代——继承 #

“小白，看继承呢？”小铭忙完自己的事情走过来。

“是呀，刚才学习类，发现每个类都有3个部分，第一部分是构造函数内的，这是供实例化对象复制用的，第二部分是构造函数外的，直接通过点语法添加的，这是供类使用的，实例化对象是访问不到的，第三部分是类的原型中的，实例化对象可以通过其原型链间接地访问到，也是为供所有实例化对象所共用的。然而在继承中所涉及的不仅仅是一个对象。”

“对呀，不过继承这种思想却很简单，如千年文明能够流传至今靠的就是传承，将这些有用的文化一年一年地流传下来，又如我们祖先一代一代地繁衍，才有了今天的我们。所以继承涉及的不仅仅是一个对象。如人类的传宗接代，父母会把自己的一些特点传给孩子，孩子具有了父母的一些特点，但又不完全一样，总会有自己的特点，所以父母与孩子又是不同的个体。”

“可是JavaScript并没有继承这一现有的机制，它又是如何实现的呢？”

## 子类的原型对象——类式继承 ##

“对呀，也正因为JavaScript少了这些显性的限制才使得其具有了一定的灵活性，所以我们可以根据不同的需求实现多样式的继承。比如常见的类式继承。”

// 类式继承
    // 声明父类
    function SuperClass(){
        
    　　this.superValue = true;
    }
    // 为父类添加共有方法
    SuperClass.prototype.getSuperValue = function(){
        
    　　return this.superValue;
    };
    // 声明子类
    function SubClass(){
        
    　　this.subValue = false;
    }
    // 继承父类
    SubClass.prototype = new SuperClass();
    // 为子类添加共有方法
    SubClass.prototype.getSubValue = function (){
        
    　　return this.subValue;
    };

“很像，真的很像!”小白很惊讶。

“像什么？”小铭不解地问。

“刚才看过的封装呀，不同的是这里声明了2个类，而且第二个类的原型prototype被赋予了第一个类的实例。”小白解释道。

“很对，继承很简单，就是声明2个类而已，不过类式继承需要将第一个类的实例赋值给第二个类的原型。但你知道为何要这么做么？”

“类的原型对象的作用就是为类的原型添加共有方法，但类不能直接访问这些属性和方法，必须通过原型prototype来访问。而我们实例化一个父类的时候，新创建的对象复制了父类的构造函数内的属性与方法并且将原型proto指向了父类的原型对象，这样就拥有了父类的原型对象上的属性与方法，并且这个新创建的对象可直接访问到父类原型对象上的属性与方法。如果我们将这个新创建的对象赋值给子类的原型，那么子类的原型就可以访问到父类的原型属性和方法。”小白还有些不自信。

“对，你分析得很准确。补充一点，你说的新创建的对象不仅仅可以访问父类原型上的属性和方法，同样也可访问从父类构造函数中复制的属性和方法。你将这个对象赋值给子类的原型，那么这个子类的原型同样可以访问父类原型上的属性和方法与从父类构造函数中复制的属性和方法。这正是类式继承原理。”

“原来是这样，但是我们要如何使用子类呢？”小白问道。

“使用很简单，像下面这样即可。”小铭说。

var instance = new SubClass();
    console.log(instance.getSuperValue());　　//true
    console.log(instance.getSubValue());　　　　//false

“另外，我们还可以通过instanceof来检测某个对象是否是某个类的实例，或者说某个对象是否继承了某个类。这样就可以判断对象与类之间的继承关系了。”小铭补充说。

“instanceof？它如何就知道对象与类之间的继承关系呢？”小白不解。

“instanceof是通过判断对象的prototype链来确定这个对象是否是某个类的实例，而不关心对象与类的自身结构。”

“原来是这样。”于是小白写下测试代码。

console.log(instance instanceof SuperClass); 　　//true
    console.log(instance instanceof SubClass);　　　　//true
    console.log(SubClass instanceof SuperClass);　　//false

“我们说subClass继承superClass，可是为什么SubClass instanceof SuperClass得到的结果是false呢？”小白不解。

“前面说了，instanceof是判断前面的对象是否是后面类（对象）的实例，它并不表示两者的继承，这一点你不要弄混，其次我们看看前面的代码，你看我们在实现subClass继承superClass时是通过将superClass的实例赋值给subClass的原型prototype，所以说SubClass.prototype继承了superClass。”小铭解释说。

于是小白半信半疑地写下测试代码。

console.log(SubClass.prototype instanceof SuperClass);　　//true

“哦，这么说Object就是所有对象的祖先了。”小白笑着说。

“哈哈，可是你知道吗，这种类式继承还有2个缺点。其一，由于子类通过其原型prototype对父类实例化，继承了父类。所以说父类中的共有属性要是引用类型，就会在子类中被所有实例共用，因此一个子类的实例更改子类原型从父类构造函数中继承来的共有属性就会直接影响到其他子类，比如你看下面的代码。”

function SuperClass(){
    　　this.books = ['JavaScript', 'html', 'css'];
    }
    function SubClass(){}
    SubClass.prototype = new SuperClass();
    var instance1 = new SubClass();
    var instance2 = new SubClass();
    console.log(instance2.books);　　// ["JavaScript", "html", "css"] 
    instance1.books.push('设计模式');
    console.log(instance2.books);　　// ["JavaScript", "html", "css", "设计模式"]

“instance1的一个无意的修改就会无情地伤害了instance2的book属性，这在编程中很容易埋藏陷阱。其二，由于子类实现的继承是靠其原型prototype对父类的实例化实现的，因此在创建父类的时候，是无法向父类传递参数的，因而在实例化父类的时候也无法对父类构造函数内的属性进行初始化。”

“那我们要如何解决这些问题呢？”小白好奇地追问。

## 创建即继承——构造函数继承 ##

“别着急，JavaScript是灵活的，自然也会有其他继承方法来解决，比如常见的构造函数继承。”

//构造函数式继承
    // 声明父类
    function SuperClass(id){
        
    　　// 引用类型共有属性
    　　this.books = ['JavaScript', 'html', 'css'];
    　　// 值类型共有属性
    　　this.id = id;
    }
    // 父类声明原型方法
    SuperClass.prototype.showBooks = function(){
        
    　　console.log(this.books);
    }
    // 声明子类
    function SubClass(id){
        　
    　　// 继承父类
    　　SuperClass.call(this, id);
    }
    // 创建第一个子类的实例
    var instance1 = new SubClass(10);
    // 创建第二个子类的实例
    var instance2 = new SubClass(11);
    instance1.books.push("设计模式");
    console.log(instance1.books);　 　　// ["JavaScript", "html", "css", "设计模式"]　
    console.log(instance1.id);　　　　// 10 
    console.log(instance2.books); 　　// ["JavaScript", "html", "css"] 
    console.log(instance2.id); 　　　　// 11 
    instance1.showBooks();　　　　　　// TypeError

“小白，注意这里。SuperClass.call(this, id);这条语句是构造函数式继承的精华，由于call这个方法可以更改函数的作用环境，因此在子类中，对superClass调用这个方法就是将子类中的变量在父类中执行一遍，由于父类中是给this绑定属性的，因此子类自然也就继承了父类的共有属性。由于这种类型的继承没有涉及原型prototype，所以父类的原型方法自然不会被子类继承，而如果要想被子类继承就必须要放在构造函数中，这样创建出来的每个实例都会单独拥有一份而不能共用，这样就违背了代码复用的原则。为了综合这两种模式的优点，后来有了组合式继承。”

## 将优点为我所用——组合继承 ##

“组合继承是不是说将这两种继承模式综合到一起呀？那么它又是如何做到的呢？”

“别着急，我们先总结一下之前两种模式的特点，**类式继承是通过子类的原型prototype对父类实例化来实现的**，**构造函数式继承是通过在子类的构造函数作用环境中执行一次父类的构造函数来实现的**，所以只要在继承中同时做到这两点即可，看下面的代码。”

// 组合式继承
    // 声明父类
    function SuperClass(name){
        
    　　// 值类型共有属性
    　　this.name = name;
    　　// 引用类型共有属性
    　　this.books = ["html", "css", "JavaScript"];
    }
    // 父类原型共有方法
    SuperClass.prototype.getName = function(){
        
    　　console.log(this.name);
    };
    // 声明子类
    function SubClass(name, time){
        　
    　　// 构造函数式继承父类name属性
    　　SuperClass.call(this, name);
    　　// 子类中新增共有属性
    　　this.time = time;
    }
    // 类式继承 子类原型继承父类
    SubClass.prototype = new SuperClass();
    // 子类原型方法
    SubClass.prototype.getTime = function(){
        
    　　console.log(this.time);
    };

“小白看到没，在子类构造函数中执行父类构造函数，在子类原型上实例化父类就是组合模式，这样就融合了类式继承和构造函数继承的优点，并且过滤掉其缺点，你测试看看。”

于是小白写下测试代码。

var instance1 = new SubClass("js book", 2014);
    instance1.books.push("设计模式");　　
    console.log(instance1.books);　　　// ["html", "css", "JavaScript", "设计模式"] 
    instance1.getName();　　 　　　　// js book
    instance1.getTime();　　 　　　　// 2014　
    var instance2 = new SubClass("css book", 2013);
    console.log(instance2.books);　　　// ["html", "css", "JavaScript"] 
    instance2.getName();　　　　　　　// css book 
    instance2.getTime();　　 　　　　// 2013

“真的是这样呀，”小白兴奋地说，“子类的实例中更改父类继承下来的引用类型属性如books，根本不会影响到其他实例，并且子类实例化过程中又能将参数传递到父类的构造函数中，如name。这种模式真的很强大，所以这应该是继承中最完美的版本吧？”

“还不是，因为我们在使用构造函数继承时执行了一遍父类的构造函数，而在实现子类原型的类式继承时又调用了一遍父类构造函数。因此父类构造函数调用了两遍，所以这还不是最完美的方式。”

“难道还有更好的方式么？”

“那当然，JavaScript很灵活嘛。不过在学习这种方式之前我们先学习一个简单而很常用的方式。”

## 洁净的继承者——原型式继承 ##

“2006年道格拉斯·克罗克福德发表一篇《JavaScript中原型式继承》的文章，他的观点是，借助原型prototype可以根据已有的对象创建一个新的对象，同时不必创建新的自定义对象类型。大师的话理解起来可能很困难，不过我们还是先看一下他实现的代码吧。”

// 原型是继承
    function inheritObject(o){
        
    　　// 声明一个过渡函数对象
    　　function F(){
        }
    　　// 过渡对象的原型继承父对象
    　　F.prototype = o;
    　　// 返回过渡对象的一个实例，该实例的原型继承了父对象
    　　return new F();
    }

“这种方式怎么和类式继承有些像呢？”

“对，它是对类式继承的一个封装，其实其中的过渡对象就相当于类式继承中的子类，只不过在原型式中作为一个过渡对象出现的，目的是为了创建要返回的新的实例化对象。”

“如果是这样，是不是类式继承中的问题在这里也会出现呢？”小白追问。

“是这样的，”小铭接着说，“不过这种方式由于F过渡类的构造函数中无内容，所以开销比较小，使用起来也比较方便。当然如果你感觉有必要可以将F过渡类缓存起来，不必每次创建一个新过渡类F。当然这种顾虑也是不必要的。随着对这种思想的深入，后来就出现的Object.create()的方法。”

“创建的新对象会不会影响到父类对象呢？”于是小白写下测试用例（测试代码）。

var book = {
    　　name: "js book",
    　　alikeBook: ["css book", "html book"]
    };
    var newBook = inheritObject(book);
    newBook.name = "ajax book";
    newBook.alikeBook.push("xml book");
    var otherBook = inheritObject(book);
    otherBook.name = "flash book";
    otherBook.alikeBook.push("as book");
    console.log(newBook.name);　　　　　　//ajax book 
    console.log(newBook.alikeBook);　　　　//["css book", "html book", "xml book", "as book"] 
    console.log(otherBook.name);　　　　//flash book 
    console.log(otherBook.alikeBook);　　//["css book", "html book", "xml book", "as book"] 
    console.log(book.name); 　　　　　　//js book
    console.log(book.alikeBook); 　　　　//["css book", "html book", "xml book", "as book"]

“跟类式继承一样，父类对象book中的值类型的属性被复制，引用类型的属性被共用。”小白感叹道。

“然而道格拉斯·克罗克福德推广的继承并不只这一种，他在此基础上做了一些增强而推出一种寄生式继承。”

## 如虎添翼——寄生式继承 ##

“寄生式继承？这还头一次听说，它是怎么实现的？”

“不着急，大师对该模式论述的话我们就不深究了，我们还是看看这种继承的实现吧。”

// 寄生式继承
    // 声明基对象
    var book = {
    　　name: "js book",
    　　alikeBook: ["css book", "html book"]
    };
    function createBook(obj){
        
    　　// 通过原型继承方式创建新对象
    　　var o = new inheritObject(obj);　　　　
    　　// 拓展新对象
    　　o.getName = function(){
        　　　　　　　　
    　　　　console.log(name);
    　　};　　
    　　// 返回拓展后的新对象
    　　return o;　　　　　　　　　　　　　　
    }

“看懂了吗？”小铭问小白，“其实寄生式继承就是对原型继承的第二次封装，并且在这第二次封装过程中对继承的对象进行了拓展，这样新创建的对象不仅仅有父类中的属性和方法而且还添加新的属性和方法。”

“哦，这种类型的继承果如其名，寄生大概指的就是像寄生虫一样寄托于某个对象内部生长。当然寄生式继承这种增强新创建对象的继承思想也是寄托于原型继承模式吧。”

“嗯，是这个道理，而这种思想的作用也是为了寄生组合式继承模式的实现。”

## 终极继承者——寄生组合式继承 ##

“寄生组合式继承？”小白好奇地问道。

“嗯，之前我们学习了组合式继承，那时候我们将类式继承同构造函数继承组合使用，但是这种方式有一个问题，就是子类不是父类的实例，而子类的原型是父类的实例，所以才有了寄生组合式继承。但是你知道是哪两种模式的组合么？”

“寄生当然是寄生式继承，寄生式继承依托于原型继承，原型继承又与类式继承相像，另外一种就不应该是这些模式了，所以另外一种继承模式应该是构造函数继承了吧。当然，子类不是父类实例的问题是由于类式继承引起的。”小白回答道。

“对，正是这两种继承，但是这里寄生式继承有些特殊，这里它处理的不是对象，而是类的原型。我们再次来看看道格拉斯·克罗克福德对寄生式继承的一个改造。”

/**
     * 寄生式继承 继承原型
     * 传递参数 subClass　 子类
     * 传递参数 superClass 父类
     **/ 
    function inheritPrototype(subClass, superClass){
    　　// 复制一份父类的原型副本保存在变量中
    　　var p = inheritObject(superClass.prototype);　 
    　　// 修正因为重写子类原型导致子类的constructor属性被修改
    　　p.constructor = subClass;　　
    　　// 设置子类的原型　　　　　 
    　　subClass.prototype = p;　　　　　　　　
    }

“组合式继承中，通过构造函数继承的属性和方法是没有问题的，所以这里我们主要探究通过寄生式继承重新继承父类的原型。我们需要继承的仅仅是父类的原型，不再需要调用父类的构造函数，换句话说，在构造函数继承中我们已经调用了父类的构造函数。因此我们需要的就是父类的原型对象的一个副本，而这个副本我们通过原型继承便可得到，但是这么直接赋值给子类会有问题的，因为对父类原型对象复制得到的复制对象p中的constructor指向的不是subClass子类对象，因此在寄生式继承中要对复制对象p做一次增强，修复其constructor属性指向不正确的问题，最后将得到的复制对象p赋值给子类的原型，这样子类的原型就继承了父类的原型并且没有执行父类的构造函数。”

“看上去好复杂呀。”小白惊叹道。

“所以你要去测一测呀。测试很简单，与组合模式相比只有一个地方做了修改，就是子类原型继承父类原型这一处，测试看看吧。”

“好吧。”于是小白写下了测试用例。

// 定义父类　　　　　　　　　　 
    function SuperClass(name){
        
    　　this.name = name;
    　　this.colors = ["red", "blue", "green"];
    }
    // 定义父类原型方法
    SuperClass.prototype.getName = function(){
        
    　　console.log(this.name);
    };
    // 定义子类
    function SubClass(name, time){
        　
    　　// 构造函数式继承
    　　SuperClass.call(this, name);
    　　// 子类新增属性
    　　this.time = time;
    }
    // 寄生式继承父类原型
    inheritPrototype(SubClass, SuperClass);
    // 子类新增原型方法
    SubClass.prototype.getTime = function(){
        
    　　console.log(this.time);
    };
    // 创建两个测试方法
    var instance1 = new SubClass("js book", 2014);
    var instance2 = new SubClass("css book", 2013);

小白首先创建了父类，以及父类的原型方法，然后创建子类，并在构造函数中实现构造函数式继承，然后又通过寄生式继承了父类原型，最后又对子类添加了一些原型方法。

最后小白测试了一下，结果如下：

instance1.colors.push("black");
    console.log(instance1.colors); 　　//["red", "blue", "green", "black"]
    console.log(instance2.colors); 　　//["red", "blue", "green"]
    instance2.getName();　　　　  　　　//css book
    instance2.getTime();　　　　    　　//2013

“现在你明白了吧，其实这种方式继承如下图所示，其中最大的改变就是对子类原型的处理，被赋予父类原型的一个引用，这是一个对象，因此这里有一点你要注意，就是子类再想添加原型方法必须通过prototype.对象，通过点语法的形式一个一个添加方法了，否则直接赋予对象就会覆盖掉从父类原型继承的对象了。”

![示例][20161106154203138]

# 老师不止一位——多继承 #

“是这样呀，对了，我记得有一些面向对象语言中支持多继承，在JavaScript中能实现么？”

“嗯，不过是有一些局限性的。你知道，在JavaScript中继承是依赖于原型prototype链实现的，只有一条原型链，所以理论上是不能继承多个父类的。然而JavaScript是灵活的，通过一些技巧方法你却可以继承多个对象的属性来实现类似的多继承。”小铭接着说，“讲解多继承之前先跟你说一下当前很流行的一个用来继承单对象属性的extend方法。”

// 单继承 属性复制　　
    var extend = function(target, source) {
        　
    　　// 遍历源对象中的属性
    　　for (var property in source) {
    　　　　// 将源对象中的属性复制到目标对象中
    　　　　target[property] = source[property];　
    　　}
    　　// 返回目标对象
    　　return target;　
    };

“原来extend方法的实现就是对对象中的属性的一个复制过程呀。”小白惊讶地说。

“嗯，是这样，我们的这个extend方法是一个浅复制过程，他只能复制值类型的属性，对于引用类型的属性它无能为力。而在jquery等一些框架中实现了深复制，就是将源对象中的引用类型的属性再执行一遍extend方法而实现的。我们这里实现得比较简单，所以你测试也比较容易。”

于是小白写下如下测试代码。

var book = {
    　　name : 'JavaScript设计模式',
    　　alike : ['css', 'html', 'JavaScript']
    }
    var anotherBook = {
    　　color : 'blue'
    }
    extend(anotherBook, book);
    console.log(anotherBook.name);　　　// JavaScript设计模式 
    console.log(anotherBook.alike); 　　// ["css", "html", "JavaScript"] 
    anotherBook.alike.push('ajax');
    anotherBook.name = '设计模式';
    console.log(anotherBook.name);　　　// 设计模式
    console.log(anotherBook.alike); 　　// ["css", "html", "JavaScript", "ajax"] 
    console.log(book.name);　　　 　   　// JavaScript设计模式 
    console.log(book.alike);　　　   　　// ["css", "html", "JavaScript", "ajax"]

“真的是这样。但是多继承呢？”

“很容易，既然上面的方法可以实现对一个对象属性的复制继承，那么如果我们传递多个对象呢？”

// 多继承 属性复制　　
    var mix = function() {
        　
    　　var i = 1,　　　　　　　　　　　// 从第二个参数起为被继承的对象
    　　　　len = arguments.length, 　　// 获取参数长度
    　　　　target = arguments[0],　　　// 第一个对象为目标对象
    　　　　arg;　　　　　　　　　 　　　　// 缓存参数对象
    　　// 遍历被继承的对象
    　　for(; i < len; i++){
    　　　　// 缓存当前对象
    　　　　arg = arguments[i];
    　　　　// 遍历被继承对象中的属性
    　　　　for (var property in arg) {
    　　　　　　// 将被继承对象中的属性复制到目标对象中
    　　　　　　target[property] = arg[property];　
    　　　　}
    　　}
    
    　　// 返回目标对象
    　　return target;　
    };

“mix方法的作用就是将传入的多个对象的属性复制到源对象中，这样即可实现对多个对象的属性的继承。”

“这是实现方式真不错，可是使用的时候需要传入目标对象（第一个参数——需要继承的对象）。”

“当然你也可以将它绑定到原生对象Object上，这样所有的对象就可以拥有这个方法了。”

Object.prototype.mix = function(){
        
    　　var i = 0,　　　　　　　　　　　// 从第一个参数起为被继承的对象
    　　　　len = arguments.length,　　// 获取参数长度
    　　　　arg;　　　　　　　　　　　　　　// 缓存参数对象
    　　// 遍历被继承的对象
    　　for(; i < len; i++){
    　　　　// 缓存当前对象
    　　　　arg = arguments[i];
    　　　　// 遍历被继承对象中的属性
    　　　　for (var property in arg) {
    　　　　　　// 将被继承对象中的属性复制到目标对象中
    　　　　　　this[property] = arg[property];　
    　　　　}
    　　}
    }

“这样我们就可以在对象上直接调用了。如……”

otherBook.mix(book1, book2);
    console.log(otherBook);　　// Object {
       color: "blue", name: "JavaScript设计模式", mix: function, about: "一本JavaScript书"}

“在JavaScript中实现的多继承是如此的美妙。”

# 多种调用方式——多态 #

“小铭，在面向对象编程中不是还有一种特性叫作多态么？在JavaScript中可以实现么？”

“多态，就是同一个方法多种调用方式吧。在JavaScript中也是可以实现的，只不过要对传入的参数做判断以实现多种调用方式，如我们定义一个add方法，如果不传参数则返回10，如果传一个参数则返回10+参数，如果传两个参数则返回两个参数相加的结果。”

//多态
    function add(){
        
    　　　　// 获取参数
    　　var arg = arguments,
    　　　　// 获取参数长度
    　　　　len = arg.length;
    　　switch(len){
    　　　　// 如果没有参数
    　　　　case 0:
    　　　　　　return 10;
    　　　　// 如果只有一个参数
    　　　　case 1:
    　　　　　　return 10 + arg[0];
    　　　　// 如果有两个参数
    　　　　case 2:
    　　　　　　return arg[0] + arg[1];
    　　}
    }
    // 测试用例
    console.log(add());　　　　// 10
    console.log(add(5));　　　　// 15
    console.log(add(6,7));　　　　// 13

“当然我们还可以让其转化成更易懂的类形式：”

“对于多态类，当我们调用add运算方法时，他会根据传参不同做相应运算，当然我们将不同运算方法封装在类内，这样代码更易懂。”

--------------------

# 回忆 #

封装与继承是面向对象中的两个主要特性，继承即是对原有对象的封装，从中创建私有属性、私有方法、特权方法、共有属性、共有方法等，对于每种属性与每种方法特点是不一样的，有的不论对类如何实例化，它只创建一次，那么这类属性或者方法我们称之为静态的。有的只被类所拥有，那么这类属性和方法又是静态类方法与静态类属性。当然可被继承的方法与属性无外乎两类，一类在构造函数中，这类属性与方法在对象实例化时被复制一遍。另一类在类的原型对象中，这类属性与方法在对象实例化时被所有实例化对象所共用。

提到类的实例化我们就引出了继承，当然如果实例化的是对象那么则为对象继承，如果实例化的是类（当然类也是一种对象，只不过是用来创建对象的），那么就是一种类的继承。对于类的继承我们根据继承的方式又分为很多种，通过原型链继承的方式我们称之为类式继承，通过构造函数继承的方式我们称之为构造函数式继承，那么将这两种方式组合起来的继承方式我们称之为组合继承，由于类式继承过程中会实例化父类，这样如果父类构造函数极其复杂，那么这种方式对构造函数的开销是不值得的，此时有了一种新的继承方式，通过在一个函数内的过渡对象实现继承并返回新对象的方式我们称之为寄生式继承，此时我们在结合构造函数时继承，这样再融合构造函数继承中的优点并去除其缺点，得到的继承方式我们称之为寄生组合式继承。当然有时候子类对父类实现继承可以通过拷贝方法与属性的方式来实现，这就有了多继承，即将多个父类（对象）的属性与方法拷贝给子类实现继承。

对于面向对象中的多态，在JavaScript中实现起来就容易得多了，通过对传递的参数判断来决定执行逻辑，即可实现一种多态处理机制。

[20161106154203138]: /images/20220715/022d3ad2ec084c4e8d3e3bea5963afad.png