面向对象 构造函数的写法

面向对象  构造函数的写法

 

1.对象的几种创建方式

创建单一的一个对象、字面量的方式创建

    let obj1 ={

        "sname":"xm",

        "age":19,   

        "study":function(){

            return "学习中ing"；

        }

    }

let obj2 = new  object();

     obj2.sname = "dm";

      obj2.age =20;

        obj2.study =function(){

        return "学习中ing";

}

//缺点：同类对象的创建    代码会重复

 

2.工厂模式   

工厂模式  （设计模式的一种）了解   可以通过函数调用的方式创建对象

//类是对象的抽象化   对象是类的具象化

  funtion   student（）{

            //配料   --   创建一个对象

            let  obj =new object();

            //加工 --  为创建的对象添加属性 或者方法  

            obj.sname =sname;

            obj.age =age;

            obj.study = function(){

                return "学习ing"；

            }

            //出厂-- 返回对象

                return   obj；

    }

// 再创建一个工厂

    function animal（name，age）{

        //配料 --     创建一个对象

              let  obj =new object();

            //加工 --  为创建的对象添加属性 或者方法  

            obj.name =name;

            obj.age =age;

            obj.running = function(){

                return "奔跑"；

            }

            //出厂-- 返回对象

                return   obj；

    }

 

 

//创建多个同类对象

let  s1=student("小白" ， 20)；

let   s2 = student（“大白”， 21）；

//创建动物animal对象

let a1 =animal("小美"，1)；

console.log(s1.sname, s1.age, s1.study());

console.log(s1.sname, s1.age, s1.study());

 

 

缺点： 1.对象的创建方式  不规范      是通过普通函数的调用创建的对象， 一般对象是new出来的   

        2.不能确定某个对象属于哪一个类

 

 

//instanceof       确定某个对象属于哪个类     或者说 哪个构造函数  

        console.log（s1 instanceof  Object）;

        console.log（a1 instanceof  Object）;    

                                    //结果都为ture   所以没有办法确定某个对象属于哪个构造函数   或者哪个类

 

3.构造函数

构造函数：

         使用new 关键字创建对象的函数  比如 ：new Array()   new String()   这里的Array 和 String 就是构造函数

构造函数中的this   指向 当前函数new出来的对象

 

function Animal(name,age){

    this.name = name ;        //实例属性

    this.age =age;

    this.running =function (){       //实例方法

        return "奔跑"；

        }

    }

let A1 =new Animal("小美"， 1);

 

function Student(name,age){

          this.name = name; //实例属性

          this.age = age;

          this.study = function(){ //实例方法

              return "学习";

          }

     }

     let A1 = new Animal( "小美"  , 1 );

     let A2 = new Animal( "豆丁"  , 2 );

     let S1 = new Student( "小明"  , 20 );

     //确定某个对象属于哪一个构造函数

     console.log( A1 instanceof Animal );//true

     console.log( S1 instanceof Animal );//false

     

     //优点 ： 解决了上面遇到的缺点

     //缺点 ： 多个同类对象的相同方法 空间不共享

比如：

     //alert( A1.running == A2.running );//false

 

使用new运算符生成一个实例时，需要执行的步骤有下面几个步骤：

创建一个新对象    new 对象

改变this指向     构造函数中的this指向了new出来对象

执行构造函数里的代码    调用对象的方法或属性

返回一个对象       

 

 

4.构造函数中定义        原型方法  以及  原型 属性

原型方法：    多个同类对象的方法调用时，空间共享

function Teacher (name){

        this.name = name ;

}

//写在构造函数外面的  叫做原型方法  

    Teacher.prototype.teach=function(){

        return   "教学ing";

        }

    Teacher.prototype.eat = function(){

        return "吃饭";

    }

 

//原型属性    多个同类对象的属性值相同   一改全改

    Teacher.prototype.name="lce";

//创建对象    

    let t1 = new Teacher;

    let t2 = new Teacher;

//alert( t1.teach == t2.teach )//true

     console.log( t1.name , t2.name );  // lce   lce  

     导致无法改变 原型属性后面 new出来的属性值    

5.构造函数中定义    混合写法 

属性写成 实例属性

方法写成 原型方法

 

6.原型对象prototype

        凡是通过 new Function() 创建的对象都是函数对象，其他的都是普通对象

        普通对象没有prototype,但有__proto__属性                                                                                 构造函数.prototype    对象.__proto__

        构造函数没有 __proto__ 但有  prototype属性

        prototype属性(对象)会默认获得一个constructor(构造函数)属性，这个属性是一个指向prototype属性所在函数的指针

 

所有的构造函数都有一个prototype属性，这个属性就称为原型对象  

所有的构造函数new出来的对象都有一个__proto__ 属性 ， 这个属性也对应着一个对象就是原型对象

 

面试题 ： 在Array的原型上实现数组去重 

               在String的原型上实现去掉字符串两端的空白字符

转载于:https://www.cnblogs.com/wangwenxin123/p/11175943.html