Classes and Objects

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:
    1. Declare the object reference variable
    2. 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 the object

    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:

    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)