第1章面向对象的JavaScript

　　针对基础知识的每一个小点，我都写了一些小例子，https://github.com/huyanluanyu1989/DesignPatterns.git，便于大家理解，如有疑问，大家可留言给我，最近工作比较忙，可能更新会比较慢，大家多我原谅，有兴趣可以关注一下，后续我会尽快更新的，谢谢大家支持！！！

第一部分基础知识

第1章面向对象的JavaScript

1.1 动态类型语言和鸭子类型

　　编程语言按照数据类型大体可以分为两类，一类是静态类型语言，另一类是动态类型语言。

　　静态类型语言在编译时便已确定变量的类型，而动态类型语言的变量类型要到程序运行的时候，待变量被赋予某个值之后，才会具有某种类型。

　　鸭子类型（duck typing）的通俗说法是：“如果它走起路来像鸭子，叫起来也是鸭子，那么它就是鸭子。

<script type="text/javascript">

	var duck = {

		duckSinging : function(){

			console.log('嘎嘎嘎');

		}

	}

	var chicken = {

		duckSinging : function(){

			console.log('嘎嘎嘎');

		}

	}

	var choir = [];

	var joinchoir = function(animal){

		if(animal && typeof(animal.duckSinging) === 'function'){

			choir.push(animal);

			console.log('恭喜加入合唱团');

			console.log(choir.length);

		}

	}

	joinchoir(duck);

	joinchoir(chicken);

</script>

1.2 多态

　　多态的实际含义是：同一操作作用于不同的对象上面，可以产生不同的解释和不同的执行结果。换句话说，给不同的对象发送同一个消息的时候，这些对象会根据这个消息分别给出不同的反馈。

　　多态背后的思想是将“做什么”和“谁去做以及怎样去做”分离开来，也就是将“不变的事物”与 “可能改变的事物”分离开来。把不变的部分隔离出来，把可变的部分封装起来。

<script type="text/javascript">

		var makeSound = function (animal){

			if(animal instanceof duck){

				 console.log("嘎嘎嘎");

			}else if(animal instanceof chicken){

				console.log("咯咯咯");

			}

		}

		var duck = function(){};

		var chicken = function(){};

		makeSound(new duck);

		makeSound(new chicken);

</script>

1.3 封装

　　封装的目的是将信息隐藏。

　　封装数据：JavaScript只能依赖变量的作用域来实现封装特性，而且只能模拟出 public 和 private 这两种封装性。

　　封装类型：是通过抽象类和接口来进行的。

　　封装变化：通过封装变化的方式，把系统中稳定不变的部分和容易变化的部分隔离开来，在系统的演变过程中，我们只需要替换那些容易变化的部分。

<script type="text/javascript">

	var goolgeMap = {

		show:function(){

			console.log("谷歌地图")

		}

	}

	var baiduMap = {

		show:function(){

			console.log("百度地图");

		}

	}

	var renderMap = function(map){

		if(map.show instanceof Function){

			map.show();

		}

	}

	renderMap(goolgeMap);

	renderMap(baiduMap);

</script>

1.4 原型模式和基于原型继承的 JavaScript 对象系统

　原型编程范型至少包括以下基本规则：

　1. 所有的数据都是对象。

　　JavaScript在设计的时候，模仿 Java 引入了两套类型机制：基本类型和对象类型。基本类型：undefined、number、boolean、string、function、object。除了 undefined 之外，一切都应是对象。

　　JavaScript 中的根对象是 Object.prototype 对象。Object.prototype 对象就是它们的原型。

<script type="text/javascript">

	var Plane = function(){

		this.blood = 100;

		this.attackLevel = 1;

		this.defenseLevel = 1;

	}

	var plane = new Plane();

	plane.blood=500;

	plane.attackLevel=10;

	plane.defenseLevel=7;

	var clonePlane = Object.create(plane);

	console.log(clonePlane)

</script>

　2.要得到一个对象，不是通过实例化类，而是找到一个对象作为原型并克隆它。

<script type="text/javascript">

	function Person(name){

		this.name = name;

	}

	Person.prototype.getName = function(){

		return this.name;

	}

	var objectFactory = function(){

		var obj = new Object(); // 从 Object.prototype 上克隆一个空的对象

		Construtor = [].shift.call(arguments);// 取得外部传入的构造器，此例是 Person

		obj.__proto__ = Construtor.prototype;// 指向正确的原型

		var ret = Construtor.apply(obj, arguments);// 借用外部传入的构造器给 obj 设置属性

		return typeof ret === 'object' ? ret : obj ;// 确保构造器总是会返回一个对象

	}

	var a = objectFactory(Person, 'sven');

	// var a = new Person('Remen')

	console.log(a.name);

	console.log(a.getName());

	console.log(Object.getPrototypeOf(a) === Person.prototype);

</script>

　3.对象会记住它的原型。

　　对象把请求委托给它的构造器的原型。　　

　4. 如果对象无法响应某个请求，它会把这个请求委托给它自己的原型。

　　在 JavaScript 中，每个对象都是从 Object.prototype 对象克隆而来的，只能得到单一的继承关系，即每个对象都继承自 Object.prototype 对象，

　在原型继承方面，JavaScript也同样遵守这些原型编程的基本规则。

<script>

//一个类继承自另一个类时

	var A = function(){};

	A.prototype = {name : 'sven'};

	var B = function(){};

	B.prototype = new A();

	var b = new B();

	var a = new A();

	console.log(b.name)

</script>

巴特西

第1章面向对象的JavaScript

最新文章

热门文章

巴特西

第1章 面向对象的JavaScript

最新文章

热门文章

第1章面向对象的JavaScript