面向对象

核心： 高内聚，低耦合（依赖）
面向分析—OOA
面向设计—OOD
面向对象—OOP

首先，我们先来区分一下面向过程和面向对象

• 面向过程：分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步实现，使用的时候一个一个依次调用就可以了
• 面向对象：先实现功能，再运行。分工协作，同时发生，解决问题

面向对象的特点：
封装--------不考虑内部实现，只考虑功能实现
多态--------提高代码复用性；继承是多态的前提
继承--------从已有对象上，继承出新对象

两种工厂模式

1.JS的工厂模式

工厂模式：批量创建具有相同特点的对象（现已基本不用了）

优点：解决了单例模式的批量生产的问题，避免了单例模式中的大量冗余代码，进行系统的封装，提高代码的重复利用

function Person (name,age){
	//原料
	var obj = {};
	//加工对象
	obj.name = name;
	obj.age = age;
	obj.info = function(){
		return "我的名字是" + this.name + "我" + this.age + "岁了"
	}
	//出厂
	return obj;
}
var p1 = Person("lili",18);
console.log(p1.info());		//我的名字是lili我18岁了
var p2 = Person("Jhon",20);
console.log(p2.info());		//我的名字是Jhon我20岁了

2.内置工厂模式（构造函数）

优点：JS内置的工厂模式比传统的工厂模式更高效，复用性更强

function Person(name,age){
	this.name = name;
	this.age  = age;
	this.info = function(){
		return "我的名字是" + this.name + "我" + this.age + "岁了"
	}
}
//不能这样直接执行，因为这样this的指向指的是window，会引用大量的全局变量
Person("张三",22);
console.log(name);	//张三
console.log(age);		//22

var p1 = new Person("李四",88);
console.log(p1);
p1.info();		//Person {name: "李四", age: 88, info: ƒ}

为了解决构造函数的冗余问题，我们将属性写在构造函数内，方法写在原型中。
面向对象的编程格式之一：
1.属性写在构造函数内；
2.方法写在原型中
3.构造函数中的this指向当前函数同名对象
4.原型方法中的this指向当前原型所属的函数同名对象

原型对象

__proto __：（隐式）原型链对象，表示当前类型的父级对象
prototype：（显示）原型对象，只有函数才有（除了箭头函数），专门用来给将来new出来的对象做父级的，可以让函数所实例化的对象都可以找到公用的属性和方法
constructor：从一个对象指向另一个函数，即指向该对象的构造函数

function Fn(){};
var f = new Fn();

console.log(Fn);
console.log(Fn.prototype);
console.log(f);
console.log(f.__proto__);

console.log(Fn.prototype == f.__proto__);		//true

console.log(Fn.constructor);
console.log(f.constructor);

console.log(f.constructor == Fn);		//true

console.log(f.constructor == Fn.prototype.constructor);		//true

console.log(f.__proto__.constructor == Fn.prototype.constructor);		//true

console.log(f.__proto__.constructor == Fn);		//true

所有类型，都具有__proto__，所有类型的__proto__，最终都指向Object函数
Object()最大的构造函数，是所有类型的构造函数