1. Section 6.2
Classes &
Objects

2. Review of Math Class Methods
abs
sqrt
min
max
pow
round
ceil
floor

3. Review of Math Class AttributesPI E
Circumference of a Circle / its Diameter
About
Base of the Natural Log
About

4. Visual Classes
1 Class:
Bug
5 Objects:
All Bug Objects

5. Visual Classes 2 Classes: 8 Objects: Bug Rock 5 Bug Objects
3 Rock Objects

6. Visual Classes 4 Classes: 4 Objects: Bug Flower Rock Actor
1 Bug Object
1 Flower Object
1 Rock Object
1 Actor Object

7. Visual Classes 4 Classes: 12 Objects: Bug Flower Rock Actor
3 Bug Objects
3 Flower Objects
3 Rock Objects
3 Actor Objects

8. Section 6.3
Using Object
Methods

9. // Java0601.java
// This program demonstrates that the methods of a class are not always
// accessible, like they were with the <Math> class. In this case an
// attempt is made to use methods of the <Bank> class without success.
public class Java0601 {
public static void main (String args[])
System.out.println("\nJAVA0601.JAVA\n");
Bank.checkingDeposit(1000.0);
Bank.savingsDeposit(5000.0);
System.out.println("Checking balance: " + Bank.getChecking());
System.out.println("Savings balance: " + Bank.getSavings());
System.out.println(); }

10. // Java0602.java
// This program creates two Bank objects, called tom and sue.
// Each object stores its own Bank information.
public class Java0602 {
public static void main (String args[])
System.out.println("\nJAVA0602.JAVA\n");
Bank tom;
tom = new Bank();
Bank sue;
sue = new Bank();
tom.checkingDeposit(1000.0);
tom.savingsDeposit(5000.0);
sue.checkingDeposit(1500.0);
sue.savingsDeposit (4000.0);
System.out.println("Tom's checking balance: " + tom.getChecking());
System.out.println("Tom's savings balance: " + tom.getSavings());
System.out.println("Sue's checking balance: " + sue.getChecking());
System.out.println("Sue's savings balance: " + sue.getSavings());
System.out.println(); }

11. Data Types & Variables vs. Classes & Objects
You have seen program statements like:
In this case, int is the data type and x is the variable.
The previous program had this statement:
In this case, Bank is the data type and tom is the variable ; however, Bank is a special data type called a class, and tom is a special variable called an object.
int x;
Bank tom;

12. // Java0603.java This program demonstrates how an object can be constructed with a specified
// initial balance in checking and savings. Most Java classes have multiple
// constructors to create objects for multiple situations.
public class Java0603 {
public static void main (String args[])
System.out.println("\nJAVA0603.JAVA\n");
Bank tom; tom = new Bank(5000.0, );
Bank sue; sue = new Bank(3000.0, );
System.out.println("Tom's checking balance: " + tom.getChecking());
System.out.println("Tom's savings balance: " + tom.getSavings());
System.out.println("Sue's checking balance: " + sue.getChecking());
System.out.println("Sue's savings balance: " + sue.getSavings());
System.out.println();
System.out.println("Tom makes a $ checking deposit");
tom.checkingDeposit(1000.0);
System.out.println("Tom makes a $ savings deposit");
tom.savingsDeposit(2000.0);
System.out.println("Sue makes a $ checking deposit");
sue.checkingDeposit(1500.0);
System.out.println("Sue makes a $ savings deposit");
sue.savingsDeposit(3000.0);
System.out.println("Sue's savings balance: " + sue.getSavings()); System.out.println(); }

13. The Preferred Way int x; x = 5; int x = 5; Bank tom;
Let us think back to Chapter 3.
You were shown statements that
define and initialize variables like:
But then, you were shown that it is
better to define and initialize your
variables in one statement like this:
The same thing applies to creating objects.
The previous program first declared an object,
and then constructed it, with 2 separate statements:
As before, it is better to combine these 2 statements into one.
We can declare and construct the object in one statement like this:
int x;
x = 5;
int x = 5;
Bank tom;
tom = new Bank(5000.0, );
Bank tom = new Bank(5000.0, );

