A program consists of one or more class definitions, which should be in separate files. The name of the file should be the same as the name of the class, for example, MyApplication.java. One of these clases must define a method main. We next show a simple program that creates two objects of type Particle.

public class MyApplication {

   public static void main(String[] args) {
     Particle a = new Particle(1.0,1.0);        // create an instance of Particle called a
     System.out.println(a.distanceFromOrigin());
     System.out.println(a.mass);
     Particle b;
     b = new Particle();
     b.x = 2.0;
     b.y = 3.0;
     b.mass = 3;
     System.out.println(b.distanceFromOrigin());
     System.out.println(b.mass);
     System.out.println(b.getWeight());
   }
}

• The first statement in main declares a to be a Particle and uses the new keyword to instantiate an object. These two operations could have been done separately in two lines as is illustrated for Particle b. Note that java already defines primitive data types such as int and double.

• A method called main must appear in the application class, which is always the first part of the code executed. If a program has more than one class, one and only one of the classes must define main().

• The statement System.out.println() allows us to print the argument to the standard output with a call to the System class.

Java uses three explicit keywords and one implied keyword to set the boundaries in a class. The default access specifier for variables and methods is "package visibility" which means that all the other classes in the current package have access to them. Packages are Java's way of making libraries and will be discussed later. The specifier public provides access to anyone, private provides access only to methods within the same class, and protected provides access to methods in the same package and to all subclasses even if they are in different packages.

Now that we have defined a particle class, we can extend it to consider charged particles for example. That is, we want a new class ChargedParticle, that has all the functionality of Particle, but also has the ability to have a charge. We can implement ChargedParticle as an extension or subclass of Particle as shown below.

public class ChargedParticle extends Particle {
   // magnitude of electron charge in Coulombs
   public static final double ELQ = 1.602e-19;
   private int charge;
   
   public ChargedParticle(double x,double y, double mass, int charge) {
      super(x,y,mass);     // constructor for Particle
      this.charge = charge;
   }

   public int getCharge() {
      return charge;
   }
   
   public void setCharge(int newCharge) {
      charge = newCharge;
   }

   public static int netCharge(ChargedParticle a, ChargedParticle b) {
      return a.charge + b.charge;
   }
}

public class MyApplication {
      public static void main(String[] args) {
      ChargedParticle a = new ChargedParticle(10.0,0,0,1);
      System.out.println(a.distanceFromOrigin());
      System.out.println(a.getCharge());
      System.out.println(ChargedParticle.ELQ*a.getCharge());
      ChargedParticle b = new ChargedParticle(-5.0,0,0,-1);
      System.out.println(b.distanceFromOrigin());
      System.out.println(ChargedParticle.netCharge(a,b));
      b.setCharge(3);
      System.out.println(ChargedParticle.netCharge(a,b));
      }
   }

• Note how the constant ELQ, the charge of an electron, has been introduced. A variable declared final is a constant. Its value must be specified when it is declared and this value cannot be changed. The static keyword means that there is only one copy of this variable, regardless of the number of instances of the class that are created. (A better name is class variable.) The C convention of using CAPITAL letters for constants is used.

• The method setCharge defines the behavior of a particular object. In contrast, the method netCharge belongs to the class and not to a particular substantiation of the class. To call a static method one uses the class name rather than an instance name. Thus, to call the method netCharge we use ChargedParticle.netCharge(a,b) not a.netCharge(a,b). A static method is equivalent to a global function in C.

The following example illustrates the nature of static variables:

public class Test {
   public static int x = 0;
   public int y = 0;

   public String showxandy() {
      return "x = " + x + ", y = " + y;
   }

   public static void main(String[] args) {
      Test a = new Test();
      Test b = new Test();

      a.x = 5;     // static variable
      a.y = 12;    // instance variable
      System.out.println(a.showxandy());      // outputs 5, 12
      b.x = 7;
      b.y = 13;
      System.out.println(a.showxandy());      // outputs 7, 12
      System.out.println(b.showxandy());      // outputs 7, 13
      Test.x = 2;
      System.out.println(a.showxandy());      // outputs 2, 12
      System.out.println(b.showxandy());      // outputs 2, 13
   }
}

