Design Patterns

CHAPTER 3 ■ ENCAPSULATION AND INFORMATION HIDING 35
object is instantiated. This has the potential to use more memory than the other patterns, so it
should only be used when you require true private members. This pattern is also hard to subclass.
The new inherited class will not have access to any of the superclass’s private attributes or methods.
It is said that “inheritance breaks encapsulation” because in most languages, the subclass has
access to all of the private attributes and methods of the superclass. In JavaScript, this is not the
case. If you are creating a class that might be subclassed later, it is best to stick to one of the fully
exposed patterns.
More Advanced Patterns
Now that you have three basic patterns at your disposal, we’ll show you a few advanced patterns.
Part 2 of this book goes into much more detail about specific patterns, but we will take
an introductory look at a few of them here.
Static Methods and Attributes
Applying the lesson of scope and closures from earlier in the chapter can lead to a way to
create static members, which can be both private and publicly accessible. Most methods
and attributes interact with an instance of a class; static members interact with the class
itself. Another way of putting it is to say that static members operate on the class-level instead
of the instance-level; there is only one copy of each static member. As you will see later in
this section, static members are called directly off of the class object.
Here is the Book class with static attributes and methods:
var Book = (function() {
// Private static attributes.
var numOfBooks = 0;
// Private static method.
function checkIsbn(isbn) {
...
}
// Return the constructor.
return function(newIsbn, newTitle, newAuthor) { // implements Publication
// Private attributes.
var isbn, title, author;
// Privileged methods.
this.getIsbn = function() {
return isbn;
};
this.setIsbn = function(newIsbn) {
if(!checkIsbn(newIsbn)) throw new Error('Book: Invalid ISBN.');
isbn = newIsbn;
};