14. // Java0604.java
// This program demonstrates how an object can be declared and defined all in one statement.
// It also shows the checkingWithdrawal and savingsWithdrawal method.
public class Java0604 {
public static void main (String args[])
System.out.println("\nJAVA0604.JAVA\n");
Bank tom = new Bank(5000.0, );
Bank sue = new Bank(3000.0, );
System.out.println("Tom's checking balance: " + tom.getChecking());
System.out.println("Tom's savings balance: " + tom.getSavings());
System.out.println("Sue's checking balance: " + sue.getChecking());
System.out.println("Sue's savings balance: " + sue.getSavings());
System.out.println();
System.out.println("Tom makes a $ checking withdrawal");
tom.checkingWithdrawal(1000.0);
System.out.println("Tom makes a $ savings withdrawal");
tom.savingsWithdrawal(2000.0);
System.out.println("Sue makes a $ checking withdrawal");
sue.checkingWithdrawal(1500.0);
System.out.println("Sue makes a $ savings withdrawal");
sue.savingsWithdrawal(3000.0); }

15. Section 6.4
Using the
DecimalFormat
class

16. NOTE: The output.format is ignored for numbers that are too large.
// Java0605.java
// This program demonstrates how to "right justify" integers with an object
// of the <DecimalFormat> class and the <format> method.
import java.text.DecimalFormat; // necessary to use DecimalFormat class
public class Java0605 {
public static void main (String args[])
System.out.println("\nJAVA0605.JAVA\n");
DecimalFormat output = new DecimalFormat("00000");
System.out.println(output.format(1));
System.out.println(output.format(12));
System.out.println(output.format(123));
System.out.println(output.format(1234));
System.out.println(output.format(12345));
System.out.println(output.format(123456));
System.out.println(output.format( ));
System.out.println(); }
NOTE: The
output.format
is ignored
for numbers
that are
too large.

17. // Java0606.java
// This program demonstrates how to insert commas in numerical output
// with a <DecimalFormat> object.
import java.text.DecimalFormat;
public class Java0606 {
public static void main (String args[])
System.out.println("\nJAVA0606.JAVA\n");
DecimalFormat output = new DecimalFormat("0,000,000");
System.out.println(output.format(1));
System.out.println(output.format(12));
System.out.println(output.format(123));
System.out.println(output.format(1234));
System.out.println(output.format(12345));
System.out.println(output.format(123456));
System.out.println(output.format( ));
System.out.println(); }
Try this!
Change the DecimalFormat to “0,000” and make the last number

18. DecimalFormat money = new DecimalFormat("$0.00");
// Java0607.java
// This program demonstrates how to display US currency amounts.
// Additionally note how the <format> methods rounds off to the nearest penny.
// Also, note that the object does not have to be called "output".
import java.text.DecimalFormat;
public class Java0607 {
public static void main (String args[])
System.out.println("\nJAVA0607.JAVA\n");
DecimalFormat money = new DecimalFormat("$0.00");
System.out.println(money.format(1));
System.out.println(money.format(12.2));
System.out.println(money.format(123.32));
System.out.println(money.format( ));
System.out.println(money.format( ));
System.out.println(money.format( ));
System.out.println(money.format( ));
System.out.println(); }

19. // Java0608.java
// This program demonstrates how to control rounding off to a specified
// number of digits beyond the decimal point.
// It also shows that multiple DecimalFormat objects can be in the same program.
import java.text.DecimalFormat;
public class Java0608 {
public static void main (String args[])
System.out.println("\nJAVA0608.JAVA\n");
DecimalFormat output1 = new DecimalFormat("0.0");
DecimalFormat output2 = new DecimalFormat("0.00");
DecimalFormat output3 = new DecimalFormat("0.000");
DecimalFormat output4 = new DecimalFormat("0.0000");
DecimalFormat output5 = new DecimalFormat(" ");
DecimalFormat output6 = new DecimalFormat(" ");
DecimalFormat output7 = new DecimalFormat(" ");
DecimalFormat output8 = new DecimalFormat(" ");
System.out.println(Math.PI);
System.out.println(output1.format(Math.PI));
System.out.println(output2.format(Math.PI));
System.out.println(output3.format(Math.PI));
System.out.println(output4.format(Math.PI));
System.out.println(output5.format(Math.PI));
System.out.println(output6.format(Math.PI));
System.out.println(output7.format(Math.PI));
System.out.println(output8.format(Math.PI)); System.out.println(); }

