1 Language Model
2 Syntactic Forms
3 Datatypes
4 Structures
5 Classes and Objects
6 Units
7 Contracts
8 Pattern Matching
9 Control Flow
10 Concurrency
11 Macros
12 Input and Output
13 Reflection and Security
14 Operating System
15 Memory Management
16 Running PLT Scheme
Bibliography
Index
Version: 4.0.2

 

5 Classes and Objects

 (require scheme/class)

The bindings documented in this section are provided by the scheme/class and scheme libraries, but not scheme/base.

    5.1 Creating Interfaces

    5.2 Creating Classes

      5.2.1 Initialization Variables

      5.2.2 Fields

      5.2.3 Methods

        5.2.3.1 Method Definitions

        5.2.3.2 Inherited and Superclass Methods

        5.2.3.3 Internal and External Names

    5.3 Creating Objects

    5.4 Field and Method Access

      5.4.1 Methods

      5.4.2 Fields

      5.4.3 Generics

    5.5 Mixins

    5.6 Traits

    5.7 Object and Class Contracts

    5.8 Object Serialization

    5.9 Object, Class, and Interface Utilities

    5.10 Surrogates

A class specifies

In the context of the class system, an object is a collection of bindings for fields that are instantiated according to a class description.

The class system allows a program to define a new class (a derived class) in terms of an existing class (the superclass) using inheritance, overriding, and augmenting:

An interface is a collection of method names to be implemented by a class, combined with a derivation requirement. A class implements an interface when it

A class can implement any number of interfaces. A derived class automatically implements any interface that its superclass implements. Each class also implements an implicitly-defined interface that is associated with the class. The implicitly-defined interface contains all of the class’s public method names, and it requires that all other implementations of the interface are derived from the class.

A new interface can extend one or more interfaces with additional method names; each class that implements the extended interface also implements the original interfaces. The derivation requirements of the original interface must be consistent, and the extended interface inherits the most specific derivation requirement from the original interfaces.

Classes, objects, and interfaces are all values. However, a class or interface is not an object (i.e., there are no “meta-classes” or “meta-interfaces”).