No Calrity on Multiple Inheritance Concept Of Java..!

Question

In SCJP Book by "karty serie " .
In Java
a subclass of class Object, (except of course class Object itself). In other words, every
class you'll ever use or ever write will inherit from class Object. You'll always have
an equals method, a clone method, notify, wait, and others, available to use.
Whenever you create a class, you automatically inherit all of class Object's methods.
A class cannot extend more than one class. That means one parent per class. A
class can have multiple ancestors, however, since class B could extend class A, and
class C could extend class B, and so on. So any given class might have multiple
classes up its inheritance tree, but that's not the same as saying a class directly
extends two classes.
class PlayerPiece extends GameShape, Animatable { // NO!
// more code
If the above code is invalid, is it legal to write the code like ...
class PlayerPiece extends GameShape, Object { // NO!
// more code
Thanks In Advance
Kiran

Answer 1

I think I can help straighten out what is confusing you.
Let's say you have a class B that extends class A, and a class C that extends class B.
Then class C implicitly extends class A, but java does not allow you to make that explicit.
So, yes, in a way, class C does subtype both class A and B, but it only directly subclasses class B. The subtyping of class A is implicit.
The following should demonstrate some patterns that should help clear things up:
class A { } 
// This automatically is a subclass of Object,
// you don't need to specify that.
// or
class A extends Object { } 
// This is legal, but not necessary, since a class
// that doesn't extend anything else implicitly extends Object
class B extends A { } 
// This directly subclasses class A,
// and implicitly subtypes Object
// but
class B extends A, Object { } 
// This is NOT legal in java, and will not compile,
// even though the previous code would
// make class B a subtype of Object
class C extends A { } 
// Again, a direct subclass of A,
// and indirect subclass of Object
class D extends B, C { } 
// This is NOT legal in java, and is what people
// usually mean when they say that multiple
// inheritance is prohibited.  In this case, you
// are attempting to subclass two different
// classes, where one is *not* a subtype of
// another.  There is no work around to make
// this happen in java, but you can use interfaces
// and composition to get a similar effect with a
// bit of glue code to hook things together.
// For example:
interface X {
  public void doX();
class XImpl implements X {
  public void doX() {
    // do something
interface Y {
  public void doY();
class YImpl implements Y {
  public void doY() {
    // do something else
class Z implements X, Y {
  private X x = new XImpl();
  private Y y = new YImpl();
  public void doX() {
    x.doX();
  public void doY() {
    y.doY();
// This is basically what goes on behind the scenes
// in languages like C++ that do support MI