0

I am having trouble understanding with some of the code snippets about this part of the Java tutorial: http://docs.oracle.com/javase/tutorial/java/IandI/interfaceAsType.html

public Object findLargest(Object object1, Object object2) {
   Relatable obj1 = (Relatable)object1;
   Relatable obj2 = (Relatable)object2;
   if ((obj1).isLargerThan(obj2) > 0)
      return object1;
   else 
      return object2;
}

and:

public interface Relatable {

    // this (object calling isLargerThan)
    // and other must be instances of 
    // the same class returns 1, 0, -1 
    // if this is greater than, 
    // equal to, or less than other
    public int isLargerThan(Relatable other);
}
  1. In the first example, why am I downcasting Object types into Relatable types? What happens if the first method doesn't include the first two statements?
  2. Let's say I wrote a Rectangle class that implements the Relatable interface and has the "findLargest" method. If I know that I'm comparing two Rectangle objects, why not just make the first method downcast the objects into Rectangles instead?
Improve this question

3 Answers 3

Reset to default
1

  1. You cast the Objects into Relatable types because otherwise you cannot use the methods declared in the Relatable interface. Since Object does not have the isLargerThan method, you would get a compiler error without casting.

    Honestly, in my opinion the findLargest method as shown here was not very well designed; a better illustration of the purpose of Interfaces would be to ask for Relatable objects as the parameters like so:

    public Object findLargest(Relatable object1, Relatable object2) { //implementation not shown to save space }

    This way, the user must pass Relatable objects, but they can pass any object whose class implements Relatable (such as Rectangle)

  2. "If I know that I'm comparing two Rectangle objects..."

    True, if you know that you are comparing two Rectangle objects, there is little use for an interface, but the purpose of interfaces is to allow you to create a generic "type" of object that can be used to define common features of several different classes.

    For example, what if you also had a Circle class and a Square class (both of which implemented Relatable)? In this case, you do not necessarily know the exact type of object you have, but you would know that it is Relatable, so it would be best to cast to type Relatable and use the isLargerThan method in a case like this.

Improve this answer
Sign up to request clarification or add additional context in comments.

1 Comment

Hmm, all the answers to this question were helpful and it's hard to pick one. I feel this one is the most detailed though so I'll accept this one, thanks!
0

Interfaces define a set of methods which every class which the interface implements has to implement. The downcast is necessary to get access to these methods.

You don't know if you are comparing rectangles with this interface. You could get any Relatble passed. This is one of the cases generics come in handy.

Improve this answer

Comments

0

1.In the first example, why am I down casting Object types into Relatable types? What happens if the first method doesn't include the first two statements?

Answer
Every object has some basic functionality and you want a specific object write now. You are down casting your object into a "Relatable" so you can use the "isLargerThan" method(an object wont have it since it has only basic common stuff). If you didn't down cast, you would not pass compilation.

2.Let's say I wrote a Rectangle class that implements the Relatable interface and has the "findLargest" method. If I know that I'm comparing two Rectangle objects, why not just make the first method downcast the objects into Rectangles instead?

Answer
Since you want to create something generic. Lets say you have a Student and a Driver. Both of them are People. You can create an interface called IPeople and make both the Student and the driver implement it. IPeople will have a method called "getAge()" that each of them will implement. IPeople will have all the functionality that you need for "People". That's how you create cross object functionality under the "same hat".

Improve this answer

1 Comment

It is downcasting. The cast is from a supertype down to a subtype.