AC

Exam Study Notes: Classes and Objects

Classes and Objects

  • Most programs manipulate things called objects, which combine data and operations.
  • Objects can represent real-world items.
  • Object-oriented programming languages represents objects as variables.

Objects

  • An object is the core element that programs create and manipulate.
  • It comprises a thing and the operations that act upon it.
  • Example: A four-digit code number for a photocopy machine.
    • Object: The four-digit code number.
    • Operations: readNumber, getSeparateDigits, testValidity, and writeNumber.
  • A program may involve multiple types of objects.
  • Example: A library database program.
    • Book object: Manipulated by getTitle, getAuthor, isOnShelf, isFiction, and goOutOfPrint.
    • ListOfBooks object: Manipulated by search, addBook, removeBook, and sortByAuthor.
  • Objects are defined by:
    • State (attributes): Characteristics such as title and author.
    • Behavior: Actions that the object can perform, such as going out of print.
  • An object is a concept independent of specific programming languages.
  • Java uses object references to represent objects as variables.

Classes

  • A class serves as a blueprint for creating objects of a particular type.
  • An object is a single instance of a class.
  • The state of an object is stored in data fields (instance variables) of the class.
  • The class methods define the object's behavior and operations.
  • Data encapsulation: Combining an object's data and methods into a class.

Public, Private, and Static

  • public: The class is usable by all client programs (code outside the class).
    • In AP Java, all classes are public.
  • Public methods are accessible to all client programs.
  • Client programs should not access private instance variables or methods.
  • private: Restricts access.
    • Private methods and variables can only be accessed by methods within the same class.
    • In AP Java, instance variables are private.
  • static: A static variable (class variable) is shared by all instances of the class; memory allocation happens once.
    • Typical uses: tracking statistics, accumulating totals, providing unique ID numbers.
    • Static final variables (constants) cannot be changed; often declared public (e.g., Math class constants).
    • A client accesses a static variable using ClassName.VARIABLE_NAME; within the class, it is referred to as VARIABLE_NAME.

Methods Headers

  • The general form for method headers (excluding constructors and static methods) is:
    • accessSpecifier returnType methodName(parameterList)
    • Access specifier: Determines method accessibility.
    • Return type: void indicates no return value.
    • Parameter list: Comma-separated items, each with a data type.
  • The implementation of the method, enclosed in a {} block, follows the header.

Types of Methods

Constructors

  • Constructors create objects of a class, sharing the same name as the class and having no return type.

  • Multiple constructors allow for different object initialization methods.

  • No-argument constructor: Provides default initial values.

    • Example: BankAccount b = new BankAccount(); initializes a BankAccount object with a zero balance and an empty string password.
    • The new operator returns the address of the new object, which is assigned to the object variable (reference).

  • Constructor with parameters:

    • Sets instance variables to specified values upon object creation.
    • Example: BankAccount c = new BankAccount("KevinC", 800.00);
    • b and c are object variables that hold the memory addresses (references) of their BankAccount objects.

Accessors

  • Accessors are public methods that access an object's state without modifying it, returning information about the object.
  • They allow access to private instance variables.
  • Example:
    public double getBalance(){
    return balance;
    }
  • Dot operator: The . operator indicates that getBalance() is a method of the BankAccount class.
  • Non-void methods return a single value, specified in the method header.

Mutators

  • Mutators change the state of an object by modifying instance variables.
  • These methods are frequently void.
  • Mutators can be private helper methods or public methods.

Static Methods

  • Static methods perform operations for the entire class, not individual objects.

  • They are declared using the static keyword in their header.

  • Static methods cannot directly call instance methods or access private instance variables because there's no implied object.

  • They can use static variables.

  • Example: A static method to get the employee count in an Employee class.
    public static int getEmployeeCount() { return employeeCount; }

  • Example: A static method to retrieve the interest rate for all bank accounts.

  • Instance methods are called using an object variable (e.g., object.method()).

  • Static methods are called using the class name (e.g., ClassName.method()).

  • Driver Class:

    • main method

  • Static methods within a driver class containing main() must be static.

  • The main() method needs to be static since, at the start of program execution, no objects exist yet.

Method Overloading

  • Method overloading involves two or more methods in the same class (or a subclass) with the same name but different parameter lists.
  • The compiler determines which method to call based on the method's signature (name and parameter types).
  • Return type is irrelevant for overloading purposes.
  • Overloaded constructors allow various object initialization methods.

Scope

  • The scope of a variable or method refers to the region where it is visible and accessible.
  • Class scope: Instance variables, static variables, and methods are accessible throughout the class (from the opening brace to the closing brace).
  • Local variable: Defined inside a method or a statement; its scope extends from its declaration point to the end of the enclosing block ({}).
  • Local variables take precedence over instance variables with the same name.

The this Keyword

  • this refers to the implicit parameter (the object for which the method is called) within an instance method.
  • Within instance methods, instance variables can be written with the this prefix (e.g., this.variableName).
  • Explicit and Implicit Parameters:
    • In a method call obj.doSomething("Mary", num), "Mary" and num are explicit parameters, while obj is the implicit parameter.
  • Examples of Using this:
    • To print the current object in the printPerson method: System.out.println(this); (invokes the toString method).
    • To differentiate between instance variables and parameters with the same name in a constructor:
      this.num
      this.denom

References

  • Reference vs. Primitive Data Types:

    • Primitive data types: double, int, char, boolean.
    • Reference data types: objects and arrays (e.g., String, Random, int[], String[][], custom classes).
    • Primitive variables directly store values; reference variables store memory addresses.

  • Declaration of objects:
    Date d = new Date(2, 17, 1948);
    * This creates a reference variable d that refers to a Date object. The value of d is the address in memory of that object

  • Aliasing: Having two references to the same object.

    • Example:
      Date birthday = d;

    • Changes made through one reference affect the other.

    • Null Reference

    • You can test whether a variable refers to an object or is uninitialized by using the keyword null

    • Example:
      if (b == null)

    • The declaration BankAccount b; defines a reference b that is uninitialized. This is known as uninitialized object variable or a null reference/pointer.

  • If a reference is not null, it can be set to null with the statement b = null;

  • Compile-time vs Run-time errors:

    • Failing to initialize a local variable results in a compile-time error.
    • Failing to initialize an instance variable results in a run-time error (NullPointerException).
    • Do not make a method call with an object whose value is null.

Method Parameters

  • Formal vs. Actual Parameters:

    • Formal parameters: Placeholders in the method header (e.g., acctPassword and amount in withdraw(String acctPassword, double amount)).
    • Actual parameters: Values supplied during the method call (e.g., "TimB" and 250 in b.withdraw("TimB", 250)).

  • Passing Primitive Types as Parameters

    • Parameters are passed by value; a copy of the argument's value is created in a new memory slot.
    • Changes to parameters within the method do not affect the original arguments.

  • Passing Objects as Parameters

  • In Java both primitive types and object references are passed by value

    • The key difference is that the address (reference) is copied, not the values of the individual instance variables.
    • Changes to the parameter within the method do affect the original object.

  • The reference is unchanged throughout, however any value associated is changed.

  • Returning an object from a method means that you are returning the address of the object (does not create a new object).