/**
* 创建一个对象模型
* @param {} config
* [Object Object]对象
* {name : '', age:12 }
* @param {} namespace
* 命名空间
*/
var createObj = function(config,namespace){
var c = namespace.split(".");
var obj = window;
//创建名名空间
for(var i=0;i<c.length;i++){
var ns = c[i];
if(i == c.length-1){
obj[ns] = function(){};
obj = obj[ns];
break;
}
if(!obj[ns]){
obj[ns]={};
obj = obj[ns];
}
}
//创建模型
for(var key in config){
if(key){
obj.prototype[key] = config[key];
}
}
return obj;
}
/**
* 继承一个类
* @param {} config
* 需要重写或者扩展属性和方法对象
* 类型：[Object Object]
* @param {} obj
* 父类
*/
var extend = function(config,obj){
var tmp = function(){};
//父类模型的引用
tmp.superclass = obj.prototype;
//继承父类的模型
for(var key in obj.prototype){
if(key && key != "constructor" ){
tmp.prototype[key] = obj.prototype[key];
}
}
//重写或者扩展模型
for(var key in config){
if(!key){
return;
}
tmp.prototype[key] = config[key];
}
return tmp;
}
createObj({
name : null,
age : null,
ns : 'Liz.test.Person',
hello : function(){
alert("person name is "+ this.name +",age is "+this.age);
}
},"Liz.test.Person"); Liz.test.Student = extend({
name : 'XiaoMing',
level : 'middle school',
ns : 'Liz.test.Student',
age : 15,
hello : function(){
alert("student name : "+ this.name +",age : "+this.age +", level : "+this.level);
}
},Liz.test.Person); var p = new Liz.test.Student();
p.hello();
//调用父类方法
Liz.test.Student.superclass.hello.call(p);
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<title>javascript面向对象基础知识</title>
<script type="text/javascript">
/* javascript中创建对象，需要用function来模拟
function Teacher() {
}
*/
var Teacher = new Object(); //也可以使用这种方式创建对象
var Student = {}; //也可以使用这种对象直接量的方式来创建对象，类似于JSON数据格式
//给对象动态的添加属性和方法，并赋值
Teacher.name = "Dylan";
Teacher.codeType = "Ajax";
Teacher.hello = function () {
alert("hello wolrd");
}
Teacher.sayHello = function () {
return "hello";
}
//将Teacher对象最为Student对象的属性
Student.teacher = Teacher;
//访问对象的属性
// alert(Student.teacher.name);
//也可以通过这种方式访问对象的属性（JSON数据格式）
// alert(Student["teacher"]["name"]);
//当然，也可以将这两种访问方式混合起来使用
// alert(Student.teacher["name"]);
//访问对象中的函数
// alert(Student.teacher.hello); //弹出的是整个函数体
// alert(Student.teacher.hello()); //有"()"，会调用hello这个函数.判断该函数有没有返回值，没有返回值时弹出undefined
// alert(Student.teacher.sayHello());//有"()",相当于调用了sayHello这个函数，该函数具有返回值，所以弹出的是sayHello这个函数的返回值
//建议使用这种方式创建对象，并且将“类名”首字母大写，这样能更好的区分“类”和普通的function函数
//这个函数还承担了模拟“构造函数“的作用。当使用new关键字来创建对象(该类的实例)时，该function中的代码会被执行
var Book = function (name) {
//模拟类的公有属性和方法
this.name = name;
this.setName = function (nname) {
this.name = nname;//this关键字--作用域 当前对象
}
this.getName = function () {
return this.name;
}
}
oopTest();
function oopTest() {
//var teacher = new Teacher();
//alert(teacher instanceof Teacher); //true --判断对象是不是类的实例
var bookOne = new Book("java");//相当于创建了简单对象，调用了类的构造函数
var bookTwo = new Book("C#");
alert(bookOne.name);
alert(bookTwo.name);
bookOne.setName("Ajax");
alert(bookOne.name);
alert(bookTwo.name);
}
//javascript中的原型对象，prototype
var proBook = Book.prototype;
//给原型对象添加属性
proBook.hobby = "coder";
proBook.sayName=function () {
alert("dinglang");
}
//拥有这个原型对象的function，他所模拟出来的“类对象”都具有原型对象上面的属性 //一种更为合适的公共属性和方法的定义
var animal = function (name) {
//公共属性,在function内部定义，使用this关键字
this.name = name;
//定义私有的属性和方法（利用局部变量var关键字）
var count = 0;
var getCount = function () {
count++;//典型的闭包（函数中嵌套函数，且使用了外层函数--类中定义的私有变量。该私有变量不会被内存回收掉）
}
}
//公有方法定义在原型对象上
animal.prototype.setName = function (nname) {
this.name = nname;
}
animal.prototype.getName = function () {
return this.name;
} //一个单独的类，期望拥有一些私有的信息
/*
var priObj = new function () {
var priName = "wang";
this.setName = function (nname) {
priName = nname;
}
this.getName = function () {
return priName;
}
}
*/ //通过匿名函数的方式，来实现对象拥有私有属性
var priObj = (function (name) {
this.priName = name;
return {
getName: function () {
return priName;
},
setName: function (nname) {
priName = nname;
}
};
})("wang"); //模拟类的静态方法和静态变量
Book.staticValue = "10";
Book.staticMetnhod = function () {
Book.staticValue++;
}
//定义一个公有的extend方法，实现“继承”
Function.prototype.extend(function (parent) {
//保留原有的成员，并能继承扩展（如果重名了，则会被后者覆盖）
for (var preName in parent.prototype) {
this.prototype[preName] = parent.prototype[preName];
}
//这样也能实现继承（当前对象中的成员将会完全被重定义）
//this.prototype = new parent();
})
</script>
</head>
<body></body>
</html>