Programming Languages‎ > ‎Java‎ > ‎

05. Object Oriented Programming with Java

Object
  • An object is an encapsulation of services (behavior) and attributes/data (state).  Software objects are often used to model real-world objects you find in everyday life.  
  • Two important characteristics of real-world objects:  Have state, Have behavior
  • Software objects are modeled after real-world objects, so software objects have state and behavior. A software object maintains its state in variables and implements its behavior with methods

Classes

A class is a template or blueprint from which an object is actually made.  This is similar to a C structure, but with functions. Unlike the classes we have written so far, a class for an object will contain variables for one object and methods that operate on those variables. An instance of a class is an object

You may use a UML (Unified Modeling Language) class diagram to describe the class:

UML diagram for the Circle class:

Circle

-radius: double
-xCoord: double
-yCoord: double

+Circle( r:double, x:double, y:double) <<constructor>>
+circumference():double
+area():double
+getRadius():double
+getXCoord():double
+getYCoord():double
+setRadius(r: double)
+setXCoord(x: double)
+setYCoord(y: double)
+display()

Note: param-id : param-type may be a list
Optional before var-id or method-id: + (public), - (private), # (protected)

Optional access modifier (before class): public

  • Recall that public means class may be accessed from anywhere
  • There may be only one public class in a file
  • The name of the file must be the name of the public class (with the .java extension)
  • If NOT public (no access modifier), then the class and its members are accessible only by other classes within the same package (same directory) (more on packages later)


