Section 6.2 Classes & Objects

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

Review of Math Class Attributes PI E Circumference of a Circle / its Diameter About 3.1415926535897932384626433832795 Base of the Natural Log About 2.7182818284590452353602874713526

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

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

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

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

Section 6.3 Using Object Methods

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

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;

// 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 deposit"); tom.checkingDeposit(1000.0); System.out.println("Tom makes a $2000.00 savings deposit"); 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("Sue's savings balance: " + sue.getSavings()); System.out.println(); }

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

Section 6.4 Using the DecimalFormat class

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(1234567)); System.out.println(); } NOTE: The output.format is ignored for numbers that are too large.

// 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(); } Try this! Change the DecimalFormat to “0,000” and make the last number 1234567890

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

Section 6.5 Displaying Graphics Characters

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

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

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

Section 6.6 Drawing Polygons

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

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

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

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…

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

Section 6.7 Drawing Regular Polygons

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

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

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

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

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

Section 6.8 Creating new Colors

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

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

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

Section 6.9 Creating Random Numbers

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

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.

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

Java0622 Outputs

Section 6.10 Random #s with Graphics

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

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!

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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

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

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