20. Section 6.5
Displaying
Graphics
Characters

21. // This program demonstrates the <drawString> method.
// Java0609.java
// This program demonstrates the <drawString> method.
// With <Expo.drawString(g,"Hello World",x,y)>, the string
// Hello World will be displayed starting at the [x,y] pixel coordinate.   
import java.awt.*;
import java.applet.*;
public class Java0609 extends Applet {
public void paint(Graphics g)
Expo.drawString(g,"Top-Left-Hand Corner",40,40);
Expo.drawString(g,"Top-Right-Hand Corner",840,40);
Expo.drawString(g,"Bottom-Left-Hand Corner",40,640);
Expo.drawString(g,"Bottom-Right-Hand Corner",820,640);
Expo.drawString(g,"Middle",480,330); }

23. Hello There! The drawString Method x, y
Expo.drawString(g,"Hello There!", x, y);
Draws any String starting at coordinate (x,y).
Hello There!
x, y

24. // Java0610.java
// This program introduces the <setFont> method. setFont requires a Name, Style and Size.
// Name is either "Courier", "TimesRoman", "Arial", or any other available font.
// Style is either Font.PLAIN, Font.BOLD, Font.ITALIC or Font.BOLD+Font.Italic.
// Size is the point size value of the Font.
import java.awt.*;
public class Java0610 extends java.applet.Applet {
public void paint(Graphics g)
Expo.drawString(g,"Default Appearance with drawString",20,20);
Expo.setFont(g,"Courier",Font.PLAIN,20);
Expo.drawString(g,"Courier 20-point plain font",20,60);
Expo.setFont(g,"Courier",Font.BOLD,20);
Expo.drawString(g,"Courier 20-point bold font",20,100);
Expo.setFont(g,"TimesRoman",Font.PLAIN,36);
Expo.drawString(g,"Times Roman 36-point plain font",20,180);
Expo.setFont(g,"TimesRoman",Font.ITALIC,36);
Expo.drawString(g,"Times Roman 36-point italic font",20,260);
Expo.setFont(g,"Arial",Font.PLAIN,72);
Expo.drawString(g,"Arial 72-point plain font",20,400);
Expo.setFont(g,"Algerian", Font.BOLD+Font.ITALIC, 48);
Expo.drawString(g,"Algerian 48-point bold/italic font",20,500);
Expo.setFont(g,"Qwerty",Font.PLAIN,24);
Expo.drawString(g,"Arial 24-point plain font substituted for non-existent Qwerty font",20,600); }

26. Section 6.6
Drawing
Polygons

27. // Java0611.java
// This program draws a pentagon with the <drawPolygon> method.
// The <drawPolygon> method can draw polygon in the range of
// [3-12] coordinate points.   
import java.awt.*;
import java.applet.*;
public class Java0611 extends Applet {
public void paint(Graphics g)
Expo.drawPolygon(g,500,100,800,200,600,400,400,400,200,200); }
500,100
200,200
800,200
400,400
600,400

28. // This program demonstrates that the sequence of adding coordinate
// Java0612.java
// This program demonstrates that the sequence of adding coordinate
// points as parameters is significant. The same coordinates of the
// previous program are used in a different sequence.
// The display is very different.   
import java.awt.*;
import java.applet.*;
public class Java0612 extends Applet {
public void paint(Graphics g)
Expo.drawPolygon(g,400,400,500,100,800,200,200,200,600,400); }
500,100
200,200
800,200
400,400
600,400

29. // Java0613.java
// This program demonstrates fillPolygon.
import java.awt.*;
import java.applet.*;   
public class Java0613 extends Applet {
public void paint(Graphics g)
Expo.fillPolygon(g,500,100,800,200,600,400,400,400,200,200); }

30. // Java0614.java
// This program fills 2 Polygons to draw a little boy with a red shirt
// and blue pants.
import java.awt.*;
import java.applet.*;
public class Java0614 extends Applet {
public void paint(Graphics g)
Expo.drawCircle(g,500,100,50);
Expo.drawLine(g,500,150,500,400);
Expo.drawLine(g,500,400,400,600);
Expo.drawLine(g,500,400,600,600);
Expo.drawLine(g,300,225,700,225);
Expo.setColor(g,Expo.red);
Expo.fillPolygon(g,350,200,650,200,650,250,575,250,575,350,425,
350,425,250,350,250);
Expo.setColor(g,Expo.blue);
Expo.fillPolygon(g,425,375,425,425,350,550,450,600,500,450,550,
600,650,550,575,425,575,375); }