Class-scope Variables:

  • public variables may be accessed from any method that could access the class in which they are declared
  • private variables may be accessed only from methods inside its class (actual access may be limited)
  • static variables exist from when class is loaded to the end of the program and are called "class variables"
  • instance variables (any class-scope variable that's NOT static) exist when only when the class in which they are declared is instantiated until it's "garbage collected"

Note: Class-scope variables may be (public OR private OR none) AND (static OR not). No access specifier is package-scope


Method definitions:

  • Often include one or more constructor methods which are usually used to initialize the variables. A constructor is automatically called when a class is instantiated
  • Often include accessor methods which return the values of private variables, usually named getVarName
  • Sometimes include mutator/modifier methods which change the values of private variables, usually names setVarName
/*
Exercise 5.1: (.java document and the UML diagram) - Create a class Rectangle that has attributes (private instance variables) called length and width,  each of which defaults to 1. Include either instance variables or methods for the area and perimeter.
 - First write the UML diagram for the Rectangle class. Then write it in Java. If one or both of the parameters are <=     0, the constructor should leave or assign the default values, and the mutator should leave the length or width as it     was before.
 - Before you could test this, read page 5.7 first (not required to run this for the exercise).
*/
public class Exercise_5_1_Rectangle
{
    private double d_length = 1;
    private double d_width = 1;
   
    public Exercise_5_1_Rectangle(double length, double width)            // Constructor
    {
        // Only assign value if it is > 0 otherwise set value to 1
        d_length = (length > 0) ? length : 1;
        d_width = (width > 0) ? width : 1;
    }
   
    public double calculatePerimeter()
    {
        return 2 * (d_length + d_width);
    }   
   
    public double calculateArea()
    {
        return d_length * d_width;
    }
   
    public double getLength()
    {
        return d_length;
    }
   
    public double getWidth()
    {
        return d_width;
    }
   
    public void setLength(double length)
    {
        d_length = length;
    }
   
    public void setWidth(double width)
    {
        d_width = width;
    }
   
    public static void main(String[] args)
    {
        // Exercise 5.2
    }
}
/*
-- UML diagram

Exercise_5_1_Rectangle
-d_length: double
-d_width: double

+Exercise_5_1_Rectangle( length:double, width:double) <<constructor>>
+CalculatePerimeter():double
+CalculateArea():double
+getLength():double
+getWidth():double
+setLength(length: double)
+setWidth(width: double)
+display()
*/


Creating Java Objects

In order to create a Java object (other than a String), you need to instantiate a class.
Syntax to instantiate a class:     new ClassName( initial-values )

Note that the initial-values must match in number and type of at least one of the constructors for that class
    Example:  new Circle(1., 3., 5.);


Declaring Object Variables:

The syntax to declare an object variable is the same as declaring a variable of a primitive type, BUT the type is a class, and ...

  • an object variable will only refer to an object (after it is assigned), but is not the whole object (unlike C++)
  • you cannot copy whole objects by assigning an object variable to another object variable

/* Exercise 5.2: Write main (may be in the same or separate class from the Rectangle class) to test the Rectangle class (in Exercise 5.1).
    Instantiate at least 2 Rectangle objects, assigning them to Rectangle variables in main.
    Call several of the instance methods in the Rectangle class on those objects, displaying the results. */
public class Exercise_5_2_Rectangle
{
    private double d_length = 1;     // Remove initialization from here, not needed
    private double d_width = 1;
  
    public Exercise_5_2_Rectangle()  // Default Constructor
    {
        d_length = 1;
        d_width = 1;
    }
   
    public Exercise_5_2_Rectangle(double length, double width)            // Constructor
    {
        // Only assign value if it is > 0 otherwise set value to 1
        d_length = (length > 0) ? length : 1;
        d_width = (width > 0) ? width : 1;
    }
   
    public double calculatePerimeter()
    {
        return 2 * (d_length + d_width);
    }   
   
    public double calculateArea()
    {
        return d_length * d_width;
    }
   
    public double getLength()
    {
        return d_length;
    }
    public double getWidth()
    {
        return d_width;
    }
    public void setLength(double length)
    {
        // d_length = length;                            // -> NOT Correct in submitted homework 5.1
        d_length = (length > 0) ? length : 1;
    }
    public void setWidth(double width)
    {
        //d_width = width;                                // -> NOT Correct in 5.1
        d_width = (width > 0) ? width : 1;
    }
    public void display(){
        System.out.println("Rectangle: length = "+ d_length + ", width = " + d_width +
            ", perimeter = "+ calculatePerimeter() + ", area = " + calculateArea());    // Only for test
  }
    public static void main(String[] args)
    {
        // Exercise 5.2
        Exercise_5_2_Rectangle oRectangle1 = new Exercise_5_2_Rectangle(5,2);
        Exercise_5_2_Rectangle oRectangle2 = new Exercise_5_2_Rectangle(0,-2);
        Exercise_5_2_Rectangle oRectangle3 = new Exercise_5_2_Rectangle();                // Default constructor
       
        // Test constructor
        oRectangle1.display();
        oRectangle2.display();
        oRectangle3.display();
       
        // test get set method
        oRectangle3.setLength(10);
        oRectangle3.setWidth(0);
        System.out.println("Rectangle3: getLength() - " + oRectangle3.getLength() + ", getWidth() - " + oRectangle3.getWidth());
        oRectangle3.display();
    }
}
/* Output:
Rectangle: length = 5.0, width = 2.0, perimeter = 14.0, area = 10.0
Rectangle: length = 1.0, width = 1.0, perimeter = 4.0, area = 1.0
Rectangle: length = 1.0, width = 1.0, perimeter = 4.0, area = 1.0
Rectangle3: getLength() - 10.0, getWidth() - 1.0
Rectangle: length = 10.0, width = 1.0, perimeter = 22.0, area = 10.0
*/


Class Features

  • this keyword refers to the object on which the method operates, for instance methods only (examples below)
  • A class may have more than one constructor or method with the same name, but eachmust be unique in its parameters (for example, differ in number of parameters and/or type of parameters).  This is another example of method overloading.
  • Garbage Collection is the Java interpreter de-allocating memory for objects that have no references to them.  This occurs sporadically, when "nothing else is going on" (e.g., waiting for input or events)
  • May call System.gc( ) to force garbage collection

/* Exercise 5.3: Write a class called Customer which has private instance variables for a name, account number and SavingsAccount. Include a constructor with a String, long, and double parameters which instantiates a SavingsAccount using the double parameter. Also include accessors (get) for each instance variable and a mutator(set) for the name only. You MUST also write the UML class diagram for this class.*/

public class Exercise_5_3_Customer
{
    private String s_CustomerName;
    private long l_CustomerAcctNum;
    private Exercise_5_3_SavingsAccount oExercise_5_3_SavingsAccount;
   
    public Exercise_5_3_Customer()
    {
        oExercise_5_3_SavingsAccount = new Exercise_5_3_SavingsAccount();        // in case, might prevent exception
    }

    public Exercise_5_3_Customer(String customerName, long customerAcctNum, double balance)
    {
        s_CustomerName = customerName;
        l_CustomerAcctNum = customerAcctNum;
        oExercise_5_3_SavingsAccount = new Exercise_5_3_SavingsAccount(balance);
    }
   
    public String getCustomerName()
    {
        return s_CustomerName;
    }
   
    public long getCustomerAcctNum()
    {
        return l_CustomerAcctNum;
    }
   
    public Exercise_5_3_SavingsAccount getSavingsAccount()
    {
        return oExercise_5_3_SavingsAccount;
    }
   
    public void setCustomerName(String CustomerName)
    {
        s_CustomerName = CustomerName;                            // is it require to check for empty string ??
    }
   
    public void display()
    {
        System.out.println("Customer Name: " + s_CustomerName);
        System.out.println("Customer A/C no: " + l_CustomerAcctNum);
        System.out.println("Customer Balance: " + oExercise_5_3_SavingsAccount.getBalance());
    }
   
    public static void main(String[] args)
    {
        // Test case
        Exercise_5_3_Customer oExercise_5_3_Customer = new Exercise_5_3_Customer("ABC", 1234567890, 1000.00);
        oExercise_5_3_Customer.display();
       
        oExercise_5_3_Customer.oExercise_5_3_SavingsAccount.transaction(500);
        oExercise_5_3_Customer.display();
    }
}
/*
-- UML diagram
----------------------
Exercise_5_3_Customer
----------------------
-s_CustomerName: String
-l_CustomerAcctNum: long
-oExercise_5_3_SavingsAccount: Exercise_5_3_SavingsAccount
----------------------
+Exercise_5_3_Customer()
+Exercise_5_3_Customer(customerName: String, customerAcctNum: long, balance: double)
+getCustomerName(): String
+getCustomerAcctNum(): long
+getSavingsAccount(): Exercise_5_3_SavingsAccount
+setCustomerName(CustomerName:String)
+display()
----------------------
*/

/*
Output:
Customer Name: ABC
Customer A/C no: 1234567890
Customer Balance: 1000.0
Customer Name: ABC
Customer A/C no: 1234567890
Customer Balance: 1500.0
*/

public class Exercise_5_3_SavingsAccount
{
    private static double annualIntRate; // default 0.
    private double balance; // default 0.
   
    public Exercise_5_3_SavingsAccount(double bal)
    {
        if( bal > 0 )
            balance = bal;
        // else leave as 0
    } // end constructor
   
    public Exercise_5_3_SavingsAccount(){ }            //default const.   
    public double getBalance(){ return balance; }
   
    public boolean transaction(double amount)
    {
        if( balance + amount >= 0 )
        {   
            balance += amount;
            return true;   
        }// end if
        return false;
    } // end transaction
   
    public double addMonthlyInterest()
    {
        double interest;
   
        interest = balance*annualIntRate/12.;
        // should be rounded to nearest 100th
        balance += interest;
        return interest;
    } // end addMonthlyInterest
   
    public static boolean modifyIntRate(double newRate)
    {
        if( newRate >= 0 )
        {
            annualIntRate= newRate;
            return true;       
        }// end if
        return false;
    } // end modifyIntRate
   
    public static double getAnnualIntRate()
    {
        return annualIntRate;
    } // end getAnnualIntRate
} // end SavingsAccount

Arrays of Objects

  • Declaring arrays of objects is the same as declaring arrays of primitive types, except the type will be a class.  
  • Assigning to each element of an array of objects, however, is very different. Each element must be assigned either null (default) or an object reference.  
  • When allocating memory for an array using the new operator, each element will be initialized to null unless otherwise assigned.

/* Exercise 5.4: Declare an array of Customers in main.  Write a static method (call from main) that returns an array of Customer objects. In this method, read how many Customers from the user (prompt first),  then in a for loop, prompt and read a name, account number and savings balance, which will be passed to the Customer constructor when instantiating and assigning to an array element.*/

import java.util.Scanner;
public class Exercise_5_4_CustomerArray
{
    static Scanner oScanner = new Scanner(System.in);
    private String s_CustomerName;
    private long l_CustomerAcctNum;
    private Exercise_5_3_SavingsAccount oExercise_5_3_SavingsAccount;
   
    public Exercise_5_4_CustomerArray()
    {
        oExercise_5_3_SavingsAccount = new Exercise_5_3_SavingsAccount();        // in case, might prevent exception
    }
    public Exercise_5_4_CustomerArray(String customerName, long customerAcctNum, double balance)
    {
        s_CustomerName = customerName;
        l_CustomerAcctNum = customerAcctNum;
        oExercise_5_3_SavingsAccount = new Exercise_5_3_SavingsAccount(balance);
    }
    public String getCustomerName()
    {
        return s_CustomerName;
    }
    public long getCustomerAcctNum()
    {
        return l_CustomerAcctNum;
    }
    public Exercise_5_3_SavingsAccount getSavingsAccount()
    {
        return oExercise_5_3_SavingsAccount;
    }
    public void setCustomerName(String CustomerName)
    {
        s_CustomerName = (CustomerName != null && CustomerName != "") ? CustomerName : s_CustomerName;        // Check customer name is not null or empty string from a method or main function
    }
   
    public void display()
    {
        System.out.println("Customer Name: " + s_CustomerName);
        System.out.println("Customer A/C no: " + l_CustomerAcctNum);
        System.out.println("Customer Balance: " + oExercise_5_3_SavingsAccount.getBalance());
    }
   
    // Display customer array
    public static void displayCustomerArray(Exercise_5_4_CustomerArray [] otempExercise_5_4_CustomerArray)
    {
        for(int i = 0; i < otempExercise_5_4_CustomerArray.length; i++)
        {
            System.out.println("Customer " + (i+1));
            otempExercise_5_4_CustomerArray[i].display();
        }
    }
   
    // Create array of Customers (Note: It is a static method3)
    public static Exercise_5_4_CustomerArray [] CreateCustomerArray()
    {
        int i_numOfCustomer;
        Exercise_5_4_CustomerArray [] otempExercise_5_4_CustomerArray;
        System.out.println("Enter number of customers for whom you want to create bank accounts");
        i_numOfCustomer = oScanner.nextInt();
        if(i_numOfCustomer > 0)
        {
            // Only create memory location if user entered > 0
            otempExercise_5_4_CustomerArray = new Exercise_5_4_CustomerArray[i_numOfCustomer];
            //if(otempExercise_5_4_CustomerArray[0] == null)    // it is null, memory is allocated when constructor is called later
            //    System.out.println("NULL Ha ha ha");
            String customerName;
            long accountNum;
            double balance;
           
            for(int i = 0; i < otempExercise_5_4_CustomerArray.length; i++)
            {
                // prompt and read a name, account number and savings balance
                System.out.println("Enter information for Customer " + (i+1));
                System.out.print("Name: ");
                oScanner.nextLine();                    // to flush new line before taking value from user
                customerName = oScanner.nextLine();
                System.out.print("Account #: ");
                accountNum = oScanner.nextLong();
                System.out.print("Bank Balance $: ");
                balance = oScanner.nextDouble();
                otempExercise_5_4_CustomerArray[i] = new Exercise_5_4_CustomerArray(customerName, accountNum, balance);
            }
            return otempExercise_5_4_CustomerArray;
        }
        else
        {
            return null;               
// Handle if required

        }
    }
    public static void main(String[] args)
    {
        Exercise_5_4_CustomerArray [] oExercise_5_4_CustomerArray;
        oExercise_5_4_CustomerArray = CreateCustomerArray();
        if(oExercise_5_4_CustomerArray != null)
            displayCustomerArray(oExercise_5_4_CustomerArray);
        else
            System.out.println("No customer has been created");
    }
}
/* Output:
Enter number of customers for whom you want to create bank accounts
1
Enter information for Customer 1
Name: Firstname Lastname
Account #: 1212121
Bank Balance $: 1000
Customer 1
Customer Name: 
Firstname Lastname
Customer A/C no: 1212121
Customer Balance: 1000.0
*/


Static variables

  • May only be declared at class scope (not method scope)
  • Are allocated memory when the class in which it's declared is loaded
  • There is only one version of the static variable
  • May be accessed without instantiating its class
  • The order of initialization is declaration order


Static methods

  • May be called without instantiating its class
  • When called from another class, is called by giving: ClassName.methodName
  • May NOT access instance members (instance variables or methods) in its class


Static initialization block

  • Is a block of code preceded only by the keyword static
  • Is used to initialize static variables
  • A class may have more than one static initialization block
  • Get executed ONLY ONCE when the class is first loaded
  • Are executed in declaration order
  • In a static initialization block, any static variables or static methods referred to must be declared before the block
  • Is useful when the value of a static variable must be computed

Example of a static initialization block:

public class CreditAccount {

          private static double intRate;
          private static double difference = .05;
          
          static { // assume Bank class has static var.
              intRate = Bank.primeRate + difference;
              // good to use if you want a loop to initialize!
          }
          // other parts of the CreditAccount class here
} // end class CreditAccount


Comments