Editing JavaLanguage (section)

====Overriding Methods====

A non-static method defined in a subclass with the same name and paramter list (signature) as a method in one of its ancestors classes overrides the method of the ancestor class from the subclass. Alle Methoden sind virtual. The access modifier of the overriding method must provide at least as much access as the overridden method, which seems a little bit strange. Overriden methods cannot be accessed outside of the class that overrides them.

A method with the same signature but different return types or a static method with a the same signature as one of one of the ancestor classes or a non-static method with the same signature as a static method of one of the ancestor classes generates a compiler error. 

If you have an object of class B which extends class A and which overrides f() it is impossible to call f() of A but in methods of B using super.f(). Finding the correct method is called overloading resolution. '''Final''' methods cannot be overriden. '''Abstract''' methods must be overriden.

Überschriebene '''synchronized''' Methoden erben diese Eigenschaft nicht automatisch, sondern müssen ebenfalls als synchronized deklariert werden. Allerdings bleibt die Basisklassen Methode weiterhin synchronisiert.

Static methods can not be declared in interfaces, cannot be declared abstract and cannot be overriden (but hidden).

 class Super {
   static String greeting() {
     return "goodnight";
   }
   String name() {
     return "Richard";
   }
 }
 
 class Sub extends Super {
   static String greeting() { // hidden
     return "hello";
   }
   String name() {            // override
     return "Dick";
   }
 }
 
 Super s = new Sub();
 System.out.println(s.greeting() + " " + s.name());  // prints out 'goodnight dick'


It’s no problem to ‘override’ private methods because in reality it is no overriding.