类

編程世界有兩大思想：

1. 面嚮過程：按解決問題的过程，罗列步骤的方法来解决问题。
   优点：性能比较高，适合跟硬件联系紧密的东西。
   缺点：没有面向对象易维护，易复用，易维护。

2. 面向對象： 把事务分解成一个个对象，按对象的方法来划分问题。
   优点：灵活，代码可复用，容易维护和开发,适合多人开发合作的大型项目。
   缺点：性能比面向过程低。

   栗子：把大象装进冰箱

   面嚮過程步骤：1.把冰箱门打开，2.把大象装进去 3.冰箱门关上。

   面嚮對象解决方法：
   1.大象对象：
   功能：进入
   2.冰箱对象：
   功能：打开，关闭
   3.使用大象和冰箱的功能

面向对象的思维特点：

1. 抽取（抽象）对象公共属性和行为组织（封装）成一个类模板
2. 对类进行实例化成具体的对象。

对象是指某一个具体的事物，类抽象了对象的公共部分，泛指一类事物。
例如：汽车设计图纸是一个类，定义了汽车这一类事物公共特性，如有轮子，底盘，有颜色，可以启动等等.一辆真实的宝马是对象的实例。

类是什么，有哪些特性

在面向对象编程中，类是对象的模板，定义了同一组对象共有的属性和方法，通过类模版可以生产出无数个一样的对象，而不用一次次声明去定义。
类的三大特性：

1. 封装：将抽象出来的公共特征打包封装起来,通过接口调用或访问封装的内容。目的是增强程序安全性、简化编程，让修改或扩展也更方便；

2. 继承：目的是代码重用

3. 多态：通过一个固定的接口可以得到多种形态的结果,
   如果从父类继承的方法不能满足子类的需求，子类可以进行重写覆盖或者新增方法。

---

1. 类的公有、私有、静态方法/属性:

• 公有是指，在外部环境中可以获取的,通过实【例对象.】获得。（在构造函数中用this进行声明）
• 私有是指，该属性/方法只能在对象构造函数内访问。（声明在构造函数里的变量和方法，没有用到this）
• 静态是指，属性/方法是归属于类的，而非实例对象。可以直接通过类名来调用得到。
• 共享是指，实例对象之间，共享属性和方法，借助向原型对象添加属性和方法，可以实现。

//对象构造函数
	function talk(name,message){
        //1.公有属性,在对象实例化后调用
        this.name=name;    
        //2.私有属性，只能在对象构造函数内部使用 
        var message= message;  
        //3.公有方法(可访问所有权限的方法和属性)  
        this.sayHello=function(){ 
        alert(this.name) 
        alert(this.getName())//使用原型添加的方法
        alert(this.age)  //使用原型添加的属性
        alert(talk.language) //静态属性调用格式【对象.静态属性】
        alert("hello !"+this.name+"I want to say:"+message);//公有属性/方法要用this.访问，私有属性/方法直接访问
        }
        //4.私有方法(只能访问私有的方法和属性)
        function getMessage(){  
            alert(message);
        }
    }
    
    //5.类方法 (公有静态方法），是静态方法直接调用。 语法格式：类名称.方法名称 = function([参数...]){ 语句行; }
      talk.Say = function(){
            alert("我是类方法 Say");
        }
    talk.Say();//可以直接使用 【对象.静态方法()】

    //6.类属性 (公有静态属性)
    //公有静态属性不能使用 【this.属性】，只能使用 【对象.属性】 调用
      talk.age = 18; 

    //7.原型方法 (公有共享方法) 【this.方法】调用
        talk.prototype.getName = function(){
            alert("My name is "+this.name);
            //如果原型方法当作静态方法直接调用时，this.name无法被调用
        }
        talk.prototype.getName();   
        //原型方法当成静态方法使用时【对象.prototype.方法()】
        
    //8.原型属性 (公有共享属性)，当作是类内部的属性使用【this.原型属性】，也可以当成公有静态属性使用【对象.prototype.原型属性】
    talk.prototype.sex = "女";
     alert(talk.prototype.sex);   
     //原型属性当作静态属性使用时【对象.prototype.方法()】

2. ES6 的类创建

//ES6中类没有变量提升，所以一定要先定义再实例化。
        var that ;
		class Star{     
            //类中构造函数不需要function
			construtor(name,age){ 
            //construtor 里面的this指向创建的实例对象。
            //construtor 接受传递的参数，同时返回实例，new生成实例时自动调用。
            //类里共有属性和方法一定要加this
            that = this;//把实例对象this赋值给一个变量，供私有方法使用。
				this.name= name;
                this.age = age;
                this.btn = document.getElementById("btn");
                this.btn.onclick = sing()
                //这里sing方法中的this指向btn
            }
            sing(){
                //私有方法中的this指向调用者.
                console.log(this)
                //that 里面存储的是constructor里面的this
                consoloe.log(that.name)
            }
        }
        // 利用类创建对象
        var cat = new Animal("cat","miao");

new 一个普通函数时发生什么事

new 命令的作用，就是执行构造函数，返回一个实例对象。实际上会经历以下步骤:

1. 创建一个空对象，作为将要返回的对象实例
2. 将这个空对象赋值给函数内部的 this 关键字
3. 将这个空对象的原型_proto_，指向构造函数的 prototype 属性
4. 执行构造函数中的代码（为新对象添加属性）
5. 返回该对象（对于一个构造函数即使它最后没有return，也会默认return this）

new 后面的函数名一定要大写吗?

不一定

如何理解Prototype查找一个对象的某个属性过程

prototype 是指原型对象，_proto_指向constructor的prototype，即是儿子的_proto_永远指向父亲的prototype .
js里完全依靠"原型链"(prototype chain)模式来实现继承，查找属性是按就近原则，先在自己的prototype 查找，如果没有就顺着_proto_指针一路查找，如果找到原型链的末尾Object.prototype.proto 即是null,表示没有找到，返回undefined.

给一个对象设置属性时都发生了什么

给对象obj设置属性name，

obj.name = “Jenny”

1. obj上有name这个属性，如果有就把属性值修改为Jenny.
2. 如果obj上没有，就顺着原型链找，如果找不到，name直接添加到obj上，并且赋值为Jenny
3. 如果name在原型链上找到。

为什么把方法写在prototype中而不写在构造函数中
因为写在构造函数中更消耗内存。写在构造函数中的话，每次用构造函数new一个对象的话，都会创建一份新的属性和方法存到内存中。而写在原型对象中就没有这个问题，对于这个类，只有一个原型对象，因此写在原型对象之下的方法也不会多次复制，永远只有一份。
（如果写在原型对象中，多个实例调用这个方法，会有什么问题吗？比如对同一个对象进行操作？）

两大编程思想：
面向过程：分析解决问题的步骤，

面向对象：把事物分解成一个个对象，让后分工合作。以对象的功能来划分问题

面向对象编程具有灵活，代码可复用，容易维护和开发的优点。

面向对象有三个典型特性：
封装性
继承性
多态性