I'm coming to RoR from 7 years of Java/J2EE development
You probably have more experience with this kind of thing than I do than. Take my suggestions with a grain of salt.
Typing is a problem in any language, but I think in this case it is safe to say that a BillingAddress "is-a" Address, and thus a candidate for an inheritance relationship.
What makes it a billing address however? That is dependent upon how it relates to other objects. Let's see if I can make it clearer with another example:
Sister is a Female, Female is a Human. You could do Human > Female > Sister subclassing. The Female subclass I would say is okay because Female is a constant state of the object - it never changes. However, Sister I would say is a bad subclass because it is dependent upon the relationship. She may be a Sister when compared to other siblings, but she may also be a Mother, Daughter, Aunt, etc when compared to others.
However, to extend the example further, I would say the Sister subclass is okay if your application only covers the scope of siblings. You could say the same thing with your application. If you never want a Billing address to also be a Street/Mailing address, and if you never need to change the type of the address, then subclassing may be the right approach.
In either case, it sounds odd to me to say that a person belongs to an address rather than the other way around.
Sometimes the has_many/belongs_to wording doesn't make sense, but don't let that stop you from making a good relationship. All "belongs_to" means is that the foreign key is in that table. It doesn't really mean the model "belongs to" the other model. Most of the time it works, but some cases like this it doesn't make as much sense, but it doesn't make the relationship any less correct.
Assuming I took the "person belongs-to address" approach, wouldn't that require explicit management of the person-address relationship rather than simply relying on active record? For example, I would have to destroy each of the addresses when a person is destroyed rather than just calling person.destroy, correct?
Hmm, destroying may be difficult to do. You can set up a has_many association in the Address model with a :dependent option, however, since it is a polymorphic association I don't know how well that will work. I would need to do some tests if I were to try that.
Or maybe I'm not understanding your example code correctly? Isn't the relationship being defined twice here? Once with has_many and once with belongs_to?
Correct, the relationship is defined twice, but in different contexts. In the has_many you are just defining which addresses that person has. In the belongs_to relationship you are defining which of those addresses you want to mail to.
From an interface perspective, you could have a list of a person's addresses with a radio button next to each one. Here the user can select which address he wants to be the mailing address. This can be done very easily by setting the id of the selected address as the mailing_address_id. If you do subclasses you would have to juggle around changing the type of the Address and handling errors of setting multiple addresses as the mailing address.
- Free Ruby on Rails Screencasts