JavaScript面向对象2 学习打卡

思维导图

封装

概念
把对象内部的数据和操作细节进行隐藏； private – 接口一般为调用方法
1、JavaScript中没有专门封装的关键词 可以使用闭包创建这种模式 – 函数内部声明的变量外部是无法访问的
2、能否被访问 取决于：公有和私有内容区别 – 能否在对象外部被访问
特点
1、这种模式有点消耗内存，一直return 创建对象；
2、其实封装的本意就是局部的属性隐藏起来；

// 封装
	function A(){
		function _xx(){
			alert(111);
		}
		this.xx = function(){
			return _xx;
		}
	}
	
	A.prototype = {
		oth:function(){
			alert(222);
		}
	}
	
	var a = new A();
	alert(a.xx()());
	a.oth();

继承

1、原型：是利用prototype添加属性和方法
2、原型链：proto(对象的内置属性) – 用于指向创建他的函数对象的原型对象prototype

// 继承 案例一
	var person = function(){
		person.prototype.say = function(){
			alert(333);
		}
	}
	person.prototype.salary = 500;
	
	var programmer = function(){}
	programmer.prototype = new person();
	programmer.prototype.wcd = function(){
		alert(444);
	}
	programmer.prototype.salary = 1000;

	var p = new programmer();
	p.say();//可以调用
	p.wcd();//可以调用


	// 继承 案例二
	function person(name,age){
		this.name = name;
		this.age = age;
	}

	person.prototype.sayHello = function(){
		alert('属性值name：' + this.name);
	}

	function student(){};
	student.prototype = new person('lisi',18);
	student.prototype.grade = 3;
	student.prototype.test = function(){
		alert(this.grade);
	}

	var s = new student();
	s.sayHello();
	alert(s.grade);

构造继承

在子类的内部构造父类的对象实现继承

// 构造继承
	function parents(name){
		this.name = name;
		this.say = function(){
			alert('父亲的名字：' + this.name);
		}
	}

	function child(name,age){
		// 继承parent
		this.pObj = parents;
		// 子对象的参数name传递到父对象中 
		// 用父对象来创建子对象
		this.pObj(name);
		// parents(name)
		this.age = age;
		this.sayC = function(){
			alert('child:' + this.name + ' ' + 'age:' + this.age);
		}
	}

	var p = new parents('zhangsan');
	p.say();
	var c = new child('lisi',20);
	c.sayC();

call和apply的用法

对象内置方法中的apply和call都会用于继承，区别在于传参方式不同；
1、call：调用一个对象的一个方法，以另一个对象替换当前对象
2、Apply：应用某一个对象的一个方法，以另一个对象替换当前对象

// call apply
	function parents(name,age,len){
		this.name = name;
		this.age = age;
		this.len = len;
		this.say = function(){
			alert(this.name + this.age + this.len);
		}
	}
	//call继承
	function student(name,age){
		parents.call(this,name,age);
	}
	//apply继承
	function teacher(name,age,len){
		parents.apply(this,[name,age,len]);
	}
	//实例化
	var per = new parents('zhangsan',25,180);
	per.say();
	var stu = new student('lisi',20);
	stu.say();
	var tea = new teacher('wangwu',28,178);
	tea.say();

JavaScript多继承方式

// 多继承
	function fun1(){
		fun2.call(this);
		fun3.apply(this,['play','aa']);
	}

	function fun2(){
		this.name = 'zhangsan';
		this.eat = function(){
			alert('eating');
		}
	}

	function fun3(paly,name){
		this.paly = play;
		this.name = name;
	}

	var car = new fun1();
	alert(car.name);
	alert(car.play);
	car.eat();

对象冒充

将父类的属性和方法一起传给子类作为特权属性和特权方法

// 对象冒充
	function person(name,age){
		this.name = name;
		this.age = age;
		this.sayHi = function(){
			alert('Hello world!');
		}
	}

	person.prototype.walk = function(){
		alert('walk around');
	}

	function student(name,age,grade){
		this.newObj = person;
		// 冒充person对象 传递特权属性和特权方法给子类
		this.newObj(name,age);
		this.grade = grade;
	}

	var stu1 = new student('zhangsan',15,5);
	alert(stu1.grade);
	alert(stu1.age);
	alert(stu1.name);
	alert(stu1.sayHi);
	stu1.walk();//调用共有方法是报错的
	// 注意：stu1 继承了person的特权属性和特权方法，但是没有继承共有属性和共有方法