Outline of Class 3: Procedural Programming in Java

Miscellaneous

• Let me know when my handwriting becomes hard to read. With some effort, I can make it more readable.
• For those of you interested in another tutorial guide to Java, check out http://java.sun.com/docs/books/tutorial/index.html.
• How often do you folks read your email? Can I count on you reading a letter I send during the day by the evening?
• Although yesterday's notes include a step-by-step disection of the HelloWorld class that we didn't get to, we won't be going over it today.
• Since my web pages tend to change regularly, you may want to do a forced reload from your browser when you return to a page.

Procedural Programming

• Although Java is primarily concerned with the creation of classes and objects, and with the communication between objects, the definitions of methods in Java are primarily imperative/procedural.
• (Those of you who didn't take 151 in Scheme can probably sleep for the next few comments.)

• In a procedural (or imperative) language, programs are written as collections of what I term "basic actions" which are then sequenced with "control structures".
• Basic actions are typically of one of the following forms:
• Get a value from memory
• Store a value in memory
• Compute a value from other values
• Read a value from an input device
• Write a value to an output device
• We usually reserve and assign types to memory locations using variables. These are similar to the things you declare using let.
• There are a variety of control structures in imperative languages. The basic ones include
  • Sequencing
  • Conditionals
  • Loops
  • Function calls
• In imperative languages, instructions are often presented in sequences, and the instructions are then executed one-by-one. This corresponds to the block command in scheme.
• Conditionals select one of a number of options, based on a selector value. The most common conditional is the if statement. In most imperative languages, if selects between two alternative sequences of actions (or decides whether or not to execute a single alternative) based on the value of a boolean expression.
• Loops repeat a sequence of actions some number of times. The number of times can be fixed, or it can depend on a condition that is regularly checked. You may know loops form the do loop of scheme.
• Function calls are similar to those of Scheme. When you call another function, the body of that function is executed.

Java Basics

• In Java, you program by defining classes, constructing instances of (objects from) those classes, and doing things with those instances.
• Each class is stored in a separate file. (Okay, you can combine the source code for a number of classes into one file, but when compiled they are broken into separate files.)
• When building large projects, you often group classes into projects. We'll come back to these later.
• What are the components of a class? (Not in order.)
  • The class name
  • The protection level of the class (for now, we'll just use public)
  • The body of the class, which includes
    • attributes (also called fields), which are then customized for each instance of the class
    • methods, which may behave differently for each instance of the class
    • class attributes, which belong to the class as a whole, rather than to any individual members (we'll come back to these later)
    • class methods, which belong to the class as a wholle, and are not associated with individual members
    • constructors, which describe how to build instaces of the class
    • destructors, which describe how to get rid of instances of the class
• How do you define a class?
  • A class definition begins with the keyword class and the name of the class. Custom says that we capitalize the names of classes.
  • The body of the class begins with a left brace, and ends with a right brace.
  • Attributes are declared by writing the class (or primitive type) of the attribute, followed by the name of the attribute, followed by a semicolon.
  • Java allows you to restrict access to classes. To make a class generally accessible, you precede the keyword class with public.
  • Java allows you to base classes on other classes. We'll get back to this later.
  • Java allows you to indicate that your class will support particular sets of actions. We'll get back to this later.
  • Attributes can also have protection modifiers (like the public we use with the class).

• The "primitive types" mentioned above are the primary building blocks of objects. They are the basic kinds of values that the Java machine knows about, and include
  • boolean, for true/false values
  • char, for characters (unlike many other languages, Java officially supports more than just the basic American set; it has built-in support for full Unicode)
  • byte, for very small integers in the range
    • 128 to 127 (integers are numbers without fractional portions)
  • short, for small integers in the range
    • 32,768 to 32,767.
  • int, for integers in the approximate range
    • 2 billion to 2 billion
  • long, for integers in a much bigger range
  • float, for numbers that may have a fractional component (e.g., 10.32533).
  • double, for better accuracy
  • See p. 227 of Flanagan for full list.
• The names are composed of letters, numbers, and underscores (and perhaps a few other things) and must begin with a letter or underscore.

• Here's a simple class definition of a class that has no methods.

  public class Complex {
    double real_part;
    double imaginary_part;
  }
  

• This says that class Complex has two fields, each of type double.

• How do you get a new element of the class? Traditionally, you can declare a new object with
  class-name variable-name = new class-name()
• For example,
  Complex c1 = new Complex()

• To define a method of a class, you provide
  • The return type of the method (you return values from methods with the return statement).
  • The name of the method
  • An open paren
  • The list of parameters to the method
  • A close paren
  • An open brace
  • The body of the method (a series of statements, each of which is terminated by a semicolon)
  • A close brace
• You can also preface the return type with a number of modifiers, which we'll come back to later.
• Standard methods can refer to the attributes associated with the class (and ancestor classes, but we'll get back to that later).
• To call the method associated with an object, you use
  • the object's name
  • a period
  • the method's name
  • an open paren
  • the paremeters to the method
  • a close paren
• Note that this is somewhat different than in a language like C or Pascal, in which the object would be one of the parameters.

• Here's our sample class, extended with three methods, one to set the parts, one to get the real part, and one to get the imaginary part.

  public class Complex {
    double real_part;
    double imaginary_part;
    public void setValue(double rpart, double ipart) {
      real_part = rpart;
      imaginary_part = ipart;
    }
    public double getReal() {
      return real_part;
    }
    public double getImaginary() {
      return imaginary_part;
    }
  }
  

• How does Java know where to begin executing your program, especially when you may have multiple classes, each with multiple methods? You must tell the Java interpereter which class to begin with, and that class must have a special main method, which is where the interpreter begins. main has type void and must be public and static. It takes one parameter, an array of strings.
• Here is a main routine for our sample class

  public static void main(String[] args) {
    Complex c1 = new Complex();
    System.out.print("Initially, the real part is ");
    System.out.println(c1.getReal());
    System.out.print("Initially, the imaginary part is ");
    System.out.println(c1.getImaginary());
    c1.setValue(1.0,3.4);
    System.out.print("Now, the real part is ");
    System.out.println(c1.getReal());
    System.out.print("Now, the imaginary part is ");
    System.out.println(c1.getImaginary());
  }
  

Exercise

• I don't expect to get to this exercise until tomorrow, but I though I'd at least give you something to think about. If you'd like, you can try it tonight, but you don't have to.
• Define a class, Chair, that includes at least one attribute, serial_number, of type int, and at least two methods, setNumber(), which sets the number, getNumber(), which returns the number.
• Add a main() routine to the class which creates two chairs, gives them serial numbers, and then prints out the serial numbers.
• Experiment with the class. Here are a few things to try. You should try to guess what will happen before trying it.
  • What happens if you try to call Chair.getNumber()?
  • What happens if you try to call ugly.main(), where ugly is an object of class Chair?
  • What happens if you try to set the serial number to a too-large number?
  • What happens if you try to set the serial number to a floating point number?