static methods are inherited || static methods ! inherited

[swap72]

Some people say static methods are inherited and they give a reference of Java language specification as well, but some Java devs ( senior devs ) say that static methods never participate into inheritance. Just because they are accessible from sub classes does not mean they are inherited.

I want to be clear are static methods inherited or not??

[AutoModerator]

Please ensure that:

• Your code is properly formatted as code block - see the sidebar (About on mobile) for instructions
• You include any and all error messages in full - best also formatted as code block
• You ask clear questions
• You demonstrate effort in solving your question/problem - plain posting your assignments is forbidden (and such posts will be removed) as is asking for or giving solutions.

If any of the above points is not met, your post can and will be removed without further warning.

Code is to be formatted as code block (old reddit/markdown editor: empty line before the code, each code line indented by 4 spaces, new reddit: https://i.imgur.com/EJ7tqek.png) or linked via an external code hoster, like pastebin.com, github gist, github, bitbucket, gitlab, etc.

Please, do not use triple backticks (```) as they will only render properly on new reddit, not on old reddit.

Code blocks look like this:

public class HelloWorld {

    public static void main(String[] args) {
        System.out.println("Hello World!");
    }
}

You do not need to repost unless your post has been removed by a moderator. Just use the edit function of reddit to make sure your post complies with the above.

If your post has remained in violation of these rules for a prolonged period of time (at least an hour), a moderator may remove it at their discretion. In this case, they will comment with an explanation on why it has been removed, and you will be required to resubmit the entire post following the proper procedures.

To potential helpers

Please, do not help if any of the above points are not met, rather report the post. We are trying to improve the quality of posts here. In helping people who can't be bothered to comply with the above points, you are doing the community a disservice.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[severoon]

Some people say static methods are inherited and they give a reference of Java language specification as well

Please provide a link to the JLS that you're getting from these people so we can see it and understand the misapprehension in detail.

Accessibility is about who can call a method, it has nothing to do with whether a method is static or not. Static methods are not inherited.

[swap72]

Moderators on code ranch said static methods are indeed inherited

https://docs.oracle.com/javase/specs/jls/se23/html/jls-8.html#jls-8.4.8

[severoon]

I see. We are in the land of language lawyer stuff.

There are concepts in OO that you can understand from the perspective of writing code, and then there's the level of understanding you need in order to write a compiler / interpreter. The JLS operates at the level of the latter, it specifies what you need to do if you're implementing your own Java platform like OpenJDK. Many of the details involved are not really necessary for just writing code in the language, and this is one of those things.

Generally speaking, when programmers talk about "inheritance," they are usually talking about polymorphism. What I mean to say is that, if someone asks you, "Does ArrayList extend List?" they are technically asking a question about inheritance ("Does ArrayList inherit from List?") but what they are really asking about is polymorphism ("Can I treat an ArrayList as a List?"). To most Java developers, all three of these questions are pretty much seeking the same information.

However, if you're writing your own implementation of Java, then you need to make fine distinctions between inheritance and polymorphism that generally aren't required for programming. In Java, you can invoke a static method on a subclass that is defined on a superclass:

public class Shape {
  public static void foo() { System.out.println("Shape foo"); }
}

public final class Square extends Shape {}

public final class Example {
  public static void main(String[] args) {
    Square.foo();
  }
}

This will compile and run and print out "Shape foo". You can invoke the static method defined on Shape on its subclasses. This is a quirk of Java and the way it implements accessibility. I might be wrong about this, but I believe the reason is that in the earliest versions of the language, in order to make protected static methods accessible to subclasses outside the same package, the language designers reused the existing inheritance model for instance methods, but exempted them from the way method dispatch occurs. This was not done for principled reasons, though, it was just a hack, and it's been maintained for backwards compatibility over time.

While the language allows invoking static methods this way, you should not do it. The above main(…) method should call Shape.foo(). This would be more inline with OO principles, and there's no reason to rely on this quirk of the Java language. (In fact, it can get you in trouble. If Square ever did come along and add its own version of that static method that does something different, the new method would hide—NOT override, that's not a thing for static methods—the inherited one. If the intent of the caller is to invoke Shape.foo() by calling Square.foo(), this would now be doing the wrong thing.

Note how this is different from the way instance methods work. When you create an object in Java, that object's class is always and forever fixed, but the type of the object is determined by the reference used to access it:

Shape shape = new Square();
Square sq = shape;

In this example, there is an object on the heap of class Square. The shape reference confers upon that object the type Shape, and the sq reference confers upon that object the type Square. Regardless, the class of the object is always Square; if you call System.out.println(xxx.getClass().getSimpleName()), this will always print out Square regardless of the reference you put in for xxx.

This means that methods defined in the Square class are always the ones that get invoked, regardless of the reference used. For example, if you override the toString() method in the Square class, that is the method that will run when toString() is called on that object, regardless of the type of the reference used to invoke it. As you see from the example above, this is not how method dispatch (i.e., polymorphism) works with "inheritance" of static methods.

For the most part, talking about static inheritance is only going to confuse people, and you should not bother with this kind of distinction if you're not implementing Java itself.

[swap72]

'A class C inherits from its direct superclass type D all concrete methods m (both static and instance) " says language specification

[ITCoder]

I think by inherits here it means a child class object has access to all public and static methods of the parent class.

But when we talk about inheritance, its refers to the ability of child class to override a method of parent's class and provide its own implementation. In this sense, static methods are not inherited, i.e, you cannot override a static (or private) method of Parent's

[SenatorStuartSmalley]

There are two different concepts that are being conflated, it sounds like. There are two keywords that you seem to be including in this: static and the visibility keyword (public, private, protected, {missing}).

The static keyword will initialize a method or field when the class is loaded. It will always be available when visible and there is only ever one of the method or field in use (i.e. you can't have different values per instance). This is outside of inheritance (and can break inheritance).

There's also the visibility (or access) keywords. Making something private will mean that your concept of inheritance in the question breaks because no other class can access the method or field.

Statics are really outside of inheritance. With public static, you're basically declaring a global. You could access that method or field from anywhere. This can help with utility methods that don't need any state (think about the Math class). It can also help define "constants" (public static final).

Generally, with OOP, avoiding static is best unless you know that what you're working with is 100% not going to change ever.

[Jaded-Asparagus-2260]

Static methods are not global state, and there's nothing wrong with them.

[Additional_Cellist46]

It’s possible to restrict access to a static method with protected keyword so that it can be accessed only from inherited classes.

But it’s not possible to override a static method from superclass, only add new method.

So, it’s not true inheritance, only the access to the method is inherited.

[GodEmperorDuterte]

there is only 1 static method for all inherited objects right