We are designing software for a car dealer. We design an Inventory class that uses a LinkedList to keep track of all cars on the lot. Each car is represented by an object instance of particular class designed for that car. However, when we design the software we do not know what car will arrive in the future, thus we cannot use conditional statements to create an object for a particular class. Instead, we decide to use the Reflection API to create an object.
The addCar method takes in two parameters: String carName - represents the name of the car and the name of class that is designed for that particular car; Object initArgs- initial arguments to be passed to the constructor of the car class. The initArgs objects are in the same order as the parameters in the constructor.
Below is a fragment of code from method addCar.
Class carClass = Class.forName(carName);
Class initClassArgs= new Class[initArgs.length];
Constructor carConstructor =
Car newCar = (Car)carConstructor.newInstance(initArgs);
First, we obtain a Class object for the car we want to create. This Class object allows us to access metadata for that particular car class. Using the forName method we get Class object for the class with the name same as carName. We then want to find a constructor for the particular carName class. To obtain the constructor, we need to match the initArgs to parameters of the constructor. We thus create an array of Class that has Class objects for each object of initArgs. Using the getConstructor method, we try to match the constructor to the arguments in intiArgs. (We could pass in null to obtain the constructor without any parameters.) Once we have the constructor, we can create a new instance of that class by the newInstance(Object) method where we pass the arguments we received in the initArgs.
When we write the code, we do not know what cars are available. Using Reflection we can create instance of classes (to represent the cars) that might be written after the code for addCar is written. Dynamically loading classes using Reflection allows for better code because we need not alter the code every time a new class is introduced. This allows our program to be more versatile in that as changes are made in the future, the code does not need to be updated, it adapts to certain changes as result of use of Reflection.
Source Code (Inventory.java) Source Code (Accord.java) Source Code (Car.java)