Classes & Objects

What is an Object?

Object Oriented Programming is a way of designing programs by breaking things down into "objects". Objects combine data members and functions together in one unit. An object consists of three things:

Name: provides a way of referencing the object.
Attributes: describe what the object is.
Behavior: describes what the object does.

Objects are defined as being part of some class. A class is a blueprint for an object and describes what attributes and behavior it will have. An object is an "instance" of class. There can be many instances of the same class.

Classes are meant to serve as building blocks for use in programs.

Using Objects

We have actually used several objects in our programs already:

String
Scanner
Random
FileInputStream and PrintWriter.
Each type of exception.

To use a regular variable, we only need to declare it, and normally initialize it:


int x = 10;     // not an object, so no need for new

To use an object, we need to not only declare it, but also construct it with new:


Scanner in = new Scanner(System.in);    // objects must be constructed

Uninitialized objects are "null" and cannot be used without a NullPointerException

Once we have an object of some class, we can call functions on that object (often called methods). here are the methods of the String class.

Creating Our Own Classes

In addition to using built-in classes, we can also create our own. We actually have created a class for each program we have created. In Java, every program needs at least one class with the "main" method, but there can be others as well.

In Java, each code file can contain only one public class, and others must not be public. We can create another class in a file as:


class Name {
    // variables and methods
};

Variables declared in a class belong to each object of the class.
The methods of a class can access the variables.
If something is public, any class can access it. If it's private, only the class itself can.
Generally, all variables should be private - because it reduces the chance of them getting set accidentally.

Below is a simple example of a program with a Circle class:


// a class used only in this program
class Circle {
    // a private variable
    private double radius;
    
    // public function to change the radius
    public void setRadius(double r) {
        if (r < 0) {
            throw new IllegalArgumentException("Radius should not be negative");
        }
        radius = r;
    }
    
    // public functions to calculate the area or circumference
    public double getArea() {
        return Math.PI * radius * radius;
    }
    public double getCircumference() {
        return 2.0 * Math.PI * radius;
    }
}

// the "main" class for the program
public class test {
    // the main function
    public static void main(String args[]) {
        // declare two circle objects
        Circle c1, c2;
        
        // construct them
        c1 = new Circle();
        c2 = new Circle();
        
        // set the radii
        c1.setRadius(2.5);
        c2.setRadius(42.0);
        
        // print the information
        System.out.printf("Circle 1: Area = %f, Circumference = %f\n",
            c1.getArea(), c1.getCircumference());
        System.out.printf("Circle 2: Area = %f, Circumference = %f\n",
        c2.getArea(), c2.getCircumference());
    }
}

It is a good idea to keep the data in a class private. That lets us prevent errors such as the code using the class setting the radius to a negative number, for example.

static vs. non-static functions

Notice that the functions of the Circle class are not static, unlike the ones we have talked about so far. There is a big difference between static and non-static things in Java:

static
Things which are static belong to the class itself and are shared between all actual objects of a class. static variables are shared amongst all objects (try making radius static above). static functions can only be called with the name of the class (such as Math.sqrt), not the name of an object.
non-static
Things which are non-static belong to the individual objects of a class. All objects have their own copy of the non-static variables, and non-static methods are called on individual objects, not the class name.

Constructors

In the circle example above, the member data are uninitialized before calling the set functions. If we called getArea before setRadius, what would happen?

In order to avoid this, we need to give the class at least one constructor.

A constructor is a special member function that has the same name as the class.
Their job is to initialize the data members so the class is in a consistent state.
A class can have many different constructors with different parameter lists.
A constructor with no parameters is called a default constructor.
Constructors are called when an object is created with new.

The following two functions are constructors for the Circle class:


    // default constructor sets radius to 0
    public Circle() {
        radius = 0.0;
    }
    
    // constructor which allows a radius to be passed in
    public Circle(double r) {
        setRadius(r);
    }

If we place them in the Circle class (public section), then we can initialize our circles as follows:


    Circle c1 = new Circle();     // default
    Circle c2 = new Circle(42.0);  // non-default

this

Notice that the setRadius function takes the parameter as "r" and assigns it to the member variable "radius". What would happen if we use the same name "radius" for each?


// public function to change the radius
public void setRadius(double radius) {
    if (radius < 0) {
        throw new IllegalArgumentException("Radius should not be negative");
    }
    radius = radius;
}

What happens when we run this?

We can avoid this by either using a different name, or by using the "this" keyword which allows us to refer to the member variables unambiguously:


// public function to change the radius
public void setRadius(double radius) {
    if (radius < 0) {
        throw new IllegalArgumentException("Radius should not be negative");
    }
    this.radius = radius;
}

"this" lets you always make sure you refer to the member variables as opposed to a local one.