在这节，老师讲了面向对象的三大特性：1、全局变量；2、封装；3、继承；
现在我就我自己的理解总结一下这节课的内容，并提出相应的疑惑，望老师解答
其一：全局变量
声明变量的方法有三：1，在全局对象中var a一个变量；2，window.a一个变量；3.直接去掉var,如：a=1一个变量。
第一种声明方式是我们声明变量的标准形式。现在我主要说说第二种和第三种声明变量的方式：
对于第二种方式和第三种方式声明的变量，不同于标准声明1：
其实实质上就是创建了全局对象的一个新属性，本质上不是变量。并且这两种方式声明的变量只在代码执行阶段才会出现，在预解析代码时是不会出现在执行环境中（变量对象）中。
对于第二种方式和第三种方式声明的变量，不同于标准声明2：
这两种声明变量的方式是可以运用delete操作符删除的，而标准声明方式却不能，原因在于标准声明的变量有一个Donot delete属性。（也除例外情况，如：在eval上下文中，标准声明的方式没有Donot delete这个属性，所以也是可以删除的）
注：例外在声明变量时应少声明全局变量，会引发一些不必要的影响
其二：封装
说到封装，先讲讲三大声明的形式：1、private;2、protected;3、public
js中并没有这些特性，但我们可以通过代码人为实现这三种特性
对于私有类型（private),我们便可以采用封装的形式，将函数中一部分信息隐藏，但为了给外部引用，提供相应的接口（我觉得这就是引用闭包的特性，来实现这些接口）
对于保护类型（protected)，虽然没有其实现方法，但我们可以通过人为的书写规范来辨别，如：将受保护类型的变量，可以在变量名前加下划线来区分它与公有类型。
其三：继承（困扰我好久）
其实，老师上课说的继承的两种实现方式，只说了其实现过程，并没有具体和我们分析分析，所以我就找了好多资料，来做一个总结吧！
先说说普通的原型链继承：
function sub(){
this.proterty=true;
}
sup.prototype.getValue=function(){
return this.property;
}
function sub(){
this.subValue=false;
}
sub.prototype=new sup();
var instance=new sub();
alert(instance.getValue());
原型链继承：
原理：
就是通过原型链来实现的继承，就是你的sub函数的原型对象的_proto_属性指向sup的原型对象，而sub实例化的instance对象的_proto_属性指向sub的原型对象，通过这条链来查找所需方法和属性。
优点：可以在sup的原型对象中添加的方法可以实现共享，利于代码的复用
缺点：如果sub中的引用类型的属性会被所有实例化的对象共享，不能保证各实例化对象的不同状态。
为了解决原型链继承这个缺点，我们引用了借用构造函数继承的方法：
function sup(){
this.num=[1,2,3];
}
function sub(){
sup.call(this);
}
var instance1=new sub();
instance1.num.push(‘4‘);
var instance2=new sub();
instanc2.num.push(‘5‘);
借用构造函数继承:
原理：
就是通过这行关键代码来实现继“sup.call(this);”，这行代码的意思就是，在sub的词法环境中我们在全局作用域中调用sup函数（借用sup的函数），所以执行完这行代码一行以后，sub就继承了sup。之后在实例化sub时，每个实例化对象，都会有num属性的副本，这其中就是通过this的指向来完成的。如：实例化instance1时，sub中的this就会指向instance1，而sub会借用sup的this，所以每个实例化的num属性都会不一样，这样就可以实现各实例化对象的不同状态。
优点：可以实现各实例化对象的不同状态；
缺点：不利于代码的复用
综合上面两种继承方法的优缺点，就引出了第三种继承方案：组合继承
function sup(name){
this.name=name;
this.num=[1,2,3]
}
sup.prototype.sayName=function(){
alert(this.name);
}
function sub(){
sup.call(this);
}
sub.prototype=new sup();
sub.prototype.construcor=sub;
var instance1=new sub();
instance1.num.push(‘4‘);
instance1.sayName();
var instance2=new sub();
instanc2.num.push(‘5‘);
instance2.sayName();
组合继承：
原理：综合以上两种方式的原理来实现；
优点：可以让sub的不同实例化对象分别有自己的状态属性，而且又可以使用相同的方法
缺点：两次调用sup构造函数，不利于性能优化
为了解决组合继承这个缺点，我们引用了寄生式组合继承的方法：
function imp(sub,sup){
var proto=Object(sup.prototype);
proto.constructor=sup;
sub.prototype=proto;
}
function sup(name){
this.name=name;
this.num=[1,2,3];
}
sup.prototype.sayName=function(){
alert(this.name);
}
function sub(){
sup.call(this);
}
imp(sub,sup);
寄生式组合继承:
原理，之前说的两次调用sup构造函数，第一次是sup.call(this);第二次是创建sub对象原型的时候；分析第二次调用sup构造函数，其实实质上就是我们需要的只是sup原型对象的一个副本，说白了就是希望sub原型对象的_proto_属性指向sup的原型对象。为了解决这个问题，我们可以用一个函数封装来实现
function imp(sub,sup){
var proto=Object(sup.prototype);
proto.constructor=sup;
sub.prototype=proto;
}
只要我们创建一个sup的原型对象，在把sup原型对象的construct指或sup，最后在把sub的原型对象指向sup的原型对象。我们就可以实现继承sup原型对象上的方法了
优点：避免在sub的原型对象上创建不必要的属性。
说完了我对高程上继承的理解，我说说老师课上继承的两种方式：1、类继承；2、原型继承
其一：类继承
(function(){
function classA(){};
classA.classMethod=function(){};
classA.prototype.api=function(){};
function classB(){
classA.apply(this,arguments);
}
classB.prototype=new classA();
classB.prototype.constructor=classB;
classB.prototype.api=function(){
classA.prototype.api.call(this,arguments);
}
var b=new classB()
})()
关于这段代码，我提出两个疑问：
疑惑一：
classB.prototype.constructor=classB;
关于这句语句：
我的理解：将classB原型对象上的constructor指回classB;
原因是执行完classB.prototype=new classA();以后classB的原型对象指向了classA的原型对象，而classA的原型对象中的constructor属性是指向classA的
我的疑惑：如果不加这句语句，那么classB原型对象上的constructor属性指向哪里？是classA吗？（我理解的constructor属性指向prototype属性所在的构造函数）如果不加这句语句，那么通过classB实例化的对象b，b的构造器会指向classA不会指向classB吗？对原形链有什么影响吗？请老师好好帮我分析分析，我实在想不出！
疑惑二：
classA.prototype.api.call(this,arguments);
关于这句语句：
我的理解：就是在classB的原型对象上添加api方法。我认为在classA的原型对象中已经添加了api方法，我们可以通过原型继承（原型链），在classB实例化的对象中访问到api方法，不需要再在classA的原型对象上在调用一次这个方法.请问老师这样写还有其他目的吗?还是我的理解不准确？
其二：原型继承
(function(){
var proto={
action1:function(){}
}
var obj=Object.create(proto);
})()
对于原型继承我的理解是：它和之前说的原型链继承有同样的弊端，不利于每个实例对象的属性状态的不同的保存。
这种继承还存在兼容性，我们可以封装一个函数解决。
以上就是我对继承的理解，因为还是学生，没有实践经历，理解层次还处于理论阶段，可以在以后实践会有不同吧！慢慢来。
在前端自学的路上，遇到好多问题，想对继承方法的命名不同，导致我不同的理解，弄混之前的理解。后现在觉得名字什么的只是一个说法，理解才是最重要的。所以我们可以在应用中针对不同的案例实现不同的继承方法