javascript面向对象编程-优快云博客

本文深入探讨了面向对象编程的概念、特点、实现方法及优化技巧，并通过实例展示了如何运用面向对象思想解决实际问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

什么是面向对象编程

用对象的思想去写代码，就是面向对象编程

过程式写法

面向对象写法

我们一直都在使用对象

数组 Array 时间 Date

面向对象编程(OOP)的特点

抽象：抓住核心问题

封装：只能通过对象来访问方法

继承：从已有对象上继承出新的对象

多态：多对象的不同形态

对象的组成

方法（行为、操作）——函数：过程、动态的

属性——变量：状态、静态的

创建第一个面向对象程序

为对象添加属性和方法

Object对象

this指向

创建两个对象 : 重复代码过多

<script>

//var obj = {};

var obj = new Object();  //创建了一个空的对象
obj.name = '小明';  //属性
obj.showName = function(){  //方法
	alert(this.name);
};

obj.showName();


var obj2 = new Object();  //创建了一个空的对象
obj2.name = '小强';  //属性
obj2.showName = function(){  //方法
	alert(this.name);
};

obj2.showName();



</script>

优化面向对象，来封装函数（在面向对象中叫做工厂方式）

<script>

//工厂方式 : 封装函数

function createPerson(name){
	
	//1.原料
	var obj = new Object();
	//2.加工
	obj.name = name;
	obj.showName = function(){
		alert( this.name );
	};
	//3.出场
	return obj;
	
}

var p1 = createPerson('小明');
p1.showName();
var p2 = createPerson('小强');
p2.showName();

</script>

工厂方式

面向对象中的封装函数

改成与系统对象类似写法

首字母大写

New 关键字提取

This指向为新创建的对象

构造函数

用来创建对象的函数，叫做构造函数

存在的问题

对象的引用

浪费内存

-----------------------------------------------------------------------------------------------

//当new去调用一个函数 : 这个时候函数中的this就是创建出来的对象,

而且函数的的返回值直接就是this啦(隐式返回)

//new后面调用的函数 : 叫做构造函数

------------------------------------------------------------------------------------------------

<script>


//当new去调用一个函数 : 这个时候函数中的this就是创建出来的对象,而且函数的的返回值直接就是this啦(隐式返回)

//new后面调用的函数 : 叫做构造函数

function CreatePerson(name){
	
	this.name = name;
	this.showName = function(){
		alert( this.name );
	};
	
}

var p1 = new CreatePerson('小明');
//p1.showName();
var p2 = new CreatePerson('小强');
//p2.showName();

alert( p1.showName == p2.showName );  //false

var arr = new Array();
var date = new Date();

</script>

对象的引用

/*var a = [1,2,3];
var b = [1,2,3];

alert( a == b );  //false*/

//var a = 5;
//var b = a;
//b += 3;
alert(b); //8
//alert(a); //5   基本类型 : 赋值的时候只是值的复制

//var a = [1,2,3];
//var b = a;
//b.push(4);
alert(b);  //[1,2,3,4]
//alert(a);  //[1,2,3,4]   对象类型 : 赋值不仅是值的复制，而且也是引用的传递

//var a = [1,2,3];
//var b = a;
//b = [1,2,3,4];       //有赋值，就重新生成了一块地址
alert(b); //[1,2,3,4]
//alert(a); //[1,2,3]

//var a = 5;
//var b = 5;
//
//alert(a == b);  //基本类型 : 值相同就可以

//var a = [1,2,3];
//var b = [1,2,3];

//alert( a == b );  //false  //对象类型 : 值和引用都相同才行

var a = [1,2,3];
var b = a;
alert( a==b );  //true

原型-prototype

概念

重写对象方法，让相同方法在内存中存在一份（提高性能）

学习原型

类比 : CSS中的Class

通过原型改写工厂方式

原则

相同的属性和方法可以加载原型上

混合的编程模式

总结面向对象写法

构造函数加属性，原型加方法

<script>

//原型 : 去改写对象下面公用的方法或者属性 , 让公用的方法或者属性在内存中存在一份 ( 提高性能 )

//原型 : CSS中的class
//普通方法 : CSS中的style

//原型 : prototype : 要写在构造函数的下面

/*var arr = [1,2,3,4,5];
var arr2 = [2,2,2,2,2];

arr.sum = function(){
	
	var result = 0;
	for(var i=0;i<this.length;i++){
		result += this[i];
	}
	return result;
	
};
arr2.sum = function(){
	
	var result = 0;
	for(var i=0;i<this.length;i++){
		result += this[i];
	}
	return result;
	
};

//alert( arr.sum() );  //15
//alert( arr2.sum() );  //10*/

//原型的写法

var arr = [1,2,3,4,5];
var arr2 = [2,2,2,2,2];

Array.prototype.sum = function(){
	var result = 0;
	for(var i=0;i<this.length;i++){
		result += this[i];
	}
	return result;
};

alert( arr.sum() );  //15
alert( arr2.sum() );  //10

</script>

把工厂方式改写成原型的写法

/当new去调用一个函数 : 这个时候函数中的this就是创建出来的对象,而且函数的的返回值直接就是this啦(隐式返回)

//new后面调用的函数 : 叫做构造函数

function CreatePerson(name){
	
	this.name = name;
	
}
CreatePerson.prototype.showName = function(){
	alert( this.name );
};

var p1 = new CreatePerson('小明');
//p1.showName();
var p2 = new CreatePerson('小强');
//p2.showName();

alert( p1.showName == p2.showName );  //true

最后面向对象的写法

<script>

function 构造函数(){
	this.属性
}

构造函数.原型.方法 = function(){};


var 对象1 = new 构造函数();
对象1.方法();
</script>