一、面向对象

- 面向过程和面向对象

1. 面向过程 C语言 注重问题的解决
2. 面向对象 java 完成对真实世界的模拟，把一个对象的共同特点抽离出现，有了所有的'属性'和'方法' class
3. js并不是一个真正的面向对象的语言，他只是在模拟面向对象
4. constructor 构造器

        // 封装函数
        function dog(type , age) {  
            console.log('有一只' + age + '岁的' + type);
        }

        dog('二哈' , 3)

        // 面向对象 
        function Dog(type , age) {  
            const obj = {
                dog : type  ,
                age ,
                say : function () {  
                    console.log('有一只' + this.age + '岁的' + this.dog);
                }
            }
            return obj
        }

        const d = Dog('二哈' , 3) ;
        console.log(d);
        d.say()


        const d1 = Dog('二哈' , 3) ;
        const d2 = Dog('二哈' , 3) ;


        // 不会共享内存
        console.log(d1.say == d2.say);   // false

        // d1也不是Dog生的
        console.log(d1.constructor); // Object

- 工厂模式、

1. 缺点：创建出来的对象跟函数没有任何联系，创建出来的对象之间的方法不共享

   // 工厂模式
        function dog(type , age) {  
            // 原材料
            const obj = {} ;
            // 加工
            obj.type = type ;
            obj.age = age ;
            obj.say = function () {  
                console.log('有一只' + obj.age + '岁的' + obj.type);
            }
            // 出厂
            return obj
        }

        const dog1 = dog('柯基' , 3) ;

- 认识new

• new做了什么？

1. 给函数添加了返回值，返回一个对象
2. 把this指向了这个对象
3. 创建了一个对象

function Dog(type , age) {  
            // const obj = {} 
            // this -> obj 
            this.type = type ;
            this.age = age ;
            this.say = function () {  
                console.log('有一只' + this.age + '岁的' + this.type);
            }
            // return obj 
        }

        const dog1 = new Dog('柯基' , 3) ;
        const dog2 = new Dog('二哈' , 2) ;
        console.log(dog1);

        console.log(dog1.constructor);  // Dog

        console.log(dog1.say == dog2.say);  // false

• 任何一个函数都可能成为一个构造函数，只要有new就可以
• 为了区分普通函数和构造函数，JS建议构造函数使用大驼峰命名

- 原型对象和原型

• 原型 proto

1. 任何一个对象都有原型 proto，也就是这个构造函数

• 原型对象 prototype

1. 任何一个函数都有原型对象prototype给所有的实例化对象提供共有的属性和方法

        function Fn(type) {  
            this.type = type ;
            this.age = age ;
            // this.say = function () {  
            //     console.log('汪');
            // }
        }

        Fn.prototype.species = '狗' ;
        Fn.prototype.say = function () {  
            console.log('汪');
        }

        var dog = new Fn('狗子') ;
        console.log(dog);
        var dog2 = new Fn('柯基') ;
        console.log(dog);

        dog.say()

        // 每一个实例化对象都共享say方法
        console.log(dog.say == dog2.say);   // true

- js面向对象的模拟最终版

1. 自身拥有的属性和方法写在构造函数中
2. 共有的属性和方法写在构造函数的原型对象上

- js面向对象的发展过程

• 工厂模式

1. 创建一个对象，给对象加工(添加属性和方法) ， 返回这个对象。
2. 缺点：创建出来的对象和函数没有关系 ，方法也不共享 。

• new

1. 创建对象，把this指向了这个对象和返回对象都由new完成了
2. 解决的关系问题 ， 方法依然不共享

• prototype

1. 原型对象：提供共享的属性和方法