Objects, Inheritance and Polymorphism

Object Semantics

Suppose we have a simple class Foo:

class Foo {
    private int theValue;
    public Foo(int v) {theValue = v;}
    public int getValue() {return theValue;}
    public void setValue(int v) {theValue = v;}
}

Foo x = new Foo(3);
Foo y = new Foo(5);
x.setValue(2);        // x is now 2
x = y;                // x is now 5
x.setValue(3);        // x and y are now 3. Why does y change?

It is important to understand why y changes at the end. The local variables x and y do not represent two different locations for the Foo objects; instead, they represent pointers to the objects. After the line x=y, x and y point to the same object.

Polymorphism

Here is a fundamental example about classes and so-called inheritance, also in the file poly.cs. The Child class "extends" the class Base. However, a Child object permanently retains its identity, even when it is assigned to a Base variable (as in b2 = new Child(4,5)). When the get() method is called, it is the Child get method, not the Base get method.

using System;
using System.IO;

class Demo {
    static void Main(string[] args) {
	Base b1 = new Base(3);
	Base b2 = new Child(4,5);
	Console.WriteLine("b1.get() = {0}, b2.get = {1}", b1.get(), b2.get());
    }

}

class Base {
    private int x;
    public virtual int get() {return x;}
    public Base(int X) {x = X;}
}

class Child : Base {
    private int y;
    public override int get() {return base.get()+y;}
    public Child (int X, int Y) : base(X) {y=Y;}
}

ToString

Console.WriteLine is polymorphic: when you give it a non-string type, it calls the object's ToString() method to convert it to a string. We saw this in the ratio.cs demo.

Ratio.ToString can be called explicitly whenever needed, as r.ToString(). However, note that ToString() works more generally, using inheritance. The master parent class Object defines ToString(); any subclass can override that definition, as is being done here. In WriteLine(), when an Object needs to be printed then ToString() is called implicitly; the rules of inheritance ensure that the most specific version of ToString is the one to be invoked.

Shapes

One classic application of this is with drawing shapes. There is a base class Shape, and then child classes for each specific shape: Triangle, Rectangle, Circle, etc. The base class has a draw() method, but it does nothing (in fact, it is usually labeled abstract, meaning it must be supplied by a subclass). If we have a list shapeList of Shape objects (that is, a picture!) we can draw it as follows:

    foreach (Shape s in shapeList)
        s.draw();

We do not have to check each shape s for what kind of shape it is.

Zuul

        while (! finished) {
            Command command = parser.getCommand();
            finished = processCommand(command);
        }

• getShortDescription()
• getExitString()
• getLongDescription() (a combination of the above)
• getExit(): for going to a new room
• respond(Command c, List<Item> inventory): how a Room responds to a Command. The inventory is needed for TAKE and DROP commands, but also to check if you are carrying a light or a key or a sword.

Each room contains a list of Items found in the room; Items are portable and can be TAKEn or DROPped.

Downcasting

    public static Light getLight(List<Item> inv) {
        int i = 0;
        foreach (Item itm in inv) {
            if (itm is Light) {
                Light lt = itm as Light;         // note (cast)
                if (lt.isOn()) return lt;
            }
        }
        return null;    // get here if not found
    }

Shapesworld

Commands and double dispatch