31. Continued on the next slide…
// Java0615.java
// This program reviews drawPolygon, setFont, and drawString.
import java.awt.*;
import java.applet.*;
public class Java0615 extends Applet {
public void paint(Graphics g)
Expo.drawPolygon(g,175,175,250,50,350,200);
Expo.drawString(g,"Triangle",225,150);
Expo.drawPolygon(g,400,200,525,200,600,50,475,50);
Expo.setFont(g,"Arial",Font.BOLD,16);
Expo.drawString(g,"Quadralateral",425,175);
Expo.drawPolygon(g,650,100,750,50,850,100,850,200,650,200);
Expo.setFont(g,"Arial",Font.ITALIC,24);
Expo.drawString(g,"Pentagon",700,150);
Expo.drawPolygon(g,25,250,225,250,175,325,225,400,25,400,75,325);
Expo.setFont(g,"TimesRoman",Font.PLAIN,24);
Expo.drawString(g,"Hexagon",75,375);
Expo.drawPolygon(g,275,250,375,250,475,300,475,400,350,400,350,325,275,325);
Expo.setFont(g,"TimesRoman",Font.BOLD,28);
Expo.drawString(g,"Heptagon",300,300);
Continued on the next slide…

32. …Java0615.java Continued
Expo.drawPolygon(g,525,300,600,250,650,250,725,300,725,350,650,400,600,400,525,350);
Expo.setFont(g,"TimesRoman",Font.BOLD+Font.ITALIC,44);
Expo.drawString(g,"Octagon",550,340);
Expo.drawPolygon(g,775,300,800,250,975,250,925,325,975,325,975,400,875,400,825,375,
850,325);
Expo.setFont(g,"TimesRoman",Font.ITALIC,36);
Expo.drawString(g,"Nonagon",800,300);
Expo.drawPolygon(g,150,500,200,450,250,500,300,450,350,500,350,550,300,600,250,550,
200,600,150,550);
Expo.setFont(g,"Algerian",Font.PLAIN,36);
Expo.drawString(g,"Decagon",175,540);
Expo.drawPolygon(g,400,450,600,450,575,525,600,525,600,600,550,575,500,600,450,575,
400,600,400,525,425,525);
Expo.setFont(g,"Courier",Font.BOLD,28);
Expo.drawString(g,"Undecagon",425,560);
Expo.drawPolygon(g,650,525,700,450,700,525,725,525,725,450,775,450,775,525,800,525,
800,450,850,525,850,600,650,600);
Expo.setFont(g,"Courier",Font.ITALIC,28);
Expo.drawString(g,"Dodecagon",675,560); }

34. Section 6.7
Drawing
Regular
Polygons

35. The drawRegularPolygon Method
Expo.drawRegularPolygon(g, centerX, centerY, radius, sides);
The first 4 parameters for Expo.drawRegularPolygon are the same as Expo.drawCircle.
The last parameter indicates the number of sides.
centerX, centerY
radius

36. // Java0616.java
// This program demonstrates the drawRegularPolygon of the Expo class.
// Regular Polygons are drawn from their center (X,Y) with a certain
// radius and a certain number of sides with
// drawRegularPolygon(g,x,y,radius,numSides).
import java.awt.*;
import java.applet.*;
public class Java0616 extends Applet {
public void paint(Graphics g)
Expo.drawRegularPolygon(g,200,170,130,5);
Expo.drawRegularPolygon(g,500,170,130,6);
Expo.drawRegularPolygon(g,800,170,130,7);
Expo.drawRegularPolygon(g,200,490,130,8);
Expo.drawRegularPolygon(g,500,490,130,9);
Expo.drawRegularPolygon(g,800,490,130,10); }

