Today in class we went over how to write a simple "hello world" program. Although I did it from the command line, you will probably want to write your programs using an Integrated Development Environment (IDE) such as Eclipse.

Today we focused on some important built-in variable types, including char, int, float and double.

Unlike Python, Java requires you to explicitly declare the type of a variable before you assign it a value. This is shown in the example below, which we created in class today.

A char is generally used to store the individual characters in a String. It uses up one byte of storage, which is 8 bits. Therefore it can store 2⁸ or 256 different values.

An int is a 32 bit integer. One bit is reserved for the sign (to determine whether the integer is positive or negative) and the other 31 bits give the magnitude. This allow values from about -2³¹ to +2³¹, or from about -2 Billion to +2 Billion.

A float is not used all that much. It's a form of scientific notation, with a single sign bit, an8 bit exponent storing a power of two shift, and a 23 bit mantissa.

I was slightly off in my description of double in class. It actually has an 11 bit exponent (sorry about that -- I was trying to go from memory).

There are total of 64 bits (8 bytes) in a double. The top bit is for the sign, then 11 bits for the exponent, then the remaning 52 bits for the mantissa.

You probably don't need to know more than that at this point, although we may revisit this topic later in the semester if we have time.

Constants that have a decimal point -- like 5.3 -- are interpreted by the compiler as double. If they don't have a decimal point, they are interpreted as an int.

Rules for combining ints and doubles:

• In an expression with two ints, the result is an int (eg: 3 + 4).
• In an expression with an int and a double, the result is a double (eg: 3 + 4.5).
• In an expression with two doubles, the result is a double (eg: 3.2 + 4.5).

int n = (int)(3.5 + i);

Here is the example we created in class:

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

   // EXAMPLES OF DECLARING AND SETTING INTEGER VARIABLES

      int i = 4;
      int j = 10;
      int k = i + j;
      int m = 5 * k;

   // EXAMPLES OF DECLARING AND SETTING DOUBLE VARIABLES

      double x = 5 * k;
      double y = 5.0 * k;

   // EXAMPLE OF CASTING A DOUBLE EXPRESSION TO AN INT

      int n = (int)(50.1 * k);

      System.out.println(n);
   }
}

Your homework for Wednesday is to email your web URL to the grader. The subject line of your email should read "PERLIN CLASS". Your short essay should already be up on your web page.

Your homework, which will be due Wednesday September 21, will be to create a program that tells a "procedural story" as we discussed in class, in which your program's output mixed printed text and variables.

Your program should incorpate arguments from the command line. To run a program with command line arguments from Eclipse:

• Right-click on the project name in the Package Explorer window long the left.
• Select Run As → Run Configurations...
• In the window that pops up, select the "Arguments" tab (the second tab).
• Type in your command line arguments, separated by spaces.

See if you can make your procedural story fun and interesting. As inspiration, you can use some subject that interests you, such as baseball stats, history, physics, fashion (eg; converting clothing sizes betw. U.S. and somewhere else), math puzzles, economics, geography or literature.

To upload your homework you will need to go into the Eclipse workspace folder in your computer's file system (on a Mac it is, by default, within the Documents folder).

Compressing your folder into a zip file:

• On a Mac: Right-click on the file, and choose the "Compress [filename]" option.

• On Windows: Right-click on the file, and choose the "Send to" → Compressed (zipped) folder" option.

You will end up with a file named something like HelloWorld.zip.

Upload this file into the public folder on the web site you use for this class. Then link to the zip file from your index.html file.

As we said in class, the syntax for embedding a link into an html file looks something like this:

My homework is in <a href=HelloWorld.zip>This compressed file</a>.

In class we covered the topic of Strings, and discussed the fact that the '+' operator is overloaded, so that it results in concatenation, if at least one of its two operands is a String. If the other operand is not a String, then that other operand becomes promoted to a String. For example:

System.out.println("The value is " + 3);

The value is 3

We ended up with the following program, which is an example of a kind of procedural story:

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

// CHECK TO SEE THAT THE USER HAS ENTERED AT LEAST FOUR COMMAND LINE ARGUMENTS

      if (args.length < 4) {

 // IF THEY HAVEN'T, PRINT OUT A MESSAGE DESCRIBING CORRECT USAGE OF THIS PROGRAM.

         System.out.println();
         System.err.println("usage: MathProblem person1 person2 int double");
         System.out.println();
         return;
      }

// THE FIRST TWO COMMAND LINE ARGUMENTS ARE PEOPLE'S NAMES.

      String person1 = args[0];
      String person2 = args[1];

// THE LAST TWO COMMAND LINE ARGUMENTS NEED TO BE CONVERTED INTO STRINGS.

      int n = Integer.parseInt(args[2]);
      int m = 103;
      double x = Double.parseDouble(args[3]);

// THE OUTPUT INTERMIXES TEXT AND ARITHMETIC EXPRESSIONS.
// JUST TO BE SAVE, ALWAYS ENCLOSE ARITHMETIC EXPRESSIONS IN PARENTHESES.

      System.out.println();
      System.out.println();
      System.out.println();
      System.out.println(person1 + " has " + n + " bags of groceries.");
      System.out.println("Each bag has " + m + " twinkies.");
      System.out.println();
      System.out.println(person2 + " eats " + x + " bags of his twinkies.");
      System.out.println("How many twinkies does " + person1 + " have?");
      System.out.println();
      System.out.println("He has " + ((n - x) * m) + " twinkies.");
      System.out.println();
      System.out.println();
      System.out.println();
   }
}

