Can inner classes be overidden ?

[faisal usmani]

Hi,

Can we override an inner class in a derived class ?

thanx in advance.

[Ernest Friedman-Hill]

No, classes can never be "overridden". You can extend a class, including an inner class. But if a class is constructed by name in a piece of code, there's no way to make that code use some other class (which is the situation I expect you're facing.)

The way to fix this kind of problem is to move the constructor calls in the base class into a sort of "factory method", and then override the factory method in the subclass; i.e., if you have something like this:

class Outer {
  class Inner {
  }
 
  public void foo() {
    Inner in = new Inner();
    // Do something with in
  }
}

then change it to this:

class Outer {
  class Inner {
  }
  
  Inner makeInner() {
    return new Inner();
  }
  public void foo() {
    Inner in = makeInner();
    // Do something with in
  }
}

Now in a subclass, you can say

class Subclass extends Outer {
  class SubclassInnner extends Inner {
  }
  public Inner makeInner() {
    return new SubclassInner();
  } 
}

Now Subclass.foo() will use an instance of SubclassInner, not Inner itself.
[ April 24, 2006: Message edited by: Ernest Friedman-Hill ]

[Ilja Preuss]

What would it *mean* to override an inner class?

[faisal usmani]

sorry Ilja for asking stupid questions :roll: . Thanx to Ernest.


One last thing is it possible to extend an inner class in a derive class directly.

There is no duty more obligatory than the repayment of kindness.
[ April 24, 2006: Message edited by: faisal usmani ]

[Paul Clapham]

If the inner class is public then you can certainly write

public class Something extends Outer.Inner { ...

[faisal usmani]

Thanx Paul, but this code gives me error !!

______________________________________________________________________

class Outer
{
public class Inner
{
public void show()
{
System.out.println("Hello");
}
}
}

class INHERIT extends Outer.Inner
{
public static void main(String ar[])
{
System.out.println("Compiled");
}

}

[Jeff Albertson]

Inner needs an enclosing object to be constructed:

class Outer {
    private final String name;
 
    public Outer(String name) {
        this.name = name;
    }
 
    public class Inner {
        public String getName() {
            return name;
        }
 
        public void show(){
            System.out.println("Hello Inner, inside " + getName());
        }
    }
 
    public static class Inner2 {
        public void show2(){
            System.out.println("Hello Inner2");
        }
    }
}
 
class Inherit extends Outer.Inner {
    public Inherit(Outer outer) { //<-- this is the crucial thing
        outer.super();
    }
 
    public void show(){
        System.out.println("Hello Inherit, inside " + getName());
    }
}
 
class Inherit2 extends Outer.Inner2 {
    public void show2(){
            System.out.println("Hello Inherit2");
    }
}
 
public class Main {
    public static void main(String[] args) {
        Outer outer = new Outer("enclosing");
        Outer.Inner inner = new Inherit(outer);
        Outer.Inner2 inner2 = new Inherit2();
        inner.show();
        inner2.show2();
    }
}

I'm not recommending this as good coding style. Needing to subclass Inner is usually a sign that (1) Inner should be a full-fledged top-level class, or (less likely) (2) Inner should be subclassed but only within a subclass of Outer:

class ExtendsOuter extends Outer {
    public ExtendsOuter(String name) {
        super(name);
    }
 
    public class ExtendsInner extends Inner {
        public void show(){
             System.out.println("Howdy, inside " + getName());
        }
    }
}

[faisal usmani]

Thanx Jeff,







That best portion of a good man's life, His little, nameless, unremembered acts of kindness and of love. No act of kindness, no matter how small, is ever wasted