javascript原型,组合,动态原型,稳妥构造函数式

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
<%
String path = request.getContextPath();
String basePath = request.getScheme()+"://"+request.getServerName()+":"+request.getServerPort()+path+"/";
%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
  <head>
    <base href="<%=basePath%>">
    
    <title>My JSP ‘test3.jsp‘ starting page</title>
    
	<meta http-equiv="pragma" content="no-cache">
	<meta http-equiv="cache-control" content="no-cache">
	<meta http-equiv="expires" content="0">    
	<meta http-equiv="keywords" content="keyword1,keyword2,keyword3">
	<meta http-equiv="description" content="This is my page">
	<!--
	<link rel="stylesheet" type="text/css" href="styles.css">
	-->
	<script src="js/jquery-2.1.1.min.js"></script>
	<script type="application/javascript">
	//原型的概念:原型对象里的所有属性和方法被所有构造函数实例化出来的对象所共享
//	function Person(){
//
//	}
//	Person.prototype={
//		constructor:Person,
//		name:‘程序员‘,
//		age:21,
//		friends:[‘wangwu‘,‘zhaoliu‘],
//		say:function(){
//			alert(this.friends);
//		}
//	}
	//原型里的属性和方法被所有对象共享
	/*
	var p1=new Person();
	p1.friends.push(‘lisi‘);
	p1.say();                        //wangwu,zhaoliu,lisi
	var p2=new Person();
	p2.say();                        //wangwu,zhaoliu,lisi ,p1添加friends,p2也添加了friends
	*/

	//组合模式:一般使用原型和构造函数
	/*
	function Person1(name,age,friends,job){
		this.name=name;
		this.age=age;
		this.friends=friends;
		this.job=this.job;

	}
	Person1.prototype={
		constructor:Person1,
		sayName:function(){
			alert(this.name);
		}
	}

	var p3=new Person1(‘zhangsan‘,21,[‘wangwu‘,‘zhaoliu‘],‘程序员‘);
	var p4=new Person1(‘lisi‘,21,[‘wangwu‘,‘zhaoliu‘],‘程序员‘);
	p3.sayName();
	p4.sayName();

	*/

	//动态原型模式(让你的代码封装到一起)
	/*
	function Person2(name,age,friends,job){
		this.name=name;
		this.age=age;
		this.friends=friends;
		this.job=this.job;
		//动态原型方法
		if(typeof this.sayName !=‘function‘){
			//
			Person2.prototype.sayName=function(){          //sayName方法只创建一次

				alert(this.name);
			}
		}

	}
	var p5=new Person2(‘zhangsan‘,21,[‘wabgwu‘,‘zhaoliu‘],‘chengxuyuan‘);
	p5.sayName();

	*/

	//稳妥构造函数式   durable object(稳妥对象) 非常安全的环境中
	//1.没有公共属性,
	//其他对象中也不引用this对象,不能使用this关键字
	function Person3(name,age,job){
		var object={};
		//可以定义私有的方法和属性
		var name=name;
		var age=23;
		var job=‘程序员‘;
		object.sayName=function(){
			alert(name);
		}
		return object;
	}

	var p7=new Person3(‘zhangsan‘,21,‘chenuxyuan‘);
	p7.sayName();

	</script> 

  </head>
  
  <body>
    This is my JSP page. <br>
  </body>
</html>
时间: 2024-10-27 03:02:10

javascript原型,组合,动态原型,稳妥构造函数式的相关文章

js17---创建对象:构造函数式和原型组合模式、动态原型模式、稳妥构造函数式

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd"> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <title>Unt

javascript学习笔记10(基于组合与动态原型创建对象)

基于组合与动态原型创建对象 方法一:在外部设置prototype <script type="text/javascript">/** * 为了解决原型所带来的问题,此处需要通过组合构造函数和原型来实现对象的创建 * 将属性在构造函数中定义,将方法在原型中定义 * 这种有效集合了两者的优点,是目前最为常用的一种方式 */    function Person(name,age,friends){        //属性在构造函数中定义        this.name =

JavaScript ES5类 原型 原型链 组合、原型、寄生式继承

ES5类 原型  原型链 继承 JavaScript中,原型是相对于构造函数(类)的叫法(或者说概念),原型链是相对于构造函数(类)的实例对象的叫法. 对于JavaScript对象,如果在对象自身上找不到该属性,那么就会向上沿着原型链继续查找该属性 创建一个ES5类 在ES5中,类是由函数名首字母大写的函数,通过关键字new创建的. 类的构造函数就是函数自身 一般情况下,ES5类的原型对象prototype是自身构造函数,该类的实例化对象的原型链对象__proto__也是该构造函数,这二者指向同

JavaScript之面向对象学习七(动态原型模式和寄生构造函数模式创建自定义类型)

一.动态原型模式 在面向对象学习六中的随笔中,了解到组合构造函数模式和原型模式创建的自定义类型可能最完善的!但是人无完人,代码亦是如此! 有其他oo语言经验的开发人员在看到独立的构造函数和原型时,很可能会感到非常困惑.因为对象在其他oo语言中往往是封装在一块的,而构造函数确是和原型分开的,所以并没有真正意义上的封装,所以动态原型模式正是致力与解决这一问题的一个方案! 动态原型模式将所有的信息都封装在构造函数中(包括原型和实例属性),通过在构造函数中实例化原型(仅在必要的情况下)实现封装,又保持了

组合使用构造函数模式和动态原型模式、寄生构造函数模式(创建具有额外方法的特殊数组)

function Bird(name, age) {     this.name = name;     this.age = age;     this.sons = ["Tom", "John"];     //在sayName()方法不存在的情况下,添加到原型中     if (typeof this.sayName != "function") {         Bird.prototype.sayname = function() {

【JavaScript】面向对象与原型

ECMAScript有两种开发模式: 1.函数式(过程化) 2.面向对象(OOP) 但是ECMAScript没有类的概念,因此与基于类的语言的对象也有所不同. 一.创建对象 var box=new Object(); box.name='lee';                          //属性 box.run=function(){                  //方法 returnthis.name+'运行中...'; } alert(box.run()); 关于工厂模式方

7中创建对象的方式(工厂模式、构造函数模式、原型模式、动态原型模式等分析)

1.工厂模式 // 定义工厂函数 function createPerson(name, age, hobby) { // 创建一个临时object对象 var obj = new Object(); // 将工厂函数的参数赋值给临时对象 obj.name = name; obj.age = age; obj.hobby = hobby; obj.sayName = function() { console.log("我的名字叫:"+this.name); } // 返回这个包装好的临

关于JavaScript的原型继承与原型链

在讨论原型继承之前,先回顾一下关于创建自定义类型的方式,这里推荐将构造函数和原型模式组合使用,通过构造函数来定义实例自己的属性,再通过原型来定义公共的方法和属性. 这样一来,每个实例都有自己的实例属性副本,又能共享同一个方法,这样的好处就是可以极大的节省内存空间.同时还可以向构造函数传递参数,十分的方便. 这里还要再讲一下两种特色的构造函数模式: 1.寄生构造函数从形式上来看,这种模式和工厂模式并无区别: function Person(name, age, job){var o = new O

JavaScript 深入之从原型到原型链(转载)

构造函数创建对象 我们先使用构造函数创建一个对象: function Person() { } var person = new Person(); person.name = 'name'; console.log(person.name) // name 在这个例子中,Person就是一个构造函数,我们使用new创建了一个实例对象person. 很简单吧,接下来进入正题: prototype 每个函数都有一个prototype属性,就是我们经常在各种例子中看到的那个prototype,比如: