Thread: Inheritance - Object class

Hello,

The following code doesn't compile because it says "method area()" not found when called with the object reference "o". If every class in Java is a subclass of the Object class, why is this throwing an error?

package test;
  // Using abstract methods and classes.
abstract class Figure{
double dim1;
double dim2;
Figure(double a, double b) {
dim1 = a;
dim2 = b;
}
// area is now an abstract method
abstract double area();
}
class Rectangle extends Figure {
Rectangle(double a, double b) {
super(a, b);
}
// override area for rectangle
double area() {
System.out.println("Inside Area for Rectangle.");
return dim1 * dim2;
}
}
class AbstractDemo {
public static void main(String args[]) {
 
 
Object o = new Rectangle(10,5);
 
System.out.println("Area is " + o.area());
 
/* This is compiling
 
Figure f = new Rectangle (10,5);
System.out.println("Area is" + f.area()); */
 
 
}
}

area isn't a method of the Object class.

What does it even mean to take the area of an Object? What if that Object is a String?

The compiler has no way of knowing what type of object the variable o is going to contain. It could be rectangles, squares, strings, jframes, etc. So it does the only sensible thing it can do and that is throw a compiler error.

On the other hand, a Figure is defined to have an area method. That means every instance of a Figure or a subclass of Figure is guaranteed to implement area. It may not be implemented correctly, but it exists so it is perfectly valid syntax to try and call that method.

You're saying 2 things:

Object o

This declares a variable. It has a type Object. That means it can hold an instance of the Object class, or any class which extends the Object class.

o = new Rectangle()

This creates a new instance of the Rectangle class. The variable o refers to this instance. It is allowed to do so because Rectangle extends Object. However, you are only allowed to use this Rectangle instance is if it was an Object instance. This is known as polymorphism.

Why is this useful?

Take the following example:

Say you have three classes: Rectangle, Circle, and Triangle. Each class has an implementation of the area method. Now you want to be able to find the sum area of a given collection of Rectangles, Circles, and Triangles.

You could do this:

public static double sumArea(Rectangle[] rects, Circle[] circs, Triangle[] triags)
{
    double sum = 0;
    for(int i = 0; i < rects.length; ++i)
    {
        sum += rects[i].area();
    }
    for(int i = 0; i < circs.length; ++i)
    {
        sum += circs[i].area();
    }
    for(int i = 0; i < triags.length; ++i)
    {
        sum += triags[i].area();
    }
    return sum;
}

This works, but there are 2 big flaws:

1. What if you have a dozen or more different shapes? The amount of code even for 3 different shapes is already starting to get out of hand.

2. What if you decide at a later date that you want to add a Pentagon class? That means you'd have to go back through your other code and manually modify them to include code which handles pentagons.

The preferred method is to have a common base class/interface which each shape would implement. The base class needs to be able to do at least what your application requires. For example, say I had a Shape class:

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

I could then implement the sumArea method this way:

public static double sumArea(Shape[] shapes)
{
    double sum = 0;
    for(int i = 0; i < shapes.length; ++i)
    {
        sum += shapes[i].area();
    }
    return sum;
}

I think you're confusing the actual instances vs. variables.

All variables must have a type in Java. This is fixed and must be explicitly declaring it, a variable will always hold a value/instance of that type.

If I declare a variable r with type Rectangle, it can only hold rectangles. I can't do this:

Rectangle r = new Circle();

So the question is what variable type should you use if you have various shapes? You need a common base class that has all the features you need/want.

If you want an area method, this isn't in the Object class so you must define your own class which does have the area method defined. The Java compiler can't figure out at compile time what exact instance a variable will hold (if any), so it does the only thing it can do and that's give you a compiler error.

If all you need is a specific type, then there's no reason why you can declare a variable of that type directly.

Rectangle r = new Rectangle();
r.area();

This is used quite a lot and there's nothing wrong with it. Just be aware of the benefits you get from using polymorphism as I pointed out above.

How do you refer to a class instance? It's done using a variable. A variable must have exactly one type explicitly declared for as long as the variable exists.

So you want a variable that can refer to both circles and rectangles. How can you do that? You need to trace back the inheritance tree until you find a common class both share. If there is no common class it's impossible for any single variable to refer to either a rectangle or circle instance. Note that this isn't necessarily true for some other languages which allow dynamically typed variables. Java just isn't one of those languages.

Your textbook is simply referring to this as a "super-class reference variable" because it's type is that common base class. There's not much really special about it, the syntax is exactly the same as you would declare any other variable. The textbook is merely making a point to show that a variable can hold the type it is explicitly declared with as well as any sub-types.