OOP 面向对象 七大原则 （一）

OOP 面向对象   七大原则 （一）

　　大家众所周知，面向对象有三大特征继承封装多态的同时，还具有这七大原则，三大特征上一篇已经详细说明，这一篇就为大家详解一下七大原则： 单一职责原则，开闭原则，里氏替换原则，依赖倒置原则，接口隔离原则，迪米特法则，组合聚合复用原则

　　单一职责原则:一个类只负责一个领域的内容，简而言之就是自己的类负责自己的事情，与别的类互不干涉

　　场景案例：女孩子购物

　　

/**
			 * 	oop 单一原则实现
			 *  @author gongliying
			 * 	@data 2019-06-10
			 */
			aaa(){
				class People{
					getAll(){
						console.log("打车去Dior实体店买口红")
						console.log("打车去Only实体店买裙子")
					}
				}
				new People().getAll();
			}

　　　打车去实体店买口红跟打车去实体店买裙子，我虽然写在了同样一个方法里面，但是呢却不能同时进行

　　　　解决思路：面向对象单一职责，一个类只做一件事情，互不干涉

aaa(){
				class People{
					Dior(content){
						console.log('打车去Dior实体店买' + content)
					}
					Only(content){
						console.log('打车去Only实体店' + content)
					}
					getAll(){
						this.JD('口红')
						this.TM('裙子')
					}
				}
				new People().getAll();        //打车去Dior实体店买口红
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//打车去Only实体店买裙子
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
			}

　　这样事情就解决了，一个类方法只做一件事情，我在Dior的方法中只能去买口红，不能去进行买裙子的操作，这就是单一原则

 　　开闭原则：对修改关闭，对扩展开放

　　　　一个对象（模板，类，方法）只要是在生命周期内，都会发生变化，而开闭原则就是在不修改原有模块的基础上，扩展其功能

　　　　还以口红为例，商场中有一家店面里面之后Dior和CHANEL两个品牌，那么店员介绍的品牌不是Dior就是CHANEL，一般情况下都会这样写

/**
	* oop 开闭原则实现
	* @author 宫丽颖
	* @date 2019-06-13
 */
	achieve(){
		let  type ='dior'
		if (type == 'dior') {
			console.log('这是dior')
		}else{
			console.log('这是chanel')
		}
         }        
　　　　　//这是dior

　　　　这样写是没有什么问题的，但是呢，店面中又有新牌子了ysl，这就变成不是dior 不是CHANEL就是ysl了  随之我们的代码就又变成的这样　　

/**
			 * oop 开闭原则实现
			 * @author 宫丽颖
			 * @date 2019-06-13
			 */
			achieve(){
				let  type ='chanel'
				if (type == 'dior') {
					console.log('这是dior')
				}else if(type == 'chanel'){
					console.log('这是chanel')
				}else{
					console.log('这是ysl')
				}
　　　　　　　　　　　　　　　　　　　　//这是chanel
			},

　　　　随着商店店面更新的口红牌子越来越多，需求越来越多的时候，随之意味这样的代码，对原来代码的修改也越来越多，如果一不小心改错的话，可能整段就垮掉，为了解决这样的事件，建议使用开闭原则，对修改关闭，对扩展开放

/**
			 * oop 开闭原则实现
			 * @author 宫丽颖
			 * @date 2019-06-13
			 */
			achieve() {
				let  type = 'ysl'
				if (type == 'dior') return this.dior.dior();
				if (type == 'chanel') return this.chanel.chanel();
				if (type == 'ysl') return this.ysl.ysl();
			},

　　　　　　　　　　　　　　dior : {
		　　　　　　dior() {
　　　　　　　　　       	　　alert('这是dior')
			　}
	　　　　　　	},
		　　　　chanel : {
			chanel() {
　　　　　		　　alert('这是chanel')
			}
	　　　　　　　　　},
		　　　　ysl : {
			ysl() {
			　　alert('这是ysl')
			}
		　　　　}           //结果为弹出  这是ysl

　　这样增加需求的时候直接在data里面定义一个就好了，再多的需求也不怕不怕啦~~~

　　里氏替换原则：父类能出现的地方，可以用子类代替，子类拥有父类的所有属性和方法，通俗来说子类拥有父类的功能，可以拓展父类的功能，但是不能修改父类的功能

　　口红为例？

/**
			 * oop 里氏替换原则实现
			 * @author 宫丽颖
			 * @date 2019-06-13
			 */
			achieve() {
				class Kouhong{
					constructor(e){
						this.name=e.name
						this.price=e.price
					}
					look(){
						console.log(this.name,'的口红，一共',this.price,'元')
					}
				}

				//子类
				class Dior extends Kouhong{
					look(){
						console.log('这是',this.name,'的口红，一共',this.price)
					}
				}

				var kouhong = new Kouhong({
					name:"砖红色",
					price:300
				})
				var dior =new Dior({
					name:"脏橘色",
					peice:280
				})

				kouhong.look()   //砖红色 的口红，一共 300 元
				dior.look()      //这是 大红色 的口红，一共 280

			},

