javascript面向对象

1.创建1个对象，然后给这个对象新建属性和方法

var box = new Object();//创建对象
box.name='Lee';//添加属性
box.age=100;
box.run=function (){
	return this.name +this.age+'运行中...';//this表示当前作用域下的对象
}
console.log(box.run());
var name = 'Jack';
console.log(this.name);//这里的this代表的是window

2.关于对象的引用问题

//对象引用
var box = new Object();//创建对象
box.name='Lee';//添加属性
box.age=100;
box.run=function (){
	return this.name +this.age+'运行中...';//this表示当前作用域下的对象
}
console.log(box.run());
var box2 = box;//box2引用box
box2.name='Jack';//添加属性
box2.age=200;
box2.run=function (){
	return this.name +this.age+'运行中...';//this表示当前作用域下的对象
}
console.log(box.run());//对象相互引用造成了混淆
console.log(box2.run());

3.为了解决多个类似对象声明的问题，可以使用工厂模式

//工厂模式
function createObj(name,age){
	var obj = new Object();//创建对象
	obj.name = name;//添加属性
	obj.age = age;
	obj.run = function(){//添加方法
		return this.name+this.age+'运行中...';
	}
	return obj;//返回对象引用
}
var box = createObj('Lee',100);
console.log(box.run());
var box2 = createObj('Jack',200);
console.log(box2.run());
console.log(typeof box);
//工厂模式解决了重复实例化的问题，但是存在识别问题，无法确定他们到底是哪个对象的实例
console.log(box instanceof Object);

4.工厂模式解决了重复实例化的问题，但是存在识别的问题，无法确定他们到底是哪个对象的实例，可以使用构造函数解决这个问题

/ECMAScript中可以采用构造函数来创建特定的对象
function Box(name,age){//创建一个对象，所有构造函数的对象其实就是Object
	this.name = name;//添加属性
	this.age = age;
	this.run = function(){//添加方法
		return this.name+this.age+'运行中....';
	}
}
//1.构造函数没有new Object,但他后台会自动var obj = new Object();
//2.this就相当于obj
//3.构造函数不需要返回对象引用，她是后台自动返回的
//4.构造函数也是函数，但函数名第一个字母大写
//5.必须new 构造函数名(),构造函数名第一个字母必须大写
//6.必须使用new运算符
var box1 = new Box('Lee',100);
var box2 = new Box('Jack',200);
console.log(box1.run());
console.log(box2.run());
console.log(typeof box1);
console.log(box1 instanceof Box);//可以识别，box1是Box对象的引用
//关于this的使用，this代表当前作用域对象的引用，如果在全局范围this就代表window对象，
//如果在构造函数体内，就代表当前的构造函数所生命的对象
var name = 'kkk';
console.log(this.name);

5.探讨一下构造函数内部的方法问题，看看2个实例化后的属性或方法是否相等

function Box(name,age){//创建一个对象，所有构造函数的对象其实就是Object
	this.name = name;//添加属性
	this.age = age;
	this.run = function(){//添加方法
		return this.name+this.age+'运行中....';
	}
}
//console.log(Box('Lee',100));//undefined 构造函数用普通函数调用是无效的，必须使用new运算符
var o = new Object();
Box.call(o,'Lee',100);//对象冒充
//console.log(o.run());
var box1 = new Box('Lee',100);
var box2 = new Box('Lee',100);
console.log(box1.name==box2.name);//true 属性的值相等
console.log(box1.age==box2.age);
console.log(box1.run==box2.run);//false 方法其实也是一种引用地址
console.log(box1.run()==box2.run());//true 方法的值相等，因为传参一致

//加深理解，关于function是引用
function Box(name,age){//new Function的唯一性
	this.name = name;//添加属性
	this.age = age;
	this.run = new Function("return this.name+this.age+'运行中....';");
}
var box1 = new Box('Lee',100);
var box2 = new Box('Lee',100);
console.log(box1.name==box2.name);//true 属性的值相等
console.log(box1.age==box2.age);
console.log(box1.run==box2.run);//false 方法其实也是一种引用地址
console.log(box1.run()==box2.run());//true 方法的值相等，因为传参一致

function Box(name,age){//创建一个对象，所有构造函数的对象其实就是Object
	this.name = name;//添加属性
	this.age = age;
	this.run = run;
}
function run(){//把构造函数内部的方法通过全局来实现引用地址一致
	return this.name+this.age+'运行中....';
}
var box1 = new Box('Lee',100);
var box2 = new Box('Lee',100);
console.log(box1.name==box2.name);//true 属性的值相等
console.log(box1.age==box2.age);
console.log(box1.run==box2.run);//true 方法其实也是一种引用地址
console.log(box1.run()==box2.run());//true 方法的值相等，因为传参一致
//通过使用全局函数保证了引用地址的一致性，但这种方法又带来了新的问题，
//全局的this在对象调用时是Box本身，而当作普通函数调用的时候this又代表window
console.log(run());//出现了问题

上述面向对象基础是以后学习原型的基础，需要好好理解。