通俗的来讲就是说我们有一些秘密不想让人知道。我们就需要通过私有化变量和私有化方法的形式，将函数封装起来。这样的话外界不能访问函数内部的私有化变量私有化方法;如果你有一些想让大家知道的东西，你就可以通过 this 在创建的属性看作是对象共有的属性和对象共有方法。这样别人就能知道你的公共的东西，不止如此你还可以访问到类或者对象自身的私有属性和私有方法。
var Book = function ( id, name, price ) {
this . id= id;
this . name= name;
this . price= price;
}
var Book = function ( id, name, price ) {
var num= 1 ;
function checkId ( ) ;
var bookname= '' ;
this . getName = function ( ) {
return bookname;
} ;
this . getPrice = function ( ) { } ;
this . setName = function ( ) {
bookname= name
} ;
this . setPrice = function ( ) { } ;
this . id= id;
this . aaa = function ( ) { } ;
this . setName ( name) ;
this . setPrice ( price) ;
}
var b= new Book ( 1 , 'Javascrpit 面向对象' , 8.9 ) ;
console. log ( b. num) ;
console. log ( b. id) ;
console. log ( b. setName ( 'aaaaa' ) ) ;
闭包是有权限访问另外一个函数作用域中变量的函数。也就是在一个函数内部创建另外一个函数。 闭包呢，是在一个函数内部创建一个新的函数。并且在函数的外部调用内部创建的新函数作用域内的变量或函数所构成的闭合区间。称之为闭包。 ( function ( ) {
var bookNum= 0 ;
function checkBook ( name ) {
}
function Book ( newId, newNeme, newPrice ) {
var name, price;
var setNemt = function ( name_ ) {
name= ` 《 ${ name_} 》 ` }
var setPrice = function ( price_ ) {
price= Number ( price) 2 ;
}
setNemt ( newName) ;
setNemt ( newPrice) ;
bookNum++ ;
if ( bookNum> 3 ) {
throw new Error ( '我们仅出版3本书' )
}
this . getName = function ( ) {
return name;
} ;
this . getPrice = function ( ) {
return price;
} ;
this . id= newId;
}
Book . prototype= {
isBookType : '历史书'
}
return Book;
} ) ( ) ;
继承性是子类自动共享父类数据结构和方法的机制，这是类之间的一种关系。在定义和实现一个类的时候，可以在一个已经存在的类的基础之上来进行，把这个已经存在的类所定义的内容作为自己的内容，并加入若干新的内容。 每一个类大致有三部分：
1.是构造函数内的，是提供实例化对象赋值用的。 2.构造函数外部的直接通过点儿语法添加的。这是供类使用的。实例化对象是访问不到的。 3.类的原型当中，实例化对象可以通过其原型链简单的访问到也是提供所有实例化对象共有的。 function SuperClass ( ) {
this . superValue = true ;
}
SuperClass . prototype. getSuperValue = function ( ) {
return this . superValue;
} ;
function SubClass ( ) {
this . subValue = false ;
}
function User ( ) {
this . type= '人' ;
}
User . prototype = {
sayType : function ( ) {
return this . type;
}
}
/ @class
/
function Student ( score ) {
this . score = score;
}
Student . prototype= new User ( ) ;
/
@class
/
function Teacher ( xs ) {
this . xs = xs;
}
Teacher . prototype= new User ( ) ;
缺点:就是一个子类的实例原型。从父类构造函数当中继承来的共有属性就会直接影响到其他子类。 function SuperClass ( ) {
this . books= [ 'js' , 'jquery' , 'html' ] ;
}
function SubClass ( ) { }
SubClass . prototype= new SuperClass ( ) ;
var a= new SubClass ( ) ;
var b= new SubClass ( ) ;
额外的知识点:InstancesOf。是通过对象的prototype。来确定这个对象是否是某个类的实例，而不关心对象与类的自身结构。 构造函数式继承是通过在子类的构造函数作用环境中执行一次父类的构造函数来去实现。
function User ( name ) {
this . name= name;
this . books= [ 'js' , 'jquery' , 'html' ]
}
User . prototype. showBooks = function ( ) {
console. log ( this . books) ;
}
function Student ( name ) {
User . call ( this . books) ;
this . score= score;
}
var s1= new Student ( '佚名' , 99 ) ;
var s1= new Student ( '佚名' , 22 ) ;
s2. books. push ( "金瓶梅" ) ;
构造函数式继承,的关键在与call函数和apply函数 缺点：子类继承了父类的所有属性，却没办法继承父类的原型属性。
function User ( name ) {
this . name= name;
this . books= [ 'a' , 'b' , 'c' ]
}
User . prototype. getname = function ( ) {
console. log ( this . name) ;
}
function Student ( name ) {
User . call ( this . name) ;
this . score= score;
}
Student . prototype= new User ( ) ;
Student . prototype. getScore = function ( ) {
console. log ( this . score) ;
}
子类的实例当中。更改父类继承下来的引用属性。引用类型的属性。比如说那里边儿的 books。根本不会影响到其他的实例对象。并且子类实例化过程当中又能将参数传递到父类的构造函数里面。并且系成了父类的原型方法。 原型式继承。跟类是继承一样。父类对象当中的那个 books 中的值的这个类型的属性时会被复制一遍。引用类型的属性是被共有的。
function inheritObject ( obj ) {
function F ( ) { }
F . prototype= obj;
return new F ( ) ;
}
var book= {
name : 'jacasctipt 面向对象' ,
istyoe : [ 'css3 入门' , 'html5 页面编程' ]
}
var newBook= inheritObject ( book) ;
newBook. name= 'jquery Book' ;
newBook. istyoe. push ( 'ajax Book' ) ;
var otherBook= inheritObject ( book) ;
otherBook. name= 'php Book' ;
otherBook. istyoe. push ( 'mysql Book' ) ;
在一个函数内部找一个过渡对象来去实现继承，并且返回新对象。 通过在一个函数内的过渡对象。中实现继承并返回新对象的这种方式。称之为寄生式的继承. 寄生就像寄生虫一样。寄托于某个对象的内部生长。就是对原型继承的第二次封装。并且在这第二次封装的过程当中，对继承的对象进行了一些扩展。这样新的新创建的对象不仅仅有父类的属性和方法。而且还添加了新的属性和方法。
function Book ( ) {
}
var book = {
name : "javascript 面向对象" ,
istype : [ "css3入门" , "html5 页面编程" ]
} ;
function inheritObject ( obj ) {
function F ( ) { }
F . prototype = obj;
return new F ( ) ;
}
function createBook ( obj, score ) {
var o = new inheritObject ( obj) ;
o. score = score;
o. getName = function ( ) {
console. log ( o. name) ;
}
return o;
}
function inheritObject ( obj ) {
function F ( ) { }
F . prototype = obj;
return new F ( ) ;
}
/
寄生式继承 继承原型
传递参数 subClass, 子类
传递参数 superClass, 父类
/
funtion inheritPrototype ( subClass, superClass ) {
var superPrototype = inheritObject ( superClass. prototype)
subClass. prototype = superPrototype;
}
function SuperClass ( name ) {
this . name = name;
this . books = [ 'js' , 'html' , 'css' ] ;
}
SuperClass . prototype. getName = function ( ) {
console. log ( this . name) ;
}
function SubClass ( name, score ) {
SuperClass . call ( this , name) ;
this . score = score;
}
inheritPrototype ( SubClass, SuperClass) ;
SubClass . prototype. getScore = function ( ) {
console. log ( this . score) ;
}
多态就是通过对传递的参数判断来去执行不同的逻辑。就可以实现一种多态处理机制。我们通过这个多态调用一个运算方式，根据不同的参数做不同的运算。 function Add ( ) {
function zero ( ) {
return 0 ;
}
}
function one ( num ) {
return num;
}
function two ( num1, num2 ) {
return num1+ num2;
}
function more ( nums ) {
var result= 0 ;
for ( var i= 0 ; i< nums. length; i++ ) {
result+= nums[ i] ;
}
}
this . a = function ( ) {
var arg= arguments;
len= arg. length;
switch ( len) {
case 0 :
return zero ( ) ;
case 1 :
return one ( arguments[ 0 ] ) ;
case 2 :
return two ( arguments[ 0 ] , arguments[ 1 ] ) ;
default :
return more ( arguments) ;
}
}
本文详细讲解了JavaScript中的面向对象编程，包括封装的实现（构造函数封装和闭包），各种继承方式（类式继承、构造函数式继承、组合继承和原型式继承），以及多态的概念和应用。通过实例展示了如何使用这些概念在实际开发中操作类和对象。
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
