js中的面向对象

举两个例子：
1，把大象装进冰箱：
面向过程：1，打开冰箱门,2，把大象放进去；3，关上冰箱门
面向对象：1，先创建一个冰箱的对象，还有大象的对象；
2，给冰箱对象一个开开冰箱门，关上冰箱门的功能；给大象一个走进冰箱的功能
3，调用大象的走进冰箱的方法，调用冰箱的关上冰箱门的方法
2，五子棋游戏
面向过程：1，黑子先走，判断黑子有没有连城一条线
2，白字再走，判断白字有没有连城一条线
面向对象：先创建出来黑子，白字的对象，都有落旗子的功能，再创建出来游戏规则对象，判断哪一方赢
调用黑子的落旗子方法，调用游戏规则对象判断黑子是否赢
调用白字的罗旗子方法，调用游戏规则对象判断白字是否赢

对象里的几个重要的概念：
类
对象（实例）：属性（对象的特征），方法（对象的行为）
封装
继承
多态
js是基于对象的语言，而不是面向对象的语言，当需要使用js代码实现面向对象编程思想时，就使用js代码来模拟面向对象语言的各种概念，特征
类（class）是一堆具有相同属性、方法的数据类型的集合，对象是把类（class）的属性和方法具体化后的一种数据类型。
在面向对象语言中，必须通过类来创建对象，而js中没有类的概念，所以就是用“构造函数”来模拟（充当、代替）面相对象语言中的"类"，通过构造函数来创建对象。
// 属性和方法
// 属性就是属于某个对象的变量，该变量只能通过他所归属的对象调用、访问，其他对象无法获取到；
// 方法就是属于某个对象的函数，该函数只能通过他所归属的对象调用、访问，其他对象无法获取到。

在js中，因为直接通过"var”定义的变量、函数都默认属于window对象，所以js就有了"基于对象"这个语言名称。
继承：类与类之间一旦声明了继承关系，如：A继承自B（A是通过B创建出来的子类，B是父类，A是子类），B类中拥有的属性、方法，在A类中不用再次创建，因为子类可以获取到父类的属性和方法，这种关系就是继承。
多态：各个对象在获取到创建这个对象的类中所有的方法时，方法是同一个方法，但是因为是由不同对象调用的，所以这些方法执行结果可能不同（同一个类创建的不同对象，具备同样的方法，但是因为对象不同，所以方法执行的结果也可能不同），这种行为就是多态。

js创建对象的方法
1，直接创建：
var person = {
name：'张三'，
age：34，
sayHi：function(){
alert('hello')
}
}
2,使用工厂方法创建对象
function createPerson(name,age){
//创建一个空对象
var per = new Object();
// var per = {};
per.name = name;
per.age = age;
per.sayHi = function(){
alert('hello')
}
return per;
}
//调用工厂函数，获取新创建的对象
var person1 = createPerson('zhang',34)
3,构造函数创建对象（都要用this）
function CreatePerson(name, age) {
//此this是指的window
this.name = name;
this.age = age;
this.sayHi = function () {
alert('hello');
}

        }
     var per1 = new CreatePerson('张三', 18);
        console.log(per1);
        console.log(per1 instanceof CreatePerson);
        var per2 = new CreatePerson('李四', '22');
        console.log(per2);

4，通过原型创建对象
// 通过原型创建对象
// 优势：可以把对象公有的数据统一托管在原型中，以达到节约内存的目的
function CreateAnimal(name, age) {
// 把所有对象公有的相同属性和所有方法全部存在原型中，以达到节约内存的目的
// 把各自对象值不同的属性，放在实例中，有对象自己开辟内存空间，维护自己独有的值
this.name = name;
this.age = age;
CreateAnimal.prototype.sayHi = function () {
alert('汪汪');
}
}

        var dog1 = new CreateAnimal('阿黄', 4);
        console.log(dog1.name);
        console.log(dog1.age);

        var dog2 = new CreateAnimal('旺财', 8);
        console.log(dog2.name);
        console.log(dog2.age);

        console.log(dog1.name);
        console.log(dog1.age); 

5，// 动态原型创建对象
// 如果原型中已经存在相关的属性和方法，则构造函数中，添加原型属性、方法的代码不再执行。
function CreateCat(name, age) {
this.name = name;
this.age = age;
// CreateCat.prototype.sayHi
//
if (typeof(CreateCat.prototype.sayHi) != 'function') {
CreateCat.prototype.sayHi = function () {
alert('喵喵,我的名字是:' + this.name);
}
}
}

        var cat1 = new CreateCat('咪咪', 18);
        var cat2 = new CreateCat('哈哈哈哈', 2);

        cat1.sayHi();
        cat2.sayHi();

  访问对象的属性
    function CreatePerson(name,age) {
            this.name = name;
            this.age = age;
            this.sayHi = function () {
                alert('hello');
            }
        }

        var person1 = new CreatePerson('张三', 18);

        // 通过点语法的方式访问：对象名.属性名
        console.log(person1.name);
        // 通过下标的方式访问属性:对象名['字符串类型的属性名']
        var name = 'name';
        console.log(person1[name]);

        // 修改属性的值:对象名.属性名=赋新值
        person1.name = '李四';

        person1.gender = '男';
        console.log(person1);

        // 删除对象下的属性:delete
        delete person1.gender;
        console.log(person1);


        var arr = [12, 23, 34, 45, 56, 67, 78, 89, 90];

        // 使用快速遍历，来遍历对象属性
        for (var item in person1) {
            // 通过条件，过滤对象中的方法，只遍历出属性
            if (typeof(person1[item]) != 'function') {
                console.log(person1[item]);
            }
        }
// 定义一个构造函数，通过该函数可以创建一个能计算平方的对象
        function PingFang(num) {
            this.num = num;
            this.pingFang = function () {
                return this.num*this.num;
            }
        }

        var obj = new PingFang(3);
        var result = obj.pingFang()
        console.log(result);