Looking for clarification on this: Object1 extends Object2<Object3>

[Tom Landry]

The extends is not an issue.
The question really pertains to Object3 in the brackets.
Is this a way to have Object2 extend Object3 since multiple inheritances can't be done?

public class Object1 extends Object2<Object3>.....

Any insight on what the above declaration implies???

[manish ghildiyal]

Just like you do
public class Object1 extends Object2

you simply need to do
public class Object2 extends Object3

Manish

[Jayesh A Lalwani]

First of all, Objects don't inherit other objects. Classes inherit classes

Secondly, I think I'm not following your question. Do you mean whether you can have

class A extends B<C> {
....
}

class B<T> extends C {
...
}

Yes, nothing in Java will stop you from doing that. However, I don't know why you would do that.

It's much more common to do this with interfaces when you build a Proxy pattern

interface MyInterface {
   void foo();
}

class MyClass implements MyInterface {
     void foo() {
         // do whatever you want to do
     }
}

abstract class Proxy<T extends MyInterface> extends MyInterface {
    final T delegate;
    Proxy(T delegate) {
          this.delegate = delegate;
     }
    void foo() {
       doBefore();
       delegate.foo();
       doAfter();
    }
   abstract  void doBefore();
   abstract  void doAfter();
}

Here MyInterface is the interface, and MyClass implements an interface. Proxy class wraps an object of type MyInterface(called delegate), and also extends MyInterface. When you call the method on the proxy, it calls doBefore, then the method on the delegate then do After. THis allows you to "inject" behavior by extending Proxy

class MyClassLoggingProxy extends Proxy<MyInterface> {
    void doBefore() {
         // log a before message
     }
    void doAfter() {
         // log a after message
     }
}

MyInterface a = new MyClassLoggingProxy(new MyClass());

This kind of design is very common

[Tom Landry]

Yes, you are correct in that what is listed as Object3 is an interface.

public class A extends TableRowSorter<TableModel>......

[Jayesh A Lalwani]

Yes you are probably seeing an implementation of either a Proxy pattern, or a decorator pattern. Both patterns are very common

[Winston Gutkowski]

Tom Landry wrote:Yes, you are correct in that what is listed as Object3 is an interface.
public class A extends TableRowSorter<TableModel>......

But there's absolutely nothing to stop you doing it for something more specific if you want, eg:
public class BitMap extends HashMap<Integer, Boolean> { ...

(purely for illustration, you understand; I'm not sure it's the best idea )

Jayesh's example is simply a common pattern.

Winston