37. // This program demonstrates fillRegularPolygon. import java.awt.*;
// Java0617.java
// This program demonstrates fillRegularPolygon.
import java.awt.*;
import java.applet.*;
public class Java0617 extends Applet {
public void paint(Graphics g)
Expo.setColor(g,Expo.blue);
Expo.fillRegularPolygon(g,200,170,130,5);
Expo.setColor(g,Expo.gold);
Expo.fillRegularPolygon(g,500,170,130,6);
Expo.setColor(g,Expo.magenta);
Expo.fillRegularPolygon(g,800,170,130,7);
Expo.setColor(g,Expo.red);
Expo.fillRegularPolygon(g,200,490,130,8);
Expo.setColor(g,Expo.green);
Expo.fillRegularPolygon(g,500,490,130,9);
Expo.setColor(g,Expo.purple);
Expo.fillRegularPolygon(g,800,490,130,10); }

38. The drawStar Method centerX, centerY
Expo.drawStar(g, centerX, centerY, radius, points);
The first 3 parameters for Expo.drawStar are the same as Expo.drawCircle.
The last parameter indicates the number of points.
centerX, centerY
radius

39. // Java0618.java
// This program demonstrates the drawStar and fillStar methods.
import java.awt.*;
import java.applet.*;
public class Java0618 extends Applet {
public void paint(Graphics g)
Expo.setColor(g,Expo.blue);
Expo.drawStar(g,200,170,130,5);
Expo.setColor(g,Expo.gold);
Expo.fillStar(g,500,170,130,6);
Expo.setColor(g,Expo.magenta);
Expo.drawStar(g,800,170,130,7);
Expo.setColor(g,Expo.red);
Expo.fillStar(g,200,490,130,8);
Expo.setColor(g,Expo.green);
Expo.drawStar(g,500,490,130,9);
Expo.setColor(g,Expo.purple);
Expo.fillStar(g,800,490,130,10); }

40. Section 6.8
Creating
new Colors

41. // This program demonstrates setColor command being used to "create"
// Java0619.java
// This program demonstrates setColor command being used to "create"
// new colors. The program will draw the Official Texas Flag with the
// EXACT shades of red and blue.
import java.awt.*;
import java.applet.*;
public class Java0619 extends Applet {
public void paint(Graphics g)
Expo.setColor(g,0,39,104); // Official shade of blue used in the Texas Flag
Expo.fillRectangle(g,0,0,325,650);
Expo.setColor(g,190,10,47); // Official shade of red used in the Texas Flag
Expo.fillRectangle(g,325,325,1000,650);
Expo.setColor(g,255,255,255);
Expo.fillStar(g,162,325,130,5); }
// Three 255s is the same as color Expo.white

43. Where do you get the 3 color #s
I started by downloading an image of the Official Texas Flag.
I then loaded it in Paint.
Using the eye-dropper tool,
I then clicked on
the desired color.
I then clicked
[Edit Colors] and
made note of the red,
green & blue values.
By using the same 3 numbers in my program, I get the exact same color in the
output of my Java program:
Expo.setColor(g,0,39,104);

44. // Java0620.java
// This program shows all the shades of Red, Green and Blue using the <setColor> method.
import java.awt.*;
import java.applet.*;
public class Java0620 extends Applet {
public void paint(Graphics g)
int x = 50;
for (int red = 0; red <= 255; red++)
Expo.setColor(g,red,0,0);
Expo.drawLine(g,x,0,x,650);
x++; }
x = 350;
for (int green = 0; green <= 255; green++)
Expo.setColor(g,0,green,0);
x = 650;
for (int blue = 0; blue <= 255;blue++)
Expo.setColor(g,0,0,blue);

46. Section 6.9
Creating
Random
Numbers

47. // Java0621.java
// This program uses the <random> method of the Expo class
// 5 times to create 5 random numbers between 1 and 100.
public class Java0621 {
public static void main (String args[])
System.out.println("\nJAVA0621.JAVA\n");
System.out.println(Expo.random(1,100)); }

48. Java0621
Outputs
Since we are working with RANDOM numbers, your outputs will be different than mine – and also different from the other students in the class.

49. // Java0622.java
// This program allows the user to specify the range of random numbers.
public class Java0622 {
public static void main (String args[])
System.out.println("\nJAVA0622.JAVA\n");
System.out.print("Enter the smallest number you want. --> ");
int minimum = Expo.enterInt();
System.out.print("Enter the largest number you want. --> ");
int maximum = Expo.enterInt();
System.out.println();
System.out.println(Expo.random(minimum,maximum)); }

