There are countless ways to build objects. Here are a few.
Classic Constructors
Many class-based object oriented languages have
constructors that look suspiciously like methods. Unlike instance methods which operate on existing objects, though, these constructors bring new objects into existence, and generally use a special syntax (such as an operator called
new) to distinguish their invocation from that of a method.
new Point("Pantages Theater", 34.1017, -118.3255,
"Hollywood", "Los Angeles", "CA", "us", "90028",
new LocalDate(1930, 6, 4), Status.ACTIVE)
If there are too many parameters, you can pass in a map (dictionary, associative array, hash), or your language might support named parameter association.
Setters
With setter methods, you first construct an object in which all of its fields are set to default values, then you customize the object by setting just those fields that differ from the defaults.
Point p = new Point();
p.setName("Pantages Theater");
p.setLatitude(34.1017);
p.setLongitude(-118.3255);
p.setNeighborhood("Hollywood");
p.setCity("Los Angeles");
p.setState("CA");
p.setCountry("us");
p.setPostalCode("90028");
p.setEstablished(new LocalDate(1930, 6, 4));
p.setStatus(Status.ACTIVE);
This approach solves the three problems above, but introduces a new problem: the object being constructed can't be immutable. How can you get around this?
- Some languages allow fields to be marked "final" so that after the first set, they can't be set again.
- In some languages, you can scope the setter methods so that only the parts of the code that are supposed to the construct the objects can see the setters. Since objects should be able to be constructed anywhere, this all but requires the programmer to factor out construction code into its module, which could be unwieldy. But there are ways to do it nicely in general; one way is the builder, described next.
Builders
Builder objects are common too. They have the three advantages of the setter approach (no need to supply non-default values, order doesn't matter, and reader knows what the arguments mean), while also allowing the newly constructed object to be immutable.
Point p = new PointBuilder()
.name("Pantages Theater");
.latitude(34.1017);
.longitude(-118.3255);
.neighborhood("Hollywood");
.city("Los Angeles");
.state("CA");
.country("us");
.postalCode("90028");
.established(new LocalDate(1930, 6, 4));
.status(Status.ACTIVE)
.build();
Factory Methods
A factory method is any regular method (or regular function) that creates and returns a new object. There's no special syntax here; all that is done is to call a constructor, builder, or other device inside the body of the factory method. In Java:
public class Card {
private Suit suit;
private Rank rank;
private Card(Suit s; Rank r) { // Constructor must be private
suit = s; // to force all clients to use
rank = r; // the factory method below
}
public static Card fromRankAndSuit(Rank r, Suit s) {
return new Card(s, r);
}
. . .
}
Literals
In languages without classes, or when classes are not too important (say, when there is duck typing), object literals create new objects. Here's a JavaScript example. Fields are string literals, but we get to omit the quotes if the field name is a simple word that is not a reserved word:
{name: "Pantages Theater", lat: 34.1017, "long": -118.3255,
neighborhood: "Hollywood", "state or province": "CA",
country: "us", "postal code": "90028", city: "Los Angeles",
established: new LocalDate("1930-06-04"), status: Status.ACTIVE)}
Object literals are also possible in languages with statically typed, closed classes. In Ada:
type Point is record
X: Integer;
Y: Integer;
end record;
. . .
var P: Point := Point'(6, 5);
var Q: Point := Point'(Y => 5, X => 6);
Construction in Prototypal Languages
Modern (ECMAScript 5-based) JavaScript has nice features for creating objects with a given prototype. I came up with this pattern:
/*
* An immutable circle datatype. Synopsis:
*
* var c = Circle.create(5, {x: 1, y: 4});
* c.radius => 5
* c.center => {x: 1, y: 4}
* c.area() => 25π
* c.perimeter() => 10π
*/
var Circle = {
prototype: {
area: function () {return Math.PI * this.radius * this.radius;},
perimeter: function () {return 2 * Math.PI * this.radius;}
},
create: function (r, c) {
return Object.create(this.prototype, {
center: {value: c},
radius: {value: r}
});
}
};
The circles we create with Circle.create are immutable because we use JavaScript's default property descriptors for center and radius: they're not writable, not enumberable, we can't delete them, nor can we change these settings. The same isn't true for the Circle properties (prototype and create), nor for the prototype's own properties...is it worth using property descriptors on these too?
