home *** CD-ROM | disk | FTP | other *** search
/ Collection of Education / collectionofeducationcarat1997.iso / COMPUSCI / TOT11.ZIP / TOTDOC11.ZIP / CHAPT16.TXT < prev    next >
Text File  |  1991-02-11  |  17KB  |  367 lines
  1.                                                                              OOP
  2.                                                                       Principles
  3.  
  4.  
  5.  
  6.          "The human mind treats a new idea the way the body treats a strange
  7.          protein; it rejects it."
  8.  
  9.                                                         P. B. Medawar, Biologist
  10.  
  11.  
  12.          Part 2 of the User's manual explains how, by using object oriented
  13.          programming, you can customize the Toolkit to meet your very specific
  14.          needs. In this chapter, some of the main features of OOP extensibility
  15.          are explained. If you are an experienced OOPer, you may want to skip
  16.          this chapter and proceed with the Toolkit specific text.
  17.  
  18.          If you are new to OOP, be sure to read the Object Primer starting on
  19.          page 3.1 before you look at this chapter.
  20.  
  21.  
  22. Understanding Inheritance
  23.          One of the most powerful and alluring aspects of object oriented pro-
  24.          gramming is the ability to modify and expand an object without changing
  25.          any of the object's source code. What's more, it's easy to do! The
  26.          basic approach is to create an object which inherits all the properties
  27.          of another object, i.e. you clone the object (sorry Compaq). You can
  28.          then change some of the properties of the cloned object so that it
  29.          functions the way you want it to.
  30.  
  31.          This feature allows you to enhance and improve the Toolkit without
  32.          changing a single line of Toolkit source code. That way, when we
  33.          release a new and improved version, you don't have to wrestle with two
  34.          sets of source code - the code that you changed and the code that we
  35.          changed. All you need to do is "plug in" the new Toolkit and your
  36.          objects will automatically inherit the new features added to the Tool-
  37.          kit.
  38.          To illustrate object inheritance, let's solve a practical problem.
  39.          Imagine that you use the EquipOBJ object, but need to enhance it so
  40.          that it will report if a CD-ROM is installed. Rather than change the
  41.          EquipOBJ object, the approach is to create a new object which inherits
  42.          all the properties of EquipOBJ, and add the new CD-ROM method to it.
  43.  
  44.          You may recall from chapter 3: Toolkit Basics that declaring an object
  45.          is very similar to declaring a record. To declare a object that inher-
  46.          its the properties of another object, you specify the name of the par-
  47.          ent object in parentheses after the object keyword. The following code
  48.          fragment declares a new object type, NewEquipOBJ, which inherits all
  49.          the properties of EquipOBJ:
  50.          NewEquipOBJ = object (EquipOBJ)
  51.          end; {NewEquipOBJ}
  52.  
  53. 16-2                                                       Extending the Toolkit
  54. --------------------------------------------------------------------------------
  55.  
  56.          If you create an object which is a descendant of a Toolkit object, you
  57.          must define two special methods known as the CONSTRUCTOR and the
  58.          DESTRUCTOR. Furthermore, these should be named INIT and DONE, respec-
  59.          tively. These special methods instruct Turbo Pascal to use special
  60.          memory techniques when creating and disposing of the object. The
  61.          NewEquipOBJ object declaration must be expanded to include the con-
  62.          structor and destructor methods as follows:
  63.  
  64.          NewEquipOBJ = object (EquipOBJ)
  65.             constructor Init;
  66.             destructor  Done;
  67.          end; {NewEquipOBJ}
  68.          Now we can add the new CD-ROM method to the object declaration.  Assum-
  69.          ing that the new method is just a boolean function, it would be
  70.          declared as follows:
  71.  
  72.          NewEquipOBJ = object (EquipOBJ)
  73.             constructor Init;
  74.             function    CDROM: boolean;
  75.             destructor  Done;
  76.          end; {NewEquipOBJ}
  77.          As well as adding new methods to the object, you can override or change
  78.          existing methods. For example, the GameAdapter function inherited from
  79.          EquipOBJ can be replaced with a new method by expanding the object
  80.          declaration as follows:
  81.  
  82.          NewEquipOBJ = object (EquipOBJ)
  83.             constructor Init;
  84.             function    CDROM: boolean;
  85.             function    GameAdapter: boolean;
  86.             destructor  Done;
  87.          end; {NewEquipOBJ}
  88.          Although you have only declared NewEquipOBJ with four methods, it
  89.          actually includes all the data and methods it has inherited from Equi-
  90.          pOBJ. The following table compares the data and methods declared in
  91.          EquipOBJ, with the data and methods in NewEquipOBJ. The non-bold items
  92.          are inherited.
  93.  
  94.  
  95.                        EquipOBJ                          NewEquipOBJ
  96.           vMainInfo: integer;                vMainInfo: integer;
  97.           vComputerID: byte;                 vComputerID: byte;
  98.           vRomDate: string[8];               vRomDate: string[8];
  99.           constructor Init;                  constructor Init;
  100.           function    ComputerID:byte;       function    ComputerID:byte;
  101.           function    ParallelPorts:byte;    function    ParallelPorts:byte;
  102.           function    SerialPorts:byte;      function    SerialPorts:byte;
  103.           function    FloppyDrives:byte;     function    FloppyDrives:byte;
  104.  
  105.  
  106.  
  107.  
  108. OOP Principles                                                              16-3
  109. --------------------------------------------------------------------------------
  110.  
  111.           function    ROMDate:string;        function    ROMDate:string;
  112.           function    SerialPrinter:boolean; function    SerialPrinter:boolean;
  113.           function    MathChip:boolean;      function    MathChip:boolean;
  114.           function    GameAdapter:boolean;   function    GameAdapter:boolean;
  115.           destructor  Done;                  function    CDROM:boolean;
  116.                                              destructor  Done;
  117.  
  118.  
  119.  
  120.  
  121.            Note: an inherited object may also include data items, provided
  122.            the identifiers (or variable names) are different from the ones
  123.            inherited from the parent object.
  124.  
  125.  
  126.  
  127.          The object declaration defines a new object type and should be located
  128.          in the TYPE declaration section of your program or unit. The corre-
  129.          sponding detail of each object method must be listed either in the body
  130.          of your program, or in the implementation section of a unit.
  131.  
  132.          Listed below is a unit, EXTDEM1.PAS, which fully defines the new object
  133.          NewEquipOBJ. One of the important points to note is that the construc-
  134.          tor and destructor methods must call the associated constructor and
  135.          destructor from the parent method. This ensures that the inherited data
  136.          is initialized and disposed of properly. These important statements are
  137.          highlighted in bold in the listing.
  138.  
  139.  
  140.          Unit ExtDem1;
  141.          INTERFACE
  142.  
  143.          Uses DOS,CRT, totSYS;
  144.          TYPE
  145.  
  146.          NewEquipOBJ = object (EquipOBJ)
  147.             constructor Init;
  148.             function    CDROM: boolean;
  149.             function    GameAdapter: boolean;
  150.             destructor  Done;
  151.          end; {NewEquipOBJ}
  152.          IMPLEMENTATION
  153.  
  154.          constructor NewEquipOBJ.Init;
  155.          {}
  156.          begin
  157.             EquipOBJ.Init;
  158.          end; {NewEquipOBJ.Init}
  159.  
  160.  
  161. 16-4                                                       Extending the Toolkit
  162. --------------------------------------------------------------------------------
  163.  
  164.          function NewEquipOBJ.CDROM:boolean;
  165.          {If you know how to do this - please tell us!
  166.           For now, we'll assume one isn't installed}
  167.          begin
  168.             CDROM := false;
  169.          end; {NewEquipOBJ.CDROM}
  170.  
  171.          function NewEquipOBJ.GameAdapter:boolean;
  172.          {}
  173.          begin
  174.             GameAdapter := paramstr(1) = '/G';
  175.          end; {NewEquipOBJ.GameAdapter}
  176.          dest