Java Inheritance - calling superclass method
Solution 1
You can do:
super.alphaMethod1();
Note, that super
is a reference to the parent class, but super()
is its constructor.
Solution 2
Simply use super.alphaMethod1();
Solution 3
You can't call alpha's alphaMethod1() by using beta's object But you have two solutions:
solution 1: call alpha's alphaMethod1()
from beta's alphaMethod1()
class Beta extends Alpha
{
public void alphaMethod1()
{
super.alphaMethod1();
}
}
or from any other method of Beta like:
class Beta extends Alpha
{
public void foo()
{
super.alphaMethod1();
}
}
class Test extends Beta
{
public static void main(String[] args)
{
Beta beta = new Beta();
beta.foo();
}
}
solution 2: create alpha's object and call alpha's alphaMethod1()
class Test extends Beta
{
public static void main(String[] args)
{
Alpha alpha = new Alpha();
alpha.alphaMethod1();
}
}
Solution 4
It is possible to use super to call the method from mother class, but this would mean you probably have a design problem.
Maybe B.alphaMethod1()
shouldn't override A's method and be called B.betaMethod1()
.
If it depends on the situation, you can put some code logic like :
public void alphaMethod1(){
if (something) {
super.alphaMethod1();
return;
}
// Rest of the code for other situations
}
Like this it will only call A's method when needed and will remain invisible for the class user.
Solution 5
Solution is at the end of this answer, but before you read it you should also read what is before it.
What you are trying to do would break security by allowing skipping possible validation mechanisms added in overridden methods.
For now lets imagine we can invoke version of method from superclass via syntax like
referenceVariable.super.methodName(arguments)
If we have classes like
class ItemBox{ //can sore all kind of Items
public void put(Item item){
//(1) code responsible for organizing items in box
}
//.. rest of code, like container for Items, etc.
}
class RedItemsBox extends ItemBox {//to store only RED items
@Override
public void put(Item item){ //store only RED items
if (item.getColor()==Color.RED){
//(2) code responsible for organizing items in box
}
}
}
As you see RedItemsBox
should only store RED items.
Regardless which of the below we use
ItemBox box = new RedItemsBox();
RedItemsBox box = new RedItemsBox();
calling
box.put(new BlueItem());
will invoke put
method from RedItemsBox
(because of polymorphism). So it will correctly prevent BlueItem
object from being placed in RedItemBox
.
But what would happen if we could use syntax like box.super.put(new BlueItem())
?
Here (assuming it would be legal) we would execute version of put
method from ItemBox
class.
BUT that version doesn't have step responsible for validating Item color. This means that we could put any Item
into a RedItemBox
.
Existence of such syntax would mean that validation steps added in subclasses could be ignored at any time, making them pointless.
There IS a case where executing code of "original" method would make sense.
And that palce is inside overriding method.
Notice that comments //(1) ..
and //(2)..
from put
method of ItemBox and RedItemBox are quite similar. Actually they represent same action...
So it makes sense to reuse code from "original" method inside overriding method.
And that is possible via super.methodName(arguments)
call (like from inside put
of RedItemBox):
@Override
public void put(Item item){ //store only RED items
if (item.getColor()==Color.RED){
super.put(item); // <<<--- invoking code of `put` method
// from ItemBox (supertype)
}
}
roz
Updated on July 05, 2022Comments
-
roz almost 2 years
Lets suppose I have the following two classes
public class alpha { public alpha(){ //some logic } public void alphaMethod1(){ //some logic } } public class beta extends alpha { public beta(){ //some logic } public void alphaMethod1(){ //some logic } } public class Test extends beta { public static void main(String[] args) { beta obj = new beta(); obj.alphaMethod1();// Here I want to call the method from class alpha. } }
If I initiate a new object of type beta, how can I execute the
alphamethod1
logic found in class alpha rather than beta? Can I just usesuper().alphaMethod1()
<- I wonder if this is possible.Autotype in Eclipse IDE is giving me the option to select
alphamethod1
either from classalpha
or classbeta
. -
Asif Mushtaq about 7 yearsSome call super method at the end or some at the start why?
-
Michał Šrajer almost 7 yearsIn constructor, you need to call super() as a first statement (if you call it explicitly). On regular methods you call it wherever you want depending on your app logic needs. For example at the beginning if you want to add extra steps after call or at the end if you add extra check.
-
Rudra about 6 years@MichałŠrajer using
super
you cannot call method from classalpha
intoTest
class which extends classbeta
-
U. Windl about 6 yearsAs a Java beginner I just wonder why
super()
does not have the magic to know in which method it is being used (Meaning: Iffoo()
callssuper()
, it's obvious thatsuper()
meanssuper.foo()
. Constructors are just too special in Java IMHO) SeePrecursor
in Eiffel, where it's done right. -
Pshemo about 3 yearsAdditional info:
super.alphaMethod1();
can't be called frommain
method. This answer doesn't state it, but this call needs to be made from somewhere within non-static context of subclass:beta
. -
abc123 over 2 years@Michal, this is a totally wrong answer. If you use super.alphaMethod1() you get a compiler error saying "cant invoke from static context, make main non-static". How is this answer upvoted??