Java Inheritance on the fly

Question

Let ClassA represent an abstract class.

I'm wondering if it's possible to do something like this in Java:

public static abstract class ClassA {
    abstract void foo();
}

private ClassB extends ClassA a = new ClassA() {
     // define abstract methods here
     foo() { System.out.println("in anon!"); }

     // define OTHER variables here
     public int varB = 10;
}

// later... varB is not defined in ClassA, but it is in a.
// how can I access varB from a?
System.out.println(a.varB);

I want to make a special note: notice how I'm printing varB. Say varB was NOT defined in ClassA, only in the anonymous inner class.

I have a lot of abstract classes wherein I define their abstract methods on the fly when I create them. However, I would also like to treat these classes as their own type because sometimes I need to access variables from that class that are specific to that version of the object.

Is there a way of doing something similar to what I've shown above, or do I need to create a "ClassB" that extends from "ClassA" every time?

Is there some type of workaround?

Thanks

Answer 1

Try Java Anonymous inner classes. sample as below :

abstract class ClassA {  
 abstract void eat();  
}  
class TestAnonymousInner{  
 public static void main(String args[]){  
  ClassA p=new ClassA (){  
    void eat(){System.out.println("nice fruits");}  
  };  
  p.eat();  
}  
}  

EDIT:

As far as accessing the variable varA is concerned, you need to declare that variable in the Abstract class, as ClassA needs the information about the variable. Here we can treat object referred by p as the child class of ClassA which referred by its parent's reference, and hence parent does not have access to the methods and variable introduced in the child class( in this case the anonymous class ).

Answer 2

Would anonymous classes not suit your usecase?

public static void main(String[] args) {
    // Make an anonymous instance of A
    final A first = new A() {
        private final int i = 10;

        void foo() {
            System.out.println(i);
        }
    };

    // Make another anonymous instance of A
    final A second = new A() {
        private final String message = "Listen!";

        void foo() {
            System.out.println("Hey!");
            System.out.println(message);
        }
    };

    // They do their own unique things
    first.foo();
    second.foo();

    // Both have A as a super-type
    System.out.println(first instanceof A);
    System.out.println(second instanceof A);

    // But first and second are *not* A and therefore not the same class!
    final boolean isSameClass = first.getClass().equals(second.getClass());
    System.out.println(isSameClass);
  }

  static abstract class A {
     abstract void foo();
  }

The idea here is that when you make a new anonymous class, you're actually sub-typing the class you use for a single instance. This is part of the reason why double brace initializers are a bad idea!

EDIT: Accessing a variable that belongs solely to an anonymous class is not possible. However if you're okay with reflection, something like this could work:

try {
    final Field i = first.getClass().getDeclaredField("i");
    i.setAccessible(true);
    System.out.println(i.getInt(first));
} catch (NoSuchFieldException | IllegalAccessException e) {
    e.printStackTrace();
}

This is pretty messy and I wouldn't necessarily recommend it, but it does accomplish what you're setting out to do here.

Answer 3

You can define a new class locally in a method.

I have added a new class MixA int the method main. Just for sake of see how it works this class extends an abstract class ClassA and implements an interface AInterface but you don't need to do this, just extends or implement what you need.

So given the the class is defined you can at compile time find every method or public you add:

abstract class ClassA {
  abstract void doThis();
}

interface AInterface {
  public int getInternalValue();
}

public class TestAnonymousInner {
  public static void main(String args[])
  {

     class MixA extends ClassA implements AInterface {

      public int varB = 10;

      @Override
      public int getInternalValue()
      {
        return 0;
      }

      @Override
      void doThis()
      {
      }

    }

    MixA b = new MixA();    
    b.getInternalValue();
    b.doThis();

    System.out.println(b.varB);

  }
}