how should i decide which class is responsible of object creation? - oop

Question

are there general rules, common pitfalls, about object creation responsability?
how should i decide who is responsible of object creation?
sometimes it is obvious, sometimes not, i'm trying to avoid redundant code and limit only to the minimum necessary.
what i should ask to myself when i have to decide where to write the creation method?
class State
{
...
public [City] getCapitalCity()
{
return new City(this.capitalCityID);
}
}
class City
{
...
public static [City] getCapitalOf(State s)
{
return new City(s.capitalCityID)
}
}
thank you in advance

Answer 1

A flaw of your first method is that it creates a new City object for every call. Something like that would be more natural to me:
class State
{
protected [City] capitalCity;
...
public [City] getCapitalCity()
{
if (this.capitalCity == null) {
this.capitalCity = City::getCapitalOf(this);
}
return this.capitalCity;
}
}
class City
{
...
public static [City] getCapitalOf(State s)
{
return new City(s.capitalCityID)
}
}
Note that I kept both methods in place but delegated one to the other. Another thing, which is still unsolved after this change, is that you won't be able to exchange the City object, i.e. for a mock in unit testing. The dependency is hard-wired.
Talking about design patterns, for a loosely coupled design the only classes that instantiate objects should be factories.
If we apply that here, it might look like that:
class CityFactory
{
...
public static [City] createCapitalFromState(State s)
{
return new City(s.capitalCityID);
}
}
class State
{
protected [City] capitalCity;
...
public [City] getCapitalCity()
{
if (this.capitalCity == null) {
this.capitalCity = CityFactory::getCapitalOf(this);
}
return this.capitalCity;
}
}
class City
{
....
}
For the sake of simplicity I kept the factory method static, in reality you would have access to some instance of CityFactory. And this could easily be exchanged to yield different objects.
what i should ask to myself when i have to decide where to write the creation method?
Two things:
do I introduce a new hard-wired dependency?
could I extract object creation to an own class?
One could think that two domain objects like City and State are not the best example for decoupling exercises because they obviously will always be used together, right?
But if you think about it, it's not too far-fetched: Maybe at some point you will subclass or decorate your Cities to distinguish certain differences in behaviour. With a City factory you will only have to change the creation of cities at one point if you ever want to change it. And this is an important goal in OOD: if you have to change something, it should not be necessary to change it all over the place, but only at one point.

Answer 2

I would probably say that it depends entirely on how your classes are going to be used. In this case, I'd opt for the State.getCapitalCity() since it's more likely that a developer's workflow would be to inquire what the capital city is of a state object they already have.
My class design would probably look similar to the following. That way, I can go back and forth between the two entities if need be.
class State
{
...
public City CapitalCity()
{
return new City(this.capitalCityId);
}
}
class City
{
...
public State State()
{
return new State(this.stateId);
}
public bool IsCapitalCity()
{
return this.isCapitalCity;
}
}