- subclass inherits from superclass by using keyword extends
- Ex: public class subclass extends superclass {}
- A subclass inherits all public instance variables and methods of superclass, but does not inherit the private instance variables and methods
- A nonpublic class can only be inherited by classes from the same package
- Inherited methods can be overridden. The method cannot be overridden if it’s marked with final modifier
- To invoke the superclass version of a method from a subclass that’s overridden the method, use the super keyword
- Ex: super.method()
- superclass obj = new subclass() //The left is called reference type. The right is called object type
- With polymorphism, the reference type can be a superclass of the actual object type.
- obj.method() // If method is overridden in subclass, then method of subclass is called though the reference type is superclass
- Besides assignment, we can also have polymorphic arguments and return types.
- Rules for overriding
- Arguments must be the same types and return types must be compatible.
- The method can’t be less accessible.
- Overloading vs overriding
- Overloading is having two methods with the same name but different argument lists
- The return types can be different
- You can’t change only the return type
- You can vary the access levels in any direction
- The main reason for abstract class is that some classes just should not be instantiated
- Ex: abstract public class superClass{}
- The abstract method means the method must be overridden.
- Ex: public abstract void method(); // There is no body for abstract method
- Abstract class can contain both abstract and non-abstract methods
- The first concrete class in the inheritance tree must implement all abstract methods
- You cannot make a new instance of an abstract type, but you can make an array object declared to hold that type
- Ex:
- superClass obj = new superClass() // illegal
- superClass[] objs = new superClass[5] // legal, each element inside objs can be either superClass or subClass
- You can call a method on an object reference only if the class of the reference type actually has the method
- Ex:
- public class subClass extends superClass{}
- There is a method METHOD which is only defined in subClass
- superClass obj = new subClass()
- obj.METHOD() // illegal, cannot pass compiler
- The way to workaround is:
- obj_cast = (subClass) obj
- obj_cast.METHOD() //legal
- The compiler decides whether you can call a method based on the reference type, not the actual object type. The method you are calling on a reference must be in the class of that reference type. Doesn’t matter what the actual object is.
- If a class contains abstract methods, the class must be declared as abstract
- Every class in Java extends class Object
- A Java interface is like a 100% pure abstract class
- To define an interface
- public interface intClass{}
- To implement an interface
- public class subClass extends superClass implements intClass{}
- Interface methods are implicitly public and abstract, so typing ‘public’ and ‘abstract’ is optional
- Benefits of interface
- If you use interfaces instead of concrete subclasses as arguments and return types, you can pass anything that implements that interface
- A class can implement multiple interfaces
- A class that implements an interface must implement all the methods of the interface, since all interface methods are implicitly public and abstract
