面向对象的特性：
- 封装
- 继承
- 多态
封装
作用:方便代码的维护，提高代码的复用性，更安全的访问数据的方式
注意：js中的封装多了一层意思，就是使用对象来封装变量和函数
继承
现实生活中的继承：继承遗产，一个人获得另一个人所拥有的财富或者是资源的方式。
编程语言中的继承：一个类（对象）获得另外一个类（对象）的属性和方法的一种方式。
多态
多种表现形态：
对于相同的操作，不同的对象表现出不同的行为。实现：
js天生具备多态的特性（弱类型的语言）
创建对象的几种方式
- 字面量法
结构
var 对象 = {
属性名01：属性值，
属性名02：属性值，
方法01：function（）{函数体}
}
适用场合：只需简单创建单个对象
问题：如果需要创建多个相似的对象，那么代码中冗余度太高（重复的代码太多）
代码:
var book1 = {
name:"悟空传",
author:"今何在",
press:"湖南文艺出版社",
price:"28.00",
logDes:function(){
console.log("书名：" + this.name + "作者：" + this.author);
}
}
- 内置构造函数法
var book1 = new Object();
//01 设置属性
book1.name = "花田半亩";
book1.author = "田维";
book1.price = "40.01";
//02 设置方法
book1.logDes = function (){
console.log("书名：" + this.name);
}
问题:如果需要创建多个相似的对象，那么代码中冗余度太高（重复的代码太多）
- 工厂法
对于内置法把固定的部分提取写成函数的函数体，把变化的部分提取，作为参数传递
function createBook(name,author){
//01 创建空的对象
var o = new Object();
//02 设置属性和方法
o.name = name;
o.author = author;
o.logDes = function(){
console.log("作者是：" + this.author);
}
//04 返回新创建的对象
return o;
}
问题：如果创建多个不同类型的对象，那么我们无法分辨
function createPerson(name,age){
var o = new Object();
o.name = name;
o.age = age;
return o;
}
function createDog(name,age)
{
var o = new Object();
o.name = name;
o.age = age;
return o;
}
//创建具体的对象
var obj1 = createPerson("张三",88);
var obj2 = createDog("阿黄",6);
console.log(obj1.constructor); //Object
console.log(obj2.constructor); //Object
最终的返回值类型都是Object类型,只看结果不能够准确的辨认obj1和obj2对应的都是谁
- 构造法
001 提供一个构造函数
002 通过this指针来设置属性和方法
003 通过new操作符创建对象
function Person(name,age){
// 默认 创建对象
//var o = new Object();
//默认会赋值给this
//this = o;
// 01 通过this指针来设置属性和方法
this.name = name;
this.age = age;
this.showName = function(){
console.log(this.name);
};
this.showAge = function(){
console.log(this.age);
}
//默认返回
//return this;
}
//03 使用new操作符来创建对象
var p1 = new Person("张三",20);
var p2 = new Person("张老汉",200);
console.log(p1);
console.log(p2);
自定义构造函数方式创建对象内部的实现细节
01 我们在使用new关键字调用构造函数的时候，内部默认会创建一个空的对象
02 默认会把这个空的对象赋值给this
03 通过this来设置新对象的属性和方法
04 在构造函数的最后，默认会把新创建的对象返回
自定义构造函数和工厂函数对比
001 函数的名称不一样，构造函数首字母大写
002 自定义构造函数创建方式内部会自动的创建空对象并且赋值给this
003 默认会自动返回新创建的对象
返回值
01 没有显示的return ,默认会把新创建的对象返回
02 显示的执行了return语句，就得看具体的情况
001 返回的是值类型，那么直接忽略该返回，把新创建的对象返回
002 返回的是引用类型的数据，会覆盖掉新创建的对象，直接返回引用数据类型的值
function Dog(name)
{
this.name = name;
//return "demo"; 忽略
return function (){console.log(name);};最终返回的值
}
var dog = new Dog("阿黄");
console.log(dog);
//function (){console.log(name) -->返回值
当然这也不是自定义构造函数的最终类型，最终类型将在下面讲解。
接下来的内容均是建立在自定义构造函数上的
instanceOf:判断当前对象是否是某个对象的实例
function Person(){};
function Dog(){};
var p1 = new Person();
var dog1 = new Dog();
console.log(p1 instanceof Person);//true
console.log(dog1 instanceof Dog);//true
constructor:构造器属性（获取）
console.log(p1.constructor);//function Person(){}
构造函数原型对象
原型对象：在使用构造函数创建对象的时候，默认的会生成一个与之关联的对象，这个对象就是原型对象。默认情况下，该对象是一个空的对象（{}）
原型对象的作用：使用构造函数创建的对象，能够自动拥有原型对象中所有的属性和方法
如何访问原型对象
① 构造函数.prototype
② 对象.__proto__如何设置原型对象
① 可以像设置普通对象一样来利用对象的动态特性设置属性和方法
② 使用字面量的方法来设置原型对象（直接替换）约定
正确的说法：该对象的构造函数的原型对象
构造函数的原型
构造函数的原型对象
对象的原型对象
对象的原型
以上四种说法，她们的意思是一样的，都是该对象的构造函数的原型对象
原型对象的属性和方法的设置：
构造函数.prototype.属性
实例化：
通过构造函数创建对象的过程，就叫做实例化
实例：
通过构造函数创建的对象被称为该构造函数的实例。一般在说实例的时候，需要指定构造函数。也就是说，我们通常会说这个对象是XXX构造函数实例。
function Dog(){};
Dog.prototype.des = "描写信息";
var dog = new Dog();
原型的使用方法
利用对象的动态特性来设置原型对象
function Person(){
this.name = "默认的名称";
}
//设置原型对象
//成员= 属性|方法
//01 增加成员
Person.prototype.des = "我是直立行走的人";
Person.prototype.logName = function(){
console.log(this.name);
};
//02 修改成员
Person.prototype.des = "我是直立行走的人++++";
//console.log(Person.prototype);
var p1 = new Person();
console.log(p1.des);
p1.logName();
//03 删除成员
//delete关键字
//语法 delete 对象.属性
//console.log(delete p1.des); //不能用这种方式删除原型对象上面的属性（删除的是自己的属性）
delete Person.prototype.des ;
console.log(p1.des);
替换原型对象（字面量）
注意点：
- 如果是替换了原型对象，那么在替换之前创建的对象和替换之后创建的对象她们指向的原型对象并不是同一个
- 构造器属性:在替换之后创建的对象中，它的构造器属性指向的不是Person构造函数，而是Object的原型对象的构造器属性
建议：
在设置完原型对象之后再统一的创建对象。
function Person(){
this.age = 40;
}
var p1 = new Person();
Person.prototype.sayHi = function(){
console.log("hi");
};
//设置原型对象
Person.prototype = {
name:"默认的名称",
showName:function(){
console.log(this.name);
}
};
var p2 = new Person();
// p1.sayHi(); //可以
// p2.sayHi(); //不可以
// console.log(p1.name); //undefined
// console.log(p2.name); //默认的名称
// p1.showName(); //报错
// p2.showName(); //默认的名称
function Person(){
this.age = 40;
}
var p1 = new Person();
//var obj = new Object();
Person.prototype = {
//注意：如果替换了原型对象，那么需要在原型对象中修正构造器属性
constructor:Person,//***
sayHi:function (){
console.log("hi");
}
};
var p2 = new Person();
//p2.constructor = Person; //在p2对象上添加了一个属性（constructor）
//var p3 = new Person();
//构造器属性
console.log(p1.constructor == p2.constructor); //如果不添加***所在句则false
// console.log(p1.constructor); //Person
// console.log(p2.constructor); //Object
// console.log(p2.constructor == p2.__proto__.constructor);
// console.log(p2.constructor == Object.prototype.constructor);
console.log(p2);
构造器：
属性：constructor
值：与之关联的构造函数
注意点：constructor是在原型对象身上的，我们通过对象.constructor访问得到的值其实就是原型对象中对应的值
暂时先更新到这里