We introduce Java's boolean data type, which has only two possible values: true and false -- the two boolean typed constants in Java, and therefore reserved words (that is, you can't use them as variable names).

Command-line programming in Windows:

1. You need to locate the /java/bin/ path after installing the Java SE development environment (found here: http://www.oracle.com/technetwork/java/javase/downloads/jdk-6u27-download-440405.html). By default it is C:\Program Files\Java\jdk1.6.0_XX\bin\.

2. Click Start -> Settings -> Control Panel -> System. Click on the Advanced tab -> Environment Variables. In the system variables section, you need to modify the "Path" variable, and add ";" on the end. The semicolon separates path arguments and you must include it. For example, if the Variable Path had the value "C:\Windows\System32\", it needs to be "C:\Windows\System32\; C:\Program Files\Java\jdk1.6.0_XX\bin\".
3. You may need to restart the computer, but now when you open the DOS cmd window (Start -> Run -> cmd), you can call "javac" and "java" commands directly from the command line like Ken does in class.

Simulating comand-line arguments in Eclipse:

1. Menu -> Run -> Run Configurations... -> Arguments tab -> Program Arguments

2. In the "Program Arguments" input window, on a single line you can enter the arguments that will go to your main function (just like you would from the command line from Unix or DOS).

3. The VM arguments on the same page are for changing the parameters of the java runtime engine.

In class we talked about the other kinds of conditionals: conditional expressions and switch/case statements. These are language elements that Java inherited from the C programming language, on which it is partly based.

Conditional expressions let you embed flow of control decisions right into the middle of an expression, rather than needing to build an entire if/else statement.

The syntax for a conditional expression is:

BOOLEAN-EXPR ? EXPRESSION-TO-EXECUTE-IF-TRUE : EXPRESSION-TO-EXECUTE-IF-FALSE

For example, the following expression:

n < 10 ? 100 : 200

Either of the last two expressions can itself be a conditional expression, and this allows you to do the equivalent of chained if else if else ... statements. For example, the following are both valid conditional expressions. They both do the same thing:

n > 0 ? "positive" : n < 0 ? "negative" : "zero

n >= 0 ? n > 0 ? "positive" : "zero" : "negative

Because the ? and : operators have a very low precedence, you generally want to put a conditional expression in parentheses, when you use it in a larger expression. For example, consider the following code:

if (x > 0)
   y = 10 * (x + 1) - z;
else
   y = 10 * x - z;

y = 10 * (x > 0 ? x + 1 : x) - z;

Switch/case statements are a way to explicitly express the concept of having a number of discrete cases to choose from. The syntax is as follows:

switch ( INTEGER-EXPR ) {
case INTEGER-CONSTANT : STATEMENTS
case INTEGER-CONSTANT : STATEMENTS
...
}

By default, after a case is executed, execution continues with the immediately following case. Often that is not what we want. Fortunately, there is also a special statement, break;, that jumps execution to the end of the switch/case statement.

For example, the following code assigns values to a String variable based on a numeric value.

String value = "unknown";
switch (n) {
case  1: value = "one"; break;
case  2: value = "two"; break;
case  3: value = "three"; break;
case  4: value = "four"; break;
case  5: value = "five"; break;
case  6: value = "six"; break;
case  7: value = "seven"; break;
case  8: value = "eight"; break;
case  9: value = "nine"; break;
case 10: value = "ten"; break;
}

There are also situations where it's useful to not use break statements. As we discussed in class, letting execution drop through from one case to the next can be used to compute triangular numbers or factorials:

int sum = 0;
switch (n) {
case 10: sum += 10;
case  9: sum +=  9;
case  8: sum +=  8;
case  7: sum +=  7;
case  6: sum +=  6;
case  5: sum +=  5;
case  4: sum +=  4;
case  3: sum +=  3;
case  2: sum +=  2;
case  1: sum +=  1;
}

int product = 0;
switch (n) {
case 10: product *= 10;
case  9: product *=  9;
case  8: product *=  8;
case  7: product *=  7;
case  6: product *=  6;
case  5: product *=  5;
case  4: product *=  4;
case  3: product *=  3;
case  2: product *=  2;
case  1: product *=  1;
}

Here is an example of using the default statement. In this case we are using it to flag an error condition, when variable n has an unexpected value:

int value = 0;
switch (n) {
case 0: value =   1; break;
case 1: value =   2; break;
case 2: value =   4; break;
case 3: value =   8; break;
case 4: value =  16; break;
case 5: value =  32; break;
case 6: value =  64; break;
case 7: value = 128; break;
case 8: value = 256; break;
default:
System.out.println("error: n is out of range");
break;
}

We also discussed special-purpose shorthand that Java provides, also inherited from the C programming language.

Assignment operators: Anywhere you have an assignment that modifies a variable (eg: a = a + 1), you can place the operator to the left of the equals sign, as a kind of short-hand.

Below are some examples. In the left is the long way of saying it. In the right column is the more compact way, using an assignment operator:

n = n + 1;		n += 1;
a = a * 2;		a *= 2;
x = x / 3;		x /= 3;

Special cases of assignment operator are the increment and decrement operators, which are particularly useful for controlling the value of looping variables.

The two increment operators are:

n++ // Increase n by one.  The value of this expression is what n was before the increment happened.
++n // Increase n by one.  The value of this expression is what n becomes after the increment happens.

The two decrement operators are:

n-- // Decrease n by one.  The value of this expression is what n was before the decrement happened.
--n // Decrease n by one.  The value of this expression is what n becomes after the decrement happens.

For example, the following code:

int n = 0;
while (n++ < 4)
   System.out.println(n);

1
2
3
4

int n = 0;
while (++n < 4)
   System.out.println(n);

1
2
3

Example 1 of a "variable story":

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

      if (args.length < 2) {
         System.out.println("usage: MyStory1 Y/N name1 M/F name2 M/F");
         return;
      }

      boolean areFriends = args[0].equals("Y");

      String name1 = args[1];
      String name2 = args[3];

      boolean isMale1 = args[2].equals("M");
      boolean isMale2 = args[4].equals("M");

      System.out.println();
      System.out.println();
      System.out.println(name1 + " went to the store.");
      System.out.println("While buying something, " + (isMale1 ? "he" : "she") + " saw " + name2 + ".");
      System.out.println("This made " + name2 + " " + (areFriends ? "happy" : "miserable") + ".");
      System.out.println();
      System.out.println();
   }
}

Example input for the above program:

java MyStory1 Y Fred M Wilma F

Fred went to the store.
While buying something, he saw Wilma.
This made Wilma happy.

Example 2 of a "variable story":

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

      if (args.length < 2) {
         System.out.println("usage: MyStory2 integer1 integer2");
         return;
      }

      int i = Integer.parseInt(args[0]);
      int j = Integer.parseInt(args[1]);

      System.out.println();
      System.out.println();
      System.out.println("John had the choice of having " + i + " apples or " + j + " apples.");
      if (i < j)
         System.out.println("Since " + i + " is less than " + j + ", he chose " + j + " apples.");
      else
         System.out.println("Since " + i + " is greater than " + j + ", he chose " + i + " apples.");
      System.out.println();
      System.out.println();
   }
}

Example command line input for the above program:

java MyStory2 10 20

John had the choice of having 10 apples or 20 apples.
Since 10 is less than 20, he chose 20 apples.

Example 3 of a "variable story":

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

      if (args.length < 1) {
         System.out.println("usage: MyStory3 integer");
         return;
      }

      int n = Integer.parseInt(args[0]);
 
      String colorName = "not in the box";
      switch (n) {
      case 1: colorName = "red"; break;
      case 2: colorName = "orange"; break;
      case 3: colorName = "yellow"; break;
      case 4: colorName = "green"; break;
      case 5: colorName = "blue"; break;
      case 6: colorName = "indigo"; break;
      case 7: colorName = "violet"; break;
      }

      System.out.println();
      System.out.println();
      System.out.println("Mary got a brand new set of crayons, with the colors of the rainbow.");
      System.out.println("Crayon number " + n + " was " + colorName + ".");
      System.out.println();
      System.out.println();
   }
}

java MyStory3 4

Mary got a brand new set of crayons, with the colors of the rainbow.
Crayon number 4 was green.

In class we talked about arrays. In Java, an array's index starts at 0. So, for example, an array of length 10 will have indices from 0 through 9.

You declare the type of an array by saying either:

TYPE NAME[];

TYPE[] NAME;

String[] a;
int b[];
double values[];
boolean decisions[];

String[] a = new String[10];
int b[] = new int[5];
double values[] = new double[3];
boolean decisions[] = new boolean[20];

Once you've allocated memory for an array, then you can assign values to its elements:

String names[] = new String[4];

names[0] = "Bob";
names[1] = "Carol";
names[2] = "Ted";
names[3] = "Alice";

String names[] = { "Bob", "Carol", "Ted", "Alice" };

For example, consider the following statements:

int a[], b[];

a = new int[10]; // STATEMENT_1
b = a;           // STATEMENT_2

STATEMENT_2 above declares array b and assigns to it the same memory location that was already stored in array a.

So b is not a copy of a. Rather, both a and b are actually pointing to the same storage location.

This means that the following code:

int a[] = new int[10];  // a uses memory from the heap
int b[] = a;            // b uses the same memory that a uses.

a[0] = 10;
System.out.println(b[10]);

If what you really want is a separate copy, then you need to allocate two different arrays, and copy the values from one into the other. For example, the following code:

// CREATE A NEW ARRAY a AND ASSIGN SOME VALUES TO IT:

int a[] = new int[10];

for (int i = 0 ; i < 10 ; i++)
   a[i] = i * i;

// CREATE A NEW ARRAY c AND COPY VALUES FROM a TO c

int c[] = new int[10];

for (int i = 0 ; i < 10 ; i++)
   c[i] = a[i];

// NOW ASSIGN A DIFFERENT VALUE TO a[5]:

a[5] = 1000;

System.out.println(a[5] + " " + c[5]);

Notice in the above example how useful it is to combine arrays and for loops. This is something people do a lot in programming.

To make this easier, Java lets you say NAME.length to find the length (number of elements) of an array. For example, the two loops below act in the same way:

int a[] = new int[10];

for (int i = 0 ; i < 10 ; i++)
   a[i] = i * i;

for (int i = 0 ; i < a.length ; i++)
   a[i] = i * i;

