Outline of Class 2: Starting With Java

A few misc. notes

• It appears that Java does not work on the back two rows of computers in 2435. Why not? Because they have small hard disks, which means that they don't have enough virtual memory.
  • Solution one: move forward in the classroom
  • Solution two: rlogin to another machine
  • Solution three: become rich and donate hard disks
• Mr. Stone has now installed the non-beta version of Java 1.1 in /usr/local/java with symbolic links from many other places. Thanks you Mr. Stone.
• Mr. Stone, in his excessive generocity (sp?) has also installed the Sun Java Workshop. We'll play with it somewhat during this term, but it is sloooowww.
• I've put a few "Introduction to Java" type books in the MathLan lab. Feel free to go over them, but please don't take them out of the lab.
• You can find answers to your survey questions in QandA/survey.html (starting with the course root).
• I responded to every survey I received by 9pm on Sunday. If you didn't receive a response, let me know.
• Anyone know of a good ISP in the area? I'd like to do a PPP dialup from home? Alternatively, anyone want to run some cable to my home? You'll certainly get some good extra credit :-).
• Andrew Nashel, our beloved TA, will have office hours in the MathLAN room from 8:00-10:00pm on Tuesdays and 7:00-10:00pm on Wednesdays. I'll do my best to have assignments due on Thursdays.
• Does anyone have any questions on the readings?
• I'm also teaching Java to the students in 152. In that class, I'm having them do short exercises as they go. You may want to attempt those exercises on your own (sorry, I don't have them all ready yet, but you can at least try the first set.)

Introduction to object-oriented programming

• Computer Scientists have developed a number of strategies for looking at algorithm and data design, including
  • procedural / imperative
  • object-oriented
  • functional
  • logical
  • declarative
• While individual definitions of each category may differ, most definitions have some similarities.
• As you might guess, object-oriented languages concern themselves with objects.
  • You might have a sense of what a "real world object is".
  • In computerese, an object is a collection of information (sometimes called "attributes") and operations that the object can perform (called "methods").
• We often categorize objects into classes. A class specifies common aspects of a set of objects. These aspects are often generic attributes and specifications of methods (E.g., "all objects in this class have a color, a size, and can draw themselves.")
  • When creating new objects, we must specify the class to which they belong.
• Most object-oriented languages support inheritance, in which classes can be based upon other classes. For example, we might say that trees are a subclass of plants.
  • A subclass "inherits" the attributes and methods of its parent class.
• Many object-oriented languages are event-driven. That is, you can specify "when this event happens, call this method of this object."

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());
  }