var str = "我是一个 String 对象 , 我声明在这里 , 但我不是独立存在的！"
var obj = { des: "我是一个 Object 对象 , 我声明在这里，我也不是独立存在的。" };
var fun = function() { console.log( "我是一个 Function 对象！谁调用我，我属于谁：", this ); }; obj.fun = fun; console.log( this === window );     // 打印 true console.log( window.str === str );  // 打印 true console.log( window.obj === obj );  // 打印 true console.log( window.fun === fun );  // 打印 true fun();                              // 打印 我是一个 Function 对象！谁调用我，我属于谁：window obj.fun();                          // 打印 我是一个 Function 对象！谁调用我，我属于谁：obj fun.apply(str);                   // 打印 我是一个 Function 对象！谁调用我，我属于谁：str 

var person = { name: “张三”, age: 26, gender: “男”, eat: function( stuff ) { alert( “我在吃” + stuff ); } }; person.height = 176; delete person[ “age” ];

 // 构造器 Person 本身是一个函数对象
function Person() { // 此处可做一些初始化工作
} // 它有一个名叫 prototype 的属性
Person.prototype = { name: “张三”, age: 26, gender: “男”, eat: function( stuff ) { alert( “我在吃” + stuff ); } } // 使用 new 关键字构造对象
var p = new Person();

function Person( name ) { this.name = name; }
var p = new Person();
// 对象的隐式引用指向了构造器的 prototype 属性，所以此处打印 true console.log( p.__proto__ === Person.prototype ); // 原型本身是一个 Object 对象，所以他的隐式引用指向了
// Object 构造器的 prototype 属性 , 故而打印 true console.log( Person.prototype.__proto__ === Object.prototype ); // 构造器 Person 本身是一个函数对象，所以此处打印 true console.log( Person.__proto__ === Function.prototype );

// 声明 Animal 对象构造器function Animal() { } // 将 Animal 的 prototype 属性指向一个对象，// 亦可直接理解为指定 Animal 对象的原型Animal.prototype = { name: "animal", weight: 0, eat: function() { alert( "Animal is eating!" ); } } // 声明 Mammal 对象构造器function Mammal() { this.name = "mammal"; } // 指定 Mammal 对象的原型为一个 Animal 对象。// 实际上此处便是在创建 Mammal 对象和 Animal 对象之间的原型链Mammal.prototype = new Animal(); // 声明 Horse 对象构造器function Horse( height, weight ) { this.name = "horse"; this.height = height; this.weight = weight; } // 将 Horse 对象的原型指定为一个 Mamal 对象，继续构建 Horse 与 Mammal 之间的原型链Horse.prototype = new Mammal(); // 重新指定 eat 方法 , 此方法将覆盖从 Animal 原型继承过来的 eat 方法Horse.prototype.eat = function() { alert( "Horse is eating grass!" ); } // 验证并理解原型链var horse = new Horse( 100, 300 ); console.log( horse.__proto__ === Horse.prototype ); console.log( Horse.prototype.__proto__ === Mammal.prototype ); console.log( Mammal.prototype.__proto__ === Animal.prototype );

// 声明 Person 类
var Person = Class.extend( { _issleeping: true, init: function( name ) { this._name = name; }, isSleeping: function() { return this._issleeping; } } ); // 声明 Programmer 类，并继承 Person var Programmer = Person.extend( { init: function( name, issleeping ) { // 调用父类构造函数this._super( name ); // 设置自己的状态this._issleeping = issleeping; } } ); var person = new Person( "张三" );
var diors = new Programmer( "张江男", false ); // 打印 true
 console.log( person.isSleeping() ); // 打印 false
 console.log( diors.isSleeping() ); // 此处全为 true，故打印 true console.log( person instanceof Person && person instanceof Class && diors instanceof Programmer && diors instanceof Person && diors instanceof Class );

// 声明 User 构造器
function User( pwd ) { // 定义私有属性var password = pwd; // 定义私有方法 function getPassword() { // 返回了闭包中的 password return password; } // 特权函数声明，用于该对象其他公有方法能通过该特权方法访问到私有成员this.passwordService = function() { return getPassword(); } } // 公有成员声明
User.prototype.checkPassword = function( pwd ) { return this.passwordService() === pwd; }; // 验证隐藏性
var u = new User( "123456" ); // 打印 true console.log( u.checkPassword( "123456" ) ); // 打印 undefined
 console.log( u.password ); // 打印 true console.log( typeof u.gePassword === "undefined" );