The elements of an array can be of any time -- even an array. This is how Java lets you have multiple dimension arrays. For example, the following statements are all equivalent ways of declaring a two dimensional array of doubles:

double foo1[][];  // foo1 is a two dimensional array.  Each element is a double.
double[] foo2[];  // foo2 is an array.  Each element is an array of double.
double[][] foo3;  // foo3 is the name of a two dimensional array of double.

When thinking about arrays with more than one dimension, it's useful to remember that an array is just a pointer into memory. So an array of arrays is just an array of pointers into memory.

For example, the following statement does several things:

int foo[][] = new int[3][5];

• It declares an array named foo of type "array of array of int".
• It allocates three successive locations in the heap of pointers.
• It allocates three other arrays, each containing five ints.

Here is some code we wrote in class, which shows a number of these ideas:

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

      String[] digitNames = { "zero","one","two","three","four","five","six","seven","eight","nine" };

      int a[] = new int[10];
      a[0] = 20;
      a[5] = 40;

      System.out.println("The length of array a is " + a.length);
      System.out.println();
      for (int i = 0 ; i < a.length ; i++)
         System.out.println("Element " + digitNames[i] + " of a is " + a[i]);
      System.out.println();


      double values[] = new double[6];
      values[5] = 3.14159;

      System.out.println();
      System.out.println("My values are:");
      for (int i = 0 ; i < values.length ; i++)
         System.out.println(values[i]);
      System.out.println();


      String names[] = { "Bob" , "Carol" , "Ted" , "Alice" };

      boolean doILikeThisPerson[] = { false , true , true, false};

      System.out.println();
      System.out.println("Who I like:");
      System.out.println();

      for (int i = 0 ; i < doILikeThisPerson.length ; i++)
         if (doILikeThisPerson[i])
            System.out.println("I like " + names[i]);
         else
            System.out.println("I do not like " + names[i]);

      System.out.println();
   }
}

public class arrays3
{
   public static void main(String args[]) {
       int product[][][] = new int[100][100][100];
       for (int i = 0 ; i < product.length ; i++)
        for (int j = 0 ; j < product[i].length ; j++)
           for (int k = 0 ; k < product[i][j].length ; k++)
              product[i][j][k] = i * j * k;

       System.out.println( (product[34][45][56] + product[71][82][93]) );
    }
}

Methods are Java's name for what some other programming languages call functions or procedures. Next week we will learn about objects. Until then, all methods have to be declared static. The below is a simple example of defining and calling a method:

public static void main(String[] args) {
   myFirstMethod();
}

static void myFirstMethod() {
   System.out.println("This is my first method in Java.  Oh Boy!!!");
}

• Because the method doesn't return any value, its return type is void.

• To call this method, I typed the method name followed by parentheses.

public static void main(String[] args) {
   tellingAgeMethod("Fred", 27);
}

static void tellingAgeMethod(String name, int age) {
   System.out.println(name + "'s age is " + age);
}

For example, the code below has two different methods both named "minimum". The compiler is able to tell that they are two different methods because one has two arguments and the other has three arguments:

Notice that if a method is not void, then it must contain one or more return statements. Each return statement must return a value, and eEvery possible path of execution of the method must reach a return statement:

public static void main(String args[]) {
int foo = 20;
int bar = 17;
int rho = 15;

System.out.println("The minimum of " + foo + " and " + bar + " is " + lo);
System.out.println("The minimum of " + foo + "," + bar + "," + rho + " is " + minimum(foo,bar,rho));
}

static int minimum(int a, int b) {
if (a < b)
   return a;
else
   return b;
}

static int minimum(int a, int b, int c) {
if (a < b && a < c)
   return a;
else if (b < c && b < a)
   return b;
else
   return c;
}

public static void main(String args[]) {
int myNumbers[] = { 314, 159, 265, -357, 897 };

System.out.println("The minimum of myNumbers is " + minimum(myNumbers));
}

static int minimum(int[] a) {
   int smallest = a[0];
   for (int n = 0 ; n < a.length ; n++)
      if (a[n] < smallest)
         smallest = a[n];
   return smallest;
}

public static void main(String args[]) {

   int arr1[] = new int[10];
   fillArray(arr1, 0, 5, 20);
   fillArray(arr1, 5,10, 30);
   for (int i = 0 ; i < arr1.length ; i++)
      System.out.println(i + " " + arr1[i]);
}

static void fillArray(int arr[], int lo, int hi, int value) {
   for (int i = lo ; i < hi ; i++)
     arr[i] = value;
}

public static void main(String args[]) {
   System.out.println("The sum of the first 100 number is " + sumBetween(1, 100));
}

static int sumBetween(int lo, int hi) {
   int sum = 0;
   for (int i = lo ; i <= hi ; i++)
      sum += i;
   return sum;
   }

Note the use of the return statement in the middle of the method, which allows execution to return immediately to the calling method:

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

      printFunnyStatement(2);  // This is funny
      printFunnyStatement(1);

      println();

      printFunnyStatement(1);  // This is not funny
      printFunnyStatement(2);
   }

   static void printFunnyStatement(int n) {
      switch (n) {
      case 1:
         System.out.println("Two neutrinos walk into a bar.");
         return;

      case 2:
         System.out.println("The bartender says 'We don't serve neutrinos here.'");
         return;
      }
   }
}

