extjs如何调用父类的方法

‘壹’ 在子类构造器中调用父类方法

使用super关键字在子类的构造器里调用父类的普通方法，例如：

/**
*父类
*
*@authorqd
*
*/
classF{

publicvoidteatA(){
System.out.println("teatA方法");
}
}

/**
*子类
*
*@authorqd
*
*/
classSextendsF{

//子类构造器中调用父类普通方法
publicS(){
super.teatA();
}
}

/**
*测试类
*
*@authorqd
*
*/
publicclassTest1{

publicstaticvoidmain(String[]args){

Ss=newS();
}
}

运行结果：

‘贰’ extjs 初始化函数 中的 this.callParent(arguments);类似于继承么就是继承父类的对应的初始化函数

主要是为了覆盖父类的同名方法...但是又需要父类方法同样的动作的时候...

//比如一个grid父类
Ext.define("baseGrid",{
extend:"Ext.grid.Panel",
initComponent:function(){
//这里设置表格的工具栏,用一个createDockedItems方法生成
this.dockedItems=this.createDockedItems();
this.callParent();
},
//这里是生成表格的工具栏,默认的只有一个分页栏
createDockedItems:function(){
return[{
xtype:"paging",dock:"bottom",store:this.store
}]
}
});

//然后grid1继承这个类
Ext.define("grid1",{
extend:"baseGrid",
//这里grid1不仅有分页栏,还需要有添加,修改,删除的工具栏
createDockedItems:function(){
vartbs=this.callParent();//这里调用callParent,就是父类的方法,返回父类方法中的内容,就是那个分页栏
//这里添加一个新的工具栏,包括添加修改按钮
tbs.push({xtype:"toolbar",items:[
{text:"添加"},
{text:"修改"}
]});
returntbs;
}
});

//其实主要作用是为了覆盖,而同时又不是全部都覆盖,所以有了这个方法

‘叁’ 子类怎么调用父类的方法和构造函数

调用父类的方法，直接写就可以了；
调用父类的构造方法，在子类的构造方法里面调用super（）；只能写在构造方法的第一句

‘肆’ 子类继承父类，怎么调用父类的方法

不是这个意思。所谓“实例化子类的对象前要先实例化父类中的内容，为父类初始化”，是指当子类正在实例化时，总是链式调用父类构造方法初始化父类空间。换句话说，子类的构造方法必须先调用父类的构造方法，完了才能干别的初始化工作

‘伍’ extjs调用iframe父级函数

1、以下解决方案基于extjs4.2.1 架构采用extjs MVC。
页面结构为左侧菜单树，右侧TabPanel,点击菜单树，动态在tabpanel内新建利用树的id生成的tabpanel页，当然了，iframe的内容就是树的节点herf，文中加粗部分就是这个过程的实现。
2、例程：

