Java：关于如何从基类继承工厂方法的最佳实践

Question

I'm creating a set of classes to represent various data in a legacy database. Instead of using exceptions inside constructors to signal error conditions I've decided to employ factory methods to create my various objects. However, I'm trying to figure out how best to reuse some of these factories when inheriting from those classes. I'm looking for a conceptual explanation (ie: best practices state that you should do ...) not so much an actual code example (although code examples are always welcome).

For example, let's say I have a class called User with a createUser factory method. I also have another class called Employee that extends the User class. How can I reuse (ie: call) all the code in the createUser method from the createEmployee method so that it populates all of the Employees fields that are inherited from the User class?

An obvious "work around" would be to change the Employee class to have a User class instead of extending it, but that doesn't mesh with normal OO principles.

Answer 1

You can have an additional initializeUser(User user) method, which fills all fields. createUser creates a new User and calls initializeUser with it. createEmployer creates a new Employer and calls initializeEmployer which calls initializeUser and then adds its Employer stuff.

To make it invisible to the outside user, declare both initalize methods protected so they're only visible inside the package. Another design would be to have an own factory class which holds all create and initialize methods.

Answer 2

Try to find the best way to model the problem you are doing, and don't get hung up on labeling what you are doing.

For example, you want to have two classes, User and Employee, and Employee extends User.

In some class you have getUser and getEmployee.

In getEmployee you instantiate Employee, then just populate the values for the user. Here is where I think you are getting stuck on labels.

I would have a DAO (Data Access Object) class, where I put in the logic to actually go to the database. So, I have a UserDAO and EmployeeDAO.

UserDAO only knows how to populate the User object and the same with EmployeeDAO, so EmployeeDAO does something like this:

Employee getEmployee(String id) {
  Employee emp = new Employee();
  User u = UserDAO.getUser(id);
  // either populate values or pass in the Employee since it can be a User class, to be populated.
  // get employee values
  return emp;
}

The code snippet helps me organize my thoughts. So, you can then either pass in the Employee instantiation and have it be populated from User or you would just copy the values over yourself.

But, this keeps the logic separated and allows you to have a more flexible design.

Answer 3

The way I would do that kind of thing would be something like this. I would create a polymorphic init() method for User and all the specialized subclasses of it, where necessary (for example, your Employee's init() method would only need to call the super-method). Then I'd create a separate Factory class that spits out an instance of User (the base class), be it a User or Employee or whatever. Inside its createInstance(insert params here) method, I'd create a User or Employee or your specialized instance depending on a parameter, then call the init() method for that instance you've just built. That way, you're separating the construction phase from the initialization (since every class should theoretically be able to do its own cooking at init()) and you could inherit the legacy initialization at the instance creation time if that's what you want.

Some code example:

class User() {
    //... your fields and constructor here

    public void init() {
       //... do your User init here
    }
}

class Employee extends User {
    ...
    public void init() {
       super.init();
       // ... other init stuff if you want
    }
}

class UserFactory{
    // ...

    public User createInstance(UserType type, String name, ...) {
        User user;
        switch (type) {
            case UserType.EMPLOYEE: user = new Employee(name,...);
        //... your other cases here
        }

        // the important part
        user.init();
        return user;
    }
}