• Class:
  • A definition of a set that is written in terms of the properties of the elements/members (i.e., an intensive definition of a set)
  • The set of elements/members so defined
• Object:
  • An instance of a class (i.e., an element of the set)
• Naming Conventions in Java:
  • Class identifiers begin with am uppercase letter
  • Object identifiers 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 and evaluates to a reference)

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

• The Membership Operator:
  • A binary operator with an object or class as the left-operand and a member as the right-operand
• Using the Membership Operator with Accessible Instance Attributes:
  • object.attribute
• Using the Membership Operator with Accessible Instance Behaviors:
  • object.method([actualparameter][,actualparameter]...)
  • This is referred to as calling or invoking a method

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

• 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);
        
    }

}
        

• Definition:
  • Attributes that belong to a class rather than instances of a class
• Implication:
  • They can be used without instantiating an object
• Common Uses:
  • Constants, flags, special values, etc...

• In the Integer Class:
  • MIN_VALUE
  • MAX_VALUE
• In the Double Class:
  • NEGATIVE_INFINITY
  • POSITIVE_INFINITY
  • MIN_VALUE
  • MAX_VALUE
• In the Math Class:
  • E (base of the natural log)
  • PI

• Definition:
  • Methods that belong to a class rather than instances of a class
• Implication:
  • They can be used without instantiating an object
• Common Uses:
  • Utilities, mathematical functions

• In the System Class:
  • currentTimeMillis()
  • exit()
• In the Math Class (A Utility Class):
  • abs()
  • sin()
  • cos()
  • tan()
  • log()
  • pow()
  • sqrt()

• In the Integer Class:
  • parseInt()
  • toString()
• In the Double Class:
  • parseDouble()
  • toString()

• The new Operator:
  • In Python, the constructor is invoked directly (e.g., bullwinkle = Moose())
• Primitive Types:
  • In Python, there are no primitive types (just objects/references)