Classes, Part 1: CS 310 Lecture notes

Object-Oriented Programming with Java Lecture Notes

3 February 2009 • Classes, Part 1

Outline

Object-oriented programming, again.
Basic class syntax.
Fine points for class execution.
- Field access.
- Instance variable initialization.

Object-Oriented Programming

Object-oriented programming models a system in a desired state.
- The system may or may not exist before hand.

System Modeling

A system model is a collection of interacting entities.
These models are called domain models.

Analysis and Design

From where do the domain models come?
- That’s the analysis and design part.
- Not really our concern, but listen to the problem.
One simple approach is called noun-verb analysis.
- Parse the problem for nouns and verbs.
  - The nouns represent domain entities.
  - The verbs represent interactions between (or among) entities.

Noun-Verb Example

A partial problem description:
A driver surrenders the old license to the DMV clerk, who invalidates it.
Nouns: driver, license, DMV clerk.
Verbs: surrender, invalidates.

Observations

Model entities interact via actions.
Actions are relative to particular model entities.
- Drivers don’t invalidate DMV clerks.
How can these be represented in object-oriented programming?

Classes

A class models an entity in the system being built.

Class declarations have the form

class: [ modifiers ]? class ClassName [ modifiers ]? 
  { [ declaration ]* }
  
declaration: 
  instanceVariable | method | constructor

As in C++, there is no need to declare class components before use.
- Declarations may be ordered as desired.

Class Example

class DriversLicense {

  // blah blah blah

  }

Naming Conventions

Java programmers have a lot of conventions.
- “Conventions” means “enforced by peer pressure”.
- But non-conventional source may break some tools.
Java names are in camelCase.
- Not old_max_value, but oldMaxValue.
Class names start with a capital letter.

Methods

A class may have zero or more methods representing model interactions.

Method declarations have the format

method: [ modifiers ]? returnType
         methodName ( [ arguments ]?  ) { ... }

arguments: argument [ , argument ]*

argument: [ modifiers ]? type argumentName

Conventionally, a method name is camelCase with a lower-case first letter.

Method Example

class DriversLicense {

  boolean isValid() { ... }

  void invalidate() { ... }

  }

Constructors

A constructor is a special method that creates class instances.
Constructor declarations have the format
```
constructor: 
  [ modifiers ]? ClassName ( [ arguments ]? ) {...}
```
- There’s no return type and the method name is the class name.

Default Constructors

Every class must have at least one constructor.
A class without an explicitly declared constructor gets a default constructor.
- It accepts no arguments and does nothing.
Explicitly declared constructors inhibit the implicit default constructor.
- Unlike C++, this is usually not a problem.
- Explicitly declare a default constructor if it is.

Instance Variables

A class may have zero or more instance variables representing model state.

Instance variable declarations have the format

instanceVariable: 
  [ modifiers ]? type variables ;

variables: variable [ , variable ]*

variable: variableName [ = initializer ]?

Conventionally, a variable name is camelCase with a lower-case first letter.

Instance-Variable Example

class DriversLicense {

  String licenseNumber;
  boolean valid = true;

  DriversLicense() { ... }
  boolean isValid() { ... }
  void invalidate() { ... }
  }

Class Syntax Summary

class: [ modifiers ]? class ClassName [ modifiers ]? 
  { [ declaration ]* }
  
declaration: instanceVariable | method | constructor

instanceVariable: [ modifiers ]? type variables ;

variables: variable [ , variable ]*

variable: variableName [ = initializer ]?

method: [ modifiers ]? returnType
         methodName ( [ arguments ]?  ) { ... }

arguments: argument [ , argument ]*

argument: [ modifiers ]? type name

constructor: 
  [ modifiers ]? ClassName ( [ arguments ]?  ) { ... }

Class-Component Access

A class’s non-constructor methods and instance variables (collectively known as the class’s fields) are accessed using dot notation:
classInstance.fieldName
Unlike C++, the only reason to access a Java class method is to call it.
classInstance.methodName(arg, ...)

Self Access

A method accesses the fields of its own class instance using the name this.

boolean isValid() {
  this.invalidate();   // stupid
  return this.valid;
  }

In general references to this. are omitted.

boolean isValid() {
  invalidate();   // stupid, but shorter
  return valid;
  }

Constructor `this` Convention

A constructor idiom keeps the this. for instance variable access.
- It helps cut down on variable names.

  DriversLicense(String licenseNumber) {
    this.licenseNumber = licenseNumber;
    }

  /* or */

  DriversLicense(String ln) {
    licenseNumber = ln;
    }

Instance Variable Initialization

Java requires that every variable always contain a defined value.
- “Defined” does not mean “sensible”.
- It means (among other things) non-garbage.
When instance variables are created, they have to be initialized to obey this property.

Default Initialization

Instance variables without explicit initialization receive a default value at class-instance creation.
```
class DriversLicense {

  String licenseNumber;

  // and so on
  }
```
The default value depends on variable type.

Explicit Initialization

Explicitly-initialized instance variables receive the computed value.

class DriversLicense {

  boolean valid = true;

  // and so on.
  }

The initialization value is computed at each instance creation.

Constructor Initialization

Instance variables can also be initialized in constructors.

class DriversLicense {

  String licenseNumber;
  boolean valid = true;

  DriversLicense(String licenseNumber) {
    this.licenseNumber = licenseNumber;
    this.valid = false;
    }
  }