More on Classes and Objects
Objects as Method Parameters
- Remember, objects are created with the new operator. The name
we use is a reference variable
- When an object is passed into a method, the reference variable is
copied into the method's local parameter (just like with arrays) --
method parameter becomes a reference to the original object
- Bottom line: When an object is passed into a method (by its
reference variable), the method has access to the original object.
Changes to the object (from inside the method) will affect the
original
Class Variables and Methods
The modifier static can be used on variables and on
methods
- Variables
- A static variable is shared by all instances of a class. Only one
variable created for the class.
- Instance variable (not static) -- each object (i.e. each instance of
a class) gets its own copy of such a variable
- Methods
- A regular method (instance method) can only be called by an object (an
instance of the class)
- A static method (class method) can be called without creating
instances of a class. Called through class name or object name -- but
a better practice to call through the class name (to help remind that
they are static). Example: Math.round(x)
- access
- Static variables can be accessed from both instance methods or static
methods.
- Instance variables can not be accessed from static methods
(since instance variables only exist when an object exists).
Instance variables can be accessed from instance methods
To make a class variable constant, add the keyword final as a
modifier on the declaration. It's better to make your constants also
static -- since the value won't change, it's more efficient to have one
variable shared by the entire class.
Example
class Student
{
private int testGrade; // instance variable (non-static)
private static int numStudents = 0; // static variable (class variable)
private final static int pointsPossible = 100; // class constant
public Student()
{ testGrade = 0; }
public void setGrade(int gr)
{ testGrade = gr; }
public int getGrade()
{ return testGrade; }
public static void incrementNumStudents()
{ numStudents++; }
public static int getNumStudents()
{ return numStudents; }
}
In this sample code:
- testGrade is an intance variable. Each object of type
Student will have its own copy of testGrade
- numStudents is a class varaible (static). There is only one
variable shared by the whole class. The variable's value can be changed,
but changes are seen by all objects
- pointsPossible is a class constant. There is only one
variable (because of static), and its value cannot be
changed)
- setGrade and getGrade are instance methods. They
must be called through individual objects
- incrementNumStudents and getNumeStudents are static
methods. They cannot access instance varaibles of the class, but they can
be called through the class name, regardless of whether any objects have
been created
Student.java - You can get a
copy of this code example here, along with a small sample main() program
that illustrates some calls.
The Keyword this
From inside a class method, the keyword this is a reference
variable that refers to the current object. (i.e. an instance method was
called through an object. Once inside the method, this acts
as the reference name for the object).
Arrays of Objects
Creating an array of objects is a little trickier than an array of a
primitive type.
- Create an array using similar syntax to primitive types, but use the
class name instead of the primitive type name:
Student[] list = new Student[10];
This only creates an array of reference variables --
references for type Student
- Create the individual objects with new, and attach to the
reference variables (the array positions). This can be done separately:
list[0] = new Student();
list[1] = new Student();
but it's easier with a loop (as long as you are using the same constructor
for each object):
for (int i = 0; i < list.length; i++)
list[i] = new Student();
Each list[i] is the reference to an object now.
Another class example
Here is a small class example that is not in the textbook. This is a
class that implements Fraction objects.