Our first lecture about objects in Java. An object is basically a way to create abstraction, by putting data and the methods that work on that data all in one place. People who use objects need only worry about what they actually do, not the innards of how they work.

Abstraction makes programs much easier to write and to maintain, and makes it much easier for different people to work together, especially as programming projects get very large, and involve many different people.

The example of creating a new class of objects that we went over in class was Complex numbers -- a type that is not built into Java itself, but which can be quite useful. The Java class below, in a file called Complex.java, shows how data and methods are both located inside an object.

Note how we use "getter" methods, like getReal() and getImag(), to allow access to the values of these variables. Providing this extra level of indirection means that in the future we will still have the option to change how we store this data inside the Complex class, without anybody needing to change the way they use it.

public class Complex
{
   private double real, imag;

   public Complex() {
   }

   public Complex(double r, double i) {
      real = r;
      imag = i;
   }

   public double getReal() {
      return real;
   }

   public double getImag() {
      return imag;
   }

   public String toString() {
      return "(" + real + "," + imag + ")";
   }

   public void copy(Complex c) {
      if (c != null) {
         real = c.real;
         imag = c.imag;
      }
      else {
         real = 0;
         imag = 0;
      }
   }

   public void add(Complex c) {
      if (c != null) {
         real += c.real;
         imag += c.imag;
      }
   }

   public void multiply(Complex c) {
      if (c != null) {
         double r = real;
         double i = imag;

         real = r * c.real - i * c.imag;
         imag = r * c.imag + i * c.real;
      }
      else {
         real = 0;
         imag = 0;
      }
   }
}

What makes objects really interesting is that they can be instantiated. Every time you create an object instance using the new operator, you allocate an object instance from the Heap (the same place from which you get memory for arrays).

Unless data is declared to be static, a new copy of that data is created with every object instance. For example, real and imag are not static variables. Therefore, every different Complex object instance will contain a different value for these variables.

The code, below, creates two instances of Complex, and tests out their methods:

public class objex1
{
   public static void main(String args[]) {
      Complex c1 = new Complex(2, 3.5);

      Complex c2 = new Complex(4, 7.5);

      System.out.println();
      System.out.println("old c1,c2 = " + c1 + " " + c2);
      System.out.println();

      c1.add(c2);

      System.out.println("new c1,c2 = " + c1 + " " + c2);
      System.out.println();

      c1.multiply(c2);

      System.out.println("newest c1,c2 = " + c1 + " " + c2);
      System.out.println();

   }
}

We continue our discussion of objects by talking about object inheritance. For example, here is an object class called Shape:

public class Shape
{
   public Shape() {
   }
   public Shape(double width, double height) {
      this.width = width;
      this.height = height;
   }
   public String toString() {
      return "Shape{width=" + width + ",height=" + height + "}";
   }
   public double area() {
      return width * height;
   }
   public double perimeter() {
      return 0;
   }
   protected double width, height;
}

public class Rectangle extends Shape
{
   public Rectangle() {
      super();
   }
   public Rectangle(double width, double height) {
      super(width, height);
   }
   public String toString() {
      return "Rectangle{width=" + width + ",height=" + height + "}";
   }
   public double area() {
     return width * height;
   }
   public double perimeter() {
     return width + height + width + height;
   }
}

public class RightTriangle extends Shape
{
   public RightTriangle() {
      super();
   }
   public RightTriangle(double width, double height) {
      super(width, height);
   }
   public String toString() {
      return "RightTriangle{width=" + width + ",height=" + height + "}";
   }
   public double area() {
      return width * height / 2;
   }
   public double perimeter() {
      return width + height + Math.sqrt(width * width + height * height);
   }
}

public class Oval extends Shape
{
   public Oval() {
      super();
   }
   public Oval(double width, double height) {
      super(width, height);
   }
   public String toString() {
      return "Oval{width=" + width + ",height=" + height + "}";
   }
   public double area() {
      return width * height * Math.PI / 4;
   }
   CHALLENGE: CAN YOU FIGURE OUT HOW TO IMPLEMENT A perimeter() METHOD?
}

public class objex2
{
   public static void main(String[] args) {
      Shape myShape = new Shape(3.0, 4.0);
      Rectangle myRectangle = new Rectangle(3.0, 4.0);
      RightTriangle myTriangle = new RightTriangle(3.0, 4.0);
      Oval myOval = new Oval(3.0, 4.0);

      System.out.println(myShape + " " + myShape.area() + " " + myShape.perimeter());
      System.out.println();

      System.out.println(myRectangle + " " + myRectangle.area() + " " + myRectangle.perimeter());
      System.out.println();

      System.out.println(myTriangle + " " + myTriangle.area() + " " + myTriangle.perimeter());
      System.out.println();

      System.out.println(myOval + " " + myOval.area() + " " + myOval.perimeter());
      System.out.println();
   }
}

public static void main(String[] args) {
   Shape myShapes[] = new Shape[3];

   myShapes[0] = new Rectangle(20, 20);
   myShapes[1] = new RightTriangle(20, 20);
   myShapes[2] = new Oval(20, 20);

   for (int i = 0 ; i < myShapes.length ; i++)
   System.out.println(myShapes[i].area());
}

400.0
200.0
314.1592653589793

I'm sure your program will be far more interesting and fun. :-)