Ext.define('Sys.controller.MenuController',{
extend:'Ext.app.Controller',
refs:[{
ref:'menuTreeView',
selector:'menutreeview'
},
{
ref:'contentCardView',
selector:'contentcardview'
}
],
stores:['SysTree'],

init:function(){
this.control({
'menutreeview':{
beforeitemexpand:this.onItemExpand,
beforeitemclick:this.onBeforeItemClick,
itemclick:this.onClickTree
}
})
},

onItemExpand:function(node,optd){
varstore=this.getSysTreeStore();
varmProxy=store.getProxy();
mProxy.setExtraParam("id",node.get("id"));

},
onBeforeItemClick:function(viewtree,record,item,index,e,eOpts){

e.stopEvent();
},

‘陆’ 在js中，子类如何调用父类中方法如下图示：

//子类Student
function Student(name,age,sex,phone){
//继承方法

Person.call(this,name,age);
//添加自己的属性
this.sex=sex;
this.phone=phone;
//添加自己的方法
this.say();

}
//继承父类的属性
for(var i in Person.prototype){
Student.prototype[i]=Person.prototype[i];

}
//重写父类方法
Student.prototype.say()
{
alert(this.phone+' 'this.sex);

}

‘柒’ 如何在java中子类中父类的对象如何调用父类的方法

对于有继承关系的类，子类可以通过这个关键字调用父类中的方法。
比如:super.query();
此句话的意思是调用父类中的非私有方法query。

一般的用super关键字，调用类中的父类中重载构造方法。
比如：父类有个构造方法public A(){},同时又写了一个重载的构造方法public A(String name);那么，在子类中可以使用super(name)指明调用父类的哪个构造方法进行实例化父类对象。

大概就是这样的！

‘捌’ 请教关于extjs继承jcrop的问题

Ext中实现类的继承
Js代码
extend (Object subclass,Object superclass,[Object overrides] : Object)

第一个参数：子类
第二个参数：父类
第三个参数：要覆盖的属性。
这里需要强调一下，子类继承下来的是父类中通过superclass.prototype方式定义的属性（包括用此方法定义的函数）,而不继承superclass中的定义的属性和方法，如果子类中的方法名与父类中相同则会覆盖。例子
父类
Js代码
BaseClass = function() {
f1 = function() {
alert("f1 in base");
},
f2 = function() {
alert("f2 in base");
}
}
BaseClass.prototype = {
f3 : function() {
alert("f3 in base");
},
f4 : function() {
alert("f4 in base");
}
};

子类
Js代码
ChildClass = function() {
}
// 继承
Ext.extend(ChildClass, BaseClass, {
f1 : function() {
alert("f1 in child");
},
f3 : function() {
alert("f3 in child");
}
});

实例化
Js代码
var b = new ChildClass();
b.f1();// 调用子类中的实现
//b.f2();// 会报错，因为子类中没有该方法，并且父类中定义的f2是内部变量，作用域只有在内部可见（闭包）
b.f3();// 继承并覆盖，调用子类的中的实现
b.f4();// 继承，调用父类的中的实现

补充：通过对 JavaScript 的原型继承的了解，可以知道，实例变量的优先级是高于 prototype 的，参见我之前写的文章javascript中静态方法、实例方法、内部方法和原型的一点见解 又如以下例子：
父类
Js代码
BaseClass = function() {
this.f1 = function() {
alert("f1 in base");
},
this.f2 = function() {
alert("f2 in base");
}
}

子类
Js代码
ChildClass = function() {
ChildClass.superclass.constructor.call( this );
}
// 继承
Ext.extend(ChildClass, BaseClass, {
f1 : function() {
alert("f1 in child");
},
f3 : function() {
alert("f3 in child");
}
});

实例化
Js代码
var b = new ChildClass();
b.f1();// 调用父类中的实现，注意不会调用子类中的实现
b.f2();// 调用父类中的实现
b.f3();// 调用子类中的实现

分析：在 ChildClass.superclass.constructor.call(this); 这句上， BaseClass 的 f1 成了 ChildClass 的变量，而不是 ChildClass.prototype 。由于实例变量的优先级是高于 prototype 的，所以上面的这个代码是达不到 override 的功能的。

了解了以上知识，下面讲解一下extend的实现，先看最简单的继承，实现原理，1、将子类的原型prototype设置为父类的一个实例，也就是说把父类的实例赋值给子类的prototype（这样子类就有了父类原型的所有成员），2、重新将子类原型的构造器设置为子类自己，也就是把子类赋值给子类原型的构造器。
以下代码把 subFn 的 prototype 设置为 superFn 的一个实例，然后设置 subFn.prototype.constructor 为 subFn。
Js代码
function Extend(subFn, superFn) {
subFn.prototype = new superFn();
subFn.prototype.constructor = subFn;
}

//父类
function Animal() {
this.say1 = function() {
alert("Animal");
}
}
//子类
function Tiger() {
this.say2 = function() {
alert("Tiger");
}

}
//继承应用
Extend(Tiger, Animal);
var tiger = new Tiger();
tiger.say1();// "Animal"
tiger.say2();// "Tiger"

可以看到最简单的继承只做了两件事情，一是把 subFn 的 prototype 设置为 superFn 的一个实例，然后设置 subFn . prototype . constructor 为 subFn 。

Ext.extend 的代码

Ext.extend 函数中用到了 Ext.override ，这个函数把第二个参数中的所有对象复制到第一个对象的 prototype 中。首先贴上 Ext.override 函数的代码：
Js代码
/**
* Adds a list of functions to the prototype of an existing class, overwriting any existing methods with the same name.
* Usage:<pre><code>
Ext.override(MyClass, {
newMethod1: function(){
// etc.
},
newMethod2: function(foo){
// etc.
}
});
</code></pre>
* @param {Object} origclass The class to override
* @param {Object} overrides The list of functions to add to origClass. This should be specified as an object literal
* containing one or more methods.
* @method override
*/
override : function(origclass, overrides){
if(overrides){
var p = origclass.prototype;
Ext.apply(p, overrides);
if(Ext.isIE && overrides.hasOwnProperty('toString')){
p.toString = overrides.toString;
}
}
}

以下是 Ext.extend的代码
Js代码
/**
* 继承，并由传递的值决定是否覆盖原对象的属性
* 返回的对象中也增加了 override() 函数，用于覆盖实例的成员
* @param { Object } subclass 子类，用于继承（该类继承了父类所有属性，并最终返回该对象）
* @param { Object } superclass 父类，被继承
* @param { Object } overrides （该参数可选） 一个对象，将它本身携带的属性对子类进行覆盖
* @method extend
*/
extend : function(){
// inline overrides
var io = function(o){
for(var m in o){
this[m] = o[m];
}
};
var oc = Object.prototype.constructor;

//匿名函数实现
//三个参数sb、sp、overrides分别代表subClass(子类)、superClass(父类)及覆盖子类的配置参数
return function(sb, sp, overrides){
if(typeof sp == 'object'){//传递两个参数时superClass, overrides
overrides = sp;
sp = sb;
sb = overrides.constructor != oc ? overrides.constructor : function(){sp.apply(this, arguments);};
}
var F = function(){},//定义一空函数，用来赋给其对象时清空该对象
sbp,
spp = sp.prototype;

F.prototype = spp;
// 注意下面两句就是JavaScript中最简单的继承实现。
sbp = sb.prototype = new F();//清空
sbp.constructor=sb;
// 添加了 superclass 属性指向 superclass 的 prototype
sb.superclass=spp;
if(spp.constructor == oc){
spp.constructor=sp;
}
// 为 subClass 和 subClassPrototype 添加 override 函数
sb.override = function(o){
Ext.override(sb, o);
};
sbp.superclass = sbp.supr = (function(){
return spp;
});
sbp.override = io;
// 覆盖掉子类 prototype 中的属性
Ext.override(sb, overrides);
//为子类加上类方法：extend
sb.extend = function(o){return Ext.extend(sb, o);};
return sb;
};
}(),

代码中进行了太多的简写，看起来不是特别方便，把代码中的简写补全，代码如下：
Js代码
extend : function(){
// inline overrides
var inlineOverride = function(o){
for(var m in o){
this[m] = o[m];
}
};
var oc = Object.prototype.constructor;

return function(subFn, superFn, overrides){
if(typeof superFn == 'object'){
// 如果 superFn 也是对象的话（一般来说 superFn 这里放的是父类的构造函数），那么第三个参数 overrides 参数相当于被忽略掉
overrides = superFn;
superFn = subFn;
//重新定义了函数 subFn
subFn = overrides.constructor != oc ? overrides.constructor : function(){superFn.apply(this, arguments);};
}
var F = function(){},
subFnPrototype,
superFnPrototype = superFn.prototype;

F.prototype = superFnPrototype;
subFnPrototype = subFn.prototype = new F();
subFnPrototype.constructor=subFn;
subFn.superclass=superFnPrototype;
if(superFnPrototype.constructor == oc){
superFnPrototype.constructor=superFn;
}
subFn.override = function(o){
Ext.override(subFn, o);
};
subFnPrototype.superclass = subFnPrototype.supr = (function(){
return superFnPrototype;
});
subFnPrototype.override = inlineOverride;
Ext.override(subFn, overrides);
subFn.extend = function(o){return Ext.extend(subFn, o);};
return subFn;
};
}()

代码中糅合了传两个参数和三个参数的实现，理解起来不容易明白，我们可以把代码拆分为两个参数和三个参数的实现，如下两个参数的 Ext.extend 代码

Js代码
function extend() {
// inline overrides
var inlineOverride = function(o) {
for (var m in o) {
this[m] = o[m];
}
};
return function(superFn, overrides) {
// 定义返回的子类
var subFn=overrides.constructor != Object.prototype.constructor ? overrides.constructor : function(){superFn.apply(this, arguments);};
//以下为中间变量，或叫过程变量
var F = function() {

}, subFnPrototype, superFnPrototype = superFn.prototype;

F.prototype = superFnPrototype;//F中含有了所有 superFn.prototype 中的功能

// 注意下面两句就是JavaScript中最简单的继承实现。
subFnPrototype = subFn.prototype = new F();
subFnPrototype.constructor = subFn;
//改变父类实例对象中的constructor，使其指向自身的构建函数
if(superFnPrototype.constructor == oc){
superFnPrototype.constructor=superFn;
}
// 添加了 superclass 属性指向 superFn 的 prototype
subFn.superclass = superFnPrototype;

// 为 subFn 和 subFnPrototype 添加 override 函数
subFn.override = function(obj) {
Ext.override(subFn, obj);
};
subFnPrototype.override = inlineOverride;

// 覆盖掉子类 prototype 中的属性
Ext.override(subFn, overrides);
//为子类加上类方法：extend
subFn.extend=function(o){
Ext.extend(subFn,o);
}
return subFn;
};

};

从注释中可以看到，做的工作很简单，只是定义一个 subFn 函数，这个函数中会调用 superFn 函数。定义了 subFn 以后，就使用上面的最简单的继承方式实现继承。然后为 subFn 和 subFn 的 prototype 添加了一个 override 函数。最后的 Ext.override(subFn, overrides); 把 overrides 中的函数写入 subFn 的 prototype 中。
以下是传两个参数的简单例子

Js代码
var BaseClass = function(){};
BaseClass.prototype = {
method1 : function(){
alert('father class');
}
};
//两个参数的继承
var subClass = Ext.extend(BaseClass,{
method2 : function(){
alert('sub class');
}
});

var sub = new subClass();
sub.method1();
sub.method2();

‘玖’ js中子类重写父类中方法, 重写方法中用到父类的方法怎么调用呢

子类重写方法是在基类有此方法重写，那么声名一个子类的对象，调用的方法是子类的方法，
通过base转而调用父类中的方法，最终目的还是调用父类中的方法。
还有重写方法可以改变基类方法的作用，可以实现其他的效果，重写方法，和基类同名方法是两个不同实现的方法，
最主要你要分清楚 重写跟基类中的方法不一定实现同样的效果，还有基类也不一定知道派生类中是否重写了这个方法