Powerbuilder and Java

Question

On a wider note I'm very surprised that Java hasn't catered for extending base classes and still be able to keep the inheritance chain. If I compare this with Powerbuilder for a second, their Foundation Classes all come with an empty extension object between all their pre-defined classes. This would be the same in Java as having:
Object
|
Object extension (empty)
|
Component (changed to have Object extension as ancestor)
|
Component extension (empty)
|
TextComponent (changed to have Component extension as ancestor)
|
etc, etc.
The reason I bring up the comparison is I was wondering if any Third Party Vendors have done a similar thing with Java, i.e. not just created a series of extension objects but INSERTED objects between the higher classes?
Is there such a thing to the best of anyone's knowledge or does everyone go down a route similar to the service one I've discussed above?

Answer 1

Well, for one thing, this wreak havoc on code code reusability. For example, if I create a program similar to Eclipse and allow plug in components, if you have altered the heirarchy of classes, how does that impact my code? Wht if we have both done this? Who wins?
I do agree that there is a real issue here. It's definitely a huge pain to have to extend every subclass of Component to add a little functionality. What's worse is that you can't even create a subinterface of a concrete class meaning that you can't create a MyComponent and have all your Components implement it.
I think Component should have been an interface. Other people disagree and I respect that but I think it really makes things difficult. Then all the current concrete classes would just implement these classes. Then each sub-class would implement a subinterface and use the decorator patter to get the effect you are after.
For example:
Component  <--- BasicComponent
   ^               ^       ^
   |               |       |
   |<--Label<--BasicLabel  |
   |                       |
Button <--------------BasicButtonNow you could create your own classes like so (or keep going with decorators):
MyButton extends BasicButton
    MyButton()
       super(new BasicComponent());
MyLabel extends BasicLabel
    MyLabel()
       super(new BasicComponent());
}Then down the road you want to implement a simple change in all Component behavior:
class MyComponent extends BasicComponent
   // blah blah blah
MyButton extends BasicButton
    MyButton()
       super(new MyComponent());
MyLabel extends BasicLabel
    MyLabel()
       super(new MyComponent());
}