JavaScript面向对象轻松入门之多态(demo by ES5、ES6、TypeScript)

             1
            function
             Animal(){}

             2
            var AnimalP = Animal.prototype;
 3     AnimalP.eat = function(food){
 4         console.log(‘这个动物正在吃‘ + food);
 5    };
 6 7function Snake(){}
 8var SnakeP = extend(Snake,Animal);//extend函数请看上一节 9/*snake没有对eat方法重写，继承的父类eat()方法*/10function Dog(){}
11var DogP = extend(Dog,Animal);
12     DogP.eat = function(food){
13/*对eat()方法重写*/14/*上一章讲过，也可以在这里通过 Animal.eat.call(this,food)调用父方法；*/15         console.log("这只狗正在吃"+food);
16    };
1718function Cat(){}
19var CatP = extend(Cat,Animal);
20     CatP.eat = function(food){
21         console.log("这只猫正在吃"+food);
22    };
23var snake = new Snake();
24     snake.eat(‘老鼠‘);//log:这个动物正在吃老鼠25var dog = new Dog();
26     dog.eat(‘骨头‘);//log:这只狗正在吃骨头27var cat = new Cat();
28     cat.eat(‘鱼‘);//log:这只猫正在吃鱼

            1     AnimalP.eat = function(food){
2/*定义抽象方法（虚函数），如果子类没有重写这个方法，在执行这方法的时候就会抛出错误*/3throw ‘"‘ + this.constructor.name + "‘类没有eat()方法";
4    };
5function Snake(){}
6var SnakeP = extend(Snake,Animal);
7var snake = new Snake();
8     snake.eat(‘老鼠‘);//throw:"Snake‘类没有eat()方法

            1
            var run = function(speed){
2if(typeof speed == ‘number‘){
3             console.log(‘跑的速度有‘ + speed + ‘m/s‘);
4         }elseif(typeof speed == ‘string‘){
5             console.log(‘跑的速度有‘ + speed);
6        }
7    }
8     run(15);//log:跑的速度有15m/s9     run(‘20KM/h‘);//log:跑的速度有20KM/h

             1
            function
             Dog(){}

             2
            var DogP = Dog.prototype;
 3     DogP.run = function(speed){
 4if(typeof speed == ‘number‘){
 5this._runNumber(speed);
 6         }elseif(typeof speed == ‘string‘){
 7this._runString(speed);
 8         }else{
 9throw ‘参数不匹配‘;
10        }
11    }
12     DogP._runString = function(speed){
13         console.log(‘这只狗跑的速度有‘ + speed);
14    }
15     DogP._runNumber = function(speed){
16         console.log(‘这只狗跑的速度有‘ + speed + ‘m/s‘);
17    }
18var dog = new Dog();
19     dog.run(15);//log:这只狗跑的速度有15m/s20     dog.run(‘20KM/h‘);//log:这只狗跑的速度有20KM/h21     dog.run([]);//throw:参数不匹配

             1
                class Animal{

             2
                    eat(food){

             3
            throw ‘"‘ + this.constructor.name + "‘类没有eat()方法";
 4        }
 5    }
 6    class Snake extends Animal{}
 7    class Dog extends Animal{
 8        eat(food){
 9             console.log("这只狗正在吃"+food);
10        }
11    }
12    class Cat extends Animal{
13        eat(food){
14             console.log("这只猫正在吃"+food);
15        }
16    }
17     let snake = new Snake();
18     snake.eat(‘老鼠‘);//throw:"Snake‘类没有eat()方法19     let dog = new Dog();
20     dog.eat(‘骨头‘);//log:这只狗正在吃骨头21     let cat = new Cat();
22     cat.eat(‘鱼‘);//log:这只猫正在吃鱼

             1 abstract class Animal{//定义抽象类Animal 2    constructor(){}
 3    abstract eat(food: string){}
 4/*定义抽象方法eat(),并且限定传入的参数类型是string，
 5    还可以定义返回值，接口等，如果子类不符合限定的规范，编译的时候就会报错。
 6*/ 7}
 8 class Snake extends Animal{}//报错，无法通过编译，因为没有定义eat()抽象方法 9class Dog extends Animal{
10    eat(food: string){
11         console.log("这只狗正在吃"+food);
12    }
13}
14class Cat extends Animal{
15    eat(food: string){
16         console.log("这只猫正在吃"+food);
17    }
18}
19 let dog = new Dog();
20 dog.eat(‘骨头‘);//log:这只狗正在吃骨头21 let cat = new Cat();
22 cat.eat(‘鱼‘);//log:这只猫正在吃鱼