The step method uses the Euler-Richardson integration algorithm. The first time the algorithm is used we need to compute the acceleration at the beginning of the interval. After that we can use the acceleration computed at the end of the previous interval. Note how this is used in the step method to refer to the Particle itself, and then in Force we use the argument Particle to get the particle's mass.

The class which draws the trajectory is given below.

import java.awt.*;

public class ParticleSystem extends Frame {
        public static void main(String[] args) {
                ParticleSystem ps = new ParticleSystem();   // set up window for application
        }
        
        public ParticleSystem() {     // constructor
                setSize(512, 342);
                setVisible(true);
        }

        public void paint(Graphics g) {
                setBackground(Color.white);
                calculateTrajectory(g);
        }

        private void calculateTrajectory(Graphics g) {
                final double tmax = 10.0;
                final double dt = 0.5;
                Particle p = new Particle(0.0, 200.0, 40.0, 25.0);
                Force f = new Force();
                g.setColor(Color.blue);
                double time = 0.0;
                while (time < tmax) {
                        g.drawOval((int)p.getX(),
                                getSize().height - (int)p.getY(), 10, 10);  //draw circle of diameter 10 pixels
                        p.step(dt,f);
                        time += dt;
                }
        }
}

• The import statement brings in the library of routines which contains the Graphics class needed to draw on the screen. java.awt is an example of a package.

• ParticleSystem class extends the Frame class. The paint method is called when the Frame is first shown and anytime the Frame is brought to the front.

• Note that because screen coordinates increase as you move from the top of the screen toward the botton, we need to convert the usual world coordinates to screen coordinates when drawing an oval to represent the particle. Because the last two arguments of drawOval are the same the oval will be a circle.

• Note the use of the while statement which allows all the statements within the braces of the while statement to be executed again and again as long as the argument of the while statement (time < tmax) is true.

• An alternative to the while loop is the for loop which looks like for(int i = 0; i < 10;i++){ statements to be repeated}. Note the use of semicolons to separate the fields inside the parenthesis of the for statement. The first field initializes some variable. Usually, the variable is declared here also. The second field determines under what condition the loop will continue. The third field lists how the variable in the first field changes at the end of each pass through the loop.

When you click on another application covering up the frame, and then come back to your program, Java automatically calls paint. This is nice, however in the above program it means that you must recompute the trajectory. A better approach is to first draw to an offscreen image buffer and then blast this buffer to the screen. As long as the buffer is saved no new calculations are done. First we will show how this is done for the above ParticleSystem class and then we will show an example where it is more useful.

 
import java.awt.*;

public class ParticleSystem extends Frame {
    Image offscreen;
    
        public static void main(String[] args) {
                ParticleSystem ps = new ParticleSystem();   // set up window for application
        }
        
        public ParticleSystem() {     // constructor
                setSize(512, 342);
                setVisible(true);
                offscreen = createImage(getSize().width, getSize().height);
                calculateTrajectory();
        }

        public void paint(Graphics g) {
                setBackground(Color.white);
                g.drawImage(offscreen, 0, 0, this);   // draw image onto screen
        }

        public void calculateTrajectory() {
                final double tmax = 10.0;
                final double dt = 0.5;
                Graphics g = offscreen.getGraphics();
                g.setColor(Color.blue);
                Particle p = new Particle(0.0, 200.0, 40.0, 25.0);
                Force f = new Force();
                double time = 0.0;
                while (time < tmax) {
                        g.drawOval((int)p.getX(), getSize().height - (int)p.getY(), 10, 10);
                        p.step(dt,f);
                        time += dt;
                }
        }
}

• Here the Graphics class is used to provide drawing methods for offscreen which is an instantiation of the Image class. Both Graphics and Image cannot be instantiated directly with a constructor, instead one can use the getGraphics and createImage methods, respectively. The Image class represents a displayable image.

