是否可以创建一个“超级”变量，然后将其更改为子 class 类型并能够访问子类方法

Question

What I would like is to be able to create a variable with the superclass and then 'turn' it into the subclass later & be able to access the subClasses methods. It will always be defined to a subclass I just don't know which when defining.

class SuperClass {
  //superclass methods
}

class SubClass1 extends SuperClass {
  void subClass1method() {
    //do something
  }
}

class SubClass2 extends SuperClass {
  void subClass2method() {
    //do something different
  }
}

class Main {
  public static void main ( String [] args ) {
    SuperClass a;

    if (*some reson to be SubClass1*) {
      a = new SubClass1();
      a.subClass1Method();     //this is undefined it says
      //a instanceof SubClass1 returns true which is what confused me
    } else {
      a = new SubClass2();
      a.subClass2Method();     //this is undefined it says
    }
  }
}

I am not asking why it does this but the correct way to work around it & get the results I want.

I have looked for duplicates but could have easily missed one so please let me know.

Answer 1

When you don't have control of the source then there's not too much you can do besides casting (or possibly using adapters). If instanceof and casting sound familiar from your lessons then that's probably what your prof is expecting.

Here are some of your options:

// to execute those subclass specific methods without casting..
public static void main ( String [] args ) {
    SuperClass superClass;
    if (true /*some reson to be SubClass1*/) {
        SubClass1 subClass1 = new SubClass1();
        subClass1.subClass1Method();
        superClass = subClass1;
    } else {
        SubClass2 subClass2 = new SubClass2();
        subClass2.subClass2Method();
        superClass = subClass2;
    }
    // ... ...
}

// using instanceof and casting
public static void main ( String [] args ) {
    SuperClass superClass;
    if (true /*some reson to be SubClass1*/) {
        superClass = new SubClass1();
    } else {
        superClass = new SubClass2();
    }

    // ... ... ...

    if(superClass instanceof SubClass1) {
        ((SubClass1) superClass).subClass1Method();
    } else if(superClass instanceof SubClass2) {
        ((SubClass2) superClass).subClass2Method();
    }
}

---

Below is my recommendation to achieve this goal when you have control of the source..

Rather than a new class for different behaviors you could just use composition to provide different behaviors to the one class. Note that this is especially convenient if you understand Functional Interfaces and Method References.

public class SuperClass {
    private MyBehavior behavior;

    public void setBehavior(MyBehavior behavior) { this.behavior = behavior; }

    public void doBehavior() { this.behavior.doBehavior(); }
}

public interface MyBehavior { public void doBehavior(); }

public class MyGoodBehavior implements MyBehavior {
    @Override public void doBehavior() { System.out.print("good behavior"); }
}

public class MyBadBehavior implements MyBehavior {
    @Override public void doBehavior() { System.out.print("bad behavior"); }
}

public static void main(String[] args) {
    SuperClass a = new SuperClass();
    a.setBehavior(new MyBadBehavior());
    
    a.doBehavior();
}

Answer 2

It's simple. If you define "a" of class "SuperClass" you can only access "SuperClass" methods. Eventually you could add abstract methods "subClass1method" and "subClass2method" to "SuperClass" and implement them in the subclasses.

Answer 3

When you do SuperClass a you tell the compiler that you intend to store objects of type SuperClass in the variable a . It means that you can store subclasses of SuperClass as well, but the compiler only sees a as an object of type SuperClass , regardless if you are storing a sub type.

At runtime there's no check for this, if you manage to write code that calls methods from a subclass on a , they will be called. If a is not of that particular sub class and don't implement the called method, an exception would be thrown.

But how do you force the compiler to accept that a is of the subclass type? Casting. You cast a to the subclass, then you can access methods from subclass on a . If it´s not even possible to cast an object to a subclass, you get an error at compile time.

Change your Main class to the following and it should do what you want:

class Main {
  public static void main ( String [] args ) {
    SuperClass a;

    if (*some reson to be SubClass1*) {
      a = new SubClass1();
      ((SubClass1)a).subClass1Method();     // Casting 'a' as SubClass1
    } else {
      a = new SubClass2();
      ((SubClass2)a).subClass2Method();     // Casting 'a' as SubClass2
    }
  }
}

A few examples of when casting work and don't work at compile time and runtime:

class SuperClass { }

class SubClass1 extends SuperClass { }

class SubClass2 extends SuperClass { }

class Main {
  public static void main(String... args) {
    SuperClass a;
    SubClass1 b;
    SubClass2 c;

    b = new SubClass1();
    a = b;  // autocast to SuperClass

    a = new SubClass1();
    b = a;  // Compile error
    b = (SubClass1) a;  // explicit cast

    c = new SubClass2();

    method(b);   // works
    method(c);   // compiles, but will throw exception at runtime inside method
  }

  private static void method(SuperClass object) {
    SubClass1 b = (SubClass1) object;  // allowed by compiler but will throw exception at runtime in the second call, method(c)
  }
}