Held: Tuesday, February 21, 2006
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
molds for creating new objects.
Related Pages:
Assignments
Overview:
- What is a class?
- The three components of classes: fields, methods, and constructors.
- An example: Fractions.
- 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 mold 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 methods that describe and implement the capabilities
of objects in the class.
- The fields that categorize the attributes of objects
in the class.
- The constructors that allow us to construct new objects
in the class.
- We'll consider each in turn as we attempt 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
- The things you called functions in Scheme we call
methods in Java.
- There are typically 6 parts to a method declaration.
- A comment that describes the purpose of the method.
- The protection level of the method (typically
public). + The type of value the method returns. You can use
void when a method doesn't return anything.
- The name of the method.
- The parameters of the method.
- The body of the method.
- For example
- We tend to classify methods as observers and modifiers.
- Observers extract a value from the object without
changing the object.
- Mutators change the object.
- What methods might vectors in two-space provide?
- Note that this is an ADT design question.
- 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 are special methods used to create new objects
within the class.
- Whenever you build a new object in a class, you call a constructor.
- In some languages, constructors look like other methods.
- In Java, they look somewhat different.
;
Check with Bobby