• Note how we declare offscreen outside of any method, and instantiate it with the createImage method in the constructor. This is a common technique for making objects accessible to all the methods of a class, and to insure that they continue to exist after a method returns.

Offscreen buffers are useful when we want the user to be able to draw more than one trajectory without running the program over again. To do this we want the user to interact with the program. This feature is very easy to accomplish in Java using components such as Buttons, TextFields, and Menus. Below we show how to use a TextField to receive a number from the user. We put the TextField on a separate Frame and use an actionListener to detect whether the user enters a number in the TextField. The number entered will be the friction coefficient, b,used in a drag force of the form -bv.

 import java.awt.*;
 import java.awt.event.*;   // needed for actionListener
    
 class FrictionInput extends Frame {
    TextField tf;
    Label l;
    ParticleSystem ps;
   
   public FrictionInput (ParticleSystem ps) {
      this.ps = ps;
             setUpFrame();
   }

   public void setUpFrame() {
            setTitle("Friction Input");
            setSize(200,100);
            setLocation(400,50);
            setLayout(null);   // not using any layout manager
            l= new Label("Friction Coefficient");      // new label for textfield
            l.setSize(150,20);
            l.setLocation(30,70);
            add(l);                                 // add label
            tf = new TextField();  // new textfield
            tf.addActionListener( new T());          // add listener 
            tf.setSize(50,20);
            tf.setLocation(30,40);
            add(tf);                                  // add textfield
            setVisible(true);
    }
            
  class T implements ActionListener {    // Internal class
             
         public void actionPerformed(ActionEvent e) {
             Double R = new Double(tf.getText().trim());
         ps.calculateTrajectory(R.doubleValue());
     } 
  }  
} 

• There are two objects attached to the Frame. The Label l is simply some text which will be placed under the TextField tf. The size and location of each of these components are specified. There are layout managers which automatically decide these specifications for you, but they frequently do not look good.

• Perhaps one of the neatest things about Java 1.1 is the use of the actionListener which is implemented by using the addActionListener method and an internal class which implements the ActionListener interface. An interface is like a class except none of the methods have implementations. Instead the user must supply these as we have done above for the method actionPerformed(ActionEvent e). The beauty of the above event model is that the user does not have to write any code anywhere else in the program to check for the event of the TextField being used. Whenever, a number is entered into the TextField the actionPerformed method will be executed. Here we extract the number by converting the string in the TextField to a number using the Double class, and then call the calculateTrajectory method of the object ps.

The following modification of ParticleSystem uses FrictionInput.

import java.awt.*;

public class ParticleSystem extends Frame {
    private Image offscreen;    
    private int counter = 0;  // used to change color for each trajectory
    
        public static void main(String[] args) {
                ParticleSystem ps = new ParticleSystem();   // set up window for application
                FrictionInput fi = new FrictionInput(ps);   // set up window for application
        }
        
        public ParticleSystem() {     // constructor
                setSize(512, 342);
                setVisible(true);
                offscreen = createImage(getSize().width, getSize().height); 
        }

        public void paint(Graphics g) {
                setBackground(Color.white);
                g.drawImage(offscreen, 0, 0, this);   // draw image onto screen
        }

        public void calculateTrajectory(double b) {
                final double tmax = 10.0;
                final double dt = 0.5;
                Graphics g = offscreen.getGraphics();   // create buffer
                changeColor(g);
                Particle p = new Particle(0.0, 200.0, 40.0, 25.0);
  Force f = new Force();
  f.setb(b);
                double time = 0.0;
                while (time < tmax) {
                        g.drawOval((int)p.getX(), getSize().height - (int)p.getY(), 10, 10);
                        p.step(dt,f);
                        time += dt;
                }
          repaint();
        }
        
