No.

No.  A better model for this might be:

Interface AorB{ ...}

public class ObjectA implements AorB{
   public AorB load() {

       // load the data into this.
       if (needB())
           return new ObjectB(this);
       else
           return this;
   }

   private boolean needB() {}
}

public class ObjectB implements AorB{
   private Object A a;

   ObjectB(ObjectA a)
   {
           this.a = a;
   }
}

This is, have ObjectB add behavior to an ObjectA by wrapping it, and express
their common behavior by interface implementation rather then inheritance.
The only drawback is that you might wind up writing a fair amount of
delegation code in ObjectB, e.g.

   foo(args) { return a.foo(args); }

Hi

You have a few options here:

1) Use the decorator pattern (also known as wrapper). This is basically
the solution Daniel proposed. This is most flexible approach. However,
you will need a fair about of delegation.

2) Use the factory pattern. This patterns seperates the creation from
behavior. See example:

interface MyObject { void foo(); }
class MyObjectA implements MyObject { void foo() { .. some behaviour ..
}
class MyObjectB implements MyObject { void foo() { .. some other
bevaiour .. }
class MyObject C extends MyObject A { void foo() { super.foo(); ...
some more stuff extending existing functionality .. }

class MyObjectFactory()
{
 MyObject createMyObject(.. some arguments? ..)
 {
    create the object
 }
}

Google "decorator pattern" and "factory pattern" for more details and
examples.

/mrj