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

  • 641 views

 

Statistics

Views

Total Views
641
Views on SlideShare
641
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