Loading…

Flash Player 9 (or above) is needed to view presentations.
We have detected that you do not have it on your computer. To install it, go here.

Like this presentation? Why not share!

Stoop 304-metaclasses

on

  • 661 views

 

Statistics

Views

Total Views
661
Views on SlideShare
661
Embed Views
0

Actions

Likes
0
Downloads
4
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

Stoop 304-metaclasses Stoop 304-metaclasses Presentation Transcript

  • Classes and Metaclasses - an Analysis
  •  
  • Goals
    • “ Some books are to be tasted,
    • others to be swallowed,
    • and some few to be chewed and
    • digested”
    • — Francis Bacon, Of Studies
    • Recap on Instantiation
    • Recap on Inheritance
    • At first sight, a difficult topic!
    • You can live without really understanding them, but metaclasses provide a uniform model, and you will make less errors if you learn how they work, and you will really understand the object model
    Warning
    • Every object is an instance of a class.
    • Every class (except Object) is ultimately a subclass of Object.
    • When anObject receives a message, the method is looked up in its class and/or its superclasses.
    • A class defines the structure and the behavior of all its instances.
    • Each instance possesses its own set of values.
    • Each instance shares its behavior with other instances. This behavior is defined in its class, and is accessed via the instance of link.
    The Meaning of “Instance of”
    • Everything is an object
    • Every object is instance of exactly one class
    • A class is also an object, and is an instance of its metaclass
    • An object is a class if and only if it can create instances of itself.
    Metaclass
  • Class Responsibilities
    • instance creation
    • class information (inheritance link, instance variables, method compilation...)
    • Examples:
      • Node allSubclasses -> OrderedCollection (WorkStation OutputServer Workstation File)
      • LanPrinter allInstances -> #()
      • Node instVarNames -> #('name' 'nextNode')
      • Workstation withName: #mac -> aWorkstation
      • Workstation selectors -> IdentitySet (#accept: #originate:)
      • Workstation canUnderstand: #nextNode -> true
    • Node allSubclasses -> OrderedCollection (WorkStation OutputServer Workstation
    • FileServer PrintServer)
    • PrintServer allInstances -> ()
    • Node instVarNames -> ('name' 'nextNode')
    • Workstation withName: mac -> aWorkstation
    • Workstation selectors -> IdentitySet (accept: originate:)
    • Workstation canUnderstand: nextNode -> true
    Metaclass by Example
  • The Meaning of Is-a
    • Every object is an instance of a class.
    • When anObject receives a message,
    • the method is looked up in its class
    • And it continues possibly in
    • its superclasses
    • Every class is ultimately
    • a subclass of Object (except Object).
  • A Class is an Object too…
    • So messages sent to a class are looked up into the class of the class
    • Node withName: #node1
      • Node is an instance of
      • “Node class”
      • withName: is looked up
      • in the class “Node class”
      • withName: defined in
      • “Node class”
      • lookup stops +
      • method executed
  • Class Parallel Inheritance
  • Lookup and Class Methods
  • Class Parallel inheritance
    • Workstation withName: #mac
      • Workstation is an instance of Workstation class
      • => withName: is looked up in the class Workstation class
      • withName: is not defined in Workstation class
      • => lookup continues in the superclass of Workstation class = Node class
      • withName: is defined in Node class
      • => lookup stops + method executed
    • Object
      • represents the common behavior (like error, halting...) shared by all the instances (final instances and classes)
      • all the classes should inherit ultimately from Object
      • -> Workstation inherits from Node
      • -> Node inherits from Object
    • Class
      • represents the common behavior of all the classes (compilation, method storing, instance variable storing)
      • Class inherits from Object because Class is an Object, although a special one -> Class knows how to create instances
      • So all the classes should inherit ultimately from Class
    Responsibilities of Object & Class
    • The kernel of CLOS and ObjVlisp but not the kernel of Smalltalk
    A Fragile Reflective Kernel
  • Singleton with explicit metaclasses
  • Deeper into It
    • No explicit metaclasses, only implicit non-sharable metaclasses.
    • (1) Every class is ultimately a subclass of Object (except Object itself)
    • Object
    • Behavior
    • ClassDescription
    • Class
    • Metaclass
    • (II) Every object is an instance of a class = every class is an instance of a class which is its metaclass.
    Smalltalk Metaclasses in 7 points
    • (3) Every class is an instance of a metaclass.
      • Every user defined class is the sole instance of another class (a metaclass).
      • Metaclasses are system generated and they are unnamed.
      • You can access them by sending the message class to a class.
      • Point class name -> ‘Point class’
    Smalltalk Metaclasses in 7 points
    • If X is a subclass of Y then X class is a subclass of Y class. But what is the superclass of the metaclass of Object? The superclass of Object class is Class
    • All metaclasses are (ultimately) subclasses of Class.
    • But metaclasses are also objects so they should be instances of a Metaclass
    Smalltalk Metaclasses in 7 points
    • (5) Every metaclass is an instance of Metaclass. So Metaclass is an instance of itself
      • Object : common object behavior
      • Class: common class behavior (name, multiple instances)
      • Metaclass: common metaclass behavior (no name, unique instance)
    Smalltalk Metaclasses in 7 points
    • (6) The methods of Class and its superclasses support the behavior common to those objects that are classes.
    • (7) The methods of instances of Metaclass add the behavior specific to particular classes.
      • Methods of instance of Metaclass = methods of “Packet class” = class methods (for example withName:
      • An instance method defined in Behavior or ClassDescription, is available as a class method. Example: new , new:
    Smalltalk Metaclasses in 7 points
  • Complete Picture
  • Final Thoughts
    • Finally it is not sure that the Smalltalk model is more complex than the one of ObjVlisp.
    • If we consider the programmer view of a class, Smalltalk is simpler
    • If we consider the meta-programmer, ObjVlisp is simpler
  • Responsibilities
    • Minimum state necessary for objects that have instances.
    • Basic interface to the compiler.
    • State: class hierarchy link, method dictionary, description of instances (representation and number)
    • Methods:
      • creating a method dictionary, compiling method
      • instance creation (new, basicNew, new:, basicNew:)
      • class into hierarchy ( superclass:, addSubclass:
      • accessing (selectors, allSelectors, compiledMethodAt: )
      • accessing instances and variables (allInstances, instVarNames)
      • accessing class hierarchy (superclass, subclasses)
      • testing (hasMethods, includesSelector, canUnderstand:, inheritsFrom:, isVariable)
    Behavior Responsibilities
    • ClassDescription adds a number of facilities to basic Behavior:
      • named instance variables
      • category organization for methods
      • the notion of a name (abstract)
      • the maintenance of the Changes set, and logging changes
      • most of the mechanisms needed for fileOut
      • ClassDescription is an abstract class: its facilities are intended for inheritance by the two subclasses, Class and Metaclass.
    ClassDescription Responsibilities
    • Metaclass
      • initialization of class variables
      • creating initialized instances of the metaclass’s sole instance
      • instance creation (subclassOf:)
      • metaclass instance protocol (name:inEnvironment:subclassOf:....)
    • Class
      • Class adds naming for class
      • Class adds the representation for classVariable names and shared pool variables (addClassVaraNames, addSharedPool:, initialize)
    Metaclass and Class Responsibilities
  • Summary
    • Classes are objects too
    • A class is the unique instance of another class, its metaclass