js面向对象的三大特性

一.什么是面向对象

面向对象是一种编程思想 js本身就是基于面向对象构建出来的,而js内有很多内置对象类,比如Promise就是es6
新增的内置类 js中的面型对象,和其他编程语言还是略有不同的 js中的类和实例是基于原型和原型链机制来处理的

二.面向对象的三大特征分别为:封装,继承和多态

1. 封装:低耦合高内聚

我们平时所用的方法和类都是一种封装,当我们在项目开发中,遇到一段功能的代码在好多地方重复使用的时候,我们可以 把他单独封装成一个功能的方法,这样在我们需要使用的地方直接调用就可以了。

优点:封装的优势在于定义只可以在类内部进行对属性的操作,外部无法对这些属性指手画脚,要想修改,也只能通过你定义的封装方法;

2.多态:重载和重写

优点:多态实现了方法的个性化,不同的子类根据具体状况可以实现不同的方法,光有父类定义的方法不够灵活,遇见特殊状况就捉襟见肘了

重载:方法名相同,形参个数或类型不一样(js中不存在真正意义上的重载,js中的重载指的是同一个方法,
根据传参不同,实现出不同的效果)

 eg:
    function sum(x,y,z){
        // arguments
        if(typeof z === "undefined"){
            return;  
        }
    }
    sum(1,2);
    sum(1,2,3)

重写:在类的继承中,子类可以重写父类的中的方法

 eg:
    function sum(a,b){
		return a+b
	}
	console.log(sum)	
	console.log(sum(1,2)) 
	function sum(a,b,c){
		a+b+c
	}
	console.log(sum)
	console.log(sum(1,2,3))

3. 继承 :

子类继承父类中的方法(目的是让子类的实例调取父类中的属性和方法)

优点:继承减少了代码的冗余,省略了很多重复代码,开发者可以从父类底层定义所有子类必须有的属性和方法,以达到耦合的目的;
继承的几种方式:
①原型链继承

父类的实例作为子类的原型

    特点:
		1.非常纯粹的继承关系,实例是子类的实例,也是父类的实例
		2.父类新增原型方法/原型属性,子类都能访问到
		3.简单,易于实现

	缺点:
		1.实例并不是父类的实例,只是子类的实例
		2.只能继承父类的实例属性和方法,不能继承原型属性/方法
		3.无法实现函数复用,每个子类都有父类实例函数的副本,影响性能
function Cat(){ 
}
Cat.prototype = new Animal();
Cat.prototype.name = 'cat';

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.eat('fish'));
console.log(cat.sleep());
console.log(cat instanceof Animal); //true 
console.log(cat instanceof Cat); //true
②构造继承

使用父类的构造函数来增强子类实例,等于是复制父类的实例属性给子类(没用到原型)

特点:
	1.解决了1中,子类实例共享父类引用属性的问题
	2.创建子类实例时,可以向父类传递参数
	3.可以实现多继承(call多个父类对象)

缺点:
	1.实例并不是父类的实例,只是子类的实例
	2.只能继承父类的实例属性和方法,不能继承原型属性/方法
	3.无法实现函数复用,每个子类都有父类实例函数的副本,影响性能
function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}

// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // false
console.log(cat instanceof Cat); // true
③实例继承

为父类实例添加新特性,作为子类实例返回

特点:
	1.不限制调用方式,不管是new 子类()还是子类(),返回的对象具有相同的效果
缺点:
	1.实例是父类的实例,不是子类的实例
	2.不支持多继承
	function Cat(name){
	  var instance = new Animal();
	  instance.name = name || 'Tom';
	  return instance;
	}

	// Test Code
	var cat = new Cat();
	console.log(cat.name);
	console.log(cat.sleep());
	console.log(cat instanceof Animal); // true
	console.log(cat instanceof Cat); // false
④拷贝继承
	特点:
		1.支持多继承
	缺点:
		1.效率较低,内存占用高(因为要拷贝父类的属性)
		2.无法获取父类不可枚举的方法(不可枚举方法,不能使用for in 访问到)
	function Cat(name){
	  var animal = new Animal();
	  for(var p in animal){
	    Cat.prototype[p] = animal[p];
	  }
	  Cat.prototype.name = name || 'Tom';
	}
	// Test Code
	var cat = new Cat();
	console.log(cat.name);
	console.log(cat.sleep());
	console.log(cat instanceof Animal); // false
	console.log(cat instanceof Cat); // true
⑤组合继承

通过调用父类构造,继承父类的属性并保留传参的优点,然后通过将父类实例作为子类原型,实现函数复用

特点:
	1.弥补了方式2的缺陷,可以继承实例属性/方法,也可以继承原型属性/方法
	2.既是子类的实例,也是父类的实例
	3.不存在引用属性共享问题
	4.可传参
	5.函数可复用
缺点:
	1.调用了两次父类构造函数,生成了两份实例(子类实例将子类原型上的那份屏蔽了)
	function Cat(name){
	  Animal.call(this);
	  this.name = name || 'Tom';
	}
	Cat.prototype = new Animal();
	Cat.prototype.constructor = Cat;
	// Test Code
	var cat = new Cat();
	console.log(cat.name);
	console.log(cat.sleep());
	console.log(cat instanceof Animal); // true
	console.log(cat instanceof Cat); // true
⑥寄生组合继承

通过寄生方式,砍掉父类的实例属性,这样,在调用两次父类的构造的时候,就不会初始化两次实例方法/属性,避免的组合继承的缺点

特点:
	1.堪称完美
缺点:
	1.实现较为复杂
function Cat(name){
  Animal.call(this);
  this.name = name || 'Tom';
}
(function(){
  // 创建一个没有实例方法的类
  var Super = function(){};
  Super.prototype = Animal.prototype;
  //将实例作为子类的原型
  Cat.prototype = new Super();
})();
// Test Code
var cat = new Cat();
console.log(cat.name);
console.log(cat.sleep());
console.log(cat instanceof Animal); // true
console.log(cat instanceof Cat); //true
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值