面向对象的核心

面向对象的核心：高内聚低耩合（就是对面向过程的高度封裝）
＋找到一个机器，能批量生产对象
＋生产出来的对象，每一个对象都有自己的属性和方法
＋每一个对象可能类似，但是内容不太一样
=>构造函数
=> 可以批量生产对象
=>可以向函数一样传递参数，可以给每一个对象添加一些不同的内容
=>当你需要完成一个功能的时候，我们先制造一个构造函数
-＞利用构造函数去创建一个可以完成任务的对象
-＞依赖这个对象完成功能

这个“机器"(构造函数）要生产有属性有方法的合理的对象
=>机器：就是构造函数
=>属性：直接写在构造两数体内
=>方法：写在构造两数的原型上

创建对象方式

字面量方式
var obj = { ... }
可以后期动态添加

var obj = {
                name: 'jack',
                age: 18,
                sayHi:  function () {
                    console.log('helloworld');
                }
            }

内置构造函数创建对象
var obj = new Object()

var obj = new Object();
            obj.name = 'rose';
            obj.age = 19;
            obj.sayHi = function () {
                console.log('hw');
            }

可以后期动态添加

工厂函数创建对象
3.1 制造一个工厂函数
3.2 使用工厂函数去创造对象

//创建工厂函数
            function createObj() {
                //手动创建一个对象
                var obj = {};
                //手动向里面添加属性
                obj.name = 'alan';
                obj.age = 17;
                obj.sayHi = function () {
                    console.log('hi');
                }
                // 手动返回这个对象
                return obj;
            }
            //使用工厂函数创造对象
            var obj1 = createObj();
            var obj2 = createObj();
            console.log(obj1,obj2);

//创建工厂函数
            function createObj(name,age) {
                //手动创建一个对象
                var obj = {};
                //手动向里面添加属性
                obj.name = name;
                obj.age = age;
                obj.sayHi = function () {
                    console.log('hi');
                }
                // 手动返回这个对象
                return obj;
            }
            //使用工厂函数创造对象
            var obj1 = createObj('jack',18);
            var obj2 = createObj('rose',19);
            console.log(obj1,obj2);

4.自定义构造函数创建对象
4.1 创造一个自定义构造函数
4.2使用自定义构造函数去创建对象

// 自定义构造函数
            // 1. 构造函数会自动创建对象，自动返回这个对象
            //我们只需要手动向里面添加内容就可以了
            function createObj() {
                //自动创建对象
                //手动向对象里面添加成员
                // this 指向当前实例
                this.name = 'jack';
                this.age = 19;
                this.sayHi = function () {
                    console.log('hi');
                }
                //自动返回对象
            }
            // 2. 使用自定义构造函数去创建对象
            // 构造函数在使用的时候 需要和new关键字连用
            // 如果不连用，那么没有意义

            //第一次调用createObj时 和new 关键字连用
            //createObj里面的this指向obj1
            //函数内部的代码在执行的时候 就是向obj1添加了name age sayHi
            var obj1 = new createObj();
            // 第二次相同
            var obj2 = new createObj();
            console.log(obj1,obj2);

构造函数的使用

构造函数和普通函数没有区别
只不过要在调用的时候和new连用
书写构造函数，函数名首字母大写
看到名字时就知道要和new连用
电泳的二十号需要和new连用
因为只有和new连用的时候，这个函数才会有自动创建和返回对象的能力
我们之所以写构造函数，就是为了使用它去批量生产对象
如果不和new连用，这个函数就没有创建对象的能力，没有自动返回对象的能力
调用构造函数的时候，如果不需要传递参数，可以不写后面的小括号
若要传递参数，必须写小括号

function person() {
                console.log('hi');
            }
            function Person() {
                this.name = 'jack'
            }
            //3
            var obj = new Person()
            console.log(obj);
            //4
            var obj2 = new Person;
            console.log(obj2);

当函数名和new关键字连用时
函数内部的this指向当前实例（new关键字前面的变量）
直接在函数体内写 this.xxx = 值，就是在向自动创建出来的对象里面添加内容
构造函数内部不要对编写return
当你return了一个基本数据类型的时候，写了白写
当你return了一个复杂数据类型的时候，构造函数白写

构造函数的不合理

当在构造函数体内书写方法时
当你需要在对象上添加方法时只需要new一次就会有一个函数在占用空间
当创建多个对象时会有多个一样的函数出现，但是其中很多都是重复的，没必要存在

// 1. 准备一个构造函数
            function Person(name,age){
                this.name = name;
                this.age = age;
                this.sayHi = function () {
                    console.log('hi');
                }
            }
            // 2. 创建对象
            var p1 = new Person('jack',20);
            var p2 = new Person('rose',20);
            console.log(p1,p2);
            //强用两个对象的sayHi方法
            p1.sayHi();
            // 两个对象是否一样？false
            console.log( p1 === p2);
            // 两个对象里面的函数
            console.log(p1.sayHi);
            console.log(p2.sayHi);
            console.log(p1.sayHi == p2.sayHi);//false 是两个函数

image.png