Call the "parent" method of the current method. That is the method previously
overridden by derivation or by an override (see {@link Ext#define}).

Ext.define('My.Base', {
constructor: function (x) {
this.x = x;
},

statics: {
method: function (x) {
return x;
}
}
});

Ext.define('My.Derived', {
extend: 'My.Base',

constructor: function () {
this.callParent([21]);
}
});

var obj = new My.Derived();

alert(obj.x);  // alerts 21

This can be used with an override as follows:

Ext.define('My.DerivedOverride', {
override: 'My.Derived',

constructor: function (x) {
this.callParent([x*2]); // calls original My.Derived constructor
}
});

var obj = new My.Derived();

alert(obj.x);  // now alerts 42

This also works with static methods.

Ext.define('My.Derived2', {
extend: 'My.Base',

statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Base.method
}
}
});

alert(My.Base.method(10);     // alerts 10
alert(My.Derived2.method(10); // alerts 20

Lastly, it also works with overridden static methods.

Ext.define('My.Derived2Override', {
override: 'My.Derived2',

statics: {
method: function (x) {
return this.callParent([x*2]); // calls My.Derived2.method
}
}
});

alert(My.Derived2.method(10); // now alerts 40

To override a method and replace it and also call the superclass method, use
{@link #callSuper}. This is often done to patch a method to fix a bug.

@protected
@param {Array/Arguments} args The arguments, either an array or the `arguments` object
from the current method, for example: `this.callParent(arguments)`
@return {Object} Returns the result of calling the parent method
function(args) {
            // NOTE: this code is deliberately as few expressions (and no function calls)
            // as possible so that a debugger can skip over this noise with the minimum number
            // of steps. Basically, just hit Step Into until you are where you really wanted
            // to be.
            var method,
                superMethod = (method = this.callParent.caller) && (method.$previous ||
                        ((method = method.$owner ? method : method.caller) &&
                                method.$owner.superclass[method.$name]));

            //<debug error>
            if (!superMethod) {
                method = this.callParent.caller;
                var parentClass, methodName;

                if (!method.$owner) {
                    if (!method.caller) {
                        throw new Error("Attempting to call a protected method from the public scope, which is not allowed");
                    }

                    method = method.caller;
                }

                parentClass = method.$owner.superclass;
                methodName = method.$name;

                if (!(methodName in parentClass)) {
                    throw new Error("this.callParent() was called but there's no such method (" + methodName +
                                ") found in the parent class (" + (Ext.getClassName(parentClass) || 'Object') + ")");
                }
            }
            //</debug>

            return superMethod.apply(this, args || noArgs);
        }