home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / TOT11.ZIP / TOTDOC11.ZIP / CHAPT3.TXT < prev    next >
Text File  |  1991-02-11  |  49KB  |  1,059 lines
  1.                                                                   Toolkit Basics
  2.  
  3.  
  4.  
  5.          "No, what I said was 'No new taxis'"        Georgio Bush, 1990
  6.  
  7.  
  8.  
  9.  
  10. An Object Primer
  11.  
  12.          Let's talk cars. We all know that you don't need to be a combustion
  13.          mechanic to drive a car (that's a veeehickle if you're from Texas), but
  14.          most good drivers know a few basic principles about how a car works.
  15.          The same philosophy is true for object oriented programming: you don't
  16.          need to be an OOP guru to use the Toolkit but a little understanding is
  17.          helpful. The modest goal of this section is to explain some of the
  18.          object oriented principles to help you get up and running with the
  19.          Toolkit as soon as possible. Over time, you will gain OOP expertise
  20.          without even trying! If you are already familiar with OOP, skip to the
  21.          next section.
  22.          For now, we will concentrate on those aspects of OOP you will need in
  23.          order to understand how to use the Toolkit. In Part 2: Extending the
  24.          Toolkit, the more advanced concepts of inheritance and extensibility
  25.          are addressed.
  26.  
  27.  
  28.          In plain Pascal, there are types like integer, real, string, etc. and
  29.          you declare variables to be of a specific type. You can even define new
  30.          types. For example, the following declaration defines a new type
  31.          Address:
  32.  
  33.                   TYPE
  34.                   Address = record
  35.                      Name: string[20];
  36.                      Street: string[30];
  37.                      CityStZip: string[20];
  38.                   end;
  39.  
  40.          Having defined the type Address, you can then create variables of this
  41.          type, e.g.
  42.  
  43.                   VAR
  44.                   BobsHouse: Address;
  45.  
  46.          In most programs, you will write procedures and functions that can
  47.          manipulate the data stored in these variables, e.g.
  48.  
  49.                   procedure PrintLabel(Addr: address);
  50.                   function  Zip(Addr:address): string;
  51.  
  52.  
  53.  
  54. 3-2                                                                 User's Guide
  55. --------------------------------------------------------------------------------
  56.  
  57.          But most of you know this stuff anyway. Things aren't so very different
  58.          with OOP. The primary difference is that, with OOP, the data and the
  59.          procedures and functions which manipulate the data are combined into a
  60.          single type, called an object. This concept of combining data and
  61.          procedures/functions is referred to as encapsulation. Listed below is a
  62.          way to create an object type called AddressOBJ:
  63.  
  64.                   TYPE
  65.                   AddressOBJ = object
  66.                      Name: string[20];
  67.                      Street: string[30];
  68.                      CityStZip: string[20];
  69.                      {methods ...}
  70.                      procedure PrintLabel;
  71.                      function  Zip: string;
  72.                   end; {object}
  73.  
  74.                   VAR
  75.                   BobsHouse: AddressOBJ;
  76.  
  77.          Notice that the object type declaration is very similar to a record
  78.          declaration, but the keyword object is used instead of record. The
  79.          procedure and function declaration are included in the object declara-
  80.          tion, and are referred to (in OOP nomenclature) as methods. The methods
  81.          are not passed the address record as a parameter, because the procedure
  82.          and functions in an object can directly access the data in the object,
  83.          and so don't need to be passed the data. The "variable" BobsHouse,
  84.          which is of type AddressOBJ, is referred to as an instance - in other
  85.          words, object variables are called instances! All object type declara-
  86.          tions in the Toolkit end with the characters "OBJ".
  87.  
  88.          The individual elements of an object (just like a record) can be
  89.          accessed by using the "dot" notation. For example, to print a label,
  90.          you would use the following statement:
  91.                   BobsHouse.PrintLabel
  92.  
  93.  
  94.          You can also use the "with identifier do" shortcut, e.g.
  95.                   with BobsHouse do
  96.                   begin
  97.                      PrintLabel
  98.                      .....
  99.                   end; {with}
  100.  
  101.  
  102.          In theory, you could also access the data elements using the dot
  103.          method, e.g. BobsHouse.Street := '12 Paradise Drive', but you
  104.          shouldn't! While it is syntactically correct and will compile, this is
  105.          bad practice. A basic precept of encapsulation is that you never access
  106.  
  107.  
  108. Toolkit Basics                                                               3-3
  109. --------------------------------------------------------------------------------
  110.  
  111.          the data elements of an instance directly. You should create methods
  112.          within the object to access the object's data. In the above example,
  113.          there is no way to access the data in the object (other than breaking
  114.          the rules) so a data update method would need to be created. Listed
  115.          below is an improved type declaration of the AddressOBJ:
  116.  
  117.                   TYPE
  118.                   AddressOBJ = object
  119.                      Name: string[20];
  120.                      Street: string[30];
  121.                      CityStZip: string[20];
  122.                      {methods ...}
  123.                      procedure Adddata(Nam,St,Ci,St,Zp:string);
  124.                      procedure PrintLabel;
  125.                      function  Zip: string;
  126.                   end; {object}
  127.  
  128.          The new AddData method would be used to set the values of the Name,
  129.          Street and CityStZip elements. For example, the following two state-
  130.          ments would print the label:
  131.  
  132.                   with BobsHouse do
  133.                   begin
  134.                      AddData('Bobbo','12 Paradise Drive',
  135.                              'Dome','TX','77186');
  136.                      Printlabel;
  137.                   end;
  138.  
  139.          If you are curious, each method identified in an object must be
  140.          included in the body of the program or unit. For example, later in the
  141.          program there might be the following method definition:
  142.  
  143.                   ...
  144.  
  145.                   procedure AddressOBJ.Adddata(Nam,St,Ci,St,Zp:string);
  146.                   {}
  147.                   begin
  148.                      Name := copy(Nam,1,20);
  149.                      Street := copy(St,1,30);
  150.                      ...
  151.                   end; {of proc}
  152.  
  153.                   ...
  154.  
  155.          Now, back to the main discussion. The advantage of using methods to
  156.          access the object data is that the object user (that's you) does not
  157.          need to know or care about how the data is stored within the object.
  158.          The internal data structure might be modified at some stage to use
  159.  
  160.  
  161.  
  162. 3-4                                                                 User's Guide
  163. --------------------------------------------------------------------------------
  164.  
  165.          pointers or to store ASCIIZ strings, etc, but the same method AddData
  166.          can still be called in the same way as previously. What Adddata does
  167.          (behind the scenes) may have changed, but your program still compiles
  168.          and runs without modification.
  169.  
  170.          For various reasons, many objects need to be initialized before they
  171.          can be used. For example, some memory may need to be allocated on the
  172.          heap. When you have finished with such an object, the memory will need
  173.          to be disposed of. Just because the procedure in which you declared an
  174.          object instance (i.e. variable) has terminated, it does not necessarily
  175.          mean that the object data has been removed.
  176.          Although not mandatory, a de facto OOP standard is to have two special
  177.          methods for all objects. Namely, INIT and DONE. These special methods
  178.          are used to initialize an object and dispose of an object, respec-
  179.          tively. Throughout the Toolkit, every object has IN