Quick Look Up for Inheritance in Java
Encapsulation, IS-A, HAS-A
❑ The goal of encapsulation is to hide implementation behind an interface
❑ Encapsulated code has two features:
❑ Instance variables are kept protected (usually with the private modifier).
❑ Getter and setter methods provide access to instance variables.
❑ IS-A refers to inheritance.
❑ IS-A is expressed with the keyword extends.
❑ “IS-A,” “inherits from,” “is derived from,” and “is a subtype of” are all equivalent expressions.
❑ HAS-A means an instance of one class “has a” reference to an instance of another class.
Overriding and Overloading
❑ Methods can be overridden or overloaded; constructors can be overloaded but not overridden.
❑ Abstract methods must be overridden by the first concrete (nonabstract) subclass.
❑ With respect to the method it overrides, the overriding method
❑ Must have the same argument list
❑ Must have the same return type
❑ Must not have a more restrictive access modifier
❑ May have a less restrictive access modifier
❑ Must not throw new or broader checked exceptions
❑ May throw fewer or narrower checked exceptions, or any unchecked exception
❑ Final methods cannot be overridden.
❑ Only inherited methods may be overridden.
❑ A subclass uses super.overriddenMethodName to call the superclass version of an overridden method.
❑ Overloading means reusing the same method name, but with different arguments.
❑ Overloaded methods
❑ Must have different argument lists
❑ May have different return types, as long as the argument lists are also different
❑ May have different access modifiers
❑ May throw different exceptions
❑ Methods from a superclass can be overloaded in a subclass.
❑ Polymorphism applies to overriding, not to overloading
❑ Object type determines which overridden method is used at runtime.
❑ Reference type determines which overloaded method will be used at compile time.
Instantiation and Constructors
❑ Objects are constructed:
❑ You cannot create a new object without invoking a constructor.
❑ Each superclass in an object’s inheritance tree will have a constructor called.
❑ Every class, even abstract classes, has at least one constructor.
❑ Constructors must have the same name as the class.
❑ Constructors do not have a return type. If there is a return type, then it is simply a method with the same name as the class, and not a constructor.
❑ Constructor execution occurs as follows:
❑ The constructor calls its superclass constructor, which calls its superclass constructor, and so on all the way up to the Object constructor.
❑ The Object constructor executes and then returns to the calling constructor, which runs to completion and then returns to its calling constructor, and so on back down to the completion of the constructor of the actual instance being created.
❑ Constructors can use any access modifier (even private!).
❑ The compiler will create a default constructor if you don’t create any constructors in your class.
❑ The default constructor is a no-arg constructor with a no-arg call to super().
❑ The first statement of every constructor must be a call to either this()
(an overloaded constructor) or super().
❑ The compiler will add a call to super() if you do not, unless you have already put in a call to this().
❑ Instance methods and variables are only accessible after the super constructor runs.
❑ Abstract classes have constructors that are called when a concrete subclass is instantiated.
❑ Interfaces do not have constructors.
❑ If your superclass does not have a no-arg constructor, you must create a constructor and insert a call to super() with arguments matching those of the superclass constructor.
❑ Constructors are never inherited, thus they cannot be overridden.
❑ A constructor can be directly invoked only by another constructor (using a call to super() or this()).
❑ Issues with calls to this():
❑ May appear only as the first statement in a constructor.
❑ The argument list determines which overloaded constructor is called.
❑ Constructors can call constructors can call constructors, and so on, but sooner or later one of them better call super() or the stack will explode.
❑ this() and super() cannot be in the same constructor. You can have one or the other, but never both.
❑ Overloaded methods can change return types; overridden methods cannot.
❑ Object reference return types can accept null as a return value.
❑ An array is a legal return type, both to declare and return as a value.
❑ For methods with primitive return types, any value that can be implicitly converted to the return type can be returned.
❑ Nothing can be returned from a void, but you can return nothing. You’re allowed to simply say return, in any method with a void return type, to bust out of a method early. But you can’t return nothing from a method with a non-void return type.
❑ For methods with an object reference return type, a subclass of that type can be returned.
❑ For methods with an interface return type, any implementer of that interface can be returned.