JETT Workshop - Java Basics

Computer Science (CSCI) Department
College of Engineering, Computer Science, & Technology (ECST)

JETT Workshops
Java Basics

Fall 2004

Classes and Objects are fundamental concepts of Object-Oriented Programming (OOP)
(Example code and figures from Computing Concepts with Java Essentials, 3rd edition, by Cay Horstmann.
Visit www.wiley.com/college/horstmann for information on the current edition of this excellent text.)

from the AP CS Java Subset
- Students are expected to construct objects with the new operator, to supply construction parameters, and to invoke accessor and modifier methods.
  - For the A exam, students are expected to modify existing classes (by adding or modifying methods and instance variables).
  - For the AB exam, students are expected to design their own classes.
- All instance variables are private.
- Methods, constructors, and constants (static final variables) are either public or private.
- Students need to be able to implement constructors that initialize all instance variables.
  - Class constants are initialized with an initializer:
  - The rules for default initialization (with 0, false or null) are not in the subset.
  - Initializing instance variables with an initializer is not in the subset. Initialization blocks are not in the subset.

Class
- provides the definitions needed for a given type of object

kind of like a template for object creation and manipulation
can also think of it as a factory for producing instances of a certain type of object - it has constructors
it also provides operations that work on a certain type of object - it has methods
it also specifies what kind of information should be stored for each instance of one of these objects - it has instance variables

Object
- an instance of some class
- an entity you can create and manipulate in your program
- a collection of data items that store the state of the object and methods to manipulate them
Using a Class versus Implementing a Class
- using a class
  - there are many classes already defined in the Java library
  - we can use these to create objects in our programs
  - a class will provide constructors
    - these allow the user of a class to construct (create) objects
  - a class will provide a public interface
    - these are methods the user of a class can call to manipulate objects
- implementing a class
  - we can design and implement our own classes
  - we will provide constructors and a public interface
  - a class will have a hidden implementation
    - methods and data that makes the public interface work
    - these are private - hidden from a user of the class
Object Creation
new Rectangle(5, 10, 20, 30)
- new - Java keyword - create a new object - allocates memory
- Rectangle - the type of the object - given by the name of the class
- Rectangle(5, 10, 20, 30) is a call to a constructor for a Rectangle object
- 5, 10, 20, 30 - the construction parameters - vary these for different objects

Application Programmer's Interface (API)
- Rectangle is a class provided as part of the Java API
- it is part of the Abstract Windowing Toolkit (AWT)
- a package is a collection of classes - Rectangle is in the java.awt package

Implementing a Class
- a class consists of three main components
  - constructors
  - instance variables (fields)
  - methods
Method Definition
public class Greeter
{
public String sayHello()
{
String message ="Hello,World!";
return message;
}
}
- access specifier (such as public)
- return type (such as String or void)
- method name (such as sayHello)
- list of parameters (empty for sayHello)
- method body in { }

Method Parameters

public class Rectangle
{
   . . .
   public void translate(int x, int y)
   {
      method body
   }
   . . .
}

Instance Variables
public class Greeter { ... private String name; }
- access specifier (such as private)
- type of variable (such as String)
- name of variable (such as name)

Accessing Instance Variables

The sayHello method of the Greeter class can access the private instance field

public String sayHello()
{

   String message = "Hello, " + name + "!";
   return message;
}

Other methods cannot

public class GreeterTest
{
   public static void main(String[] args)
   {

      Greeter daveGreeter = new Greeter("Dave");
      . . .
      System.out.println(daveGreeter.name); // ERROR
}

Constructors

A constructor initializes the instance variables

Constructor name = class name

public class Greeter
{
   public Greeter(String aName)
   {
      name = aName;
   }
   . . .
}

Invoked in new expression
new Greeter("Dave")

Testing a Class

Test class: a class with a main method that contains statements to test another class.
Typically carries out the following steps:
1. Construct one or more objects of the class that is being tested.
2. Invoke one or more methods.
3. Print out one or more results

Encapsulation = Hiding data and providing access through methods

Exercise - create and play with the Greeter project

set up the Greeter project
- Greeter.java
- GreeterTest.java
play with the program
- create some Greeter objects in GreeterTest
- call the sayHello( ) method