CSC3252 Lecture 20

Lecture 20

An Introduction to Java Classes & Objects

References:

Flanagan, D. 'Java in a Nutshell'
O'Reilly & Associates 1996, pp49-67.

It is essential that the reference above (or the WWW) be consulted on this topic, particularly in learning elementary Java.
It is not expected that you become a proficient Java programmer but an understanding of the basic syntax is required.

Basic Object Oriented Concepts

A class is a collection of data and methods (procedures) which operate on that data.
An instance of a class is known loosely as an object.
Supposing we were to require a class of objects known as Zlots for a new 2D animated film we were making.

Zlots are strange creatures, they can have any number of eyes, any number of legs and a circular head of a certain radius.

The intelligence of a Zlot is proportional to the square of the radius of its head, minus the number of eyes it has. (The more eyes the zlot has, the less space there is for its brain).

The Zlot's top speed (in metres per second) is given by the number of legs it has. Zlots have no other features.

Here are a few Zlots...

Creating Java Objects

Here's how the Java class for Zlots might be defined.

public class Zlot {

    // Data of the Zlot class
    
    public int legs, eyes;       // number of Zlot legs & eyes
    public double radius;        // Zlot head radius
			
    // Methods of the Zlot class
	
    public double intelligence() { return ((3.141 * radius * radius) - eyes); }
    public int speed()           { return legs; }
}

To define an object of type Zlot we could write
Zlot tim;
But this only declares a reference to a Zlot! It does not create an instance of a Zlot.

So we must write...
Zlot tim; tim = new Zlot();
...and a new Zlot (named tim) is born! Tim has been declared dynamically. He is an instance of a Zlot.

The above section of code declares a reference to a Zlot and then allocates space for a Zlot by making a call to the default constructor. (Hence the brackets after Zlot() )

Accessing Object Data Members

How many eyes does tim have? How big is he? How many legs does he have?

Let's fill tim out a little by assigning values to his data members.
Zlot tim = new Zlot(); tim.eyes = 13; tim.legs = 1; tim.radius = 4;

Calling Object Methods

To find out how fast and clever tim is, we can call the Zlot methods.

Zlot tim = new Zlot();
int    v;
double iq;

tim.eyes   = 13;
tim.legs   = 1;
tim.radius = 4;

v  = tim.speed();
iq = tim.intelligence();

Tim is slow and dumb. At least he can see well!

The speed and intelligence methods can access the data of the object with which they were called (tim in this case) and use them to calculate his vital attributes.
There is no need to pass the methods any arguments in this example. It is implied that the object (tim) and its data will be operated on by the method.
From within the Zlot methods, the calling object is referred to by the name this, referring to 'this object'.
- This this may be omitted within the method although sometimes it will make the code more clear if it is stated explicitly.
- Within a method it is implied that the method is accessing the data of the calling object unless the method contains local variables of the same name as data members of the method.
- The Zlot intelligence() method could be rewritten...
  public double intelligence() { return ((3.141 * this.radius * this.radius) - this.eyes); }

Writing Your Own Constructors

An expression: new Zlot() calls the default constructor which takes no arguments and does no useful initialization.

A Zlot constructor which initializes the Zlot's attributes through the arguments it is passed can be added to the Zlot class like this.

public class Zlot {

    public int legs, eyes;       // number of Zlot legs & eyes
    public double radius;        // Zlot head radius
	
        // Here's the constructor method...
	
        public Zlot (int legs, int eyes, double radius)
        {
            this.legs   = legs;
            this.eyes   = eyes;
            this.radius = radius;
        }
	
    public double intelligence() { return ((3.141 * radius * radius) - eyes); }
    public int speed()           { return legs; }
}

The Zlot constructor with arguments is just called like this...

tim = new Zlot(1, 13, 4.0);

The use of the this keyword ensures the parameter names are not confused with the object data member names. (We could have given the parameters a different name and not used the this keyword)
The constructor name is the same as the class name.
The constructor does not return anything and does not have a return type specified in its header line (not even void).
Multiple constructors may be defined for a class.
- Each must have the same name (The name of the class)
- Each must have a different header signature. ie. different parameter types (Used to determine the appropriate constructor to call)

The 'static' keyword

Sometimes you don't want every instance of a class to have its own copy of a variable, you want a single variable which applies to all the objects of the class.

Suppose you wanted to keep track of the Zlot population. You could do this in Java by creating a class variable using the keyword static...

public class Zlot {

    public int legs, eyes;               // number of Zlot legs & eyes
    public double radius;                // Zlot head radius
    
    public static int num_Zlots = 0;     // class variable: number of Zlots
	
        // Here's the constructor method again
	
        public Zlot (int legs, eyes, radius)
        {
            // Zlot initialization omitted
            
            num_Zlots++;
        }
        
    // Other methods omitted
    
}

The class variable num_Zlots may be accessed from within its class directly (as above) but...
The class variable num_Zlots must otherwise be accessed through its class, since it does not belong to a specific object.
System.out.println("Number of Zlots born:" + Zlot.num_Zlots);
Methods can be declared static just like data members!
- Class (static) methods are called through the class (as were static data members)
- Class methods do not have a this associated with them because they are not called with a specific object.
- Class methods may be passed parameters as normal and act on those.