　　这样写的话，你会发现子类直接覆盖了父类的内容，修改了父类的功能，虽然代码上没什么问题，但是对于以后的优化有着很大的影响，也违背了里氏替换原则，里氏替换原则要求拥有父类的所有方法，可以扩展父类的方法，但是不能修改，我用历史替换比较一下

/**
			 * oop 里氏替换原则实现
			 * @author 宫丽颖
			 * @date 2019-06-13
			 */
			achieve() {
				class Kouhong{
					constructor(e){
						this.name=e.name
						this.price=e.price
					}
					look(){
						console.log(this.name,'的口红，一共',this.price,'元')
					}
					saw(){
						console.log('口红很贵哦的！！')
					}
				}

				//子类
				class Dior extends Kouhong{
					look(){
						console.log('这是',this.name,'的口红，一共',this.price)
					}
				}

				class CHANEL extends Kouhong{
					see(){
						console.log('这是',this.name,'的口红，一共',this.price,'元')
					}
					so(){
						console.log('因为那么贵所以才买不起嘛！！！！')
					}
				}

				var kouhong = new Kouhong({
					name:"砖红色",
					price:300
				})
				var dior =new Dior({
					name:"脏橘色",
					price:280
				})
				var chanel = new CHANEL({
					name:"豆沙色",
					price:320
				})

				kouhong.look()      //砖红色 的口红，一共 300 元            父类本身
				dior.look()         //这是 脏橘色 的口红，一共 280          子类1继承父类将父类方法覆盖
				chanel.look()       //豆沙色 的口红，一共 320 元　　　　　　　子类2继承父类显示父类方法
				chanel.see()        //这是 豆沙色 的口红，一共 320 元　　　　 子类2在继承父类上扩展自己的方法
				chanel.saw()        //口红很贵哦的！！　　　　　　　　　　　　　子类2继承父类另一个方法    子类继承了父类的所有方法
				chanel.so()         //因为那么贵所以才买不起嘛！！！！        子类2扩展自己的另一个方法

			},

　　由此可见，子类1在继承父类的时候将父类覆盖，但是子类2在继承父类的时候继承了父类的所有方法并扩展了自己的方法，这就是里氏替换原则

　　依赖倒置原则：程序要依赖于抽象接口，不要依赖于具体实现。简单的说就是要求对抽象进行编程，不要对实现进行编程，这样就降低了客户与实现模块间的耦合。(节选自百度百科)

　　　　emmmm，很官方的一句话 ，我用白话解释一下，就是说高层的模块不要依赖于低层的模块，不要靠比自己层级低的模块，高层低层应该同时依靠抽象，而抽象不应该依赖于细节而是应该细节依赖抽象 ，要是还没有懂的话，画张图把，当然还是口红为例了

这样看是不是看懂了呢 这个人就是高层，左图就是在说 高层依赖低层，如果这个高层抹口红就只能抹口红，不能在抹其他的 ，要是想在抹别的，就要再加方法，太啰嗦

　　　　　　　　　　　　　　　　　而右图就是在说明定义了一个抽象类抹，如果没有口红了还可以抹眼影啊，粉底之类的，人与眼影之间依赖抹这个抽象类来实现，这个抹眼影 这个细节依赖于抽象抹这个类，而这个高层人也可以创建不同的高层话不多说，代码附上

　　　　　　　　　　　　　　　　　　　　class cosmetics{
					daub(){
						console.log('抹了什么？')
					}
				}
				class kouhong extends cosmetics{
					go(){
						return "抹了口红"
					}
				}
				class yanying extends cosmetics{
					go(){
						return "抹了眼影"
					}
				}
				class fendi extends cosmetics{
					go(){
						return "抹了粉底"
					}
				}
				class people {
					constructor(name) {
						this.name = name
					}
					gotoEat(mo) {
						console.log(this.name, mo.go())
					}
				}
				kouhong = new kouhong
				yanying = new yanying
				fendi = new fendi
				gong = new people('宫')
				liying = new people('丽颖')

				gong.gotoEat(kouhong)      //宫 抹了口红
				gong.gotoEat(yanying)      //宫 抹了眼影
				gong.gotoEat(fendi)        //宫 抹了粉底

				liying.gotoEat(fendi)      //丽颖 抹了粉底

　　结果我不仅通过抹的抽象类，创建了不同的细节，还创建不同的高层，不同的人通过抹的类创建了不同的细节，他们之间是不会相互影响的，这就是依赖倒置原则。