50. Java0622
Outputs

51. Section 6.10
Random #s
with Graphics

52. // Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }

53. Changing Random Number Ranges to Affect the Graphics Program Output
The next several slides will still show program Java0623.java, but the output of the program is different. You need to figure out how to change the each program to make it produce the output shown.
NOTE:
This skill is essential in
doing Graphics Lab 03!

54. Make the random lines only show up on the left ½ of the screen.
// Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Make the random lines
only show up on the
left ½ of the screen.

55. Solution // Java0623.java // This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,500);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,500);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Solution

56. Make the random lines only show up on the right ½ of the screen.
// Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Make the random lines
only show up on the
right ½ of the screen.

57. Solution // Java0623.java // This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(500,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(500,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Solution

58. Make the random lines only show up on the top ½ of the screen.
// Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Make the random lines
only show up on the
top ½ of the screen.

59. Solution // Java0623.java // This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,325);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,325);
Expo.drawLine(g,x1,y1,x2,y2); }
Solution

60. Make the random lines only show up on the bottom ½ of the screen.
// Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Make the random lines
only show up on the
bottom ½ of the screen.

61. Solution // Java0623.java // This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(325,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(325,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Solution

62. top-left ¼ of the screen.
// Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Make the random lines
only show up in the
top-left ¼ of the screen.

63. Solution // Java0623.java // This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,500);
int y1 = Expo.random(0,325);
int x2 = Expo.random(0,500);
int y2 = Expo.random(0,325);
Expo.drawLine(g,x1,y1,x2,y2); }
Solution

64. only show up in the bottom-
// Java0623.java
// This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0623 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(0,1000);
int y1 = Expo.random(0,650);
int x2 = Expo.random(0,1000);
int y2 = Expo.random(0,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Make the random lines
only show up in the bottom-
right ¼ of the screen.

65. Solution // Java0623.java // This program displays 1000 random lines.
import java.awt.*;
import java.applet.*;
public class Java0624 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x1 = Expo.random(500,1000);
int y1 = Expo.random(325,650);
int x2 = Expo.random(500,1000);
int y2 = Expo.random(325,650);
Expo.drawLine(g,x1,y1,x2,y2); }
Solution

66. // Java0624.java
// This program displays 1000 random colored solid circles.
// All circles have a radius of 50.
import java.awt.*;
import java.applet.*;
public class Java0624 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x = Expo.random(0,1000);
int y = Expo.random(0,650);
int red = Expo.random(0,255);
int green = Expo.random(0,255);
int blue = Expo.random(0,255);
Expo.setColor(g,red,green,blue);
Expo.fillCircle(g,x,y,50); }

68. public class Java0625 extends Applet { public void paint(Graphics g)
// Java0625.java
// This program displays 1000 random colored solid circles, with random radii.
import java.awt.*;
import java.applet.*;
public class Java0625 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x = Expo.random(0,1000);
int y = Expo.random(0,650);
int red = Expo.random(0,255);
int green = Expo.random(0,255);
int blue = Expo.random(0,255);
int radius = Expo.random(1,100);
Expo.setColor(g,red,green,blue);
Expo.fillCircle(g,x,y,radius); }

70. // Java0626.java
// This program displays 1000 randomly colored equalateral triangles.
// Creating random colors is also simplified with the setRandomColor method.
import java.awt.*;
import java.applet.*;
public class Java0626 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x = Expo.random(0,1000);
int y = Expo.random(0,650);
int radius = Expo.random(1,100);
int sides = 3;
Expo.setRandomColor(g);
Expo.fillRegularPolygon(g,x,y,radius,sides); }

72. // Java0627.java
// This program displays 1000 randomly colored polygons with a random # of sides.
import java.awt.*;
import java.applet.*;
public class Java0627 extends Applet {
public void paint(Graphics g)
for (int k = 1; k <= 1000; k++)
int x = Expo.random(0,1000);
int y = Expo.random(0,650);
int radius = Expo.random(1,100);
int sides = Expo.random(3,10);
Expo.setRandomColor(g);
Expo.fillRegularPolygon(g,x,y,radius,sides); }