Class variables as constants

A class variable may be used as a constant value by fixing its value using the final keyword.

public class Zlot {

    public int legs, eyes;       // number of Zlot legs & eyes
    public double radius;        // Zlot head radius
    
    public static final double PI = 3.14159265358932;
    
    // Methods of the Zlot class
	
    public double intelligence() { return ((PI * radius * radius) - eyes); }
    public int speed()           { return legs; }
}

The static class variable may be accessed through the class name as described above.

Destroying Java Objects

Java has built in garbage collection so you don't need to do anything like free or delete as you do in C or C++.

Eg. If you create a local Zlot in a function somewhere using new to allocate space for her, you don't need to delete her at the end of the function...

int myFunction()
{
    Zlot marigold = new Zlot(1, 3, 4.0);
    
    // Do stuff with marigold the Zlot
    
    // No need to delete or free marigold,
    // she will be collected in the garbage
    // (Poor marigold)
    
    return 1;
}

To forget about marigold in order to free up her memory...

int myFunction()
{
    Zlot marigold = new Zlot(1, 3, 4.0);
    
    // Do stuff with marigold the Zlot
    
    // Speed up garbage collection of marigold the Zlot
    // by removing the only reference to her.
    // (Poor marigold is garbage collected when she's forgotten)
    
    marigold = null;
    
    return 1;
}

Java objects may be finalized before they are garbage collected.
This is a process of cleaning up anything the garbage collection cannot. (eg. closing open files)

Do this by writing a method called finalize.

protected void finalize() { /* stuff here */ }

Inheritance

Suppose tim and marigold had a fling before marigold was garbage collected.
tim and marigold produced a new species of Zlot, the Winged_Zlot.
A Winged Zlot has all the features of a normal Zlot only it has wings too! Any number of them!

A Winged Zlot has a maximum air speed equal to the number of wings it has minus the number of legs it has. (The legs get in the way of the wings)

public class WingedZlot extends Zlot {

    // All variables and methods of the Zlot are inherited
    // automatically by wingedZlots so only WingedZlot
    // paticulars must be specified here.
    
    public int wings;
    
    public int airSpeed() { return (wings - legs); }
}

The extends keyword indicates that WingedZlot inherits all variables and methods from the Zlot class except those declared private.
airSpeed() uses the inherited variable legs.
The following are legitimate operations on a WingedZlot called zelda.
double iq = zelda.intelligence(); Zlot michael = zelda;
A class declared using the final keyword may not be extended.
public final class Clootz { ... }

The class hierarchy

In the above example, WingedZlot is a subclass of Zlot and Zlot is the superclass of WingedZlot.
Any class defined without using the keyword extends is actually a subclass of the special Java class Object.
Every class in Java except for Object has a superclass, so all Java classes are part of the Java class hierarchy. This is a tree with the class Object at its root.

The class hierarchy may be used when writing constructors for classes.

public WingedZlot(int legs, int eyes, double radius, int wings)
{
    super (legs, eyes, radius);
    this.wings = wings;
}

The keyword super invokes the constructor of WingedZlot's superclass.
- This only works within a constructor method.
- The call to the superclass constructor must be the very first thing in the method.
- If the call to super is not made explicitly, Java automatically calls the superclass constructor with no arguments, whether you like it or not.
- If there is no superclass constructor with no arguments, a compilation error occurs.
- BUT: If the first thing in the call to a constructor is a call to another constructor in the same class, super will not be called implicitly... yet!
  
  If this second constructor does not call super explicitly, Java will do so implicitly... and so on down the chain of constructors until either super is called explicitly, or the super of Object is called implicitly.
- If a class is declared as extending another but the subclass does not have any constructor Java creates a default constructor for it.
  
  This default constructor's only task is to call super.
Calls to finalize() are not chained.

Shadowed Variables

If a subclass has a variable of the same name as one in its superclass, whenever its methods access a variable of that name they refer to the variable in the subclass.

The subclass variable shadows the variable in the superclass.
A variable in the superclass may still be accessed though!
- Supposing (for some silly reason) you needed to define a variable in WingedZlot called legs which was different to the legs defined in Zlot.
- Let's say the legs of WingedZlot was a boolean variable to record the presence or absence of any legs, since WingedZlots can exist without them.
- Then to access the superclass (Zlot) variable legs in the airSpeed() method of WingedZlot...
  public class WingedZlot extends Zlot { boolean legs; // shadows Zlot's variable: int legs int wings; public int airSpeed() { return (wings - super.legs); } }
- You cannot access a variable in a super-super class using the syntax super.super.variableName but...
- You can do the same thing (to any level in the hierarchy) by casting the this of the current object to the type of the class which contains the variable you want to access.
  
  (Recall that this would otherwise have the same type as the class of object calling the current method. So an access to a variable from within the method is implicitly a call to this.variableName, ie. the variable in the class of the current method.)
  public class WingedZlot extends Zlot { boolean legs; // shadows Zlot's variable: int legs int wings; public int airSpeed() { return (wings - ((Zlot)this).legs); } }

No Zlots or WingedZlots were harmed during the making of these lecture notes. (Not even Marigold Zlot)

Lecture 20 An Introduction to Java Classes & Objects

Lecture 20

An Introduction to Java Classes & Objects