In this lecture we introduced Java Applets, which allow you to create interactive graphics in a web browser. In Eclipse, you should create a new project, and give it a source file that starts out something like this:

import java.awt.*;

public class MyApplet extends BufferedApplet {
   public MyApplet() {
   }

   public void render(Graphics g) {
      int w = getWidth();
      int h = getHeight();

      // DRAWING COMMANDS GO HERE
   }
}

Here was the first Java applet we developed in class today, which displays the primary (additive) and secondary (subtractive primary) color:

import java.awt.*;

public class MyApplet1 extends BufferedApplet
{
   public void render(Graphics g) {
      int w = getWidth();
      int h = getHeight();

      g.setColor(Color.white);
      g.fillRect(0, 0, w, h);

      g.setColor(new Color(255, 0, 0, 128)); // RED
      g.fillOval(100, 100, 150, 170);

      g.setColor(new Color(0, 255, 0, 128)); // GREEN
      g.fillOval(200, 100, 150, 170);

      g.setColor(new Color(0, 0, 255, 128)); // BLUE
      g.fillOval(300, 100, 150, 170);


      g.setColor(new Color(0, 255, 255, 128)); // CYAN
      g.fillOval(100, 200, 150, 170);

      g.setColor(new Color(255, 0, 255, 128)); // MAGENTA
      g.fillOval(200, 200, 150, 170);

      g.setColor(new Color(255, 255, 0, 128)); // YELLOW
      g.fillOval(300, 200, 150, 170);

      g.setColor(new Color(0, 0, 0, 128)); // BLACK
      g.fillOval(400, 200, 150, 170);
   }
}

import java.awt.*;

public class MyApplet2 extends BufferedApplet
{
   public void render(Graphics g) {
      int w = getWidth();
      int h = getHeight();

      g.setColor(Color.white);
      g.fillRect(0, 0, w, h);

      for (int i = 0 ; i < 144 ; i++) {
         int x = 40 + 45 * (i % 12);
         int y = 40 + 45 * (i / 12);

	 g.setColor(isPrime(i + 1) ? Color.pink : Color.cyan);

	 g.fillRoundRect(x, y, 35, 35, 10, 10);
	 g.setColor(Color.black);
	 g.drawString("" + (i + 1), x + 5, y + 22);
	 g.drawRoundRect(x, y, 35, 35, 10, 10);
      }
   }
   
   boolean isPrime(int n) {
      if (n <= 1)
         return false;
      for (int i = 2 ; i < n ; i++)
         if (n % i == 0)
	    return false;
      return true;
   }
}

import java.awt.*;

public class MyApplet3 extends BufferedApplet
{
   Font myFont = new Font("Helvetica", Font.BOLD, 24);
   int x = 50;
   int y = 50;
   int changeInX = 4;
   int changeInY = 4;
   Color shadowColor = new Color(0, 0, 0, 64);
   Color foregroundColor = new Color(255, 255, 128);

   public void render(Graphics g) {
      int w = getWidth();
      int h = getHeight();

      g.setColor(Color.white);
      g.fillRect(0, 0, w, h);

      g.setColor(Color.pink);
      g.fillRect(100, 50, 200, 300);

      g.setColor(Color.cyan);
      g.fillRect(350, 250, 200, 300);

      drawThingie(g, x, y);

      if (x + 250 >= w)
         changeInX = -4;

      if (x <= 0)
         changeInX = 4;

      if (y + 80 >= h)
         changeInY = -4;

      if (y <= 0)
         changeInY = 4;

      x += changeInX;
      y += changeInY;

      animating = true;
   }

   void drawThingie(Graphics g, int x, int y) {

      g.setColor(shadowColor);
      g.fillRoundRect(x + 10, y + 10, 250, 80, 15, 15);

      g.setColor(foregroundColor);
      g.fillRoundRect(x, y, 250, 80, 15, 15);

      g.setColor(Color.black);
      g.drawRoundRect(x, y, 250, 80, 15, 15);

      g.setFont(myFont);
      g.drawString("This is my third applet!", x + 10, y + 50);

   }
}

This listing contains two files: MyApplet4.java and thingie.java.

Notice that we put the drawing logic and the behavior logic into the Thingie class itself:

import java.awt.*;

public class MyApplet4 extends BufferedApplet
{
   Thingie[] thing = new Thingie[10];
   {
      for (int i = 0 ; i < thing.length ; i++)
         thing[i] = new Thingie(50, 50, 4 + (thing.length - i), 4 + i * 4);
   }

   public void render(Graphics g) {
      int w = getWidth();
      int h = getHeight();

      g.setColor(Color.white);
      g.fillRect(0, 0, w, h);

      g.setColor(Color.pink);
      g.fillRect(100, 50, 200, 300);

      g.setColor(Color.cyan);
      g.fillRect(350, 250, 200, 300);

      for (int i = 0 ; i < thing.length ; i++) {
         thing[i].draw(g);
         thing[i].behavior(0, 0, w, h);
      }

      animating = true;
   }
}



import java.awt.*;

public class Thingie
{
   Font myFont = new Font("Helvetica", Font.BOLD, 24);
   int x, y, changeInX, changeInY;
   Color shadowColor = new Color(0, 0, 0, 64);
   Color foregroundColor = new Color(255, 255, 128);

   public Thingie(int x, int y, int changeInX, int changeInY) {
      this.x = x;
      this.y = y;
      this.changeInX = changeInX;
      this.changeInY = changeInY;
   }

