面向对象以及特点

历史

汇编语言,C语言 对象过程化
C++,Java,javaScript,Python,PHP 面向对象编程思想

三大特征

1、抽象(封装)
抽象是指强调实体的本质、内在的属性。在系统开发中，抽象指的是在决定如何实现对象之前的对象的意义和行为。使用抽象可以尽可能避免过早考虑一些细节。

2、继承
继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。

3、多态
多态性是指相同的操作或函数、过程可作用于多种类型的对象上并获得多种结果。不同的对象，收到同一消息可以产生不同的结果，这种现象称为多态性。

思想

1.找出实体
2.分析实体属性和功能
3.让实体之间相互作用
举个例子: 一辆车以时速50km/h的速度过一条长200km的公路,多久能跑完?

var car = {
	speed:50,
	run:function(road){
		return road.length / this.speed
	}
}
var gonglu= {
	length:200
}

var hours = car.run(gonglu)

常见的创建对象的六种方法

1、new 操作符 + Object 创建对象
	var person = new Object();
    person.name = "lisi";
    person.age = 21;
    person.family = ["lida","lier","wangwu"];
    person.say = function(){
        alert(this.name);
    }
2、字面式创建对象
	var person ={
        name: "lisi",
        age: 21,
        family: ["lida","lier","wangwu"],
        say: function(){
            alert(this.name);
        }
    };
/*以上两种方法在使用同一接口创建多个对象时，会产生大量重复代码，为了解决此问题，
工厂模式被开发*/
3、工厂模式
	function createPerson(name,age,family) {
    var o = new Object();
    o.name = name;
    o.age = age;
    o.family = family;
    o.say = function(){
        alert(this.name);
    }
    return o;
}


/*工厂模式解决了重复实例化多个对象的问题，但没有解决对象识别的问题（但是工厂模式却
无从识别对象的类型，因为全部都是Object，不像Date、Array等，本例中，得到的都是o对象,
对象的类型都是Object，因此出现了构造函数模式）。*/
4、构造函数模式
	function Person(name,age,family) {
    this.name = name;
    this.age = age;
    this.family = family;
    this.say = function(){
        alert(this.name);
    }
}

/*对比工厂模式有以下不同之处：
1、没有显式地创建对象
2、直接将属性和方法赋给了 this 对象
3、没有 return 语句

以此方法调用构造函数步骤：
1、创建一个新对象
2、将构造函数的作用域赋给新对象（将this指向这个新对象）
3、执行构造函数代码（为这个新对象添加属性）
4、返回新对象 ( 指针赋给变量person ？？？ )

可以看出，构造函数知道自己从哪里来（通过 instanceof 可以看出其既是Object的实例，
又是Person的实例）
构造函数也有其缺陷，每个实例都包含不同的Function实例（构造函数内的方法在做同一件事，
但是实例化后却产生了不同的对象，方法是函数 ，函数也是对象）
因此产生了原型模式 */


Person.prototype = {
    constructor: Person,  /*每个函数都有prototype属性，指向该函数原型对象，
    原型对象都有constructor属性，这是一个指向prototype属性所在函数的指针*/
    say: function(){
        alert(this.name);
    }
}

5、原型模式
function Person() {
}

Person.prototype.name = "lisi";
Person.prototype.age = 21;
Person.prototype.family = ["lida","lier","wangwu"];
Person.prototype.say = function(){
    alert(this.name);
};
console.log(Person.prototype);   /*Object{name: 'lisi', age: 21, 
family: Array[3]}*/

var person1 = new Person();   //创建一个实例person1
console.log(person1.name);  //lisi

var person2 = new Person(); //创建实例person2
person2.name = "wangwu";
person2.family = ["lida","lier","lisi"];
console.log(person2);  //Person {name: "wangwu", family: Array[3]}
// console.log(person2.prototype.name);         //报错
console.log(person2.age);   //21
/*原型模式的好处是所有对象实例共享它的属性和方法（即所谓的共有属性，
此外还可以如代码第16,17行那样设置实例自己的属性（方法）（即所谓的私有属性)
可以覆盖原型对象上的同名属性（方法）*/

6、混合模式（构造函数模式+原型模式）
	function Person(name,age,family){
    this.name = name;
    this.age = age;
    this.family = family;
}

Person.prototype = {
    constructor: Person,  /*每个函数都有prototype属性，指向该函数原型对象，
    原型对象都有constructor属性，这是一个指向prototype属性所在函数的指针*/
    say: function(){
        alert(this.name);
    }
}

var person1 = new Person("lisi",21,["lida","lier","wangwu"]);
console.log(person1);
var person2 = new Person("wangwu",21,["lida","lier","lisi"]);
console.log(person2);
/*混合模式共享着对相同方法的引用，又保证了每个实例有自己的私有属性。
最大限度的节省了内存*/