Chapter: Objects and Classes
...Section: Creating Classes

Now let's discuss in greater detail the creation of classes by looking in depth at the code we used to define Point-class.

• What is Point-class? In order to understand this, we must explore the notion of a class. The definition of a class specifies:
  • a set of variables for the object, and
  • a set of methods which can be called to modify object variables, perform actions, and return values.

• To define a class in Scheme-- we use the keyword class. By convention, we distinguish class names by starting them with an upper case letter. This is not required by the syntax, but -- as in Java -- is merely a convention, reminding us that the name denotes a class:

  (define My-class
    (class (... parameters ...)
      ... body ...))
  

  The parameters correspond to parameters in constructors in Java. They allow initial values to be passed in when we create an instance of a class. They can be thought of as initial values for undeclared instance variables. (This is unlike Java.) In our Point-class example the parameters are x and y which provide the location of the point. These parameters are like the parameters in a lambda expression, where the keyword class is like lambda.

• The first section of the body of a class contains the instance variable bindings which are defined in much the same way as a let* expression:

  (define My-class
    (class (... parameters ...)
      ([var1 value1]
       [var2 value2]
           ...
       [varN valueN])
       
      ... body ...))
  

  In fact the instance variable bindings are also like let* in terms of scoping rules. Each variable binding is available to successive binding statements. Thus looking at the above, the expression valueN can use the values most recently bound to the variables var1 ... varN-1. A big difference between this model and Java is that, in addition to these explicitly declared instance variable, you are also able to treat the parameter names ... parameters ... just as if they were instance variables.

  In Point-class we define only one variable, visible, which tells us whether the point is visible or invisible. We give this variable the initial value #f indicating that the point is not visible. This can be changed using the setVisible method.

• Following the variables, we have (Object), which creates an instance of the superclass for this class definition. Don't worry about the superclass for the moment. This will be discussed in the section on inheritance. For now simply use (Object) to specify the superclass.

• Finally we come to the instance methods. We provide a list of the methods much as we would in a letrec expression. We use the keyword method which can be thought of as lambda for class methods. Following method is a list of the parameters for the method which are used just like the parameters for a normal procedure. So a complete class definition looks like this:

  (define My-class
    (class (... class parameters ...)
      ([var1 value1]
       [var2 value2]
           ...
       [varN valueN])
      (Object)
      ([meth1
         (method (a1 a2 ... aM)
           ... method body ...)]
       [meth2
         (method (b1 b2 ... bN)
           ... method body ...)]
       ... more methods ...
       [methL
         (method (c1 c2 ... cK)
           ... method body ...)])))
  

  In our Point-class example the methods are location?, visible?, moveTo, moveRel, and setVisible.

• The instance variables provide the internal data representations which all together constitute the object's state. Unlike ADTs, a class definition makes explicit the data structures and methods for storing and maintaining the underlying state. Several entirely distinct classes could be used to implement the same ADT. However classes share similarity with ADTs in that other users can access objects without knowing this internal structure. All they need to know is the functionality, which could be specified in an interface file without mentioning the details of implementation. This is one of the joys of object-based programming: You can use objects designed by other people without studying any intricate details of their implementations.

  While classes are not the same as ADTs, they provide a particularly easy way for programmers to implement a particular ADT. The combination of state information (variables) and operations (methods) specified by a class definition provides encapsulation for each object and is one of the most unique and attractive features of the of the object-oriented paradigm.