Classes Part II:
Interaction of Objects
At the end of this tutorial, you will find an attached .zip. This file contains pretty much all the code we are using in this tutorial, as well as the image that outlines the PopMachine's input/output.
An Introduction
So far, we've created programs that have a single class. (Be sure to have read Classes Part I.) We have not had any room for interaction of objects, either because we only made one object (instance of our only class), or because there was no need for objects of the same class (our only class) to interact, such as the button objects that I hope you made.
In this section, we will look at how objects may interact with each other. Consider a Pop Vending Machine, for example. It is an object that accepts money objects, processes your input (the buttons you push), and outputs a can of carbonated sugar. Let's write a Turing program to explore this idea, using the Pop Machine example.
A bit of Theory
We want our Pop Machine to accept Money objects and dispense Pop objects. We will give the Pop Machine a purchase method, and it will take two parameters: 1) a Money object and 2) a Pop object. It will accept the Money object, make change if necessary, and dispense the Pop object if enough Money has been given.
Allow me to highlight an idea from the last paragraph. A method in the PopMachine class will accept objects as parameters. How do we do that? Recall from the last section what our objects were represented as: pointers to a certain class, in this case the Money or Pop class. So, our parameters will have the variable type
| code: |
: pointer to Money |
or
| code: |
: pointer to Pop |
Let's write some abstract code to see if this will work.
| code: |
class Foo export message, set_message var message := "" proc set_message (value : string) message := value end set_message end Foo class Bar export message_from_Foo fcn message_from_Foo (obj : pointer to Foo) : string result Foo (obj).message end message_from_Foo end Bar var f : ^Foo new Foo, f Foo (f).set_message ("Hello from the Foo class.") var b : ^Bar new Bar, b put Bar (b).message_from_Foo (f) |
When you run this code, you will get two warnings, since "Foo" appeared twice in the Bar class, but Foo was not imported. We have to import Foo into the Bar class. Let's do that.
| code: |
class Foo export message, set_message var message := "" proc set_message (value : string) message := value end set_message end Foo class Bar import Foo export message_from_Foo fcn message_from_Foo (obj : pointer to Foo) : string result Foo (obj).message end message_from_Foo end Bar var f : ^Foo new Foo, f Foo (f).set_message ("Hello from the Foo class.") var b : ^Bar new Bar, b put Bar (b).message_from_Foo (f) |
Note that things like import and export always come at the beginning of the class (or module, or other structures), and that import always comes before export.
This may seem like an awfully long, complex way to put something to the screen, but this is just the beginning. If you made a Button or TextField class, or any other class, as the exercise to the last section, you should have realized the power of object oriented programming by now. It is neat, highly structured and organized, and repetition is easy--we can easily create many instances of the same class, and we therefore save ourselves coding.
With this initial example in mind, let's make our PopMachine, Money, and Pop classes. There's really nothing new in it than in the above code, but it shows this in a more practical light, so it is worth examining.
The Pop Machine Outline
In case we're still not clear on how the Pop Machine will work, here is a graphical representation.
We have two inputs: The Money object that we drop into the coin/bill slot, and our pop request. This is usually in the form of hitting a button, but in this example we will be more blunt: we will directly pass a Pop object (such as a Coke) into the purchase function of the PopMachine object.
The Pop Machine Code
| code: |
class Money export set_money, amount var amount : real proc set_money (value : real) amount := value end set_money end Money class Pop export set_name, set_cost, name, cost var name : string var cost : real proc set_name (value : string) name := value end set_name proc set_cost (value : real) cost := value end set_cost end Pop class PopMachine import Money, Pop export purchase fcn make_change (amount, cost : real) : real result amount - cost end make_change fcn purchase (money_given : ^Money, pop_requested : ^Pop) : string var change := make_change (Money (money_given).amount, Pop (pop_requested).cost) var pop_name := Pop (pop_requested).name if change < 0 then result "You have not given enough money for a " + pop_name + ". Please insert $" + realstr (abs (change), 0) + " more." elsif change = 0 then Money (money_given).set_money (0) result "Thank you for your purchase. Enjoy your " + pop_name + "." else Money (money_given).set_money (Money (money_given).amount - Pop (pop_requested).cost) result "Thank you for your purchase. Your change is $" + realstr (change, 0) + ". Enjoy your " + pop_name + "." end if end purchase end PopMachine var caf_vendor : ^PopMachine new PopMachine, caf_vendor var cash : ^Money new Money, cash Money (cash).set_money (1.50) var coke : ^Pop new Pop, coke Pop (coke).set_name ("Coke") Pop (coke).set_cost (1.25) put PopMachine (caf_vendor).purchase (cash, coke) put "You now have $", Money (cash).amount, "." |
The Pop Machine Options
There are a few ways the purchase method could work. It could result (read: return) a Pop object, which seems logical. But then there's the question of your change. If spitting out a can of pop is an example of "resulting" an object, so too is spitting out your change. Thus, if we want to "result" the Pop and Money, we'd need to "result" an array that contains two objects: the Pop and the Money.
Alternatively, we could define a procedure in the PopMachine class to drop the Pop object to the bottom "bin", and another procedure to drop the Money objects (the change) to the pick-up area. The purchase procedure would call these two procedures (or perhaps only call one of them, if exact change was given; or perhaps call none of them, if not enough change was given).
Further Studies
In this section of the tutorial we have learned how objects may interact. The key idea to remember is that to integrate a type of object into the framework of another object (ie. into that object's class), the variable type is pointer to ClassName, where ClassName is the name of the class of the object we wish to interact with our current object. To do this, we have to import ClassName.
In Part III, we will learn how to create a network of classes, using inheritance. We will also look at polymorphism. These are powerful concepts, and we shall use them to create the basis for working with the items of an RPG.