   public void changeColor(Graphics g) {
                switch(counter++) {                     //counter increased by 1
                    case 0: g.setColor(Color.red);break;
                    case 1: g.setColor(Color.blue);break;
                    case 2: g.setColor(Color.green);break;
                    case 3: g.setColor(Color.yellow);break;
                    case 4: g.setColor(Color.magenta);break;
                    case 5: g.setColor(Color.orange);break;
                    case 6: g.setColor(Color.cyan);break;
                    case 7: g.setColor(Color.pink);break;
                    default : g.setColor(Color.black);
            }
  }
}

• Note the use of the method repaint which clears the Frame and calls paint. However, we still have all the trajectories on the offscreen buffer so that all the trajectories can still be drawn on the screen.

• In the above we have added a method, changeColor which uses a different color each time a new trajectory is drawn up to 8 trajectories. Any more are colored black. Note the use of the switch statement. Each time a trajectory is to be drawn the value of counter is checked and then incremented (using counter++. The value checked then determines which case statement to execute. Note the use of the break statement. Without it every case would be executed.

• The switch statement is useful if there are many possible choices. If there are only a few choices or if the choices cannot be encoded as an integer, then the if statement can be used. Examples of such statements are as follows:

  if ( x < 0) { 
    y = 20;
    x = 10;
  }
  
  if ( x < 0 ) 
     y = 10;     // braces not needed for single statement
  else
     y = 20;
  
  if ( x < 0 )
     y = 10;
  else if ( x > 0)
     y = 20;
  else
     y = 30;
  
  

We now return to a single trajectory and discuss animation. Instead of showing the trajectory we will simply show a ball as it moves. The following code does this so that there is very little flicker. We have reduced the time step so that the motion of the ball will be slowed down.

import java.awt.*;

public class ParticleSystem extends Frame {
    Image offscreen;
    
        public static void main(String[] args) {
                ParticleSystem ps = new ParticleSystem();   // set up window for application
                ps.calculateTrajectory();
        }
        
        public ParticleSystem() {     // constructor
                setSize(512, 342);
                setVisible(true);
                offscreen = createImage(getSize().width, getSize().height);
        }

      
        public void paint(Graphics g) {
                setBackground(Color.white);
                g.drawImage(offscreen,0,0,this);
        }

        public void calculateTrajectory() {
                final double tmax = 10.0;
                final double dt = 0.005;
                Graphics b = offscreen.getGraphics();
                Particle p = new Particle(0.0, 200.0, 40.0, 25.0);
                Force f = new Force();
                double time = 0.0;
                while (time < tmax) {
                 Rectangle oldRect = new Rectangle((int)p.getX(),getSize().height -(int)p.getY(),11,11);
                 p.step(dt,f);
                 time += dt;
                 Rectangle newRect = new Rectangle((int)p.getX(),getSize().height -(int)p.getY(),11,11);  // new region of ball
                 Rectangle r = newRect.union(oldRect);           // new plus old region
                 b.clearRect(r.x,r.y,r.width,r.height);    // clear new plus old region on buffer
                 b.fillOval((int)p.getX(), getSize().height - (int)p.getY(), 10, 10);
                 Graphics g = getGraphics();
                 g.drawImage(offscreen,0,0,this);
            }
        }
}

The basic stategy used above is to define three rectangles. One containing the old position of the ball, one containing the new position, and one which is the union of the two. Then we clear the buffer of this latter rectangle, and draw our new ball. We then draw our image to the screen. Note how we grab the Graphics object for the screen within calculateTrajectory instead of using repaint. This avoids some of the flickering that would occur from clearing the Frame.

Often we want the user to be able to interupt a simulation while it is running, and then start it going again. For example, we might want to know the coodinates of our ball at some instant while we are watching it. One can use Threads to accomplish this. Basically, a Thread is a process whcih is running parallel to another process. Below we set up a Thread and use a MouseListener to interupt the program. The interface Runnable contains the methods we need to start, stop, and run the Thread.

import java.awt.*; 
import java.awt.event.*;

public class ParticleSystem extends Frame implements MouseListener, Runnable {
  Image offscreen;
  Graphics gb;
  Particle p;
  Force f;
  boolean running = false;
  Thread runner;
    
public static void main(String[] args) {
  ParticleSystem ps = new ParticleSystem();   // set up window for application
}
        
public ParticleSystem() {     // constructor
  setSize(512, 342);
  setVisible(true);
  offscreen = createImage(getSize().width, getSize().height);
  p = new Particle(0.0, 200.0, 40.0, 25.0);
  f = new Force();
  gb = offscreen.getGraphics();
  start();
  addMouseListener(this);    
}

      
public void paint(Graphics g) {
  setBackground(Color.white);
  g.drawImage(offscreen,0,0,this);
}
    
public void start() {
  runner = new Thread(this);
  runner.start();
}

public void stop() {
  runner.stop();
}

public void run() {
  while(true) {
    try {Thread.sleep(5);}  // delay 5 msec between updates
    catch (InterruptedException e){};
    if(running) calculateTrajectory();
  }
}

public void mouseClicked(MouseEvent e) {
  Graphics g = getGraphics();
  g.clearRect(0,0,getSize().width, getSize().height);
  g.fillOval((int)p.getX(), getSize().height - (int)p.getY(), 10, 10);
  g.drawString("x = " + String.valueOf(p.getX()),e.getX(),e.getY());
  g.drawString("y = " + String.valueOf(p.getY()),e.getX(),e.getY() + 30);
  running = false;
}
public void mouseEntered(MouseEvent e) {running = true;}
public void mouseExited(MouseEvent e) {running = false;}
public void mousePressed(MouseEvent e) {}
public void mouseReleased(MouseEvent e) {}

public void calculateTrajectory() {
  private final double dt = 0.005;
  Rectangle oldRect = new Rectangle((int)p.getX(),getSize().height -(int)p.getY(),11,11);
  p.step(dt, f);
  time += dt;
  Rectangle newRect = new Rectangle((int)p.getX(),getSize().height -(int)p.getY(),11,11);  
  Rectangle r = newRect.union(oldRect);           
  gb.clearRect(r.x,r.y,r.width,r.height);    
  gb.fillOval((int)p.getX(), getSize().height - (int)p.getY(), 10, 10);
  Graphics g = getGraphics();
  g.drawImage(offscreen,0,0,this);
}
}

We have modified calculateTrajectory so that it only computes and draws one step. We have eliminated the while statement. Instead control of the trajectory is given to the run method of the Thread runner. Note the code within this method. The try catch statement is used to interupt the Thread for 5 milliseconds to check to see if any event occurred. The MouseListener checks for events. In this case we can stop the motion by moving the mouse outside the Frame, and start it again by moving it into the Frame. If the mouse is clicked we write the x and y coodinates of the ball at the location of the mouseclick, redraw the ball, and stop the motion.

We now provide the following general purpose classes. You can use these classes without knowing the details of how they are implemented. The classes are part of a Java package called simphy. To use these files you need to add import simphy.*; to any file using classes in the package. Arrays are used heavily in the classes shown below. Note how they are declared, instantiated, and in many cases initiated. To modify any of these classes you can write your own which extends the class.

• ControlFrame This class places any number of Buttons and TextFields on a Frame. The arguments of the constructor are an object which implements the Simulation interface(see below), an array of strings for the Labels for the TextFields, an array of strings for the names of the Buttons, and an optional list of initial values for the TextFields.

• ControlMenu This class has the same functionality as ControlFrame using Menus.

• Simulation This is an interface which contains the methods used to respond to Buttons, TextFields, and Menus in ControlFrame and ControlMenu. Thus, you must write a class that implements this interface. Why do we use an interface? Why not just write a class with the necessary methods? The answer is that the interface lets ControlFrame and ControlMenu have an instantiation of any class as an argument as long as that class implements the Simulation interface.

• Table This class displays a table of formated numbers separated by tabs in a Frame. The constructor arguments are the TableName and a String array of table headings for the columns. The class contains methods for setting formats for the entries to the table, adding entries to a row, and displaying a row. The Table can be copied from the Frame and pasted directly into a spreadsheet or plotting program.

• Plot This class is used to draw simple plots in separate Frames. The constructor arguments set up the type of plot, lables for axes, and the data to be plotted.

• WorldGraphics This class creates a Frame and defines many of the methods in the Graphics class in terms of world coordinates where the vertical coordinate increases as one moves up the screen. It also uses double coordinates instead of pixels, and works with an offscreen Image buffer. The constructor arguments define the minimum and maximum coordinates in the vertical and horizontal directions.

//constructors
public ControlFrame(MySimulation S, String lstring[], String bstring[]) 
public ControlFrame(MySimulation S, String lstring[], double x[], String bstring[]) 
  // use if have initial values x[]

/*  MySimulation implements Simulation

    lstring is an array of names for the labels under the TextFields
    x is an array of initial values for the TextFields
    bstring is an array of names for the Buttons

    You can also use the following methods to place values in the TextFields   
*/

   public void setText(int k, String s) 

   public void setText(int k, int x) 
   
   public void setText(int k, double x) 
  

//constructors
public ControlMenu(MySimulation S, String lstring[], String bstring[]) 
public ControlMenu(MySimulation S, String lstring[], double x[], String bstring[]) // use if have
initial values

/*  MySimulation implements Simulation

    lstring is an array of names for the parameter menu
    x is an array of initial values for the parameters
    bstring is an array of names for the action menu
   
   ControlMenu uses InputDialog class.
   
*/
    
public interface simulation

   public void buttonAction(int k);
   
   public void textAction(int k, double x);
   
   public void menuAction(int k);
   
   public void dialogAction(int k, double x);


//constructor
public Table(String TableName String h[])   // h is an array of table headings

// methods

public void setHeadings(String h[])   // display new table headings

public void setFormat(String pattern[],int FieldSize) 
 
/* Set format for table entries. Fieldsize is maximum size for each number, pattern[k]  
is the pattern for kth number. Ex. "#.000"  prints 3 decimal places. */

public void setEntry(int i, double x) // set ith value equal to x for next row to be displayed

public void setEntry(double x0, double x1) // set first two values

public void setEntry(double x0, double x1, double x2) // set first three values

public void setEntry(double x0, double x1, double x2, double x3) // set first four values

public void addEntries()  // display next row



//constructors
 public Plot(String title, String xLabel, String yLabel, int nAxes, 
         double xmin,double xmax, double ymin, double ymax)

 public Plot(String title, String xLabel, String yLabel, int nAxes, 
         double xmin,double xmax, double ymin, double ymax, int symbolSize, String symbolType) {
 
 public Plot(int nAxes,double xmin,double xmax, double ymin, double ymax) {

    
/* nAxes = 1, one bottom horizontal axis, ymin should = 0
   nAxes = 2, one left vertical axis, one bottom horizontal axis, xmin and ymin should = 0
   nAxes = 3, one center vertical axis, one bottom horizontal axis, xmin should = -xmax, ymin should = 0
   nAxes = 4, crossed axes, xmin should = -xmax and ymin should = -ymax
   nAxes = 5, crossed axes, only x > 0, xmin should = 0 and ymin should = -ymax
   nAxes = anything else, no axes drawn.  
   symbolType = "fillsquare" or "opensquare" or "opencircle" or "fillcircle"
   symbolSize = 1 for point (default), otherwise gives size in pixels */

  public void plotPoints(double x[], double y[]);

//constructor
  public WorldGraphics(String title, 
         double xmin,double xmax, double ymin, double ymax) {

  (xmin,ymin) are the coordinates for the lower left hand corner of the Frame.   
  (xmax,ymmax) are the coordinates for the upper right hand corner of the Frame. 

  methods have the same name as those in the Jave Graphics class.

import simphy.*;

public class Utilities {
 public static void main(String args[]) { 
      Utilities u = new  Utilities();
 }  


 public Utilities() {
       String h[] = {"first","second","third"};
       Table tb = new Table("test",h);   
       String pattern[] = {"#.0000", "#.00","#.000"};
       tb.setFormat(pattern,10);
       tb.setEntry(0,3.173);
       tb.setEntry(1,999.9173);
       tb.setEntry(2,3891.73);
       tb.addEntries();
       tb.setEntry(3317.3,99.173,817.3);
       tb.addEntries();
       MySimulation S = new MySimulation();
       String lString[] = {"zero", "one", "two","three", "four", "five","six", "seven", "eight"};
       String bString[] = {"A", "B", "C","D", "E", "F","G", "H", "I"};
       double initialP[] = { 1,2,3,4,5,6,7,8,9};
       ControlFrame cf = new  ControlFrame(S,lString,initialP,bString);
       ControlMenu cm = new  ControlMenu(S,lString,initialP,bString);
       WorldGraphics v = new WorldGraphics("Visualization",0,10,0,10);
       v.setMenuBar(cm.sBar);
       S.notify(cm);
       S.notify(v);
       S.notify(cf);
     }
 }

import java.awt.*;
import simphy.*;

public class MySimulation implements Simulation{
   ControlMenu cm;
   ControlFrame cf;
   WorldGraphics v;

   public void buttonAction(int k) {
     double x[] = {0,1,2,3,4};
     double y[] = {0,1,2,3,4};
     switch(k) {
      case 0: Plot p =  new Plot("y vs x","xxxx","yyyy",1,-5,5,0,5);p.plotPoints(x,y);break;
      case 1: Plot p1 = new Plot("y vs x","xxxx","yyyy",2,-5,5,0,5);p.plotPoints(x,y);break;
      case 2: Plot p2 = new Plot("y vs x","xxxx","yyyy",3,-5,5,0,5);p.plotPoints(x,y);break;
      case 3: Plot p3 = new Plot("y vs x","xxxx","yyyy",4,-5,5,0,5);p.plotPoints(x,y);break;
   }
   
 }
     
   public void textAction(int k, double x) {
      System.out.println(x);
      cf.setText(0,x);
      cf.setText(1,(int) x);
      cf.setText(2,"hello " + String.valueOf(k));
   }
   
   public void menuAction(int k) { 
     switch(k) {
      case 0: v.drawRect(5,5,4,4.0); break;
      case 1: v.drawString("good job", 7.0,2.0);break;
      case 2: v.drawLine(0,0,10,10);break;
      case 3: v.drawRect(200,200,100,100);break;
      case 4: v.drawCircle(5,5,3);break;
      case 5: v.clearRect(0,0,10,10);break;
      case 6: v.setColor("yellow");break;
      case 7: v.setColor("green");break;
      case 8: v.setColor("random");break;
     }
     cf.texts[1].setText(String.valueOf(k));  // shows which menu selected in a TextField
   }
   
   public void dialogAction(int k, double x) {
       System.out.println(x);
   }
   
   public void notify(ControlMenu cm) {
      this.cm = cm;
   }

   public void notify(ControlFrame cf) {
      this.cf = cf;
   }
  
   public void notify(WorldGraphics v ) {
      this.v = v;
   }
}

ClassName objectName = new ClassName();

ClassName objectName;
objectName = new ClassName();

double xarray = new double[10];
double 2dxarray = new double[10][20];

double xarray[];
xarray = new double[20];

double xarray[] = {1,2,3,4,5};


ClassName.staticMethodName();
objectName.methodName();
ClassName.staticVariableName;
objectName.variableName;



for(int i = 0; i < n; i++) {

}


while(i < n) {

}
   

if(a == b) {  // equals


}


if(a != b) {   // not equals


}
else if (c == d) {


}
else {


}

switch(n) {
   case 0:x = 5;y = 7;break;
   case 1:x = 15;break;
   case 2:x = 3;y = 9;break;
   case 3:x = 25;break;
   default: x = 100;
}