Class Design for Transformers

Question

Am sure that , everyone will be aware of the Transformers ( Optimus Prime , Megatron etc).

Am trying to represent that in the form of classes and interface. For now, am not considering the attributes. Am just taking some functionalities.

My Design is

interface Car{
 public void run();
 public void stop();
}

interface Robot{
 public void walk();
 public void fight();
}

class Transformer implements Car, Robot {
 // implementing all the methods
}

So the class Transformer says, it can perform both Car and Robot operations

During instantiation

Robot R = new Transformer(); // Now the transformer is in Robot format
Car C = new Transformer();  // Now the transformer is in Car format

My Question is ,here two objects that are getting created Robot R and Car C. So, this convey the Robot is getting created and Car is getting created . But what I want is The Car is Getting Transformed to A Robot and Vice Versa

How to implement this in design.

Answer 1

As I understand it, you want the Transformer class to have either Robot functionality OR Car functionality but not both at the same time.

To model that, I would favor Composition over Inheritance.

e.g.:

class Transformer {

private Car car;
private Robot robot;
private Class currentState = Car.class;

 public void fight() {
   if (currentState.equals(Robot.class)
      robot.fight();
   }

 public void drive() {
  if (currentState.equals(Car.class)
      car.drive();
  }

 public void transform() {
  if (currentState.equals(Car.class) 
      currentState = Robot.class;
  else
      currentState = Car.class;
}

To instantiate a new Transformer, you would need to define its Car-Form and its Robot-Form, e.g.:

new Transformer(new OptimusPrimeRobot(), new GiantTruck());

with the Constructor:

Transformer(Robot r, Car c) {
   this.robot = r;
   this.car = c;
}

with OptimusPrimeRobot implementing Robot and GiantTruck implementing Car.

If you want, you can even lazy initialize your contained classes. Define fields:

Class carClass;
Class robotClass;

and a Constructor:

Transformer(Class robotC, Class carC) {
   this.robotClass = robotC;
   this.carClass = carC;
}

Then make getter Methods for Robot and Car:

private Robot getRobot() {
  if(robot == null) {
     robot = robotClass.newInstance();
  }
  return robot;
}

and adjust your code, so it uses the Getters instead of the fields:

   getRobot().fight();

Now you just specify what Classes your Transformer consists of and their objects are only instantiated when needed.