Held: Wednesday, 14 September 2005
Summary:
Today we begin the study of classes, the primary building
blocks of Java programs. As you've seen, classes can provide the
main method. However, most classes serve instead as
templates for creating new objects.
Related Pages:
Overview:
- What is a class?
- The three components of classes: fields, methods, and constructors.
- Designing classes.
- Building classes in Java.
- Now that we've written some simple programs, we're ready to
consider more details about the construction of objects and classes.
- A class provides a template for the construction of objects.
- Classes are intended to represent the similar parts of objects (e.g., every car has a color scheme, even if different cars have different color schemes).
- There are three key parts to each class:
- The fields that categorize the attributes of objects
in the class.
- The constructors that allow us to construct new objects
in the class.
- The methods that describe and implement the capabilities
of objects in the class.
- We often categorize the methods as mutators, which change
the underlying object, or observers, which simply extract
information.
- We also classify methods and fields as either related to individual
objects in the class or to the class as a whole.
- For example, the color field of cars would be associated with each individual car but a count of the total number of cars would be associated with the class as a whole.
- Similarly, each car might drive slightly differently (and the drive method would therefore be associated with individual cars) but a request to list all the available kinds of cars might be associated with the class as a whole.
- Before we attempt to implement a class, we must first design it.
- To design a class, we think about the various components.
- Fields: What are the primary pieces of data we would want to store for each object (either to describe the object or to simplify computation with the object).
- Methods: What do we want the objects in that class to be able to do?
- Constructors: What information do we need to build new objects?
- Class fields: What common information (if any) do we want to store?
- Class methods: What capabilities do we want to provide that relate to the class, but are independent of individual objects?
- Each object-oriented language provides its own syntax for describing the fields, methods, and constructors of a class.
- We'll consider each in turn as we attempt to use Java to build a simple class
for a vector in two-space. (Not necessarily a Scheme or Java "Vector".)
- You must enclose the fields, methods, and constructors of a
class in a class declaration.
- Each class gets its own file (at least in CS152).
- The typical structure of a class is as follows.
package yourname.naturalgruoping;
import ClassWhoseNameYouDontWantToTypeInFull;
/**
* A helpful introductory comment that describes the class.
*/
public class ClassName
{
// Field declarations
// Constructors
// Methods
} // class ClassName
- There are three parts to a field declaration. In reverse order,
they are:
- The name of the field.
- The type of the field. (The kinds of values it can take on.)
- An optional protection level. (We won't specify protection levels right now.)
- For example,
- You may have noted that field declarations look a lot like
variable declarations. How do they differ?
- Field declarations are part of a class; variable declarations
are part of a method definition.
- Fields are available
anywhere
in the class; variables
are available only in the method they are declared in.
- Fields have protection levels; variables do not.
- Variables may be initialized when they are declared;
fields typically are not.
- When you reference fields, you should preface them with
this.
- Here's an example of methods using the fields of a class.
public String getName()
{
return this.name;
} // getName()
public void setName(String newName)
{
this.name = newName;
} // setName(String)
- Constructors the the parts of a class that let us create new objects
within the class.
- In general, constructors assign to the fields of the class using some
initial values that come from parameters to the constructor.
- You can create many constructors for the same class, provided they
have different kinds of constructors.
- The form of constructors in Java is
protection ClassName(parameters)
{
body
} // ClassName(parameters)
- For example, if we have a field,
name, that we want to initialize with a string whenever we create an object, we might write the following:
public NamedThing(String _name)
{
this.name = _name;
} // NamedThing(String)
- Many programmers make it a custom to give the parameter a name similar to the expected field, but prefixed by an underscore.
- Note that the fields you initialize need not be directly related to the parameters.
- For example, if we were to create a Counter class, we might want to initialize an integer counter field to 0 whenever an object in that class is created.
// Fields
int counter;
// Constructors
public Counter()
{
this.counter = 0;
} // Counter()
;
Check with Bobby