Java Static Variables

Class and Object Intro

• This chapter covers class and object creation and their use in Object-Oriented Programming (OOP).
• Explanation of message sending.
• Understand copying objects and the 'this' keyword
• A review of Accessors and Mutators
• Includes the use of 'static' keyword
• Differentiation between 'static' and 'instance' methods
• Details of encapsulation and information hiding.
• Includes object composition and the string class

What is an Object

• Objects have characteristics consisting of identity, state, and behavior
• Each object has its own unique identity, also known as Object Identifier (OID)
• Object state is comprised of attributes, like gender, age, monthly salary
• Object behavior refers to actions an object can do, these actions are called methods

What is a Class

• A class defines the blueprint/structure for creating objects
• Each class contains data properties and methods
• To create an object, a related class must be defined
• UML (Unified Modelling Language) diagrams are commonly used

Classes and Objects

• An object is a specific instance of a class
• Each object has its own state, or data properties, and method behaviors
• Common class members are data and methods

Class Definition in Java

• Class definition syntax is as follows:

public class Class_Name {
    Instance_Variable_Declaration_1;
    ...
    Instance_Variable_Declaration_n;
    Method_Definition_1;
    ...
    Method_Definition_n;
}

• Example definition in Java of a Rectangle object

public class Rectangle {
    // instance variables
    // instance methods
}

Class Example

• Classes can be defined using attributes like Height.
• Classes can require operations like finding the area or perimeter

Data Abstraction

• Private data is the syntax

private Type Instance_Variable_Name;

• Defining a method requires the syntax

public Return_Type Method_Name( Parameter_List ) {
    Method_body
}

• Example object is

public class Rectangle {
    // instance variables
    private double width;
    private double height;
    // instance methods
    public double findArea() {
        return width * height;
    }
    public double findPerimeter() {
        return (width + height) * 2;
    }
}

• Using encapsulation and info hiding to define private attributes and public methods

Method Header

• The method header contains the return data type, the method name, and the input parameters.
• The general format is public <static> Return_Type Method_Name (Parameter_List)
• Some examples of usage:

  public static int successor(double num) { ... }
  public boolean savetoDB(String name, int age, char gender) { ... }

Creating Objects

• Object Variable_Name = new Class_Name();
• In java

Rectangle rect = new Rectangle();

• Memory space is allocated to store the object

Instantiating Objects

• The object reference, rect, stores the memory address of the 'Rectangle' object
• Multiple object references can point to the same memory address/object

Constructors

• Constructors are used for initializing object data
• If no constructors are written, Java has a default constructor that does nothing
• To create objects with different initial values, constructors are overloaded

public Rectangle() // Initialise instance variables

• Can also initialize with parameters:

public Rectangle(double w, double h) { //With parameters

Creating Rectangle Objects

• Using default values for width/height:

public Rectangle() {
    width = 1.0;
    height = 1.0;
}
Rectangle rect1 = new Rectangle();

• Using argument values for width/height:

public Rectangle(double w, double h) {
    width = w;
    height = h;
}
Rectangle rect2 = new Rectangle(10.0, 20.0);

In Java

• In Java, it is called finalizer which is different from a “Destructor” keyword
• Finalize is a method that releases resources for garbage collection

Message Sending

• To ask an object to do something, the syntax is Object_Variable_Name.Instance_Method(Argument_List);
• Ensure the object exists before calling its methods, or a NullPointerException Error will occur

Copying Objects

• Copying objects can be achieved via two object references and pointed to it.

Rectangle rect1, rect2
rect2 = rect1

• Or copying objects using data properties by reference

Rectangle rect = new Rectangle( width, height );
return rect

The Keyword 'this'

• The keyword this refers to the receiver object that calls the related method
• 'this' is the object reference that stores the receiver object
• Java will use 'this' automatically if the receiver object is not specified during method call
• To use when the Class is named Rectangle, the syntax for referring to an instance of the class is this.Method_Name; , or for variables is this.Instance_Variable

public class Rectangle {
    public void print() {
        System.out.println("The area of rectangle is " + this.findArea());
    }
}

• 'this' can also be used for instance variables
• this(...); refers to the constructor

Accessors and Mutators

• Data Properties of objects should not be edited directly by other classes and functions unless for very rare purposes.
• Common types of methods used in classes are accessors, to read a data property, and mutators, to set a data property

Example Accessor / Mutator Rectangle

public class Rectangle {
private double width;
private double height ;
public Rectangle() {
    this(1.0, 1.0);
}
public Rectangle(double width, double height) {
    this.width = width ;
    this.height = height ;
}
public void setWidth(double w ) { width = w;} 
public void setHeight(double h ) { height = h;}
public double getWidth() { return width ; }
public double getHeight() { return height ; }
public double findArea() { return width * height ; }
public double findPerimeter() { return (width + height) * 2; }
}

The Keyword 'static'

• The keyword static is used in declaring either an instance variable or a method
• It is applied to the whole class instead of individual objects
• static defines static variables, also known as class variables
• It can also define static methods, also known as class methods
• A common memory area stores the value for the static instance variable.

The Keyword 'final'

• Used in class constants
• Syntax is static final
• Easy to change the value
• Easy to understand (symbolic names)
• Example use of final keyword

public static final double MAX_WIDTH = 100;

Static vs Instance Methods

• class methods reference class variables and methods, but not instance variables and methods from instance states
• The area method will not recognize width, height or other data properties

Encapsulation and Info Hiding

• Encapsulation is building a protective barrier in the class to protect an object's private data, enabling the class-only private variables to be handled with public methods (getter / setters)
• Information Hiding hides the implementation details of the class from outside users
• Users need to know what a class does and how to call the methods
• The users don't need to know the implementation details for the methods

Object Composition

• Occurs when an object includes other objects in its data section.
• The class definition contains object references from another class using instance variables.
• Using object references is called the "has-a" realtionship

String Class

• String class is used to represent text values as an object
• Syntax is String Variable_Name = text; or String Variable_Name = new String (text);
• Example:

String aString = new String("Java Programming");
String aString = "Java";

Immutable String

• String contains reference address of string object.
• String.out.println("String"); OR string.charAt(0)

Java Naming Conventions

• Lowercase indicates all words written without Capitalization. For use with packages
• Uppercase indicates all words written with capitalization. For use with Constants or Enums
• CamelCase indicates use of capitalization on each word. CustomerAccount playingCard. For use with Classes or Interfaces. Also referred to as Upper CamalCase
• Mixed case indicates a modification of camel case. customerFirstName etc. Also referred to as Lower CamelCase. For use with Methods and Variables

Summary

• An object has state and behaviors.
• A Class defines a template/blueprint for defining state and behavior.

Explore static variables in Java. Understand their characteristics, memory allocation, and thread safety considerations. Includes practical examples using a Rectangle class.