Classes and Objects

Object -- an encapsulation of data along with functions that act upon that data. (Attempts to mirror the real world, where objects have attributes and are associated with activities).

An object consists of:

Name -- the variable name we give it
Attributes (or state) -- a set of data fields and their current values, describing the object
Methods (behavior) -- a set of methods that define the behavior aspects of the object

Class -- a blueprint for objects. A class is a user-defined type that describes and defines objects of the same type. A class contains a collection of data and method definitions.

An object is a single instance of a class. You can create many objects from the same class type.

Small example: Circle.java

Creating Objects

Objects are created from a class by using the new operator, and they must be attached to a reference variable. Two steps:

Declare the object reference variable
Create the object with the new operator and attach it to the reference variable

Format

  ClassName objectReference;
  objectReference = new ClassName();

(or combined into one statement)

  ClassName objectReference = new ClassName();

Examples:

  Circle myCircle;		// where Circle is a class
  myCircle = new Circle();

  Dog fido = new Dog();		// where Dog is a class

Caution: Since the name used to refer to an object is a reference variable, and not the object itself, it is important to note that any assignments done on such a variable are just on the reference. For example, if we create two objects, and then assign their variables together:

  Circle c1 = new Circle();
  Circle c2 = new Circle();

  c1 = c2;

... the last statement (c1 = c2) does not copy circle c2 into c1. Instead, it copies the reference varaible c2 to c1, which means that both reference variables are now referring to the same object (the second one, c2).

Using Objects

Once an object is created, access the object's internal methods and data with the dot-operator. Format:

  objectReference.data
  objectReference.method(arguments)   // a call to a method

Example:

  Circle c1 = new Circle();
  c1.radius = 10;		// access radius instance variable

  // compute and print the area with the findArea method
  System.out.print("Area = " + c1.findArea());

Protection levels in a class (Visibility Modifiers)

We can declare members of a class to be public or private.

public - can be accessed from inside or outside of the object.
private - can only be used by the object itself.

The public members of a class make up the interface for an object (i.e. what the outside builder of the object can use). The user of an object is some other portion of code (other classes, functions, main program).

Although there is no set rule on what is made public and what is made private, the standard practice is to protect the data of a class by making it private. Provide access to the data through public methods, which can maintain control over the state of the object.

Reasons for data hiding:

Makes interface simpler for user.
Principle of least priveledge (need-to-know)
More secure. Less chance for misuse (accidental or malicious).
Class implementation easy to change without affecting other modules that use it.

Constructors

A constructor is a special member function of a class whose purpose is usually to initialize the members of an object.

A constructor is easy to recognize because:

It has the same name as the class
It has no return type

Constructors can have parameters. A constructor without any parameters is known as a default constructor.

A constructor is automatically invoked when an object is created with new.

  c1 = new Circle();    // invokes default constructor
  c2 = new Circle(9.0)  // invokes a constructor with one parameter

The usual purpose of a constructor is to perform any initializations on the object when it is created (i.e. primarily the instance variables)

Accessors and Mutators

Since it's a good idea to keep internal data of an object private, we often need methods in the class interface to allow the user of objects to modify or access the internally stored data, in a controlled way.

An accessor method is a function that returns a copy of an internal variable or computed value. A common practice is to name these with the word get.

A mutator method is a function that modifies the value of an internal data variable in some way. The simplest form of mutator function is one that sets a variable directly to a new value -- a common practice is to name these with the word set.

Example

Here is a different version of the Circle class, called Circle2: Circle2.java.

Note that this example contains two constructors, accessor functions, and mutator functions.