Blinded by the lights

It’s good to remember that there are a few ways of defining the main() method in Java 5:

public static void main(String[] args) {}

or

public static void main(String args[]) {}

or

public static void main(String... args) {}

Sometimes, we don’t care and remeber of basic stuff, which can result in worse score on the exam

Overriding and overloading are common concepts of Java and occur often on SCJP exam. Although I know the rules that apply for them, I happen to think twice (or more) on questions dealing with them. Thus, it’s a good idea to keep the following rules in mind…

Overriding

• applies ONLY to inherited methods
• is related to polymorphism
• object type (NOT reference variable type) determines which overriden method will be used at runtime
• overriding method MUST have the same argument list (if not, it might be a case of overloading)
• overriding method MUST have the same return type; the exception is covariant return (used as of Java 5) which returns a type that is a subclass of what is returned by the overriden method
• overriding method MUST NOT have more restrictive access modifier, but MAY have less restrictive one
• overriding method MUST NOT throw new or broader checked exceptions, but MAY throw fewer or narrower checked exceptions or any unchecked exceptions
• abstract methods MUST be overridden
• final methods CANNOT be overridden
• static methods CANNOT be overridden
• constructors CANNOT be overridden

Overloading

• overloading can take place in the same class or in the subclass
• overloaded methods MUST have a different argument list
• overloaded methods MAY change the return type (in case argument list is different)
• overloaded methods MAY change the access modifier
• overloaded methods MAY throw new or broader checked excpetions
• reference type determines which overloaded method will be used at compile time
• constructors MAY be overloaded
• methods adjustment in connection with overloaded method’s arguments:
  • you cannot widen and then box (int -> Long)
  • you can box and then widen (int -> Object, via Integer)
  • you can combine var args with either widening (byte -> int) or boxing (int -> Integer):
    • widening is over boxing
    • widening is over var args
    • boxing is over var args

Finally, a few notes on polymorphism:

• a refenrence variable is of an unchangeable type, but can refer to a subtype object
• a single object can be referred to by reference variable of many differnet types (however, they MUST be the of same type or supertype of the object)
• reference type determines which method will be called

Also, keep that in mind:
Reference type determines which overloaded method is used at compile time.
Object type determines which overriden method is used at runtime.