js---12对象创建方式，构造器，原型

<script type="text/javascript">
var o = {};
var o1 = new Object();//这2种方式创建对象是一样的，因为对象都有默认属性constructor构造器，函数也是对象，js一切都是对象，函数也有构造器函数也是对象，构造器是对象的。
o.constructor 的构造器为 function Object();
o1.constructor 的构造器为 function Object();
o.constructor === o1.constructor   //true
Number.constructor 的构造器为 function Function();
function f(){} 的构造器为 function Function()
Function.constructor 为 function Function()
//在构造器层面Function()是最顶级的，只有对象才有构造器
1.constructor  //1不存在构造器
var a = 1;
a.constructor  构造器为 function Number()  ;// a变量本身是Number构造生成的

typeof 1；//‘number’
typeof true //boolean
var f = function(){}
typeof f //function
var o = {};
o instanceod Object//true

var o = {name:"abc"};
var o1 = o.constructor();
o===o1;//false,调用o的构造器不会复制o,而是另外一个对象


//1.{}创建对象
var o = {name:'cc',age:12};
var o2 = o;//o和o2指向同一个对象的引用
//2.工厂函数创建对象
function PersonFactory(pname,page){
    return {   //返回一个对象
        name:pname,
        age:page,
        headCount:1  //加不加逗号无所谓
    };
}
var p1 = PersonFactory("cj",22);
var p2 = PersonFactory("david",33);//不同的对象，js对象也是在堆里面，
//3.函数创建对象
function Person(){   //通过函数创建类，首字母要大写
    var age = 30;//函数的私有变量
    this.age=22;//通过this给对象加属性
    this.name = "cj";
}
var p = new Person();
console.log（p.name）;
var p1 = new Person();

Person.prototype.headCount = 1;//类的共同的东西放这里，p和p1里面只有name和age没有headCount,headCount放在共同区域供2个变量使用。
Person.prototype.headCount = 2;//prototype叫原型属性
console.log(p.constructor.prototype.headCount);//2,p对象的构造器指向函数本身，函数本身Person有prototype属性

/*
1.通过var s   = {} 创建相同的对象不能够复用，创建差不多的对象需要重新写{}
2.通过工厂函数创建对象，解决了创建相同的对象能够复用，但是没有解决对象成员的复用
3.函数创建对象，解决了对象公有成员的复用
*/
//只有函数才有prototype，prototype是函数的属性，prototype指向一个对象，既然是对象就有constrnctor构造器和函数对象公有的东西,面向对象的思维看待函数。
function f(){}
console.log(f.prototype);

//js没有类，只有模拟了类，
function Person(){  
    var age = 30; 
    this.age=22; 
    this.name = "cj";
}
Person.prototype.headCount = 1;//prototype指向的是一个对象，堆区域，js变量名都是跟java变量名字一样，保存的是地址值。
var p = new Person();
var p1 = new Person();
console.log(p.constructor);//function Person()
console.log(p.constructor.prototype.headCount);//2
//用构造器函数创建的对象，跟构造器的原型对象prototype，不是通过constructor构造器建立的，而是通过对象里面的__proto__关联起来的。
console.log(p.headCount);//1

Person.prototype = {xx:"xx"};//把person的prototype全部改掉
console.log(p.xx);//undefined,因为该的是Person函数类的，只是把函数的prototype重新指向了一个新对象，但是p里面的__proto__仍然指向之前的对象，
console.log(p.headCount);//3
var p2 = new Person();
console.log(p2.xx);//"xx",现在自己里面找，找不到就去公有的原型对象里面去找，
p2.xx = "yy";//会在自己对象里面加一个xx属性，值是yy
console.log(Person.prototype.xx);//xx,公有对象prototype里面的xx属性值并没有改变

//总结：函数类才有prototype属性，公有的，__proto__是函数对象有的，都是保存的内存区域的地址，new 函数名()出来的对象，开始__proto__和prototype指向同一块内存区域，