Applets

Exercises

1. As will be our custom from here on, we'll begin this lab by asking you to run the lablet, which (as should be obvious, we hope) you can do by clicking on the link in this sentence.

   Tip: The lablet's page will appear in a new window. You may as well keep both windows open while doing this lab, resizing and moving them as necessary.

   Play with the lablet until you see how it works.
   
   
   1. How many clicks does it take to get from the biggest border to the smallest?
      Answer:  
      
      
      
   2. Watch the button carefully as you click. What notable behavior does it exhibit?
      Answer:  
   
   
   
2. Now take a look at the applet's code. You can do this by going back to the window containing the applet and clicking on the link "the source" in that page (or by clicking on the link in this sentence).

   Tip: You'll find it useful to keep the source window open, too, while doing this lab.

   While you're reading the applet code, don't pay too much attention to the actionPerformed() method. While it's the place where much of the interesting behavior of the applet comes from, we'll have to defer talking about event handling until later. Do, though, take a close look at the code in the paint() method--that's the heart of this lab.

   Recall [p. 20 ] that a class like Borders, is a description of the data and methods for manipulating the data that belong to every object of that class.

   1. What are the names of the data members (also known as instance variables) of the Borders class?
      Answer:  
      
      
      
   2. In Java, every data item has a type. Data types can be primitive, like int (representing integers, like 3 or -256) or classes, like Button. What are the types of the Borders instance variables?
      Answer:  
      
      
      
   3. If a variable is declared [p. 44 ] inside a method definition, that variable is local to the method and has no meaning outside of the method definition. [p. 54 ] Which of our methods contains six local variables?
      Answer:  
      
      
      
   4. What are the names of the methods of the Borders class?
      Answer:  
      
      
      
   5. You've seen [pp. 35-38 ] that a method is a named sequence of statements that are to be executed when the name is used--either by the program or the run-time system--to call the method into action. How many statements are used in the definition of the init() method?
      Answer:  
      
      How does the compiler determine where a method definition begins and ends?
      Answer:  
      
      
      
   6. A method may have zero or more arguments, [p. 36 ] indicating information that will be sent to the method when it is called. Among the methods in the Borders class, which take one or more arguments?
      Answer:  
   
   
   
3. One way of finding out how the features of a language like Java work is by experimentation, using the compiler as an assistant. To see the purpose and nature of an aspect of Java, you can change part of a program and recompile it. If the compiler gives you an error message, the message can (sometimes) give you a useful clue about the rules of the language. If the compiler accepts your changes as legal, you can often get a further clue by then watching the program run and noting any changes in its behavior.

   Tip: It's a good idea to save a backup copy of the source code so you'll always have a clean original to which to return, in case you derange it beyond all recognition during your experiments. If you don't know how to save a copy of the source code, ask your instructor.

   1. What is the purpose of inheritance? The Borders class inherits [pp. 21-22 ] the methods and data of the Applet class, defined in the library package "java.applet." To turn off this inheritance, remove the code extends Applet and recompile your program.

      Tip: An easy (and easily undoable) way of removing a chunk of code is to "comment it out." Put a /* in front of extends Applet and then put a */ immediately after Applet--presto! you've just told the compiler to ignore everything between the comment delimiters.

      1. What error message does the compiler give you, and why?

         Answer:

         
         
      2. Undo the change you just made and then remove the line
         import java.applet.*;
         You've just made the definitions and declarations of the Applet class unavailable to the compiler. What happens?
         Answer:  
      
      Undo the changes you just made. You'll do this after each modification, from here on.
      
      
   2. What does the init() method of an applet do? Remove or comment out the method definition from your applet (everything from public void init() to the closing "}" brace five lines later) and try to compile and run it. Does your changed version of "Borders.java" compile?
      Answer:  
      
      If so, how has its behavior changed?
      Answer:  
      
      
      
   3. Do we really have to declare each of our variables before we use them? Remove or comment out the code private Button resizeBttn; What error message does the compiler give you, and where?
      Answer:  
   
   
   
   
