In this video, let's review our pizza code and look at the aspect of messaging and behavior. Let's review our existing pizza code. You may not recognize them as methods. But because of the property mechanism, whenever we referred to the.diameter,.price,.area,.radius, we were invoking their corresponding getter methods. When we assigned to diameter, we're invoking it setter method. When we refer to pizza, passing 16 as an argument, we're invoking the init method. Finally, when we print our pizza, we are invoking that string conversion method. But all of those are done transparently by Python, making it harder for us to see the method invocation as we've been discussing. Now we've added support for toppings, which is to be a list of strings. Although we could do it in a more transparent manner, we'll make the method invocation explicit this time by adding an add topping method. Once again, as in other demos, I've pre-loaded the code here so you don't have to watch me type. Each call to add topping will check to see whether we have given a string in which case it will add that one topping to the list of toppings, or if we've given it some collection in which case it will add all of the contents of the collection to our list of toppings. No, we've not done all of the parameter checking that we should do in a real program, but that would merely be an unnecessary complication at this point. Toppings itself is a property. Unlike the lack of type checking, we have added one little extra complication to this example to make a point about accessor methods. In this case, until we ask for toppings, our instance doesn't even allocate storage to hold the list reference. Only when we actually try to access the data is the list allocated. This lazy instantiation is overkill for our example, but consider the case of database access. Consider an employee has a manager, a manager has a department, a department has a list of employees. Without lazy instantiation, we'd have to load the entire department with all of the employees just as a consequence of trying to load one employee. With lazy instantiation, we can load on-demand. We've made three other changes to the code. First, we modified the price property that add $0.50 per topping. Second, we modified the string conversion to include the list of toppings, or say no toppings if there aren't any. Three, we added code to invoke the add topping method; here and here. In each case, having added the topping, we print it out. These invocations of add topping are the first time in our code that we've seen what looks like these method calls, these messages using the syntax that we have in Python. Remember from an object-oriented perspective, pizza is the receiver, add topping is the message or the selector of the message that will be sent, and extra cheese is the parameter carried in the message. That is the concept from object oriented programming: Receiver, the method, and parameter. Running this code yields the expected results. No toppings. Our one topping in here with all of our toppings. That is our demo. What we're really showing is this concept of method invocation, which in object-oriented program, what we think of as sending messages that invoke a method which implements the desired behavior. That's our demo.
