文章目录

  • 前言
  • 面向对象的编程:从宏观出发，以对象作为业务研究根据，解决相对应的问题
  • 一、javascript创建对象的几种方式
  • 二、使用步骤
  • 1.直接创建
  • 2.工厂模式
  • 3.构造函数
  • 4.原型创建


前言

面向对象的编程:从宏观出发，以对象作为业务研究根据，解决相对应的问题

一、javascript创建对象的几种方式

一、直接创建
二、工厂模式
三、构造函数
四、原型创建

二、使用步骤

1.直接创建

代码如下（示例）：

var student={
		    name:'王一',
		    age:21,
		    eat:function(){
		        console.log(this.name+"正在吃")
		    }
		}
 var s1={
            name:'王二',
            age:22,
            eat:function(){
                console.log(this.name+"正在吃")
            }
        }
        console.log(s1)//{name:王二,age:21,eat:f}
		console.log(student);//object

优点：创建简单，可以随时用
缺点：无法量产，浪费空间

2.工厂模式

重复的创建对象，需要时可以随时调用
typeof 返回对应变量的数据类型 返回根本数据类型 字符串 object
instanceof 检测变量的数据类型 ,对应变量必须为原型创建出来的 返回值为true/false
代码如下（示例）：

function Student(name,age){
            var s=new Object()
            s.name=name
            s.age=age
            s.eat=function(){
                console.log(this.name+'正在吃')
            }
            return s
        }
        function Teach(name,age){
            var t=new Object()
            t.name=name
            t.age=age
            t.eat=function(){
                console.log(this.name+'正在吃')
            }
            return t
        }
        var s1=Student("王一",21) //object
        var s2=Student("王二",10)
        var t1=Teach("张三",30)
        // 判断是否属于老师 
        console.log(t1 instanceof Teach)//false object类型无法判断属于哪个      
        console.log(s1)
        console.log(s2)
        // var arr=[1,2,3]
        //console.log(arr)//arr变量  检测arr变量是否为数组类型
        // var num=10
        // var num=new Number(10)       
        // //console.log(typeof(num)) //object number  
        //  console.log(num instanceof Object)//T

优点：可以对单个对象量产；
缺点：无法明确对象的类型 ,全都是object类型的，无法对类型进行细分

3.构造函数

代码如下（示例）：
构造函数和工厂模式的区别在于，它使用了new运算符，在内部使用this指向当前对象，而且解决了对象类型的识别问题

// this指向 对象 window  固定对象   事件源
        // this指向运行环境
        // window对象
        function fun(){
             console.log(this)//window
        }
        fun()
function Student(name,age){
            this.name=name
            this.age=age
            this.eat=function(){
                console.log(this.name+"正在吃")
            }
        }
        function Teach(name,age){
            this.name=name
            this.age=age
            this.eat=function(){
                console.log(this.name+"正在吃")
            }
        }
        // 通过new来创建对象  new做了什么？
        // 1.创建一个空对象 {}
        // 2.在执行函数的过程中 ，函数内部 this指向创建出来的{}    this={} {name:"王一",age:21,eat:function(){}}
        // 3.将创建对象 返回出来，赋值给前方变量
        var s1=new Student("王一",21)
        var s2=new Student("王二",22)
        console.log(s1)
        console.log(s2)
       // console.log(s1.__proto__==s2.__proto__)false
       //s1中eat方法  s2也有eat方法  造成内存的消耗

构造函数创建对象
好处：可以明确对应的对象类型
弊端：不同对象中的相同方法，无法公用，需要独立存储，造成内存损耗

4.原型创建

代码如下（示例）：
在创建一个函数的时候，内部会出现一个特殊的属性：prototype.这个属性指向构造函数的原型对象，包含了使用方法和共享属性，可以
发现 每一类相同的对象 ，原型对象都是一个样 ，想办法将公有的方法 放到原型中
将共有的方法放入构造函数的原型中

function Student(name,age){
            this.name=name
            this.age=age;
}
Student.prototype.eat=function(){
            console.log(this.name+'正在吃')
			console.log(this.hp--)
}	
var s1=new Student("王一",21)	
s1.eat();
var s2=new Student("王二",22)
s2.eat()

优点·：解决了属性或方法不能共享的问题，，解决了内存的问题；简便好用
缺点:构造函数是空的没有传递参数，所有的属性和方法都在原型上，某个实例无法特有自己的属性和方法，更改一个属性方法，所有对象的属性都会发生变化。