js 对象 继承

var arr = new Array();
undefined
typeof arr.valueOf
"function"

 

 

// 自定义引用类型
// var dog = new Object();
// dog.name = '小黑';
// dog.age = 13;
// dog.say = function(){
// return '汪汪汪'
// }
// console.log(dog.name+dog.say())

// 函数对象
// 函数内对象 arguments 参数对象
// this对象 函数赖以执行的环境

// 函数的属性
// length 指的是参数的个数
// prototype 函数的原型

// 函数的方法
// call(对象,参数)
// apply(对象,参数数组)
// 用于设置函数在特定的作用域下执行

// var data = 12
// function add(){
// // alert(arguments[0])
// // console.log(this)
// console.log(this == window)
// }
// add(2)

// function add(data1,data2,data3){
// return data1+data2+data3;
// }
// alert(add.length)
// alert(add.prototype)

// var age = 10;
// var person = new Object();
// person.age = 30;

// var dog = new Object();
// dog.age = 8

// function getData(color){
// alert(this.age+color);
// }
// getData.call(person) //改变了getData函数的执行环境
// getData.call(person,'黑色') //改变了getData函数的执行环境
// getData.apply(dog,['黄色']) //改变了getData函数的执行环境

// 面向对象
// 1.New Object或对象字面量
// var 对象 = {属性:属性值,属性:属性值,属性:function(){}}
// 缺点：创建多个对象，会产生大量重复代码
// var dog = {
// name:'小黑',
// age:3,
// say:function(){
// return '汪汪'
// }
// }
// console.log(dog.name+dog.say())

// 2.工厂模式
// 缺点：对象没法区别，就是不知道对象的类型，都为Object
// instanceof 用来检测对象是否由指定函数所构建
// function 函数名(){
// var obj = new Object();
// obj.属性 = 值,
// .....
// obj.属性 = function(){

// }
// return = obj
// }
// function factory(name,age){
// var dog = new Object();
// dog.name = name;
// dog.age = age;
// dog.say = function(){
// return '汪汪';
// }
// return dog;
// }
// var dog1 = factory('小黄',5);
// var dog2 = factory('小黑',2);
// console.log(dog1.name+dog2.name)
// alert(dog1 instanceof Object)
// alert(dog2 instanceof Object)

// 3.构造函数模式
// 缺点：每个对象都包含了一个相同的行为方法，相同的行为不共用
// function 函数名(参数){
// this.属性 = 值;
// this.属性 = 值;
// this.属性 = function(){

// }
// }
// var 变量 = new 函数名()
// function Dog(name,age){
// this.name = name,
// this.age = age,
// this.say = function(){
// return '汪汪';
// }
// }
// var dog1 = new Dog('小黄',5)
// console.log(dog1.name+dog1.say())
// alert(dog1 instanceof Dog)

// 4.原型模式
// 原型里的属性与方法供所有对象共享
// 缺点：所有对象都取得相同的属性值，属性为引用类型时共享不太合适
// function 函数名(){

// }
// 函数名.prototype.属性 = 值;
// 函数名.prototype.属性 = function(){}
// var dog1 = new 函数名()
// function Dog(){

// }
// Dog.prototype.name = '小花',
// Dog.prototype.age = 5,
// Dog.prototype.friends = ['小黑','大白']
// Dog.prototype.say = function(){
// return '汪汪';
// }
// var dog1 = new Dog();
// dog1.friends.push('糯米')
// document.write(dog1.name+'---'+dog1.say())
// var dog2 = new Dog();
// document.write(dog2.name+'---'+dog1.say())
// alert(dog1.say == dog2.say)
// alert(dog2.friends)

// 5.组合模式(混合模式)
// 有oop经验的人，感觉不到封装性
// function Dog(name,age,friends){
// this.name = name;
// this.age = age;
// this.friends = friends;
// }
// Dog.prototype.say = function(){
// return '汪汪';
// }
// var dog1 = new Dog('小黑',2,['小花']);
// var dog2 = new Dog('大黑',2,['大花']);
// document.write(dog1.friends)
// document.write(dog2.friends)
// alert(dog1.say==dog2.say)

// 6.动态原型模式
// 把原型放进构造函数里面进行初始化
// function Dog(name,age,friends){
// this.name = name;
// this.age = age;
// this.friends = friends;
// if(typeof this.say!= 'function'){
// Dog.prototype.say = function(){
// return '汪汪';
// }
// }
// }
// var dog1 = new Dog('小黑',2,['小花']);
// var dog2 = new Dog('大黑',2,['大花']);
// document.write(dog1.friends)
// document.write(dog2.friends)
// alert(dog1.say==dog2.say)

// 对象继承
// 原型链：访问一个对象的属性时，先在基本属性中查找，如果没有，
// 再沿着__proto__向上找，这就是原型链
// 引用共享
// 不能给父构造函数传参数

// 原型链继承
// function Animal(){
// this.name = '小白';
// this.say = function(){
// return '千奇百怪';
// }
// }

// function Tiger(){}
// Tiger.prototype = new Animal()//把实例对象赋值给Tiger的原型
// var tiger1 = new Tiger()
// document.write(tiger1.name)

// 借用构造函数法(也叫对象冒充)
// 缺点：原型中的方法不能继承
// function Person(name,age,friends){
// this.name = name;
// this.age = age;
// this.friends = friends;
// }

// Person.prototype.say = function(){
// return 'xxx';
// }

// function Worker(job,name,age,friends){
// this.job = job;
// Person.call(this,name,age,friends);
// }

// var p1 = new Worker('学生','小王',25,['大王'])
// p1.friends.push('刘某')
// document.write(p1.name+'---'+p1.friends)
// document.write('<hr/>')
// var p2 = new Worker('老师','老王',60,['小李'])
// document.write(p2.name+'---'+p2.friends)
// document.write(p2.say())

// 组合继承
// 将原型链与借用构造函数结合
// 思路：通过使用原型链实现原型上的方法继承
// 借用构造函数实现属性继承
// function Person(name,age,friends){
// this.name = name;
// this.age = age;
// this.friends = friends;
// }

// Person.prototype.say = function(){
// return 'xxx';
// }

// function Worker(job,name,age,friends){
// this.job = job;
// Person.call(this,name,age,friends);
// }

// Worker.prototype = new Person()

// var p1 = new Worker('学生','小王',25,['大王'])
// p1.friends.push('刘某')
// document.write(p1.name+'---'+p1.friends)
// document.write('<hr/>')
// var p2 = new Worker('老师','老王',60,['小李'])
// document.write(p2.name+'---'+p2.friends)
// document.write(p2.say())