工厂方法、构造函数创建对象

工厂方法-----构造函数

使用工厂方法创建对象

function createPerson(name,age) {
  var obj = new Object();
  obj.name = name;
  obj.age = age;
  obj.sayHi = function () {
    console.log(this.name+'向您说HI');
  }
  //将新的对象返回
  return obj;
}
var per1 = createPerson('孙悟空',18);
var per2 = createPerson('猪八戒',20);
var per3 = createPerson('白骨精',16);
per1.sayHi();//孙悟空向您说HI
per2.sayHi();//猪八戒向您说HI
per3.sayHi();//白骨精向您说HI
console.log(per1);//{ name: '孙悟空', age: 18, sayHi: [Function] }
console.log(per2);//{ name: '猪八戒', age: 20, sayHi: [Function] }
console.log(per3);//{ name: '白骨精', age: 16, sayHi: [Function] }

但是我们发现，log 实例时全部为object，因为这些实例对象都是object() new出来的，看不出区别，比如人的函数、狗狗的函数；所以就有了构造函数方法

构造函数(==>类（别称）)

// 创建人的类
function Person(name,age) {
  this.name = name;
  this.age = age;
  this.sayHi = function () {
    console.log(this.name+'向您说HI');
  }
}
// var per = Person(); // 作为普通函数调用，per结果为函数的返回值
var per4 = new Person('大儿子',10);//构造函数，立刻创建新的对象，将新的对象设置为this,逐行执行函数中的代码，将新的对象作为返回值返回，并赋给per4实例
var per5 = new Person('小儿子',7);
per4.sayHi(); // 大儿子向您说HI
per5.sayHi(); // 小儿子向您说HI

//创建狗狗类
function Dog(name,age) {
  this.name = name;
  this.age = age;
  this.sayWang = function () {
    console.log(this.name+':汪汪~~');
  }
}
var dog1 = new Dog('旺财',3);
var dog2 = new Dog('小七',2);
dog1.sayWang();// 旺财:汪汪~~
dog2.sayWang();// 小七:汪汪~~

console.log(per4);// Person { name: '大儿子', age: 10, sayHi: [Function] }
console.log(per5);// Person { name: '小儿子', age: 7, sayHi: [Function] }
console.log(dog1);// Dog { name: '旺财', age: 3, sayWang: [Function] }
console.log(dog2);// Dog { name: '小七', age: 2, sayWang: [Function] }

// 实例 instanceof  类  ：判断一个实例是不是属于某个类，其实是去原型链上查找
console.log(per4 instanceof Person); //true
console.log(dog1 instanceof Person); //false

//但是所有的实例都属于Object类

new创建实例时，伴随着在堆中新建sayHI方法，但所有sayHI方法都一模一样，完全可以让所有对象共享同一个方法

方法一（不推荐）：可以把sayHI方法提取到外面，但会污染全局作用域命名空间，而且并不安全

function Person(name,age) {
  this.name = name;
  this.age = age;
  this.sayHi = fun;
}
function fun() {
  console.log(this.name+'向您说HI');
}

方法二(推荐)：在构造函数的原型对象上添加共有的方法。

每个函数都有各自的prototype属性,这个属性指向原型对象，
构造函数new出来的实例对象有一个隐含属性__proto__也指向构造函数的原型对象
per4.proto === Person.prototype

原型对象就相当于一个公共的区域，所有同一个类的实例都可以访问到这个原型对象

//Person.prototype.a = '123'//所有Person类的实例都有a属性了
//当实例中有a，则实例.a的值就是实例中的a值，如果实例中没有就会去构造函数的原型对象上找
Person.prototype.canSpeak = function (name) {
  console.log(name+" can speak Chinese! nice~~");
  return 
}
var per5 = new Person('小儿子',7);
console.log(per5);//Person { name: '小儿子', age: 7, sayHi: [Function] },没有显示canSpeak方法，但下面可以调用的，因为会先找自身上的方法，自身没有就找原型链上
console.log(per5.sayHi());// 小儿子向您说HI undefined-->这个是方法return 的返回值（没return就是undefined）
console.log(per5.canSpeak(per5.name));// 小儿子 can speak Chinese! nice~~

记录，bye