A quick introduction to Java concepts 3

[r035198x]

Overriding therefore allows you to use the same method name to refer to differently implemented methods. Here is an example using the famous shapes example.

 
class Shape { 
      public Shape() {
 
       }
       public double getArea() {
             return 5.0;
       }
}
 
class Circle extends Shape {
      double radius;
      public Circle(int radius) {
             this.radius = radius;
       }
      public double getArea() {
             return Math.PI * radius * radius;
      }
}
 
class Rectangle extends Shape {
      int length;
       int width;
      public Rectangle(int length, int width) {
             this.length = length;
             this.width = width;
       }
 
      public double getArea() {
              return length * width;
       }
}
 
 

Here the Rectangle and Circle classes both extend from Shape and override the useless public double getArea() method in the Shape class to provide more meaningful implementations unique to each of these classes.
Access modifiers for an overriding method can allow more, but not less, access than the overridden method. i.e., a protected instance method in the super class can be made public, but not private, in the subclass. Remember that private methods are not accessible in subclasses and therefore cannot be overridden. If you want to override a method but want to use the result calculated by the super class version of the method you are overriding, then simply call that super class method using the keyword super as follows:

public double getArea() {
     return 5 + super.getArea();
}
 

Here the getArea() method is being overridden but the value calculated from the direct super class is being used to come up with the new version of the overriding method.
That is pretty much all there is about overriding!
Do not confuse overloading and overriding. Overloading occurs between methods in the same class with the same name but different signatures while overriding occurs between methods in different classes with one being the subclass of the other and the methods must have the same signature and return type or covariant return types.

If class A extends class B then variables of type B can hold references to objects of type A but not vice versa. That's the English version of it, the java code version of it is:

 
class B{
}
class A extends B{
}
then
 

B bVariable = new B(); //obviously allowed
B bVariable = new A(); //also allowed
A aVariable = new A();
A aVariable = new B();//! incompatible types.
 
 

Hiding is not overriding

Hiding occurs when a static method in a class has the same signature and return type as one in that class' super class.

 
class B{
     public static void test() {
            System.out.println("test from b");
     }
}
class A extends B{
       public static void test() {
              System.out.println("test from a");
       }
}
public class Test{
       public static void main(String[] args) {
             B b = new B();
             B a = new A();
             b.test();
            a.test();
      }
}
 
 

Prints

 test from b
test from b (this is not a typing error)
 

The method test is static in B and so belongs to the class.
In the main method the two variables b and a share the same class, B, and so calling a class method on them calls the same method.

A a = new A();
a.test();
 

will print test from a because now the class type is A and inside A, the test method from B is now hidden (not overridden by the test in A).
The difference with instance methods becomes clear with

 
class B{
     public static void test() {
           System.out.println("test from b");
     }
     void testInst() {
           System.out.println("testInst from b");
     }
}
class A extends B{
        public static void test() {
              System.out.println("test from a");
        }
        void testInst() {
             System.out.println("testInst from a");
        }
}
public class ShapeTest{
           public static void main(String[] args) {
                 B b = new B();
                 B a = new A();
                 b.test();
                 a.test();
                 b.testInst();
                 a.testInst();
        }
}
 

Use: In one sentence, use overriding to achieve more particular implementations of methods inherited from super classes.

abstract keyword

A class can be declared abstract meaning that no objects can be created using that class.

 abstract class A {
}
A a = new A();//!compile time error.

You may be beginning to think that an abstract class is quite useless. That's only until inheritance comes in. You can inherit from an abstract class allowing you to create a class that can be instantiated. The idea of making a class abstract is that you have a general group which objects belong to but instantiating an object of the general group really does not make sense since every object belongs to a more particular group. This is the case with the shapes example. The class Shape should be made abstract because a shape can be identified more precisely that just by calling it a shape. So

abstract class Shape {
}
class Circle extends Shape {
}
 

is more meaningful.

Methods can be declared abstract as well in which case you don't provide the method body but leave that to inheriting subclasses. In the shapes example you know that
all shapes have a getArea method but cannot write any code for it because the implementation is different for each shape so declare the getArea() method in the shape class
because that's where it belongs (all shapes have a getArea method) but you leave it abstract because you don’t know how to write it yet.

abstract class Shape {
public abstract double getArea();
}
 

Note that no {} are used. Just the signature and the ; at the end.
If a class contains an abstract method then that class is implicitly abstract and must the declared abstract otherwise the compiler will complain.
If a class inherits from an abstract class, then that class must provide implementations of all the abstract methods in the super class otherwise that inheriting class must also be declared abstract.
These things are not at all abstract and you should try them out on the compiler to see the effects.

Interfaces

An interface is a reference type whose members can be classes, other interfaces, constants and abstract methods.
They differ from classes in that they have no implementation. This is obvious since all their methods are abstract. Therefore all interfaces are abstract but you should not
put the public modifier. All interface members are implicitly public. Basically an interface is a contract that classes can choose to sign. Classes sign this contract by implementing the interface using the implements keyword.
Here are two example interfaces

interface Shape {
double getArea();
}
interface Drawable {
void draw();
}
 

These interfaces each contain one method. If any class implements the Shape interface then it must provide an implementation of the getArea() method otherwise that class must be declared abstract.
It is really as simple as that. Implement or else you're abstract, that's the rules of the contract. The interface is the boss. All this is checked at compile time.
Interfaces can declare constants as well which become available in implementing classes. A class can implement any number of interfaces. You can use this to achieve some level of multiple inheritance in Java by implementing multiple interfaces and thus being able to characterize an object into multiple groups. Here is an example. We want to be able to say that a Circle is a Drawable object and also that a Circle is a Shape.
Extending the Shape class says that a Circle is a shape. Extending the Drawable class says a Circle is a Drawable object. But we can only inherit from one class at a time so we make one of them an interface, implement it and
extend the other or we make both of them interfaces and implement them. The decision is ours, however, interfaces do not really provide any code reuse because they don't contain any implementations so it's wiser to choose a method that allow us the best in terms of code reuse. What interfaces provide is polymorphism. One interface, multiple implementations. By defining the Drawable interface, for example, we can implement it differently in all the classes that choose to implement this interface. If we had one method in some class draws shapes, we would simply need to pass an interface variable and call its draw method.

 
 
class Painter {
void drawShape(Drawable d) {
d.draw();
}
}
 
 

Now we can create classes that extend Shape and implement Drawable. In these classes since we have implemented Drawable, we then provide customized implementations of the draw method. If we wish to draw any shape, we pass it to the Painter's drawShape method which calls the draw method for that particular shape. When we change the draw method for the Circle class, the Painter is not affected, neither is any of the other shapes. This is one of the main goals of OOP. To be able to create a design which minimizes effects of changes in parts of the system. The classes in the Java packages make unforgiving use of these principles to define classes that can be used in varied circumstances by programmers.