一、工厂模式
概念：工厂方法说白了就是在工厂里面去写方法，在外部写一个公用的方法去调取工厂的独有方法，来实现客户的需求
可以批量创建相同属性和方法的对象，不用每次都重新定义对象
工厂模式需要3个基本步骤，原料投入（传参），加工过程（new—>return），成品出厂（return）
//工厂模式
var a = {};//不能重复的利用 设置公共属性的代码
// 我们需要创建10个cat属性，每个对象都有 年龄姓名的属性，包括run方法
function createCat(age, name) {//工厂模式就是标准化的生成默认对象的函数
var o = new Object();
// var o={};
o.age = age;
o.name = name;
o.run = function () {
console.log(this.name + ' running....')
}
return o;
}
var c = createCat(19, 'hhh')
var c2 = createCat(20, 'ggg')
// 优点：
// 1、可以进行批量的创建 都有公共的默认值和属性对象，解决了重复创建对象的问题
// 缺点
// 1、对象的方法不能重用，每个对象的内存都存储一份函数对象的内存
// 2、不能识别对象的原型机构造函数
// 3、c instance of Cat;//false
2、构造函数创建对象及优缺点
优点
所有创建出来的对象，都可以找到他的原型和构造函数
公共的属性和方法也可以在创建的时候统一创建和维护
缺点
对象的函数，每个对象都会拥有一份内存拷贝。浪费内存
function Cat(name, age) {
this.age = age
this.name = name
this.run = function () {
console.log(this.name, this.age)
}
}
var c1 = new Cat('black', 3);
var c2 = new Cat('white', 2);
3、组合构造函数模式与原型模式构建对象
概念：组合使用构造函数模式与原型模式
公共的属性何方法放到原型上，独立的属性使用构造函数模式，放到对象自己身上
优点：
既保证了方法等共享的属性，只在内存中保存一份，节省内存
又可以实现每个对象有自己单独存放的属性。是一种经典的构建对象的方法
function Cat() {
this.age = 19
// 如果需要共享的属性和方法我们统一放到原型中定义
// this.run = function () {
// console.log('fun')
// }
}
Cat.prototype.name = 'black cat'
Cat.prototype.run = function () {
console.log(this.name, this.age)
}
var c1 = new Cat();
var c2 = new Cat();
console.log(c1.name)//black cat
console.log(c2.name)//black cat
// c1.run();
console.log(c1.run() === c2.run())//true
c1.name = 'white cat'
console.log(c1.name);
image.png
4、稳妥构造函数模式
概念：
所谓稳妥对象，指的是没有公共属性，而且其方法也不引用this的对象
优点
可以共享属性和方法的初始代码
无论用户是否用了new还是没有使用new都会被正确的返回新的对象
缺点
无法追溯对象的原型和构造函数，默认没有公共的属性和方法，内存浪费
function Cat() {
var o = {};
o.age = 10;
o.name = 'black cat';
o.run = function () {
console.log(o.name + ' running....')
}
// 如果返回是引用类型就将他返回，如果是基本类型就返回this
// o = { name: 'liu' };
// o = 2;//2
return o;
}
// new一个对象和不用new 是一样的
var c1 = new Cat()//构造函数调用
var c2 = Cat()//函数调用模式
console.log(c1)
console.log(c2)
5、对象的继承
原型链继承方式
// 动物基类
function Animal(name, age) {
this.name = name;
this.age = age;
this.fruit = ['water', 'apple']
}
// 在动物的基类上添加方法run
Animal.prototype.run = function () {
console.log(this.name + ' running')
}
function Cat(name, age) {
this.name = name;
this.age = age;
}
// 原型链的继承方式
// Cat.prototype.constructor === Cat
// console.log(Cat.prototype.constructor === Cat)//true
Cat.prototype = new Animal();
//上面的代码把cat的prototype指向了Animal 现在要还原回来
Cat.prototype.constructor = Cat;
console.log(Cat)
console.log(Cat.prototype.constructor)//Animal
var c = new Cat('Tom', 17)//希望cat继承animal的属性和方法
c.run();//从animal原型上继承的方法
c.fruit.push('banana')
console.log(c.fruit)//["water", "apple", "banana"]
// 问题
// 1、子类的构造函数的参数，没法传给父级的构造函数
// 2、子类的原型的constructor会被改变，需要自己变回来
// 3、如果父类里有引用类型的属性，那么所有的子类会共享这个引用类
构造函数继承
// 父类
function Animal(name, age) {
this.name = name;
this.age = age;
this.fruit = ['water', 'apple']
}
// 在父类的原型上 创建run方法
Animal.prototype.run = function () {
console.log(this.name + ' running')
}
function Cat(name, age) {
// Animal(age,name)//this===window;
Animal.call(this, name, age)//借用父类的构造函数 给子类创建实例属性
}
var c = new Cat('Tom', 12)
console.dir(Cat.prototype.constructor)
console.log(c)// Tom
console.log(c.name)// Tom
console.log(c.age)// Tom
console.log(c.fruit)// ['water', 'apple']
组合继承
// 父类
function Animal(name, age) {
this.name = name;
this.age = age;
this.fruit = ['water', 'apple']
}
// 在父类的原型上 创建run方法
Animal.prototype.run = function () {
console.log(this.name + ' running')
}
function Cat(name, age) {
// Animal(age,name)//this===window;
Animal.call(this, name, age)
}
Cat.prototype = new Animal();//组合原型继承模式
Cat.prototype.constructor = Cat;
var c = new Cat('Tom', 12)
console.dir(Cat.prototype.constructor)
console.log(c)// Tom
console.log(c.name)// Tom
console.log(c.age)// Tom
console.log(c.fruit)// ['water', 'apple']
原型方法继承
function object(o) {
function F() { }
F.prototype = o//让空函数的原型指向o对象
return new F();//创建一个f实例，f的内部原型指向o对象
}
var o = { name: 'liu', age: 23 }
var m1 = object(o)
console.log(m1.name)
// 优点：
// 不需要使用new构造函数就可以直接 构造另外其他对象
// 缺点：
// 所有构造函数出来的实例会共享 原型对象上的引用类型的属性
寄生继承方式
寄生继承模式是在原型式继承模式上增强原型对象的增强模式。只是对象原型式继承的扩张而已
寄生继承类似一个工厂模式，工厂内部把原型对象进行构造出另一个实例，并对构造出来的实例进行增强，最后返回这个实例
function Person(name, age, job) {
var o = new Object();
o.name = name;
o.age = age;
o.job = job;
o.sayName = function() {
alert(this.name);
}
return o;
}
var person1 = new Person("Nicholas", 29, "Software Engineer");
var person2 = new Person("Greg", 27, "Doctor");
寄生组合的方式
image.png
image.png