   public void draw(Graphics g) {

      g.setColor(shadowColor);
      g.fillRoundRect(x + 10, y + 10, 250, 80, 15, 15);

      g.setColor(foregroundColor);
      g.fillRoundRect(x, y, 250, 80, 15, 15);

      g.setColor(Color.black);
      g.drawRoundRect(x, y, 250, 80, 15, 15);

      g.setFont(myFont);
      g.drawString("This is my third applet!", x + 10, y + 50);
   }

   public void behavior(int x, int y, int w, int h) {

      if (this.x + 250 >= x + w)
         changeInX = -4;

      if (this.x <= x)
         changeInX = 4;

      if (this.y + 80 >= y + h)
         changeInY = -4;

      if (this.y <= y)
         changeInY = 4;

      this.x += changeInX;
      this.y += changeInY;
   }
}

On Monday we started our discussion of interfaces. Interfaces are Java's way of allowing multiple inheritance -- giving objects the ability to inherit properties from more than one ancestor class.

The basic idea of interfaces is that an object implements a sort of contract, by providing an implementation of whatever methods that the interface specifies. In this way, objects that don't actually share a common ancestry of superclasses can be referred to together. For example, they can appear in the same array.

Here is a very simple example:

public interface SaysName
{
   // NOTICE THAT THE METHOD IS DECLARED, BUT NOT IMPLEMENTED.

   public void sayMyName();
}


public class Fred extends Person implements SaysName
{
   public void sayMyName() {
      System.println("I am Fred.");
   }
}


public class Corvette extends Automobile implements SaysName
{
   public void sayMyName() {
      System.println("I am a Corvette.");
   }
}


public class test
{
   public static void main(String[] args) {
      SaysName items[] = {
	 (SaysName)(new Fred()),
	 (SaysName)(new Corvette()),
      };
      for (int n = 0 ; n < items.length ; n++)
	 items[n].sayMyName();
   }
}

public interface Flashable
{
   public void setFlashing(boolean tf);
}


import java.awt.*;

public class TestSliders4 extends BufferedApplet
{
   Slider sliders[] = {
      new Slider(100, 100, 120, 80),
      new Slider(100, 300, 120, 40),
   };
   {
      for (int n = 0 ; n < sliders.length ; n++)
         sliders[n].setColor(Color.magenta);
   }

   EyeBall eyeballs[] = {
       new EyeBall(200, 300, 40, Color.green.darker()),
       new EyeBall(200, 200, 60, Color.red),
   };

   Flashable[] things = new Flashable[sliders.length + eyeballs.length];
   {
      int index = 0;

      for (int n = 0 ; n < sliders.length ; n++)
         things[index++] = (Flashable) sliders[n];

      for (int n = 0 ; n < eyeballs.length ; n++)
         things[index++] = (Flashable) eyeballs[n];
   }

   double startTime = System.currentTimeMillis() / 1000.0;

   public void render(Graphics g) {
      int w = getWidth();
      int h = getHeight();

      // ELAPSED TIME SINCE THE APPLET STARTED

      double time = System.currentTimeMillis() / 1000.0 - startTime;

      int nFlash = (int)(time % things.length);

      for (int n = 0 ; n < things.length ; n++)
         things[n].setFlashing(n == nFlash);
      
      // DRAW EVERYTHING

      if (! wasMouseDown && mouseDown)
         for (int n = 0 ; n < sliders.length ; n++)
           sliders[n].mouseDown(mouseX, mouseY);

      if (wasMouseDown && mouseDown)
         for (int n = 0 ; n < sliders.length ; n++)
           sliders[n].mouseDrag(mouseX, mouseY);

      if (wasMouseDown && ! mouseDown)
         for (int n = 0 ; n < sliders.length ; n++)
           sliders[n].mouseUp(mouseX, mouseY);

      for (int n = 0 ; n < eyeballs.length ; n++) {
	 int x = 300 + n * 200;
         eyeballs[n].setX(x + sliders[0].getValue() / (3 - n));
	 int y = 100 + n * 20;
         eyeballs[n].setY(y + sliders[1].getValue() / (3 - n));
      }

      g.setColor(Color.white);
      g.fillRect(0, 0, w, h);

      int ghoulX = (eyeballs[0].getX() + eyeballs[1].getX()) / 2;
      int ghoulY = (eyeballs[0].getY() + eyeballs[1].getY()) / 2;

      g.setColor(Color.green);
      g.fillOval(ghoulX - 200, ghoulY - 200, 400, 400);
      g.setColor(Color.black);
      g.fillOval(ghoulX - 20 - 10, ghoulY + 65, 20, 20);
      g.fillOval(ghoulX + 20 - 10, ghoulY + 65, 20, 20);

      for (int n = 0 ; n < eyeballs.length ; n++)
         eyeballs[n].draw(g);

      for (int n = 0 ; n < sliders.length ; n++)
         sliders[n].draw(g);

      animating = true;
   }
}


import java.awt.*;

public class Slider extends Widget implements Flashable
{
   public Slider(int x, int y, int width, int height) {
      super(x, y, width, height);
   }

   public void setValue(int value) {
      this.value = value;
   }

   public int getValue() {
      return value;
   }

   public void setFlashing(boolean tf) {
      isFlashing = tf;
   }

