精华内容
下载资源
问答
  • JS定义一个类有两种定法(我只知道这两种): 1. 定义函数的方式: 定义: 代码如下:function classA(a) {  this.aaa=a; //添加一个属性  this.methodA=function(ppp) //添加一个方法  {  alert(ppp)...
  • Javascript定义一个类

    2016-02-26 02:53:25
    ``` var Student=function(){ ...定义一个类,应该把这个的实例方法,写在构造函数里面,还是挂在prototype上面?为什么? valueOf,toString,如果要重写这两个函数,应该写在构造函数,还是prototype上面?
  • 主要介绍了js定义类方法,结合实例形式分析了javascript ES5与ES6标准下定义方法,需要的朋友可以参考下
  • 本文实例讲述了JavaScript...(1)定义一个类 function JMap() { var arr={};//空 //增加 this.put=function (key,value) {//用一个方法将数据加到指定类中去 arr[key]=value; } this.get=function (key) { if
  • 主要介绍了JS类定义与使用方法,结合实例形式深入分析了javascript类定义与属性、方法的调用技巧,需要的朋友可以参考下
  • 在面向对象编程(class)是对象(object)的模板,定义了同组对象共有的属性和方法Javascript语言不支持“”, 但是可以用一些变通的方法,模拟出“”。 、构造函数法 经典的方法,书上...

    在面向对象编程中,类(class)是对象(object)的模板,定义了同一组对象共有的属性和方法。

    Javascript语言不支持“类”, 但是可以用一些变通的方法,模拟出“类”。

    一、构造函数法

    经典的方法,书上也是这样教的。它用构造函数模拟类,在内部用this关键字指代实例对象。


    生成实例的时候,使用new关键字。


    类的属性和方法,还可以定义在构造函数的prototype对象之上。(具体什么是prototype, 后面找机会再研究吧)


    二、Object.create() 方法

    为了解决生成对象麻烦,Javascript国际标准提出一个新的方法Object.create()。用这个方法,“类”就是一个对象,不是函数。


    然后直接用Object.create()生成实例,不需要用到new。


    目前,各大浏览器的最新版本(包括IE9)都部署了这个方法。如果遇到老式浏览器,可以用下面的代码自行部署。


    这种方法比"构造函数法"简单,但是不能实现私有属性和私有方法,实例对象之间也不能共享数据,对"类"的模拟不够全面。

    三、极简主义

    "极简主义法"(minimalist approach)

    1、封装

    这种方法不使用this和prototype,代码部署起来非常简单,这大概也是它被叫做"极简主义法"的原因。 首先,它也是用一个对象模拟"类"。在这个类里面,定义一个构造函数createNew(),用来生成实例。

    然后,在createNew()里面,定义一个实例对象,把这个实例对象作为返回值。


    使用的时候,调用createNew()方法,就可以得到实例对象。


    这种方法的好处是,容易理解,结构清晰优雅,符合传统的"面向对象编程"的构造,因此可以方便地部署下面的特性。

    2、继承

    让一个类继承另一个类,实现起来很方便。只要在前者的createNew()方法中,调用后者的createNew()方法即可。 先定义一个Animal类。

    然后,在Dog的createNew()方法中,调用Animal的createNew()方法。

    这样得到的Cat实例,就会同时继承Cat类和Animal类。


    3、私有属性和私有方法

    在createNew()方法中,只要不是定义在dog对象上的方法和属性,都是私有的。


    上例的内部变量sound,外部无法读取,只有通过dog的公有方法makeSound()来读取。


    4、数据共享

    有时候,我们需要所有实例对象,能够读写同一项内部数据。这个时候,只要把这个内部数据,封装在类对象的里面、createNew()方法的外面即可。

    然后,生成两个实例对象

    这时,如果有一个实例对象,修改了共享的数据,另一个实例对象也会受到影响。



    后记:由于工作需要,最近开始学习JS 和 node.js开发,之前接触的比较少,内容中有什么不对的希望大家可以及时指出,谢谢。

    本人之前一直从事android方面的开发,如果有什么android方面的问题欢迎随时交流。

    展开全文
  • 代码如下: [removed] //定义一个javascript类 function JsClass(privateParam/* */,publicParam){//构造函数 var priMember = privateParam; //私有变量 this.pubMember = publicParam; //公共变量 //定义私有方法 ...
  • 个定义都可以,不过后者对FF貌似好一些,前者在FF下可能出现missing before formal parameters错误,导致js无法执行。
  • javascript es6定义类的使用方法

    千次阅读 2019-04-01 19:37:16
    es6定义类的使用方法 ... 这个导出方法在同一个工程使用就不能导出操作 //------------------------------------- cmToolBar = new cwgisToolBarClass(); // //import {cwgisMapFullE...

    javascript es6定义类和类的使用方法

    javascript类的使用
    注意://export {cwgisMapPanCmd}; 这个导出方法在同一个工程中使用就不能导出操作

    //-------------------------------------
        cmToolBar = new cwgisToolBarClass();
        //
        //import {cwgisMapFullExtentCmd} from "../static/js/openlayer52ex/cwgisToolBarClass";
        //import {cwgisMapPanCmd} from "../static/js/openlayer52ex/cwgisToolBarClass";
        mapPanCmd = new cwgisMapPanCmd(map);
        //向全局工具栏管理类注册
        if (cmToolBar && cmToolBar != null) {
            cmToolBar.addItem(mapPanCmd);
        }
        mapFullExtentCmd = new cwgisMapFullExtentCmd(map);
        //向全局工具栏管理类注册
        if (cmToolBar && cmToolBar != null) {
            cmToolBar.addItem(mapFullExtentCmd);
        }
        //-------------------------------------
    
    <li style="border-spacing: 5px">
         <div class="border">
             <img src="../static/img/web32/legend_b_32.png" alt="框选放大" "mapPanCmd.onClick();"></img>
         </div>
     </li>
     <li style="border-spacing: 5px">
         <div class="border">
             <img src="../static/img/web32/legend_b_32.png" alt="全屏" "mapFullExtentCmd.onClick();"></img>
         </div>
     </li>
    

    javascript类的定义

    //定义工具栏管理类
    //cwgisToolBarClass.js
    //vp:hsg
    //定义全局变量
    //插件调用方法cmToolbar.addItem(pluginCmdTool);
    //定义工具栏管理类
    class cwgisToolBarClass
    {
        //初始化函数
        constructor(){
            //类名称
            this.CLASS_NAME="cwgisToolBarClass";
            this.m_ToolBarItems=[];
            this.isScan= false;
        }
        getMap(){
           return map;
        }
        //添加插件项
        addItem(item) {
            if (item != null) {
                this.m_ToolBarItems.push(item);
            }
        }
        //反激活插件集合
        deactivateItems() {
            //清除全局地图事件鼠标监听者
            //this.getMap().map.events.clearMouseListener();
            //反激活所有全局工具
            if (this.m_ToolBarItems == null) return;
            for (var i=0;i<this.m_ToolBarItems.length;i++) {
                var item=this.m_ToolBarItems[i];
                if (item != null) {
                    try {
                        item.dispose();
                    }
                    catch (e) { }
                    try {
                        item.deactivate();
                    }
                    catch (e) { }
                }
            }
        }
        //启动扫描
        startScan() {
            this.isScan = true;
            window.setInterval('loopScanItemEvent()', 1000); //1000为1秒钟,时间可以自己设
        }
        //循环扫描项事件
        loopScanItemEvent() {
            if (this.isScan == true) {
                for (var item in this.m_ToolBarItems) {
                    if (this.isScan == false) break;
                    if (item != null) {
                        item.enabled;
                    }
                }
            }
        }
        //释放类
        dispose() {
            this.isScan = false;
            this.deactivateItems();
            this.m_ToolBarItems = null;
        }
    }
    //export {cwgisToolBarClass};
    
    //es6  需要采用支持es6的游览器
    //定义插件Command基类  继承于OpenLayers.Class(OpenLayers.Control)
    //基类抽象类名称:cwgisCommand
    class cwgisCommand
    {
        constructor(mapWrap){
            //定义属性
            this.map_=null;
            this.mapWrap=null;
            //
            this.values_ = {};
            //类名称
            this.CLASS_NAME="cwgisCommand";
            this.init(mapWrap);
            this.setActive(false);
        }
    
        //定义类  初始化函数
        init(p_mapCwgisClass) {
            this.mapWrap = p_mapCwgisClass;
            if(p_mapCwgisClass && p_mapCwgisClass.map) {
                this.setMap(p_mapCwgisClass.map);
            }
        }
        get(key) {
            let value;
            if (this.values_.hasOwnProperty(key)) {
                value = this.values_[key];
            }
            return value;
        }
        getKeys() {
            return Object.keys(this.values_);
        }
        getProperties() {
            return assign({}, this.values_);
        }
        set(key, value,opt_silent) {
            if (opt_silent) {
                this.values_[key] = value;
            } else {
                const oldValue = this.values_[key];
                this.values_[key] = value;
            }
        }
        //----
        getActive() {
            return this.get("ACTIVE");
        }
        getMap() {
            return this.map_;
        }
        setActive(active) {
            this.set("ACTIVE", active);
        }
        setMap(map) {
            this.map_ = map;
        }
        //释放类
        dispose() {
            this.deactivate();
        }
        deactivate(){
        }
        activate(){
        }
        //定义单击事件
        onClick () {
            if (cmToolBar != null) {
                cmToolBar.deactivateItems();
            }
            this.activate(); //激活控件
        }
    }
    //export {cwgisCommand};
    
    //定义插件Tool基类  继承于OpenLayers.Class(mapCwgisPluginCommand)
    //基类抽象类名称:cwgisTool
    class cwgisTool extends cwgisCommand
    {
        constructor(mapWrap) {
            super(mapWrap);                   //继承父类Control
            this.init(mapWrap);
            //类名称
            this.CLASS_NAME = "cwgisTool";
            //定义属性
            this.layer = null;
            this.callbacks = null;
            this.multi = false;
            this.handlerOptions = null;
            this.handlerClass = null;
        }
        //定义类  初始化函数
        initialize (p_mapCwgisClass,handler,options) {
            this.init(p_mapCwgisClass);
            //定义 处理鼠标事件基础对象 (点)   /线/面etc...
            this.handlerClass = handler;
            //
            var handlerAbsClass = this.handlerClass;
            this.handlerOptions = handlerAbsClass;
            //初始化基类OpenLayers.Control的初始化方法
            ol.control.Control.prototype.initialize.apply(this, [this.handlerOptions]);
            //定义一个回调函数
            this.callbacks = OpenLayers.Util.extend(
                {
                    done: function (geometry) { },
                    modify: function (vertex, feature) {
                    },
                    create: function (vertex, feature) {
                    }
                },
                this.callbacks
            );
            if (this.mapWrap.vlayer_drawFeature == null) {
                this.mapWrap.vlayer_drawFeature = new ol.Layer.Vector();
                this.mapWrap.map.addLayer(this.mapWrap.vlayer_drawFeature);
            }
            //定义一个临时绘制的图层
            this.layer = this.mapWrap.vlayer_drawFeature;
            //this.handlerOptions =OpenLayers.Handler.Point;// this.handlerOptions || {};
            if (!("multi" in this.handlerOptions)) {
                this.handlerOptions.multi = this.multi;
            }
            var sketchStyle = this.layer.styleMap && this.layer.styleMap.styles.select; //.temporary;
            if (sketchStyle) {
                this.handlerOptions.layerOptions = ol.Util.applyDefaults(
                    this.handlerOptions.layerOptions,
                    { styleMap: new ol.StyleMap({ "default": sketchStyle }) }
                );
            }
            //定义处理鼠标事件基础对象
            this.handler = new handlerAbsClass(this, this.callbacks, this.handlerOptions);
        }
        //定义 鼠标处理事件集合
        //定义鼠标按上事件
        onMouseUp(e){
        }
        //定义鼠标按下事件
        onMouseDown(e){
        }
        //定义鼠标移动事件
        onMouseMove(e) {
        }
        //定义鼠标双击事件
        onDoubleClick(e) {
        }
        //定义鼠标右键单击事件
        onRightClick(e) {
        }
        onSingleClick(e){
        }
        //释放类鼠标移动事件
        dispose() {
            //
            if(this.layer) {
                this.layer.destroyFeatures();
                this.layer.redraw();
            }
            //选中地块清除操作
            //this.mapWrap.layer_Highlight.destroyFeatures();
            //this.mapWrap.layer_Highlight.redraw();
            //
            //反注册鼠标按上事件 mouseup
            this.mapWrap.map.un("mouseup",  this.onMouseUp);
            //反注册鼠标按下事件 mousedown
            this.mapWrap.map.un("mousedown", this.onMouseDown);
            //反注册鼠标移动事件 mousemove
            this.mapWrap.map.un("mousemove",  this.onMouseMove);
            //反注册鼠标双击事件 dblclick
            this.mapWrap.map.un("dblclick",  this.onDoubleClick);
            //反注册鼠标右键单击事件 rightclick
            this.mapWrap.map.un("rightclick",  this.onRightClick);
            //
            //this.mapWrap.map.un("singleclick", this.onSingleClick);
            //
            this.deactivate();
        }
        //定义单击事件
        onClick() {
            if (cmToolBar != null) {
                cmToolBar.deactivateItems();
            }
            //初始化事件处理对象
            //注册鼠标按上事件 mouseup
            this.mapWrap.map.un("mouseup", this.onMouseUp);
            this.mapWrap.map.on("mouseup", this.onMouseUp);
            //注册鼠标按下事件 mousedown
            this.mapWrap.map.un("mousedown", this.onMouseDown);
            this.mapWrap.map.on("mousedown", this.onMouseDown);
            //注册鼠标移动事件 mousemove
            this.mapWrap.map.un("mousemove",  this.onMouseMove);
            this.mapWrap.map.on("mousemove",  this.onMouseMove);
            //注册鼠标双击事件 dblclick
            this.mapWrap.map.un("dblclick", this.onDoubleClick);
            this.mapWrap.map.on("dblclick",  this.onDoubleClick);
            //注册鼠标右键单击事件 rightclick
            this.mapWrap.map.un("rightclick",  this.onRightClick);
            this.mapWrap.map.on("rightclick",  this.onRightClick);
            //singleclick
            //this.mapWrap.map.un("singleclick",  this.onSingleClick);
            //this.mapWrap.map.on("singleclick",  this.onSingleClick);
            //
            this.activate(); //激活控件
        }
    }
    //export {cwgisTool};
    
    //==========================================================
    //定义 地图平移插件命令功能
    class cwgisMapPanCmd extends cwgisTool
    {
        constructor(mapWrap) {
            super(mapWrap);
            this.CLASS_NAME="cwgisMapPanCmd";
            this.init(mapWrap);
            this.dPan=null;
        }
        deactivate(){
            //this.mapWrap.map.removeInteraction(this.dPan);
        }
        activate(){
            //this.dPan=new ol.interaction.DragPan();
            //this.mapWrap.map.addInteraction(this.dPan);
        }
    };
    //export {cwgisMapPanCmd};
    
    //================
    //定义 地图全屏显示插件命令功能
    class cwgisMapFullExtentCmd extends cwgisCommand
    {
        constructor(mapWrap)
        {
            super(mapWrap);
            this.CLASS_NAME="cwgisMapFullExtentCmd";
            this.init(mapWrap);
        }
        //定义单击事件
        onClick () {
            if (cmToolBar != null) {
                cmToolBar.deactivateItems();
            }
            if (this.mapWrap) {
                this.mapWrap.fullScreenMap(); //this.mapWrap.map.zoomToMaxExtent();
            }
            //激活控件
            this.activate();
        }
    };
    //export {cwgisMapFullExtentCmd};
    class cwgisMapBoxZoomCmd extends cwgisTool
    {
        constructor(mapWrap)
        {
            super(mapWrap);
            this.CLASS_NAME="cwgisMapBoxZoomCmd";
            this.init(mapWrap);
            this.dBox=null;
        }
        deactivate(){
            this.mapWrap.map.removeInteraction(this.dBox);
        }
        //OK
        activate(){
            this.dBox=new ol.interaction.DragBox();
            var Tthis=this;
            this.dBox.onBoxEnd_=function(mapBrowserEvent){
                var t_geo=Tthis.dBox.getGeometry();
                var t_mapbounds=t_geo;
                Tthis.mapWrap.map.getView().fit(t_mapbounds, Tthis.mapWrap.map.getSize());
                Tthis.mapWrap.map.updateSize();
            };
            this.mapWrap.map.addInteraction(this.dBox);
        }
    }
    //=========================================================
    
    展开全文
  • JS中定义类方法

    万次阅读 2007-10-24 20:13:00
    JS中定义类的方式有很多种: 1、工厂方式 function Car(){ var ocar = new Object; ocar.color = "blue"; ocar.doors = 4; ocar.showColor = function(){ document.write(this.color) }; return...

    JS中定义类的方式有很多种:
    1、工厂方式 

       function  Car(){ 
       
    var  ocar  =   new  Object; 
       ocar.color 
    =   " blue "
       ocar.doors 
    =   4
       ocar.showColor 
    =   function (){ 
        document.write(
    this .color) 
       }; 
       
    return  ocar; 
      } 
      
    var  car1  =  Car(); 
      
    var  car2  =  Car(); 

      调用此函数时将创建新对象,并赋予它所有的属性和方法。使用此函数可以创建2个属性完全相同的对象。当然我妹可以通过给它传递参数来改版这种方式。 

       function  Car(color,door){ 
       
    var  ocar  =   new  Object; 
       ocar.color 
    =  color; 
       ocar.doors 
    =  door; 
       ocar.showColor 
    =   function (){ 
        document.write(
    this .color) 
       }; 
       
    return  ocar; 
      } 
      
    var  car1  =  Car( " red " , 4 ); 
      
    var  car2  =  Car( " blue " , 4 ); 
      car1.showColor()  
    // output:"red" 
      car2.showColor()   // output:"blue" 

      现在可以通过给函数传递不同的参数来得到具有不同值的对象。
      在前面的例子中,每次调用函数Car(),都要创建showcolor(),意味着每个对象都有一个自己的showcolor()方法。

     但是事实上,每个对象斗共享了同一个函数。
      虽然可以在函数外定义方法,然后通过将函数的属性指向该方法。

       function  showColor(){ 
       alert(
    this .color); 
      } 
      
    function  Car(){ 
       
    var  ocar  =   new  Object(); 
       ocar.color 
    =  color; 
       ocar.doors 
    =  door; 
       ocar.showColor 
    =  showColor; 
       
    return  ocar; 
      } 


      但是这样看起来不像是函数的方法。
    2、构造函数方式
      构造函数方式同工厂方式一样简单,如下所示: 

       function  Car(color,door)
       
    this.color = color; 
       
    this.doors = door; 
       
    this.showColor = function()
        alert(
    this.color) 
       }

      }
     
      
    var  car1  =   new  Car( " red " , 4 ); 
      
    var  car2  =   new  Car( " blue " , 4 ); 


      可以看到构造函数方式在函数内部没有创建对象,是用this关键字。因为在调用构造函数时已经创建了对象,而在函数内部只能用this来访问对象属性。
      现在用new来创建对象,看起来像那么回事了!但是它同工厂方式一样。每次调用都会为对象创建自己的方法。
    3、原型方式
      该方式利用了对象的prototype属性。首先用空函数创建类名,然后所有的属性和方法都被赋予prototype属性。 

       function  Car()
      }
     
      Car.prototype.color 
    =   " red "
      Car.prototype.doors 
    =   4
      Car.prototype.showColor 
    =   function ()
       alert(
    this.color); 
      }
     
      
    var  car1  =   new  Car(); 
      
    var  car2  =   new  Car(); 


      在这段代码中,首先定义了一个空函数,然后通过prototype属性来定义对象的属性。调用该函数时,原型的所有属性都会立即赋予要创建的对象,所有该函数的对象存放的都是指向showColor()的指针,语法上看起来都属于同一个对象。
      但是这个函数没有参数,不能通过传递参数来初始化属性,必须要在对象创建后才能改变属性的默认值。
      原型方式有个很严重的问题就是当属性指向的是对象时,如数组。 

       function  Car(){ 
      } 
      Car.prototype.color 
    =   " red "
      Car.prototype.doors 
    =   4
      Car.prototype.arr 
    =   new  Array( " a " , " b " ); 
      Car.prototype.showColor 
    =   function (){ 
       alert(
    this .color); 
      } 
      
    var  car1  =   new  Car(); 
      
    var  car2  =   new  Car(); 
      car1.arr.push(
    " cc " ); 
      alert(car1.arr);  
    // output:aa,bb,cc 
      alert(car2.arr);   // output:aa,bb,cc 

      这里由于数组的引用值,Car的两个对象指向的都是同一个数组,所以当在car1添加值后,在car2中也可以看到。
     联合是用构造函数/原型方式就可以像其他程序设计语言一样创建对象,是用构造函数定义对象的非函数属性,用原型方式定义对象的方法。 

       function  Car(color,door){ 
       
    this .color  =  color; 
       
    this .doors  =  door; 
       
    this .arr  =   new  Array( " aa " , " bb " ); 
      } 
      Car.prototype.showColor(){ 
       alert(
    this .color); 
      } 
      
    var  car1  =   new  Car( " red " , 4 ); 
      
    var  car2  =   new  Car( " blue " , 4 ); 
      car1.arr.push(
    " cc " ); 
      alert(car1.arr);  
    // output:aa,bb,cc 
      alert(car2.arr);   // output:aa,bb 

      
    5、动态原型方式
      动态原型的方式同混合的构造函数/原型方式原理相似。唯一的区别就是赋予对象方法的位置。 

       function  Car(color,door){ 
       
    this .color  =  color; 
       
    this .doors  =  door; 
       
    this .arr  =   new  Array( " aa " , " bb " ); 
       
    if ( typeof  Car._initialized  ==   " undefined " ){ 
        Car.prototype.showColor 
    =   function (){ 
         alert(
    this .color); 
        }; 
        Car._initialized 
    =   true
       } 
      }

     动态原型方式是使用一个标志来判断是否已经给原型赋予了方法。这样可以保证该方法只创建一次
    6、混合工厂方式
      它的目的师创建假构造函数,只返回另一种对象的新实例。 

       function  Car(){ 
       
    var  ocar  =   new  Object(); 
       ocar.color 
    =   " red "
       ocar.doors 
    =   4
       ocar.showColor 
    =   function (){ 
        alert(
    this .color) 
       }; 
       
    return  ocar; 
      } 

      与工厂方式所不同的是,这种方式使用new运算符。
      
      以上就是全部的创建对象方法。目前使用最广泛的就是混合构造函数/原型方式,此外,动态原型方式也很流行。在功能上与构造函数/原型方式等价。

    上述非原创,乃转载而来

    展开全文
  • JS定义静态

    2013-05-22 15:38:21
    JS定义静态,可以看看,应该很容易看懂
  • JavaScript定义类(class)的三种方法

    千次阅读 2018-12-10 14:32:06
    JavaScript定义类(class)的三种方法 1. 构造函数法 function Cat(){ this.name = "大毛"; } 生成实例时,使用 new 关键字 的属性和方法,还可以定义在构造函数的prototype(能为对象添加属性和方法...

    JavaScript定义类(class)的三种方法

    1. 构造函数法

    function Cat(){
        this.name = "大毛";
    }
    

    生成实例时,使用 new 关键字
    类的属性和方法,还可以定义在构造函数的prototype(能为对象添加属性和方法)上

    Cat.prototype.makeSound = function(){
        alert('喵喵喵');
    }
    

    2.Object.create()法

    用这个方法,‘类’就是一个对象,不是函数

    var Cat = {
        name:'大毛',
        makeSound:function(){
            alert('喵喵喵');
        }
    }
    

    然后直接用Object.create()生成实例,不需要用到new

    var cat1 = Object.create(Cat);
    alert(cat1.name);//大毛
    cat1.makeSound();//喵喵喵
    

    3.极简主义法(推荐)

    这种方法不使用this和prototype,它是用一个队形模拟类,在这个类里面,定义一个构造函数createNew(),用来生成实例

    3.1封装
    var Cat = {
        createNew:function(){
           var cat = {};
           cat.name = '大毛';
           cat.makeSound = function(){
               alert('喵喵喵');
           }
           return cat;
        }
    }
    

    使用的时候调用createNew()方法,就可以得到实例对象

    var cat1 = Cat.createNew();
    cat1.makeSound();//喵喵喵
    

    这种方法的好处是容易理解,结构清晰优雅,符合传统的‘面向对象编程’的构造

    3.2继承

    先定义一个Animal类

    var Animal = {
        createNew:function(){
            var animal = {};
            animal.sleep = function(){alert('睡懒觉');};
            return animal;
        }
    }
    

    然后,在Cat的createNew()方法中,调用Animal的createNew()方法

    var Cat = {
        createNew:function(){
            var cat = Animal.createNew();
            cat.name = '大毛';
            cat.makSound = function(){alert('喵喵喵'); };
            return cat;
        }
    }
    

    这样得到的Cat实例。就会同事继承Cat类和Animal类

    var cat1 = Cat.createNew();
    cat1.sleep();//睡懒觉
    

    3.3私有属性和私有方法

    在createNew()方法中,只要不是定义在cat对象上的方法都是私有的

    var Cat = {
        createNew:function(){
            var cat = {};
            var sound = '喵喵喵';
            cat.makeSound = function(){alert(sound)};
            return cat;
        }
    }
    

    上例的内部变量sound,外部无法读取,只有通过cat的公有方法makeSound()来读取

    var cat1 = Cat.createNew();
    alert(cat1.sound);//undefined
    

    3.4数据共享

    有时候,我们需要所有实例对象,能够读写同一项内部数据。这个时候,只要把这个内部数据,封装在类对象的里面、createNew()方法的外面即可

    var Cat = {
        sound:'喵喵喵',
        createNew:function(){
            var cat = {};
            cat.makeSound =function(){alert(Cat.sound);};
            cat.changeSound = function(x){
                Cat.sound = x;
            };
            return cat;
        }
    }
    

    然后,生成两个实例对象:

    var cat1 = Cat.createNew();
    var cat2 = Cat.createNew();
    cat1.makeSound(); // 喵喵喵
    

    这时,如果有一个实例对象,修改了共享的数据,另一个实例对象也会受到影响

    cat2.changeSound('啦啦啦');
    cat1.makeSound();//啦啦啦
    

    es6有新的定义类的方法constructor,以后有时间再做仔细的记录

    js定义类的三种方法如有不懂可点击查看参考文章

    展开全文
  • JS中定义一个二维数组

    千次阅读 2016-12-28 15:08:26
    JS中定义一个二维数组
  • 如何定义一个自己的可复用的JS文件  Java,我们可以用Jar的形式将我们常用的代码进行封装,然后复用,JS中可以不可以?当然可以,要不然这么多框架。  Java,我们可以定义自己的命名空间,,然后在类中...
  • 将近20年前,Javascript诞生的时候,只是一种简单的网页脚本语言。如果你忘了填写用户名,它就跳出一个警告。...因此,Javascript如何实现面向对象编程,就成了一个热门课题。 麻烦的是,Javascipt语法不支持”
  • 定义一个类Person,定义name和age属性,定义有参的构造方法对name和age进行初始化。在测试类中创建该的2个对象,姓名、年龄分别为lili、19和lucy、20,在屏幕打印出2个对象的姓名和年龄。 输入格式: 本题目无输入 ...
  • javascript定义一个list

    千次阅读 2019-10-07 06:15:06
    JavaScript可以定义数组类型,在javascript语言List叫Array,它有以下2种定义方式方式1:var array=new Array();方式2:var array=[];通常在我们使用中常使用方式2,另外在javascript语言,因为没有严格的数据...
  • 目录代码示例效果查看 代码示例 自定义getUsername()和setUsername()方法,get方法用于对外提供数据查询... * 模块get方法和set方法定义 */ var module = (function () { //对象定义 var userObj = { username:"lu
  • Javascript定义类(class)的三种方法

    千次阅读 2014-12-02 16:41:18
    Javascript本身并不支持面向对象... 在面向对象编程(class)是对象(object)的模板,定义了同组对象(又称"实例")共有的属性和方法。  Javascript语言不支持"",但是可以用一些变通的方法,模拟出""。
  • 当我们想在一个页面定义个变量,无论页面怎么刷新都不能改变其值,在Javascript中是没有静态变量的,但是,我们就不能定义一个类似的变量了吗? 不。我们还是可以解决这种需求的。 我们可以将要定义的变量放在...
  • 我们看看JavaScript中定义类的各种方法。 1.工厂方式 javaScript中创建自己的和对象,我们应该是必须掌握的,我们都知道javaScript中对象的属性可以在对象创建后动态定义,比如下面的代码:
  • http://www.ruanyifeng.com/blog/2012/07/three_ways_to_define_a_javascript_class.html 作者: 阮一峰 ...如果你忘了填写用户名,它就跳出一个警告。 如今,它变得几乎无所不能,
  • js中定义一个变量 var params=null;判断params为空的方法
  • var obj={}; obj.a="12"; obj.b="13" var o ={}; o.jsonObj=obj; 取得属性值直接用 obj.a; obj.b; console.log(obj); //{a:"12",b:"13"} consolo.log(o); //{jsonObj:[{a:"12",b:"13"}]} ...
  • 一度以为在javascript的世界里,所有方法都是公有的,无法真正从技术上定义一个私有方法,今天又一次发现:其实我错了! 代码如下:var Person = function(name,sex){ this.name = name; this.sex = sex; var _...
  • 一个简单的javascript类定义例子 涵盖了javascript公有成员定义、私有成员定义、特权方法定义的简单示例Java代码 //定义一个javascript类 function JsClass(privateParam/* */,publicParam){//构造函数 var ...
  • JavaScript中定义类的方式详解

    万次阅读 2017-11-07 17:25:25
    这篇文章主要介绍了JavaScript中定义类的方式,结合实例形式分析了JavaScript实现面向对象定义及使用相关技巧,并附带了四种JavaScript类定义方式,需要的朋友可以参考下 本文实例讲述了JavaScript中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,123,160
精华内容 449,264
关键字:

js定义一个类中方法