• Utility Class:
  • A class that contains only static attributes and methods
• Class:
  • A definition of a set that is written in terms of the characteristics of the elements (rather than by listing the elements)
  • The characteristics include both attributes and behaviors
  • The focus is on important characteristics - others are ignored (this is called abstraction)
• Object:
  • A particular element (or instance) of the set defined by a class

• Characteristic:
  • Member
• Attribute:
  • Field
  • Property
• Behavior:
  • Function
  • Method
  • Operation

• Primitive/Atomic/Fundamental Types:
  • boolean, double, int,...
• Class Types (One Kind of Reference Type):
  • Contain attributes (that can be of primitive type or reference type) and methods.

• Class Names:
  • Begin with an uppercase letter
• Object Names:
  • Begin with a lowercase letter (except for "constants" which are in all uppercase)
• Primitive/Fundamental/Atomic Types:
  • Begin with a lowercase letter
• Primitive/Fundamental/Atomic Variables:
  • Begin with a lowercase letter (except for "constants" which are in all uppercase)
• Method Names:
  • Begin with a lowercase letter

• Establish an Identity:
  • Declare a variable
• Initialize the Attributes:
  • Allocate memory for the attributes and call the constructor to perform the initialization using the new operator (which is a unary operator that has a constructor as its operand))

javaexamples/basics/ObjectExample1.java (Fragment: 0)

        // Establish an identity for the object
        Color       jmuPurple;

        // Allocate memory for and initialize the attributes
        jmuPurple = new Color(69, 0, 132);
        

• Default Constructor:
  • Has no parameters and is used to create an object with default attributes
• Explicit Value Constructor:
  • Has parameters that are used to initialize the corresponding attributes of the object

• Using Accessible Instance Attributes:
  • object.attribute
• Using Accessible Instance Behaviors (i.e., calling/invoking methods):
  • object.method([parameter]...)

javaexamples/basics/ObjectExample2.java (Fragment: 0)

        Color        lightRed, darkRed;
        int          blue, green, red, shades;

        // Initialize the attributes
        darkRed = new Color(102, 0, 0);

        // Use a getter/accessor
        blue = darkRed.getBlue();
        
        // Use another method
        lightRed = darkRed.brighter();
        
        // Use equals() and a static attribute of the Color class
        shades = 1;        
        if (!lightRed.equals(Color.RED))
        {
            shades++;
        }
        

• Capabilities of Objects in Existing Classes:
  • Refer to the "javadocs" (e.g., for the Color class)
• Capabilities of Objects in Classes we Create:
  • We will have the source code
  • We will document the source code so that we can create "javadocs"

• An Interesting Question:
  • Between when you declare an object and when you allocate memory for it, what reference/address is in the variable?
• The Answer:
  • A special reference/address that is denoted by null (and is a reference/address that isn't valid)
• Two Obvious (but Easily Ignored and Often Misunderstood) Issues:
  • There are no methods or attributes at the special reference/address denoted by null
  • So, attempting to use methods or attributes belonging to null will result in a run-time error called a NullPointerException

javaexamples/basics/NullExample1.java (Fragment: 0)

        // The variable darkRed has been declared as a Color
        // but not initialized

        // Print and use an Object which HAS NOT yet been initialized
        JMUConsole.println(darkRed.toString());
        JMUConsole.println(darkRed.brighter());        
        

• Two Possible Questions:
  • Do two identifiers refer to the same object?
  • Do two objects (of the same class) have the same attributes?
• Answering These Questions:
  • Answering the first question requires an understanding of references and involves the use of the == operator
  • Answering the second question usually involves an invocation of a .equals() method

• Mutable Objects:
  • Have attributes that can change (e.g., Rectangle and Frame are classes of mutable objects)
• Immutable Objects:
  • Do not have attributes that can change (e.g., String and Color are both classes of immutable objects)

• What Makes an Object Mutable?
  • public attributes (but they are very dangerous since there is no control over the changes that can be made)
  • Mutator methods (i.e., methods that allow attributes to be changed in a controlled way)
• Identifying Mutator Methods:
  • They often begin with set (and, hence, are often called setters)
  • They sometimes have other obvious names (e.g., increaseBy())
• Be Careful:
  • Methods that return an object of the same type are generally not mutators (e.g., the Color class has a darker() method that doesn't change the owning object but returns another Color object that is "darker")

javaexamples/basics/ObjectExample3.java

import java.awt.*;

/**
 * A simple example that uses objects of different kinds
 *
 * @author  Prof. David Bernstein, James Madison University
 * @version 1.0
 */
public class ObjectExample3
{
    public static void main(String[] args)
    {
       Color        purple;       
       Frame        window;

        // Construct a Color object that is JMU purple
        purple = new Color(69, 0, 132);        

        // Construct a Frame object
        window = new Frame();

        // Set the title of the Frame
        window.setTitle("CS159");     

        // Set the size of the Frame
        window.setSize(200, 200);
        
        // Set the background color of the Frame
        window.setBackground(purple);        

        // Make the Frame visible
        window.setVisible(true);
        
    }

}