   public void setVertical(boolean tf) {
      isVertical = tf;
   }

   public void mouseDown(int x, int y) {
      super.mouseDown(x, y);
      if (haveFocus)
         value = computeValue(x, y);
   }

   public void mouseDrag(int x, int y) {
      if (haveFocus)
         value = computeValue(x, y);
   }

   public void draw(Graphics g) {
      int r = height / 8;


      // HIGHLIGHT ME IF I AM FLASHING

      if (isFlashing) {
         g.setColor(Color.red);
         g.fillRoundRect(x - 20, y - 20, width + 40, height + 40, 40, 40);
      }

      super.draw(g);

      // CHANGE THIS TO MAKE A VERTICAL SLIDER

      g.setColor(Color.black);
      g.fillRect(x, y + height / 2 - r / 2, width, r);

      g.setColor(color.brighter());
      g.fillRect(x + value - r, y + height / 2 - 2 * r, 2 * r, 4 * r);
      g.setColor(Color.black);
      g.drawRect(x + value - r, y + height / 2 - 2 * r, 2 * r, 4 * r);
   }

   // CHANGE THIS TO MAKE A VERTICAL SLIDER

   int computeValue(int x, int y) {
      return Math.max(0, Math.min(width - 1, x - this.x));
   }

   private int value = 0;
   boolean isVertical = false;
   boolean isFlashing = false;
}


import java.awt.*;

public class Widget extends Rectangle
{
   public Widget(int x, int y, int width, int height) {
      super(x, y, width, height);
   }

   public void setColor(Color color) {
      this.color = color;
   }

   public void mouseDown(int x, int y) {
      haveFocus = contains(x, y);
   }

   public void mouseDrag(int x, int y) {
      if (haveFocus) {
        ; // ...
      }
   }

   public void mouseUp(int x, int y) {
      if (haveFocus) {
        ; // ...
        haveFocus = false;
      }
   }

   public void draw(Graphics g) {
      g.setColor(haveFocus ? color.darker() : color);
      g.fillRect(x, y, width, height);

      g.setColor(Color.black);
      g.drawRect(x, y, width, height);
   }

   Color color = Color.white;
   boolean haveFocus = false;
}


import java.awt.*;

public class EyeBall extends Ball implements Flashable
{
   public EyeBall(int x, int y, int radius) {
      super(x, y, radius);
   }

   public EyeBall(int x, int y, int radius, Color color) {
      super(x, y, radius);
      this.color = color;
   }

   public void setFlashing(boolean tf) {
      isFlashing = tf;
   }

   double angle = 0;

   public void draw(Graphics g) {
      double sin = Math.sin(angle);
      int wobble = isFlashing ? (int)(sin * radius / 4) : 0;

      g.setColor(Color.black);
      g.fillOval(x - radius - 5, y - radius - 5, 2 * radius + 10, 2 * radius + 10);
      g.setColor(ghoulWhite);
      g.fillOval(x - radius, y - radius, 2 * radius, 2 * radius);
      g.setColor(color);
      g.fillOval(wobble + x - radius / 2, y - radius / 2, radius, radius);
      g.setColor(Color.black);
      g.fillOval(wobble + x - radius / 4, y - radius / 4, radius / 2, radius / 2);

      angle += 0.4;
   }

   Color ghoulWhite = new Color(255, 245, 140);
   boolean isFlashing = false;
}

In this class we began implementing a more ambitious example of using interfaces. In this example, we allow objects of different classes to share the property that they can be sorted. The way we will do this is by having each object implement a compareTo() method. As long as sorting algorithms can call an object's compareTo() method, then that object can be sorted by the algorithm.

HOMEWORK due Wednesday November 9

Your assignment is going to be relatively easy this week. I really want to make sure you understand the concept of interfaces. So rather than implement lots of computer software, I'd like you to (1) write a short essay describing what you might use interfaces for, and then (2) write a interface that specifes one or more methods to express your concept.

Feel free to be creative. The key is to think of what kinds of functionality might be shared by very different objects. In the first example I gave above from Monday's course notes, that shared functionality was being able to say one's own name. In the second example, the one we implemented in class on Monday, it was being able to visually "flash" in some way.

In this class we introduced Java's concept of packages, which is a way of organizing code, so that classes that coordinate with each other on some larger task can be placed together. In Eclipse you can create a package using the menu system, and then drag java files into the package folder.

From the command line, to create a package named foobar you would do the following things:

• Create a folder named foobar (eg: by the command mkdir foobar)

• Place the java files that you would like to go into the package into folder foobar

• At the top of each of those files, add the line package foobar;

• Any java files outside the package that want to use it should have a line at the top that says import foobar.*;

	private	default	protected	public
Seen by all classes everywhere				yes
Seen by classes in this package and classes that extend this class			yes	yes
Seen by classes in this package		yes	yes	yes
Seen by this class	yes	yes	yes	yes

Because so many people were already gone for Thanksgiving, Wednesday's class was a review of all the material from the start of the semester.

Since it is the Thanksgiving weekend, and because a number of people are still finishing up their interface java applet assignments, I'm not going to give any new homework this week. Try to catch up on all your assignments.

We did two sorts of examples in class: (1) A very trivial example to show how to create a hierarchy of exceptions, and then to throw and catch those exceptions; (2) The beginning of an interactive graph drawing applet, which you will be able to use to build your own exception classes.