This question already has answers here:
Static methods and their overriding
(5 answers)
Closed 8 years ago.
What should be printed when we execute this code?
I picked the question from here where the answer is provided but I kinda believe is wrong. First the call to a static function has to be done in static way, second when we override a static function the previous one is no longer accessible ( no new memory is assigned)
class Base {
public static void show() {
System.out.println("Base::show() called");
}
}
class Derived extends Base {
public static void show() {
System.out.println("Derived::show() called");
}
}
class Main {
public static void main(String[] args) {
Base b = new Derived();;
b.show();
}
}
static method belongs to class itself and overriding works for instance methods only. If you define the same method again in sub-class then it's called re-defining hiding of the static method.
static method looks for class to invoke it and that can be verified by below same code:
Base b = null;
b.show(); // Base::show() called
It doesn't make any sense to call static method via object.
Related
This question already has answers here:
Why doesn't Java allow overriding of static methods?
(22 answers)
Is it possible to override a static method in derived class?
(6 answers)
Closed 5 years ago.
class B extends A {
static public void printMe(){
System.out.println("in static B");
}
}
class A{
static public void printMe(){
System.out.println("In static A");
}
}
public static void main(String[] args) {
A a = new B();
a.printMe();
}
Why is the output "In static A" ?
Static members bind to type rather than implemented type. Hence you see the methods executing from class A.
And static members are not to be ovverriden and they share same copy regardless of instance state.
If you need methods to be ovveriden, do not use them as static members.
Static member or method belongs to class level instead of specific instance.
A static class will have only 1 instance even if you create multiple instance or do not create instance.
In your case, since you have created instance of class A, method inside class A is implemented.
Another way to get a clear concise for the problem scenario is try running the code mentioned below:
public static void main(String[] args) {
A.printMe();
}
You will get clear idea.
This question already has answers here:
What is the difference between static and default methods in a Java interface?
(12 answers)
Closed 5 years ago.
interface TestInterface
{
public static void square(int a)
{
System.out.println("Square is "+a*a);
}
public static void show()
{
System.out.println("Default Method Executed");
}
}
class TestClass implements TestInterface
{
public void square(int a)
{
System.out.println(a*a);
}
public void show()
{
System.out.println("Overridden Method");
}
public static void main(String args[])
{
TestClass d=new TestClass();
d.square(4);
TestInterface.square(4);
TestInterface.show();
d.show();
}
}
I have a doubt in my code. I learnt that static methods cannot be overridden in JAVA, but it seems to be working fine here.
When i give both default and static keywords together, like this
interface TestInterface
{
default static void square(int a)
{
System.out.println("Square is "+a*a);
}
public static void show()
{
System.out.println("Default Method Executed");
}
}
An error crops up as follows:
illegal combination of modifiers: static and default
What is the reason for JAVA treating this as an error?
A static method is meant to be called without an instance of the class/interface concerned. Usually they are meant to be utility methods.
A default method is meant to be called on an instance of the interface concerned. All implementations of this interface will have this method definition, unless it is overridden.
The reason these two terms are not allowed together is simply because they contradict each other: default requires an object, static requires no object.
TestClass.show() and TestClass.square() are not static and therefore do not override the static methods in the interface. They are member methods and require an object to call them. On the other hand, the methods with the same name in the interface are static and so you can call them with the interface name or class name without an object.
This question already has answers here:
Are static methods inherited in Java?
(15 answers)
Why doesn't Java allow overriding of static methods?
(22 answers)
Closed 6 years ago.
Suppose I have the following simple code:
class A {
protected int someMethod() {
return staticMethod();
}
private static int staticMethod() {
return 10;
}
}
class B extends A {
protected int someMethod() {
return super.someMethod();
}
public static int staticMethod() {
return 20;
}
}
class TestX {
private void main() {
B b = new B();
int finalValue =b.someMethod();
}
}
In the above code, when b.someMethod() is executed, it ends up calling A's version of staticMethod(). But I thought static methods are called based on the type of reference of the main object. Since the object on which someMethod() is called is of type B, shouldn't B's version of staticMethod() be called even when A's someMethod() is called (because of the line return super.someMethod();) ?
Given the above code, is there a way I can make B's staticMethod() get executed so that 20 is returned instead of 10 ?
I found a similar question but the idea suggested in it isn't relevant to me I think:
Calling subclass's static method from parent class
This question already has answers here:
Are static methods inherited in Java?
(15 answers)
Closed 8 years ago.
I was able to run the following code:
class A
{
public static void display()
{
System.out.println("Inside static method of superclass");
}
}
class B extends A
{
public void show()
{
display();
}
}
public class staticMethodInheritance {
public static void main(String[] args) {
B b = new B();
b.display();
}
}
Now I was able to access the method display() from the instance of the class B then why is it said that static methods cannot be inherited. If I declare a method display in class B then it is said that the method in the superclass is hidden and the method in the child class is called then again isnt this the behavior that is desired when we override a method.
The only difference with inherited static (class) methods and inherited non-static (instance) methods is that when you write a new static method with the same signature, the old static method is just hidden, not overridden.
Static methods are inherited but cannot be overriden they can be re- defined.
This question already has answers here:
Closed 11 years ago.
Possible Duplicate:
What is the reason behind “non-static method cannot be referenced from a static context”?
public void Sort(){
*some code*
}
public void displayResults()
{*more code*
}
public static void main(String[] args)
{
Sort();
displayResults();
}
Why am I getting this error? I have sort(); in another abstract class and then this class here is extending it.
-Confused
You need to instantiate the class that contains Sort(), displayResults() and main before you can call Sort() or displayResults() from main().
class Example {
public void Sort(){
// *some code*
}
public void displayResults()
{
// *more code*
}
public static void main(String[] args)
{
Example ex = new Example()
ex.Sort();
ex.displayResults();
}
}
You need an instance of a class to call a non-static method. Calling from a static method, you don't have an instance, as statics are associated to a class, not to an instance. Therefore, you are not allowed to call non-static methods or access non-static variables from inside a static context.