Equivalent to [i]this[/i] and [i]getClass()[/i] inside a static method

Question

All business objects of my application (Customer, Car, etc.) extend a root class (RootObject) which performs retrieving operations. Such operations are delegated to a static Loader that calls the respective method according to the type of the business object (loadAllCustomers for Customers, loadAllCars for Cars, etc). The problem is that I am unable to know which class is calling RootObject.loadAll() (a Customer or a Car) because both this and getClass() cannot be used inside static methods.
So, my question is : how can I determine which class is extending RootObject from inside its static loadAll() method ? It is either a Customer or a Car, but I cannot figure out how to get such information.
public class Customer extends RootObject { /*...*/ }
public class Car extends RootObject { /*...*/ }
public class RootObject {
  protected static Loader loader = new Loader();
  public static RootObject[] loadAll() {
    return loader.loadAll(getClass());  // does not compile
public class Loader {
  public RootObject[] loadAll(Class classe) {
    if (classe == Customer.class) return loadAllCustomers();
    if (classe == Car.class) return loadAllCars();
    return null;
public static void main(String args[]) {
  Car cars[] = (Car[]) Car.loadAll();
  System.out.println("number of cars = " + cars.length);
}Thank you.

Answer 1

Thank you guys.
We are trying to simulate an object-oriented database
on top of a relational one (or a file, or whatever).Sounds like you really want ORM, like Hibernate or TopLink.
Then, to retrieve a given car, we could be able to do
Car car = new Car();
car.setId("C1");
car.load();Instead, to retrieve a list of cars, I think it is
more intuitive to use a class method instead of an
instance one because we'll return a list, not a
single object :
Car cars[] = (Car[]) Car.loadAll();instead of
Car car = new Car();
Car cars[] = (Car[]) car.loadAll();  // a little odd,
isn't it ?Then, it is a design choice to make loadAll()
a static method.Sounds to me like you're trying to create objects that know how to persist themselves. That's one way to do it.
Another would be to separate the persistence code into a separate, interface-based class called a Data Access Object (DAO) or Repository that would handle this for you:
public interface CarRepository
    List<Car> find();
    Car find(Long id);
    void save(Car c);
    void update(Car c);
    delete(Car c);
}Now you can have different implementations for this interface, depending on how to wanted to tackle persistence. If it happens to be relational, all the SQL code is hidden from clients in the interface implementation.
%