Bug
All Bug Objects

Bug
Flower
4 Bug Objects
3 Flower Objects

Bug
Flower
Rock
Actor
1 Bug Object
1 Flower Object
1 Rock Object
1 Actor Object

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

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

You have seen program statements like: int x;
In this case, int is the data type and x is the variable.
The previous program had this statement:
Bank tom;
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.

// 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,10000.0);
Bank sue; sue = new Bank(3000.0,15000.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 $1000.00 checking withdrawal"); tom.checkingDeposit(1000.0);
System.out.println("Tom makes a $2000.00 savings withdrawal"); tom.savingsDeposit(2000.0);
System.out.println("Sue makes a $1500.00 checking deposit"); sue.checkingDeposit(1500.0);
System.out.println("Sue makes a $3000.00 savings deposit"); sue.savingsDeposit(3000.0);
System.out.println();
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();
}
}

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

// 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,10000.0);
Bank sue = new Bank(3000.0,15000.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 $1000.00 checking withdrawal"); tom.checkingWithdrawal(1000.0);
System.out.println("Tom makes a $2000.00 savings withdrawal"); tom.savingsWithdrawal(2000.0);
System.out.println("Sue makes a $1500.00 checking withdrawal"); sue.checkingWithdrawal(1500.0);
System.out.println("Sue makes a $3000.00 savings withdrawal"); sue.savingsWithdrawal(3000.0);
System.out.println();
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();
}
}

// 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(1234567));
System.out.println();
}
}

// 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(1234567));
System.out.println();
Change the
DecimalFormat to
“0,000” and make the last number
1234567890

// 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(1234.432));
System.out.println(money.format(12345.543));
System.out.println(money.format(123456.654));
System.out.println(money.format(1234567.7651));
System.out.println();
}
}

// 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("0.00000");
DecimalFormat output6 = new DecimalFormat("0.000000");
DecimalFormat output7 = new DecimalFormat("0.0000000");
DecimalFormat output8 = new DecimalFormat("0.00000000");
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();
}
}

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

Draws any String starting at coordinate (x,y).
x, y

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

// Java0611.java
// The <drawPolygon> method can draw polygon in the range of
800,200 import java.awt.*; import java.applet.*;
400,400 600,400 public class Java0611 extends Applet
{ public void paint(Graphics g)
{
Expo.drawPolygon(g,500,100,800,200,600,400,400,400,200,200);
}
}

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

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

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

// 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);

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

The first 4 parameters for
Expo.drawRegularPolygon
are the same as
Expo.drawCircle
.
The last parameter indicates the number of sides.

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

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

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.

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

// 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);
// Three 255s is the same as color Expo.white
Expo.fillStar(g,162,325,130,5);
}
}

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

// 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);
Expo.drawLine(g,x,0,x,650); x++;
} x = 650; for (int blue = 0; blue <= 255;blue++)
{
Expo.setColor(g,0,0,blue);
Expo.drawLine(g,x,0,x,650); x++;
}
}
}

// 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));
System.out.println(Expo.random(1,100));
System.out.println(Expo.random(1,100));
System.out.println(Expo.random(1,100));
System.out.println(Expo.random(1,100));
}
}

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

// 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));
System.out.println(Expo.random(minimum,maximum));
System.out.println(Expo.random(minimum,maximum));
System.out.println(Expo.random(minimum,maximum));
System.out.println(Expo.random(minimum,maximum));
System.out.println();
}
}

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

Java0623.java

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

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

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

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

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

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

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

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

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

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

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

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

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

// 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 int y
= Expo.random(0,1000);
= 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);
}
}
}

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

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