4. The appearance of our applet is determined by the library classes used in the paint() method. This method uses the classes Graphics [p. 42-43 ] for its drawing routines, Color, [p. 45 ] to set the drawing colors, and Dimension, [p. 48 ] to get access to the applet's size.
   
   
   1. When paint() is called, either by the runtime system or by your program calling repaint(), it is passed a Graphics object, belonging to the applet itself. This Graphics object, represented by g in the method argument, "knows" how to draw on the screen, so, for instance, when we make the statement g.fillRect(x, y, w, h); we are calling [p. 36 ] the Graphics method fillRect() belonging to the object g.
      
      What happens when you change the line in the paint() method that reads
      g.fillRect(x, y, w, h);
      to read
      fillRect(x, y, w, h);
      Answer:  
      
      
      
   2. The fillRect() method requires four int arguments, representing the x and y coordinates of the upper-left corner of the rectangle, and the width and height of the rectangle. [p. 40 ] We set these in the first lines of the paint() method, like this:

      Dimension appletSize = getSize();
      int x = 0,
          y = 30,
          w = appletSize.width - x,
          h = appletSize.height - y;
      

      1. What happens when you change the line
         y = 30,
         to read
         y = 50,
         Answer:  
         
         
      2. Order is vitally important in method arguments. What happens when you change the line
         fillRect(x, y, w, h);
         to read
         fillRect(y, x, w, h);
         Answer:  
      
      
      
   3. In Java, as in most programming languages, statements are executed in the order in which they are written. To see why this is important, swap the statements
      

      	g.setColor(Color.black);
      	g.drawRect(x + inset, ...);
      		
      	g.setColor(Color.white);
      	g.fillRect(x + inset + 1, ...);
      

      So that they appear in this order
      

      	g.setColor(Color.white);
      	g.fillRect(x + inset + 1, ...);
      
      	g.setColor(Color.black);
      	g.drawRect(x + inset, ...);
      

      Hint: You can save a lot of typing here by creative use of Cut and Paste.

      Explain what happens and why.

      Answer:

      
      

   4. As you've probably guessed by reading the lablet code, the Color class is used to represent and manipulate colors. Besides the thirteen predefined color constants, [p. 45 ] you can define colors of your own, by specifying the amounts of red, green, and blue. Notice that four times in paint() we call the Graphics method setColor() to set the current drawing color.
      
      
      1. Change any or all of these to paint the border in any color you wish.
         
         
      2. Before we make the last setColor() call we make a new color of our own by declaring a new local variable:
         

         	Color fillColor = new Color(255, 200, 200);
         	g.setColor(fillColor);
         	

         The color specified by (255, 200, 200), as you've seen, is a light pink. Change it to (200, 20, 100)--what color results?
         Answer:  
         
         
         
      3. Change the lablet so that the background color is a deep blue-violet, like this, rather than red.
      
      
   5. For the purposes of drawing, coordinates are measured in pixels [p. 36, footnote ] from the top left of the component (the applet, in this case). The inset instance variable is used to measure the amount the border is inset from the top left of the background border, like this:
      Change the lablet so that the x-inset (horizontal) is twice as large as the y-inset. To do this, you'll have to change the width argument to the drawRect() and fillRect() calls.
   
   
   
5. We've just scratched the surface of all the Graphics methods available to us. For example, we can also draw ovals. Try it, replacing every fillRect() call by a call to fillOval(), using the same arguments as in the original, and replacing the call to drawRect() by a call to drawOval(), again using the same arguments as in the original. Before you run the program, try to predict exactly what the result will be.
   
   
   
6. While the text includes descriptions of some of the most important Java classes and their methods, space considerations dictated that we leave a lot out. One of the helpful things the people at Sun Microsystems did was to provide complete online documentation of all the Java classes. Spend some time looking at the documentation--it's located at
   
   http://www.javasoft.com/products/jdk/1.1/docs/api/packages.html
   
   If you're using your own computer, go to this page and bookmark it--you'll spend a lot of time in the future looking at it.