Does somebody know,what diffrence between overide a method or to hide?

Question

Hi All!
Does somebody know,what diffrence between overide a method or to hide?
Thanks.

Answer 1

Static methods are class methods. This means you can
access them without having any existing instances of
the class (className.methodName()).True. Further, I would argue that the language designers made a mistake in allowing static methods to be accessed via variables, since it only seems to add confusion.
A static method (or any other method in fact) can be
overriden by a sub class as long as it's not declared
final in the superclass.Not true. A static method can be hidden by a subclass;Only instance methods can be overridden. If you disagree with this, please take time to read the link in one of my earlier posts, and look at the examples here:
http://java.sun.com/docs/books/jls/second_edition/html/classes.doc.html#39617
The difference between overriding and hiding can be demonstrated by the code below:
class Superclass {
  public void instanceMethod() {
    System.out.println("Superclass.instanceMethod");
  public static void classMethod() {
    System.out.println("Superclass.classMethod");
class Subclass extends Superclass {
  public void instanceMethod() {
    System.out.println("Subclass.instanceMethod");
  public static void classMethod() {
    System.out.println("Subclass.classMethod");
public class MainClass {
  public static void main(String[] argv) {
    Superclass x = new Subclass();
    x.instanceMethod();
    x.classMethod();
}The output is:
Subclass.instanceMethod
Superclass.classMethodThe instance method has been overriden and the class method has been hidden. The difference is:
When you override a method, you are effectively saying "use this implementation instead of the one in the superclass", and client code has no way of calling the superclass' implementation. The implementation has been replaced.
When you hide a method, the original implementation from the superclass can still be called by client code, via the superclass' class name, or a variable whose compile-time type is that of the superclass.