Primitive Data Types vs. Classes A simple/primitive data type can store only one single value. This means an int can only store one integer. A double.

Primitive Data Types vs. Classes A simple/primitive data type can store only one single value. This means an int can only store one integer. A double can only store one real number. A char can only store one character. On the other hand, a class is a complex data type. An object is a complex variable that can store multiple pieces of information (class attributes) as well as several methods (class actions).

Method Review – Class Methods The following are all examples of class methods: These methods are called class methods because you must use the name of the class to call the method. class methods are sometimes called static methods. sqrt abs round pow max min enterInt drawCircle setRandomColor double x = Math.sqrt(100); System.out.println( Math.pow(2,5)); int number = Expo.enterInt(); Expo.drawCircle(g,300,200,100);

Method Review – Object Methods The following are all examples of object methods: These methods are called object methods because you must first create an object and then use the name of that object to call the method. object methods are sometimes called non-static methods. format move turn moveTo checkingDeposit DecimalFormat money = new DecimalFormat("$0.00"); System.out.println( money.format(123.4567)); Bank tom = new Bank(); tom.checkingDeposit(1000); Bug barry = new Bug(); barry.move(); barry.turn();

Method Review – return Methods The following are all examples of return methods: return methods return a value and are called as part of some other programming statement. sqrt abs round pow max min enterInt enterDouble enterChar enterString double x = Math.sqrt(100); System.out.println (Math.pow(2,5)); int number = Expo.enterInt(); if (Math.abs(-10) == 10) System.out.println("Everything is OK.");

Method Review – void Methods The following are all examples of void methods: void methods do NOT return anything. They are independent and NOT part of any other statement. print println move turn checkingDeposit drawCircle drawLine setRandomColor Bug barry = new Bug(); barry.move(); barry.turn(); System.out.print("Hello "); System.out.println("World"); Expo.setRandomColor(g); Expo.drawLine(g,100,200,300,400); Expo.drawCircle(g,300,200,100); Bank tom = new Bank(); tom.checkingDeposit(1000);

“Mr. Schram, are object methods ‘void’ or ‘return’ methods?” What you need to realize is that the whole class method vs. object method thing has nothing to do with the whole void method vs. return method thing. Let us spell it out plainly: 1.A method can be BOTH a void method and a class method. 2.A method can be BOTH a void method and an object method. 3.A method can be BOTH a return method and a class method. 4.A method can be BOTH a return method and an object method. So there are void class methods, void object methods, return class methods, and return object methods.

// Java0701.java // This program reviews using class methods & demonstrates the available class methods & data fields. public class Java0701 { public static void main (String args[]) { double halfPI = Math.PI / 2; double quarterPI = Math.PI / 4; System.out.println("The value of E is " + Math.E); System.out.println("The value of PI is " + Math.PI); System.out.println("The absolute value of (-25) is " + Math.abs(-25)); System.out.println("The square root of (1024) is " + Math.sqrt(1024)); System.out.println("(5.00001) rounded up is " + Math.ceil(5.00001)); System.out.println("(5.99999) rounded down is " + Math.floor(5.99999)); System.out.println("(5.50001) rounded normally is " + Math.round(5.50001)); System.out.println("(5.49999) rounded normally is " + Math.round(5.49999)); System.out.println("The log base 10 of (100) is " + Math.log10(100)); System.out.println("The natural log of (100) is " + Math.log(100)); System.out.println("The antilog of (4.605170185988092) is " + Math.exp(4.605170185988092)); System.out.println("With (1000,999) the greater number is " + Math.max(1000,999)); System.out.println("With (1000,999) the lesser number is " + Math.min(1000,999)); System.out.println("4 to the 3rd power is " + Math.pow(4,3)); System.out.println("3 to the 4th power is " + Math.pow(3,4)); System.out.println("The sine of (PI/2) is " + Math.sin(halfPI)); System.out.println("The cosine of (PI) is " + Math.cos(Math.PI)); System.out.println("The tangent of (PI/4) is " + Math.tan(quarterPI)); System.out.println("The arcsine of (1) is " + Math.asin(1)); System.out.println("The arccosine of (-1) is " + Math.acos(-1)); System.out.println("The arctangent of (1) is " + Math.atan(1)); System.out.println("(PI) radians equals " + Math.toDegrees(Math.PI) + " degrees"); System.out.println("(180) degrees equals " + Math.toRadians(180) + " radians"); System.out.println("A random real number between 0 & 1 is" + Math.random()); System.out.println("Another random real# between 0 & 1 is " + Math.random()); System.out.println(); }

The value of E is 2.718281828459045 The value of PI is 3.141592653589793 The absolute value of (-25) is 25 The square root of (1024) is 32.0 (5.00001) rounded up is 6.0 (5.99999) rounded down is 5.0 (5.50001) rounded normally is 6 (5.49999) rounded normally is 5 The log base 10 of (100) is 2.0 The natural log of (100) is 4.605170185988092 The antilog of (4.605170185988092) is 100.00000000000004 With (1000,999) the greater number is 1000 With (1000,999) the lesser number is 999 4 to the 3rd power is 64.0 3 to the 4th power is 81.0 The sine of (PI/2) is 1.0 The cosine of (PI) is -1.0 The tangent of (PI/4) is 0.9999999999999999 The arcsine of (1) is 1.5707963267948966 The arccosine of (-1) is 3.141592653589793 The arctangent of (1) is 0.7853981633974483 (PI) radians equals 180.0 degrees (180) degrees equals 3.141592653589793 radians A random real number between 0 & 1 is 0.7844904826995998 Another random real# between 0 & 1 is 0.272599238665994

Additional Math Class Methods (not previously shown in Chapter 4) Math.log10(p) returns the log base 10 of p Math.log(p) returns the natural log (base e) of p Math.exp(p) returns the antilog of the p or e p Math.sin(p) returns the trigonometric sine of p Math.cos(p) returns the trigonometric cosine of p Math.tan(p) returns the trigonometric tangent of p Math.asin(p) returns the trigonometric arcsine of p Math.acos(p) returns the trigonometric arccosine of p Math.atan(p) returns the trigonometric arctangent of p Math.toDegrees(p) returns the number of degrees in p radians Math.toRadians(p) returns the number of radians in p degrees Math.random() returns a random real number between 0 & 1

Modular Programming Modular Programming is the process of placing statements that achieve a common purpose into its own module. An old programming saying says it well: One Task, One Module

// Java0702.java // This program displays a simple mailing address. // It will be used to demonstrate how to divide program sections // of the main method into multiple user-created methods. public class Java0702 { public static void main(String[] args) { System.out.println("Kathy Smith"); System.out.println("7003 Orleans Court"); System.out.println("Kensington, Md. 20795"); } Kathy Smith 7003 Orleans Court Kensington, Md. 20795

// Java0703.java // This program introduces user-created class methods. The three program statements // of the Java0703.java program are now divided into three user-created methods. // Each method is called with the class-dot-method format. public class Java0703 { public static void main(String[] args) { Java0703.fullName(); Java0703.street(); Java0703.cityStateZip(); } public static void fullName() { System.out.println("Kathy Smith"); } public static void street() { System.out.println("7003 Orleans Court"); } public static void cityStateZip(){ System.out.println("Kensington, Md. 20795"); } } Kathy Smith 7003 Orleans Court Kensington, Md. 20795

User Created Method Format A user-defined method requires: A heading, which includes the method name A set of { } braces to contain the method body statements A body of program statements inside the { } braces public static void example() { System.out.println("This is an example of a"); System.out.println("user-defined method"); }

// Java0704.java // This program example displays the same output as the previous program. // This time the methods are called directly without using the class identifier. // Omitting the class identifier is possible because all the methods are // encapsulated in the same class,. public class Java0704 { public static void main(String[] args) { fullName(); street(); cityStateZip(); } public static void fullName(){ System.out.println("Kathy Smith"); } public static void street(){ System.out.println("7003 Orleans Court"); } public static void cityStateZip(){ System.out.println("Kensington, Md. 20795"); } } Kathy Smith 7003 Orleans Court Kensington, Md. 20795

// Java0705.java // This program demonstrates how to use a second class separate from the main // program class. This program will not compile, because the, // and methods are no longer contained in the class. public class Java0705 { public static void main(String args[]) { fullName(); street(); cityStateZip(); } class Address { public static void fullName() { System.out.println("Kathy Smith"); } public static void street() { System.out.println("7003 Orleans Court"); } public static void cityStateZip() { System.out.println("Kensington, Md. 20795"); } }

// Java0706.java // This program cures the problem of the previous program. It is possible to declare // multiple classes in one program, but you must use the class-dot-method format to // call any of the class methods. public class Java0706 { public static void main(String args[]) { Address.fullName(); Address.street(); Address.cityStateZip(); } class Address { public static void fullName() { System.out.println("Kathy Smith"); } public static void street() { System.out.println("7003 Orleans Court"); } public static void cityStateZip() { System.out.println("Kensington, Md. 20795"); } } Kathy Smith 7003 Orleans Court Kensington, Md. 20795

// Java0706.java // This program cures the problem of the previous program. It is possible to declare // multiple classes in one program, but you must use the class-dot-method format to // call any of the class methods. public class Java0706 { public static void main(String args[]) { Address.fullName(); Address.street(); Address.cityStateZip(); } class Address { public static void fullName() { System.out.println("Kathy Smith"); } public static void street() { System.out.println("7003 Orleans Court"); } public static void cityStateZip() { System.out.println("Kensington, Md. 20795"); } } NOTE: The 2 nd class does NOT use the keyword public. Only the class with the same name as the file uses public.

Using the Class Identifier The name of the class is called the class identifier. Using the class identifier is optional if you are calling a method that is in the same class. Using the class identifier is required if you are calling a method that is in a different class. If a file has more than one class, only the class with the same name as the file is declared public.

File Names & Class Names Review The external file name of your program must be identical to the public class name inside your program, minus the java extension. For example: If you use public class Howdy in your program then you must save the program with file name Howdy.java

// Java0707.java // In this program, the class is in the file Address.java // If the compiler does not find a class it needs in this file, // if will look for it in a.java file with the same name. // This is the whole reason why the name of the file must match the // name of the public class. // NOTE:This class contains the method. // That makes this the "Driving Class" of the program. // That means this is the file that needs to be compiled and executed. public class Java0707 { public static void main(String args[]) { Address.fullName(); Address.street(); Address.cityStateZip(); } Kathy Smith 7003 Orleans Court Kensington, Md. 20795

// Address.java // This is the class used by Java0707.java // NOTE: Now that is in its own file, it must be declared. // ALSO: This file can be compiled, but since it has not method, it cannot be executed. public class Address { public static void fullName() { System.out.println("Kathy Smith"); } public static void street() { System.out.println("7003 Orleans Court"); } public static void cityStateZip() { System.out.println("Kensington, Md. 20795"); }

Program Note While it is proper programming style to put each class in its own file, most program examples in this textbook will continue to put all classes in the same file for simplicity.

// Java0708.java // This program draws a house by placing all the necessary program statements in the method. public class Java0708 extends Applet { public void paint(Graphics g) { Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); Expo.setColor(g,Expo.red); Expo.drawLine(g,200,200,350,100); Expo.drawLine(g,500,200,350,100); Expo.drawLine(g,200,200,500,200); Expo.setColor(g,Expo.red); Expo.drawLine(g,420,146,420,80); Expo.drawLine(g,420,80,450,80); Expo.drawLine(g,450,80,450,166); Expo.setColor(g,Expo.black); Expo.drawRectangle(g,330,340,370,400); Expo.drawOval(g,350,370,10,20); Expo.fillCircle(g,366,370,3); Expo.setColor(g,Expo.black); Expo.drawRectangle(g,220,220,280,280); Expo.drawLine(g,220,250,280,250); Expo.drawLine(g,250,220,250,280); Expo.drawRectangle(g,420,220,480,280); Expo.drawLine(g,420,250,480,250); Expo.drawLine(g,450,220,450,280); Expo.drawRectangle(g,320,220,380,280); Expo.drawLine(g,320,250,380,250); Expo.drawLine(g,350,220,350,280); Expo.drawRectangle(g,220,320,280,380); Expo.drawLine(g,220,350,280,350); Expo.drawLine(g,250,320,250,380); Expo.drawRectangle(g,420,320,480,380); Expo.drawLine(g,420,350,480,350); Expo.drawLine(g,450,320,450,380); } NOTE: This is NOT Good Program Design.

// Java0709.java // This program organizes all the program // statements of the previous program into six // separate methods. This is better program design. // It is now easier to debug and alter the program. public class Java0709 extends Applet { public void paint(Graphics g) { drawFloors(g); drawRoof(g); drawDoor(g); drawWindows(g); drawChimney(g); } public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,200,200,350,100); Expo.drawLine(g,500,200,350,100); Expo.drawLine(g,200,200,500,200); } public static void drawDoor(Graphics g) { Expo.setColor(g,Expo.black); Expo.drawRectangle(g,330,340,370,400); Expo.drawOval(g,350,370,10,20); Expo.fillCircle(g,366,370,3); } public static void drawWindows(Graphics g) { Expo.setColor(g,Expo.black); Expo.drawRectangle(g,220,220,280,280); Expo.drawLine(g,220,250,280,250); Expo.drawLine(g,250,220,250,280); Expo.drawRectangle(g,420,220,480,280); Expo.drawLine(g,420,250,480,250); Expo.drawLine(g,450,220,450,280); Expo.drawRectangle(g,320,220,380,280); Expo.drawLine(g,320,250,380,250); Expo.drawLine(g,350,220,350,280); Expo.drawRectangle(g,220,320,280,380); Expo.drawLine(g,220,350,280,350); Expo.drawLine(g,250,320,250,380); Expo.drawRectangle(g,420,320,480,380); Expo.drawLine(g,420,350,480,350); Expo.drawLine(g,450,320,450,380); } public static void drawChimney(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,420,146,420,80); Expo.drawLine(g,420,80,450,80); Expo.drawLine(g,450,80,450,166); }

// Java0710.java // This program places the six methods from the // previous program into their own class, // which is even better program design. public class Java0710 extends Applet { public void paint(Graphics g) { House.drawFloors(g); House.drawRoof(g); House.drawDoor(g); House.drawWindows(g); House.drawChimney(g); } class House { public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,200,200,350,100); Expo.drawLine(g,500,200,350,100); Expo.drawLine(g,200,200,500,200); } public static void drawDoor(Graphics g) { Expo.setColor(g,Expo.black); Expo.drawRectangle(g,330,340,370,400); Expo.drawOval(g,350,370,10,20); Expo.fillCircle(g,366,370,3); } public static void drawWindows(Graphics g) { Expo.setColor(g,Expo.black); Expo.drawRectangle(g,220,220,280,280); Expo.drawLine(g,220,250,280,250); Expo.drawLine(g,250,220,250,280); Expo.drawRectangle(g,420,220,480,280); Expo.drawLine(g,420,250,480,250); Expo.drawLine(g,450,220,450,280); Expo.drawRectangle(g,320,220,380,280); Expo.drawLine(g,320,250,380,250); Expo.drawLine(g,350,220,350,280); Expo.drawRectangle(g,220,320,280,380); Expo.drawLine(g,220,350,280,350); Expo.drawLine(g,250,320,250,380); Expo.drawRectangle(g,420,320,480,380); Expo.drawLine(g,420,350,480,350); Expo.drawLine(g,450,320,450,380); } public static void drawChimney(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,420,146,420,80); Expo.drawLine(g,420,80,450,80); Expo.drawLine(g,450,80,450,166); }

// Java0711.java // This program shows that a program can // consist of multiple classes, // each of which containing multiple methods. import java.awt.*; import java.applet.*; public class Java0711 extends Applet { public void paint(Graphics g) { House.drawFloors(g); House.drawRoof(g); House.drawDoor(g); House.drawWindows(g); House.drawChimney(g); Tree.drawTrunk(g); Tree.drawLeaves(g); } class House { // same as the previous program } class Tree { public static void drawTrunk(Graphics g) { Expo.setColor(g,Expo.brown); Expo.fillRectangle(g,700,400,750,600); } public static void drawLeaves(Graphics g) { Expo.setColor(g,Expo.green); Expo.fillCircle(g,725,300,105); }

// Java0712.java // This program adds a class // to draw the "sky" and "grass". // When you run the program, all you see is the // background. // This is because the background was drawn // after, and therefore on top of everything else. import java.awt.*; import java.applet.*; public class Java0712 extends Applet { public void paint(Graphics g) { House.drawFloors(g); House.drawRoof(g); House.drawDoor(g); House.drawWindows(g); House.drawChimney(g); Tree.drawTrunk(g); Tree.drawLeaves(g); Background.drawSky(g); Background.drawGrass(g); } class Background { public static void drawSky(Graphics g) { Expo.setColor(g,Expo.lightBlue); Expo.fillRectangle(g,0,0,1000,325); } public static void drawGrass(Graphics g) { Expo.setColor(g,Expo.darkGreen); Expo.fillRectangle(g,0,325,1000,650); } class House { // same as the previous program } class Tree { // same as the previous program }

// Java0713.java // This program fixes the issue of the previous // program by drawing the background first. // The house does not look right because we // can see the background through it. // Unlike the tree, the house is not solid. import java.awt.*; import java.applet.*; public class Java0713 extends Applet { public void paint(Graphics g) { Background.drawSky(g); Background.drawGrass(g); House.drawFloors(g); House.drawRoof(g); House.drawDoor(g); House.drawWindows(g); House.drawChimney(g); Tree.drawTrunk(g); Tree.drawLeaves(g); } class Background { public static void drawSky(Graphics g) { Expo.setColor(g,Expo.lightBlue); Expo.fillRectangle(g,0,0,1000,325); } public static void drawGrass(Graphics g) { Expo.setColor(g,Expo.darkGreen); Expo.fillRectangle(g,0,325,1000,650); } class House { // same as the previous program } class Tree { // same as the previous program }

// Java0714.java // This program changes the methods of the // class so they draw solid shapes. // Now the drawing appears as it was intended. import java.awt.*; import java.applet.*; public class Java0714 extends Applet { public void paint(Graphics g) { Background.drawSky(g); Background.drawGrass(g); House.drawFloors(g); House.drawRoof(g); House.drawDoor(g); House.drawWindows(g); House.drawChimney(g); Tree.drawTrunk(g); Tree.drawLeaves(g); } class Background { // same as the previous program } class Tree { // same as the previous program } // House class on next slide…

class House { public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.lightTan); Expo.fillRectangle(g,200,200,500,400); Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { Expo.setColor(g,Expo.red); Expo.fillPolygon(g,200,200,350,100, 500,200); } public static void drawDoor(Graphics g) { Expo.setColor(g,Expo.blue); Expo.fillRectangle(g,330,340,370,400); Expo.setColor(g,Expo.black); Expo.drawRectangle(g,330,340,370,400); Expo.drawOval(g,350,370,10,20); Expo.fillCircle(g,366,370,3); } public static void drawWindows(Graphics g) { Expo.setColor(g,Expo.white); Expo.fillRectangle(g,220,220,280,280); Expo.fillRectangle(g,420,220,480,280); Expo.fillRectangle(g,320,220,380,280); Expo.fillRectangle(g,220,320,280,380); Expo.fillRectangle(g,420,320,480,380); Expo.setColor(g,Expo.black); Expo.drawRectangle(g,220,220,280,280); Expo.drawLine(g,220,250,280,250); Expo.drawLine(g,250,220,250,280); Expo.drawRectangle(g,420,220,480,280); Expo.drawLine(g,420,250,480,250); Expo.drawLine(g,450,220,450,280); Expo.drawRectangle(g,320,220,380,280); Expo.drawLine(g,320,250,380,250); Expo.drawLine(g,350,220,350,280); Expo.drawRectangle(g,220,320,280,380); Expo.drawLine(g,220,350,280,350); Expo.drawLine(g,250,320,250,380); Expo.drawRectangle(g,420,320,480,380); Expo.drawLine(g,420,350,480,350); Expo.drawLine(g,450,320,450,380); } public static void drawChimney(Graphics g) { Expo.setColor(g,Expo.red); Expo.fillPolygon(g,420,146,420,80, 450,80,450,166); }

// Java0715.java // This program has each class in its own file. // It also demonstrates the good organizational practice of // putting all files for a particular program in the same folder. // NOTE:This class contains the method. // That makes this the "Driving Class" of the program. // That means this is the file that needs to be compiled. import java.awt.*; import java.applet.*; public class Java0715 extends Applet { public void paint(Graphics g) { Background.drawSky(g); Background.drawGrass(g); House.drawFloors(g); House.drawRoof(g); House.drawDoor(g); House.drawWindows(g); House.drawChimney(g); Tree.drawTrunk(g); Tree.drawLeaves(g); }

// House.java import java.awt.*; import java.applet.*; public class House { public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.lightTan); Expo.fillRectangle(g,200,200,500,400); Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { Expo.setColor(g,Expo.red); Expo.fillPolygon(g,200,200,350,100, 500,200); } public static void drawDoor(Graphics g) { Expo.setColor(g,Expo.blue); Expo.fillRectangle(g,330,340,370,400); Expo.setColor(g,Expo.black); Expo.drawRectangle(g,330,340,370,400); Expo.drawOval(g,350,370,10,20); Expo.fillCircle(g,366,370,3); } public static void drawWindows(Graphics g) { Expo.setColor(g,Expo.white); Expo.fillRectangle(g,220,220,280,280); Expo.fillRectangle(g,420,220,480,280); Expo.fillRectangle(g,320,220,380,280); Expo.fillRectangle(g,220,320,280,380); Expo.fillRectangle(g,420,320,480,380); Expo.setColor(g,Expo.black); Expo.drawRectangle(g,220,220,280,280); Expo.drawLine(g,220,250,280,250); Expo.drawLine(g,250,220,250,280); Expo.drawRectangle(g,420,220,480,280); Expo.drawLine(g,420,250,480,250); Expo.drawLine(g,450,220,450,280); Expo.drawRectangle(g,320,220,380,280); Expo.drawLine(g,320,250,380,250); Expo.drawLine(g,350,220,350,280); Expo.drawRectangle(g,220,320,280,380); Expo.drawLine(g,220,350,280,350); Expo.drawLine(g,250,320,250,380); Expo.drawRectangle(g,420,320,480,380); Expo.drawLine(g,420,350,480,350); Expo.drawLine(g,450,320,450,380); } public static void drawChimney(Graphics g) { Expo.setColor(g,Expo.red); Expo.fillPolygon(g,420,146,420,80, 450,80,450,166); }

// Background.java import java.awt.*; import java.applet.*; public class Background { public static void drawSky(Graphics g) { Expo.setColor(g,Expo.lightBlue); Expo.fillRectangle(g,0,0,1000,325); } public static void drawGrass(Graphics g) { Expo.setColor(g,Expo.darkGreen); Expo.fillRectangle(g,0,325,1000,650); } // Tree.java import java.awt.*; import java.applet.*; public class Tree { public static void drawTrunk(Graphics g) { Expo.setColor(g,Expo.brown); Expo.fillRectangle(g,700,400,750,600); } public static void drawLeaves(Graphics g) { Expo.setColor(g,Expo.green); Expo.fillCircle(g,725,300,105); }

Some Program Design Notes Programs should not be written by placing all the program statements in the main or paint methods. Program statements that perform a specific purpose should be placed inside their own modules. These modules are called methods in Java. Object Oriented Design continues by placing modules of a common nature into a separate class. When a program has multiple classes, it is very common to put each class in its own file – one whose name matches the name of the class.

// Java0716.java // Beginning a Big Graphics Program. // Step 1 – Create the method. // This first step will not compile because the program // is attempting to call methods which do not exist. import java.awt.*; import java.applet.*; public class Java0716 extends Applet { public void paint(Graphics g) { drawFloors(g); drawRoof(g); drawDoor(g); drawWindows(g); drawChimney(g); }

// Java0717.java // Beginning a Big Graphics Program // Step 2 – Create Stubs. // Stubs are methods with nothing // between the braces { }. // With the stubs in place, the // program can compile. import java.awt.*; import java.applet.*; public class Java0717 extends Applet { public void paint(Graphics g) { drawFloors(g); drawRoof(g); drawDoor(g); drawWindows(g); drawChimney(g); } public static void drawFloors(Graphics g) { } public static void drawRoof(Graphics g) { } public static void drawDoor(Graphics g) { } public static void drawWindows(Graphics g) { } public static void drawChimney(Graphics g) { }

// Java0718.java // Beginning a Big Graphics Program // Step 3 – Write the first // method and make sure // it works. import java.awt.*; import java.applet.*; public class Java0718 extends Applet { public void paint(Graphics g) { drawFloors(g); drawRoof(g); drawDoor(g); drawWindows(g); drawChimney(g); } public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { } public static void drawDoor(Graphics g) { } public static void drawWindows(Graphics g) { } public static void drawChimney(Graphics g) { }

// Java0719.java // Beginning a Big Graphics Program // Step 4 – Write the next // method and make sure // it works. import java.awt.*; import java.applet.*; public class Java0719 extends Applet { public void paint(Graphics g) { drawFloors(g); drawRoof(g); drawDoor(g); drawWindows(g); drawChimney(g); } public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,200,200,350,100); Expo.drawLine(g,500,200,350,100); Expo.drawLine(g,200,200,500,200); } public static void drawDoor(Graphics g) { } public static void drawWindows(Graphics g) { } public static void drawChimney(Graphics g) { }

// Java0720.java // Beginning a Big Graphics Program // Step 5 – Repeat step 4 until // the entire program is done. public class Java0720 extends Applet { public void paint(Graphics g) { drawFloors(g); drawRoof(g); drawDoor(g); drawWindows(g); drawChimney(g); } public static void drawFloors(Graphics g) { Expo.setColor(g,Expo.blue); Expo.drawRectangle(g,200,200,500,300); Expo.drawRectangle(g,200,300,500,400); } public static void drawRoof(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,200,200,350,100); Expo.drawLine(g,500,200,350,100); Expo.drawLine(g,200,200,500,200); } public static void drawDoor(Graphics g) { Expo.setColor(g,Expo.black); Expo.drawRectangle(g,330,340,370,400); Expo.drawOval(g,350,370,10,20); Expo.fillCircle(g,366,370,3); } public static void drawWindows(Graphics g) { Expo.setColor(g,Expo.black); Expo.drawRectangle(g,220,220,280,280); Expo.drawLine(g,220,250,280,250); Expo.drawLine(g,250,220,250,280); Expo.drawRectangle(g,420,220,480,280); Expo.drawLine(g,420,250,480,250); Expo.drawLine(g,450,220,450,280); Expo.drawRectangle(g,320,220,380,280); Expo.drawLine(g,320,250,380,250); Expo.drawLine(g,350,220,350,280); Expo.drawRectangle(g,220,320,280,380); Expo.drawLine(g,220,350,280,350); Expo.drawLine(g,250,320,250,380); Expo.drawRectangle(g,420,320,480,380); Expo.drawLine(g,420,350,480,350); Expo.drawLine(g,450,320,450,380); } public static void drawChimney(Graphics g) { Expo.setColor(g,Expo.red); Expo.drawLine(g,420,146,420,80); Expo.drawLine(g,420,80,450,80); Expo.drawLine(g,450,80,450,166); }

Method Calls With & Without Parameters Parameter method example: double result1 = Math.sqrt(100); double result2 = Math.pow(2,5); Expo.delay(3000); Expo.drawCircle(g,500,325,100); Non-Parameter method examples: int age = Expo.enterInt( ); Address.fullName( );Bug barry = new Bug( ); Address.street( );barry.move( ); Address.cityStateZip( );barry.turn( );

Overloaded Method Calls System.out.println("Hello World"); System.out.println( ); Expo.setColor(g, Expo.red); Expo.setColor(g, 150, 100, 15); Expo.drawPolygon(g,100,100,700,100,400,400); Expo.drawPolygon(g,500,100,800,200,600,400, 400,400,200,200);

// Java0721.java // This program sends a value to a parameter method and then // displays the value of the parameter. public class Java0721 { public static void main(String args[]) { displayParameter( 100 ); } public static void displayParameter( int number ) { System.out.println(); System.out.println("The parameter value is " + number ); System.out.println(); } The parameter value is 100

Parameters Terminology Actual Parameters The parameters in the method call. This is the actual information that you are sending to the method. Formal Parameters The parameters in the method heading. This is the formal declaration of the parameters. Here their form is determined. displayParameter ( 100 ); public static void displayParameter ( int number )

// Java0722.java // This program demonstrates that the calling parameter can be: // a constant, like 13 or Math.PI, a variable, like x, // an expression with constants and/or variables, like 20 + 30 and x + 5, // and a call to a method, which returns a value, like Math.sqrt(100). public class Java0722 { public static void main(String args[]) { double x = 100.0; displayParameter(13); displayParameter(x); displayParameter(20 + 30); displayParameter(x + 5); displayParameter(Math.PI); displayParameter(Math.sqrt(225)); } public static void displayParameter(double number) { System.out.println("The parameter value is " + number); System.out.println(); } The parameter value is 13.0 The parameter value is 100.0 The parameter value is 50.0 The parameter value is 105.0 The parameter value is 3.141592653589793 The parameter value is 15.0

Actual Parameter Formats Actual parameters can be: constants (13) or (Math.PI) variables (x) expressions with constants only(20 + 30) expressions with variables & constants (x + 3) return method calls (Math.sqrt(225))

The Football Analogy The Quarterback - The Actual Parameter The Football - A copy of the data The actual parameters pass the data to the formal parameters. The Receiver - Formal Parameter displayParameter( x ); public static void displayParameter( double number ) showArea 100

// Java0723.java // This program demonstrates passing two parameters to a method. // The method is called twice. In this case reversing // the sequence of the parameters is not a problem. public class Java0723 { public static void main(String args[]) { int length = 100; int width = 50; showArea( length, width ); showArea( width, length ); } public static void showArea( int L, int W ) { System.out.println(); int area = L * W; System.out.println("The rectangle area is " + area); System.out.println(); } The rectangle area is 5000 The rectangle area is 5000

// Java0724.java // This program demonstrates that parameter sequence matters. // In this example method will display different // results when the calling parameters are reversed. public class Java0724 { public static void main(String args[]) { int num1 = 100; int num2 = 50; showDifference( num1, num2 ); showDifference( num2, num1 ); } public static void showDifference( int a, int b ) { System.out.println(); int difference = a – b; System.out.println("The difference is " + difference); System.out.println(); } The difference is 50 The difference is -50

Actual Parameter Sequence Matters The first actual parameter passes information to the first formal parameter. The second actual parameter passes information to the second formal parameter. Parameters placed out of sequence may result in compile errors or logic errors.

// Java0725.java // This program demonstrates 2 common mistakes made by students. // The "Line 1" error is caused by defining variables in the method call. // The "Line 2" error is caused by not giving the 2nd formal parameter a data type. public class Java0725 { public static void main(String args[]) { showDifference(int num1, int num2); // Line 1 } public static void showDifference(int a, b) // Line 2 { System.out.println(); int difference = a - b; System.out.println("The difference is " + difference); System.out.println(); }

Common Parameters Mistakes WrongCorrect qwerty(int num1, int num2);int num1 = 100; int num2 = 200; qwerty(num1,num2); public static void qwerty(int a, b)public static void qwerty(int a, int b)

// Java0726.java // This program demonstrates that multiple parameters may be // different data types. Parameter sequence is very important. public class Java0726 { public static void main(String args[]) { multiTypeDemo("Hans",30,3.575); // 3 different type parameters method call //multiTypeDemo(30,3.575,"Hans"); // same parameters, but in the wrong order } public static void multiTypeDemo(String studentName, int studentAge, double studentGPA) { System.out.println("\nThis method has 3 parameters with three different types"); System.out.println("Name: " + studentName); System.out.println("Age: " + studentAge); System.out.println("GPA: " + studentGPA); } Try This: Remove the comment and re-compile. This method has 3 parameters with three different types Name: Hans Age: 30 GPA: 3.575

// Java0725.java // This program demonstrates that multiple parameters may be // different data types. Parameter sequence is very important. public class Java0725 { public static void main(String args[]) { multiTypeDemo("Hans",30,3.575); // 3 different type parameters method call multiTypeDemo(30,3.575,"Hans"); // same parameters, but in the wrong order } public static void multiTypeDemo(String studentName, int studentAge, double studentGPA) { System.out.println("\nThis method has 3 parameters with three different types"); System.out.println("Name: " + studentName); System.out.println("Age: " + studentAge); System.out.println("GPA: " + studentGPA); } With the parameters in the wrong order, the program cannot compile.

Parameter Rules The actual parameters and the formal parameters must match in these 3 ways: 1.They must be the same quantity. 2.They must be the same type. 3.They must be the same sequence.

The Track Relay Analogy – Race 1 The second runner from the Netherlands is missing. The number of actual parameters and formal parameters do not match. US GB FR NL

The Track Relay Analogy – Race 2 US GB FRNL FR The second runners from the Netherlands and France are in the wrong lane. The formal parameters are not in the same order as the actual parameters. They must correspond.

The Track Relay Analogy – Race 3 The runners are in proper staring position. The parameters correspond. The fact that there are 2 people from the Netherlands with the same name is not a problem. US (John)US (Greg) GB (Charles)GB (William) FR (Gerald)FR (Louis) NL (Hans)

Important Rules About Using Parameters with Methods The number of parameters in the method call (actual parameters) must match the number of parameters in the method heading (formal parameters). The corresponding actual parameters must be the same type as the formal parameters. The sequence of the actual parameters must match the sequence of the formal parameters. The identifiers of the actual parameters may be the same as or different from the identifiers of the formal parameters.

// Java0727.java // This program introduces a return method with one parameter. // Method returns the next integer value of its parameter. public class Java0727 { public static void main(String args[]) { for (int k = 1; k <= 10; k++) { int rnd = Expo.random(10,99); System.out.println("Random number: " + rnd); System.out.println("Next number : " + getNextNumber(rnd) ); } System.out.println(); } public static int getNextNumber(int n) { n++; return n; } Random number: 73 Next number : 74 Random number: 21 Next number : 22 Random number: 15 Next number : 16 Random number: 22 Next number : 23 Random number: 21 Next number : 22 Random number: 69 Next number : 70 Random number: 13 Next number : 14 Random number: 39 Next number : 40 Random number: 24 Next number : 25 Random number: 78 Next number : 79

// Java0728.java // This example returns a boolean value, which is used // frequently to check for correct user keyboard input. public class Java0728 { public static void main(String args[]) { boolean okPIN = false; do { System.out.print("Enter your four-digit PIN ===>> "); int pin = Expo.enterInt(); okPIN = checkPIN(pin); System.out.println(); } while (!okPIN); System.out.println("Select your bank transaction:"); } public static boolean checkPIN(int pin) { boolean temp = (pin == 1234); return temp; } Enter your four-digit PIN ===>> 4600 Enter your four-digit PIN ===>> 6623 Enter your four-digit PIN ===>> 7577 Enter your four-digit PIN ===>> 1234 Select your bank transaction:

// Java0729.java // This program demonstrates the difference between a void method & a return method. // There are two differences: // Void and return methods are declared differently. // Void and return methods are also called differently. public class Java0729 { public static void main(String args[]) { int nbr1 = 1000; int nbr2 = 100; add1(nbr1,nbr2); System.out.println(nbr1 + " + " + nbr2 + " = " + add2(nbr1,nbr2) ); } public static void add1(int n1, int n2) { int sum = n1 + n2; System.out.println(n1 + " + " + n2 + " = " + sum); } public static int add2(int n1, int n2) { int sum = n1 + n2; return sum; } 1000 + 100 = 1100

// Java0730.java // This program demonstrates how to create a four-function class // with return methods. public class Java0730 { public static void main(String args[]) { int nbr1 = 1000; int nbr2 = 100; System.out.println(nbr1 + " + " + nbr2 + " = " + Calculator.add(nbr1,nbr2)); System.out.println(nbr1 + " - " + nbr2 + " = " + Calculator.subtract(nbr1,nbr2)); System.out.println(nbr1 + " * " + nbr2 + " = " + Calculator.multiply(nbr1,nbr2)); System.out.println(nbr1 + " / " + nbr2 + " = " + Calculator.divide(nbr1,nbr2)); System.out.println(); } class Calculator { public static int add(int n1, int n2) { return n1 + n2; } public static int subtract(int n1, int n2){ return n1 - n2; } public static int multiply(int n1, int n2){ return n1 * n2; } public static int divide(int n1, int n2){ return n1 / n2; } } 1000 + 100 = 1100 1000 - 100 = 900 1000 * 100 = 100000 1000 / 100 = 10

// Java0731.java // This program reviews different ways to call a return method. public class Java0731 { public static void main(String args[]) { System.out.println("Sum: " + add(200,300)); int sum = add(400,500); System.out.println("Sum: " + sum); int checking = 600; int savings = 700; if (add(checking,savings) <= 0) System.out.println("You are broke!"); else System.out.println("Let's go shopping!"); } public static int add(int n1, int n2) { int sum = n1 + n2; return sum; } Sum: 500 Sum: 900 Let's go shopping!

The Payroll Case Study You are about to study 8 stages of a case study. This is the one of many case studies that you will work with. The first program will be very simplistic and each program will make some small change or add something new.

// Java0732.java // Payroll Case Study #1 // The first stage of the Payroll program has correct syntax and logic. // However, there is no concern about any type of proper program design, // even to the degree that there is no program indentation. // This program is totally unreadable. import java.text.*;public class Java0732{public static void main (String args[]) { String a; double b,c,e,f,g,h,i,j,k; int d; DecimalFormat m = new DecimalFormat("$0.00"); System.out.println( "\nPAYROLL CASE STUDY #1\n"); System.out.print("Enter Name ===>> "); a = Expo.enterString();System.out.print("Enter Hours Worked ===>> "); b = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); c = Expo.enterDouble(); System.out.print( "Enter dependents ===>> "); d = Expo.enterInt(); if (b > 40) { e = b - 40; k = 40 * c; j = e * c * 1.5;} else { k=b*c;j = 0;}g=k+j;switch (d) {case 0:f=29.5;break;case 1:f=24.9;break;case 2:f=18.7; break; case 3:f=15.5;break;case 4:f=12.6;break;case 5:f=10.0;break;default:f=7.5;}i=g*f/100;h=g- i; System.out.println("\n\n");System.out.println("Name: " + a);System.out.println( "Hourly rate: " + m.format(c)); System.out.println("Hours worked: " +b);System.out.println( "dependents: " + d);System.out.println("Tax rate: " + f + "%"); System.out.println("Regular pay: " + m.format(k));System.out.println("Overtime pay: " + m.format(j));System.out.println("Gross pay: "+m.format(g));System.out.println( "Deductions: "+m.format(i));System.out.println("Net pay: "+m.format(h)); System.out.println("\n\n"); } }

PAYROLL CASE STUDY #1 Enter Name ===>> Tom Jones Enter Hours Worked ===>> 49 Enter Hourly Rate ===>> 8.75 Enter Dependents ===>> 3 Name: Tom Jones Hourly rate: $8.75 Hours worked: 49.0 Dependents: 3 Tax rate: 15.5% Regular pay: $350.00 Overtime pay: $118.12 Gross pay: $468.12 Deductions: $72.56 Net pay: $395.57 This is the output for most of the programs in the Payroll Case Study.

// Java0733.java // Payroll Case Study #2 // The second stage does use indentation, but it is still very poor program design. // All the program logic is contained in the method and there are no // program comments anywhere, nor are the identifiers self-commenting. import java.text.*; public class Java0733 { public static void main (String args[]) { String a; double b,c,e,f,g,h,i,j,k; int d; DecimalFormat m = new DecimalFormat("$0.00"); System.out.println("\nPAYROLL CASE STUDY #2\n"); System.out.print("Enter Name ===>> "); a = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); b = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); c = Expo.enterDouble(); System.out.print("Enter dependents ===>> "); d = Expo.enterInt();

if (b > 40) { e = b - 40; k = 40 * c; j = e * c * 1.5; } else { k = b * c; j = 0; } g = k + j; switch (d) { case 0 : f = 29.5; break; case 1 : f = 24.9; break; case 2 : f = 18.7; break; case 3 : f = 15.5; break; case 4 : f = 12.6; break; case 5 : f = 10.0; break; default: f = 7.5; }

i = g * f / 100; h = g - i; System.out.println("\n\n"); System.out.println("Name: " + a); System.out.println("Hourly rate: " + m.format(c)); System.out.println("Hours worked: " + b); System.out.println("dependents: " + d); System.out.println("Tax rate: " + f + "%"); System.out.println("Regular pay: " + m.format(k)); System.out.println("Overtime pay: " + m.format(j)); System.out.println("Gross pay: " + m.format(g)); System.out.println("Deductions: " + m.format(i)); System.out.println("Net pay: " + m.format(h)); System.out.println("\n\n"); }

// Java0734.java // Payroll Case Study #3 // Stage 3 improves program readability by using meaningful identifiers. import java.text.*; public class Java0734 { public static void main (String args[]) { String employeeName; double hoursWorked; double hourlyRate; int numDependents; double overtimeHours; double regularPay; double overtimePay; double taxRate; double grossPay; double taxDeductions; double netPay; DecimalFormat money = new DecimalFormat("$0.00"); System.out.println("\nPAYROLL CASE STUDY #3\n");

System.out.print("Enter Name ===>> "); employeeName = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); hoursWorked = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); hourlyRate = Expo.enterDouble(); System.out.print("Enter dependents ===>> "); numdependents = Expo.enterInt(); if (hoursWorked > 40) { overtimeHours = hoursWorked - 40; regularPay = 40 * hourlyRate; overtimePay = overtimeHours * hourlyRate * 1.5; } else { regularPay = hoursWorked * hourlyRate; overtimePay = 0; } grossPay = regularPay + overtimePay;

switch (numdependents) { case 0 : taxRate = 29.5; break; case 1 : taxRate = 24.9; break; case 2 : taxRate = 18.7; break; case 3 : taxRate = 15.5; break; case 4 : taxRate = 12.6; break; case 5 : taxRate = 10.0; break; default: taxRate = 7.5; } taxDeductions = grossPay * taxRate / 100; netPay = grossPay - taxDeductions; System.out.println("\n\n"); System.out.println("Name: " + employeeName); System.out.println("Hourly rate: " + money.format(hourlyRate)); System.out.println("Hours worked: " + hoursWorked); System.out.println("dependents: " + numdependents); System.out.println("Tax rate: " + taxRate + "%"); System.out.println("Regular pay: " + money.format(regularPay)); System.out.println("Overtime pay: " + money.format(overtimePay)); System.out.println("Gross pay: " + money.format(grossPay)); System.out.println("Deductions: " + money.format(taxDeductions)); System.out.println("Net pay: " + money.format(netPay)); System.out.println("\n\n"); }

// Java0735.java // Payroll Case Study #4 // Stage 4 separates the program statements in the main method with spaces and comments // to help identify the purpose for each segment. This helps program debugging and updating. // Note that this program does not prevents erroneous input. import java.text.*;// used for text output with class. public class Java0735 { public static void main (String args[]) { ///////////////////////////////////////////////////////////////////////////////////////////////////// // Program variables // String employeeName;// employee name used on payroll check double hoursWorked;//hours worked per week double hourlyRate;//employee wage paid per hour int numdependents;//number of dependents declared for tax rate purposes double overtimeHours;//number of hours worked over 40 double regularPay;//pay earned for up to 40 hours worked double overtimePay;//pay earned for hours worked above 40 per week double taxRate;//tax rate, based on declared dependents, // used for deduction computation double grossPay;//total pay earned before deductions double taxDeductions;//total tax deductions double netPay;//total take-home pay, which is printed on the check //////////////////////////////////////////////////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////////////////////////////////////// //Program object // DecimalFormat money = new DecimalFormat("$0.00"); //money is used to display values in monetary format //////////////////////////////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////////////////////////// //Program input // System.out.println("\nPAYROLL CASE STUDY #3\n"); System.out.print("Enter Name ===>> "); employeeName = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); hoursWorked = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); hourlyRate = Expo.enterDouble(); System.out.print("Enter dependents ===>> "); numdependents = Expo.enterInt(); //////////////////////////////////////////////////////////////////////////////////////////////////

//Program computation // if (hoursWorked > 40)//qualifies for overtime pay { overtimeHours = hoursWorked - 40; regularPay = 40 * hourlyRate; overtimePay = overtimeHours * hourlyRate * 1.5; } else//does not qualify for overtime pay { regularPay = hoursWorked * hourlyRate; overtimePay = 0; } switch (numdependents) { case 0 : taxRate = 29.5; break; case 1 : taxRate = 24.9; break; case 2 : taxRate = 18.7; break; case 3 : taxRate = 15.5; break; case 4 : taxRate = 12.6; break; case 5 : taxRate = 10.0; break; default: taxRate = 7.5; } taxDeductions = grossPay * taxRate / 100; //compute proper tax deductions based the number of declared dependents

netPay = grossPay - taxDeductions; //compute actual take-home-pay, which is printed on the paycheck ///////////////////////////////////////////////////////////////////////////////////////////// // Output display, which simulates the printing of a payroll check // System.out.println("\n\n"); System.out.println("Name: " + employeeName); System.out.println("Hourly rate: " + money.format(hourlyRate)); System.out.println("Hours worked: " + hoursWorked); System.out.println("dependents: " + numdependents); System.out.println("Tax rate: " + taxRate + "%"); System.out.println("Regular pay: " + money.format(regularPay)); System.out.println("Overtime pay: " + money.format(overtimePay)); System.out.println("Gross pay: " + money.format(grossPay)); System.out.println("Deductions: " + money.format(taxDeductions)); System.out.println("Net pay: " + money.format(netPay)); System.out.println("\n\n"); ///////////////////////////////////////////////////////////////////////////////////////////// }

// Java0736.java Payroll Case Study #5 // Stage #5 is more in the spirit of modular programming. The program is now divided // into five separate methods, which are called in sequence by the main method. // There is one major problem which causes many errors. All of the variables are defined // locally in the method. The other methods do not have access to them. import java.text.*; public class Java0736 { public static void main (String args[]) { String employeeName; double hoursWorked; double hourlyRate; int numDependents; double overtimeHours; double regularPay; double overtimePay; double taxRate; double grossPay; double taxDeductions; double netPay; DecimalFormat money = new DecimalFormat("$0.00"); System.out.println("\nPAYROLL CASE STUDY #5\n"); enterData(); computeGrosspay(); computeDeductions(); computeNetpay(); printCheck(); }

public static void enterData() { System.out.print("Enter Name ===>> "); employeeName = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); hoursWorked = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); hourlyRate = Expo.enterDouble(); System.out.print("Enter Dependents ===>> "); numDependents = Expo.enterInt(); } public static void computeGrosspay() { if (hoursWorked > 40) { overtimeHours = hoursWorked - 40; regularPay = 40 * hourlyRate; overtimePay = overtimeHours * hourlyRate * 1.5; } else { regularPay = hoursWorked * hourlyRate; overtimePay = 0; } grossPay = regularPay + overtimePay; }

public static void computeDeductions() { switch (numDependents) { case 0 : taxRate = 29.5; break; case 1 : taxRate = 24.9; break; case 2 : taxRate = 18.7; break; case 3 : taxRate = 15.5; break; case 4 : taxRate = 12.6; break; case 5 : taxRate = 10.0; break; default: taxRate = 7.5; } taxDeductions = grossPay * taxRate / 100; } public static void computeNetpay() { netPay = grossPay - taxDeductions; }

public static void printCheck() { System.out.println("\n\n"); System.out.println("Name: " + employeeName); System.out.println("Hourly rate: " + money.format(hourlyRate)); System.out.println("Hours worked: " + hoursWorked); System.out.println("Dependents: " + numDependents); System.out.println("Tax rate: " + taxRate + "%"); System.out.println("Regular pay: " + money.format(regularPay)); System.out.println("Overtime pay:" + money.format(overtimePay)); System.out.println("Gross pay: " + money.format(grossPay)); System.out.println("Deductions: " + money.format(taxDeductions)); System.out.println("Net pay: " + money.format(netPay)); System.out.println("\n\n"); }

:::::::::::::: The user-defined methods cannot find the variables because they are all declared inside the main method.

// Java0737.java // Payroll Case Study #6 // Stage #6 fixes the problem from Stage 5 by using class variables. // NOTE: The object is defined locally in //because that is the only method it is used in. import java.text.*; public class Java0737 { static String employeeName; static double hoursWorked; static double hourlyRate; static int numdependents; static double overtimeHours; static double regularPay; static double overtimePay; static double taxRate; static double grossPay; static double taxDeductions; static double netPay;

public static void main (String args[]) { System.out.println("\nPAYROLL CASE STUDY #6\n"); enterData(); computeGrosspay(); computeDeductions(); computeNetpay(); printCheck(); } public static void enterData() { System.out.print("Enter Name ===>> "); employeeName = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); hoursWorked = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); hourlyRate = Expo.enterDouble(); System.out.print("Enter dependents ===>> "); numdependents = Expo.enterInt(); } When done properly, the main method should look like an outline for your program.

public static void computeGrosspay() { if (hoursWorked > 40) { overtimeHours = hoursWorked - 40; regularPay = 40 * hourlyRate; overtimePay = overtimeHours * hourlyRate * 1.5; } else { regularPay = hoursWorked * hourlyRate; overtimePay = 0; } grossPay = regularPay + overtimePay; }

public static void computeDeductions() { switch (numdependents) { case 0 : taxRate = 29.5; break; case 1 : taxRate = 24.9; break; case 2 : taxRate = 18.7; break; case 3 : taxRate = 15.5; break; case 4 : taxRate = 12.6; break; case 5 : taxRate = 10.0; break; default: taxRate = 7.5; } taxDeductions = grossPay * taxRate / 100; } public static void computeNetpay() { netPay = grossPay - taxDeductions; }

public static void printCheck() { DecimalFormat money = new DecimalFormat("$0.00"); System.out.println("\n\n"); System.out.println("Name: " + employeeName); System.out.println("Hourly rate: " + money.format(hourlyRate)); System.out.println("Hours worked: " + hoursWorked); System.out.println("dependents: " + numdependents); System.out.println("Tax rate: " + taxRate + "%"); System.out.println("Regular pay: " + money.format(regularPay)); System.out.println("Overtime pay: " + money.format(overtimePay)); System.out.println("Gross pay: " + money.format(grossPay)); System.out.println("Deductions: " + money.format(taxDeductions)); System.out.println("Net pay: " + money.format(netPay)); System.out.println("\n\n"); }

// Java0738.java // Payroll Case Study #7 // In Stage #7 the method is part of the "driving" class, which is // the class responsible for the program execution sequence. The // method now contains method calls to objects of the class. import java.text.*; public class Java0738 { public static void main (String args[]) { System.out.println("\nPAYROLL CASE STUDY #7\n"); Payroll.enterData(); Payroll.computeGrosspay(); Payroll.computeDeductions(); Payroll.computeNetpay(); Payroll.printCheck(); }

class Payroll { static String employeeName; static double hoursWorked; static double hourlyRate; static int numdependents; static double overtimeHours; static double regularPay; static double overtimePay; static double taxRate; static double grossPay; static double taxDeductions; static double netPay; public static void enterData() { System.out.print("Enter Name ===>> "); employeeName = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); hoursWorked = Expo.enterDouble(); System.out.print("Enter Hourly Rate ===>> "); hourlyRate = Expo.enterDouble(); System.out.print("Enter dependents ===>> "); numdependents = Expo.enterInt(); }

public static void computeGrosspay() { if (hoursWorked > 40) { overtimeHours = hoursWorked - 40; regularPay = 40 * hourlyRate; overtimePay = overtimeHours * hourlyRate * 1.5; } else { regularPay = hoursWorked * hourlyRate; overtimePay = 0; } grossPay = regularPay + overtimePay; }

public static void computeDeductions() { switch (numdependents) { case 0 : taxRate = 29.5; break; case 1 : taxRate = 24.9; break; case 2 : taxRate = 18.7; break; case 3 : taxRate = 15.5; break; case 4 : taxRate = 12.6; break; case 5 : taxRate = 10.0; break; default: taxRate = 7.5; } taxDeductions = grossPay * taxRate / 100; } public static void computeNetpay() { netPay = grossPay - taxDeductions; }

public static void printCheck() { DecimalFormat money = new DecimalFormat("$0.00"); System.out.println("\n\n"); System.out.println("Name: " + employeeName); System.out.println("Hourly rate: " + money.format(hourlyRate)); System.out.println("Hours worked: " + hoursWorked); System.out.println("dependents: " + numdependents); System.out.println("Tax rate: " + taxRate + "%"); System.out.println("Regular pay: " + money.format(regularPay)); System.out.println("Overtime pay: " + money.format(overtimePay)); System.out.println("Gross pay: " + money.format(grossPay)); System.out.println("Deductions: " + money.format(taxDeductions)); System.out.println("Net pay: " + money.format(netPay)); System.out.println("\n\n"); }

// Java0739.java // Payroll Case Study #8 // In Stage #8 the driving // class and the // class are each placed // in separate files. public class Java0739 { public static void main (String args[]) { System.out.println("\nPAYROLL CASE STUDY #8\n"); Payroll.enterData(); Payroll.computeGrosspay(); Payroll.computeDeductions(); Payroll.computeNetpay(); Payroll.printCheck(); }

// Payroll.java import java.text.*; public class Payroll { static String employeeName; static double hoursWorked; static double hourlyRate; static int numDependents; static double overtimeHours; static double regularPay; static double overtimePay; static double taxRate; static double grossPay; static double taxDeductions; static double netPay; public static void enterData() { System.out.print("Enter Name ===>> "); employeeName = Expo.enterString(); System.out.print("Enter Hours Worked ===>> "); hoursWorked = Expo.enterDouble(); The remainder of the Payroll class is the same as the previous program.

Local Variables & Class Variables Variables that are declared inside a method or block are called local variables. Local variables are only accessible inside the method or block that they are defined in. Variables that are declared inside a class, but outside any method, are class variables. Class variables are accessible by any method of the class. Class variables are also called attributes. If a variable is only used by one method, it should be declared inside that method as a local variable. If a variable is used by 2 or more methods of a class, it should be declared as a class variable.

Program Design Notes This was the first introduction to program design. Additional design features will be introduced as you learn more object-oriented programming. At this stage you can already consider the following: Programs should use self-commenting identifiers. Control structures and block structure need to use a consistent indentation style. Specific tasks should be placed in modules called methods. Similar methods accessing the same data should be placed in a class. The main method should be used for program sequence, not large numbers of program statements.

// Java0740.java // This program demonstrates a method that will be used to display a fence. import java.awt.*; import java.applet.*; public class Java0740 extends Applet { public void paint(Graphics g) { Expo.setBackground(g,Expo.black); Expo.setColor(g,Expo.tan); Expo.fillRectangle(g,0,500,1000,525); Expo.fillRectangle(g,0,600,1000,625); Expo.setColor(g,Expo.brown); for (int x = 2; x < 1000; x+=40) { picket(g,x); } public static void picket(Graphics g, int x) { Expo.fillPolygon(g,x,650,x,500,x+18,450,x+36,500,x+36,650); Expo.delay(250); // delay for ¼ a second }

The Logic of the picket Method picket(g,x); All graphics methods need g. x is the horizontal value of the bottom left corner of the picket. The y (vertical) value of the bottom left corner is always 650 since all pickets will be at the bottom of the screen. The other 4 coordinates of the picket are relative to the point ( x,650 ). x,650x+36,650 x,500x+36,500 x+18,450

// Java0741.java // This program uses the method to create the method. import java.awt.*; import java.applet.*; public class Java0741 extends Applet { public void paint(Graphics g) { Expo.setBackground(g,Expo.black); fence(g); } public static void picket(Graphics g, int x) { Expo.fillPolygon(g,x,650,x,500,x+18,450,x+36,500,x+36,650); Expo.delay(250); // delay for ¼ a second } public static void fence(Graphics g) { // cross beams Expo.setColor(g,Expo.tan); Expo.fillRectangle(g,0,500,1000,525); Expo.fillRectangle(g,0,600,1000,625); // pickets Expo.setColor(g,Expo.brown); for (int x = 2; x < 1000; x+=40) { picket(g,x); }

// Java0742.java // This program combines many user-defined methods to create a graphics image. import java.awt.*; import java.applet.*; public class Java0742 extends Applet { public void paint(Graphics g) { nightSky(g); fence(g); } public static void randomStar(Graphics g, int x) { int y = Expo.random(25,175); int radius = Expo.random(15,20); int points = Expo.random(5,10); Expo.setRandomColor(g); Expo.fillStar(g,x,y,radius,points); Expo.delay(250); // delay for ¼ a second } public static void nightSky(Graphics g) { Expo.setBackground(g,Expo.black); moon(g); for (int x = 25; x <= 825; x+= 50) { randomStar(g,x); } public static void moon(Graphics g) { Expo.setColor(g,Expo.white); Expo.fillCircle(g,920,85,70); Expo.setColor(g,Expo.black); Expo.fillCircle(g,895,70,60); } public static void picket(Graphics g, int x) { Expo.fillPolygon(g,x,650,x,500,x+18,450, x+36,500,x+36,650); Expo.delay(250); // delay for ¼ a second } public static void fence(Graphics g) { // cross beams Expo.setColor(g,Expo.tan); Expo.fillRectangle(g,0,500,1000,525); Expo.fillRectangle(g,0,600,1000,625); // pickets Expo.setColor(g,Expo.brown); for (int x = 2; x < 1000; x+=40) { picket(g,x); }

// Java0743.java // This program does the exact same thing as the previous program, // but does not use any user-defined methods. // It also does not use any methods from the Expo class. // Can you make sense of this program? import java.awt.*; import java.applet.*; public class Java0733 extends Applet { public void paint(Graphics g) { g.setColor(Color.black); g.fillRect(0,0,4800,3600); g.setColor(Color.white); g.fillOval(850,15,140,140); g.setColor(Color.black); g.fillOval(835,10,120,120); for (int centerX = 25; centerX <= 825; centerX += 50) { int centerY = (int) (Math.random() * 151) + 25; int radius = (int) (Math.random() * 6) + 15; // continued on the next several slides…

int points = (int) (Math.random() * 6) + 5; int red = (int) (Math.random() * 256); int green = (int) (Math.random() * 256); int blue = (int) (Math.random() * 256); Color newColor = new Color(red, green, blue); g.setColor(newColor); int halfRadius; switch(points) { case 3 : halfRadius = 140 * radius / 500; break; case 4 : halfRadius = 170 * radius / 400; break; case 5 : halfRadius = 192 * radius / 500; break; case 6 : halfRadius = 233 * radius / 400; break; case 7 : halfRadius = 179 * radius / 500; break; case 8 : halfRadius = 215 * radius / 400; break; case 9 : halfRadius = 173 * radius / 500; break; case 10 : halfRadius = 212 * radius / 400; break; default : if (points < 52) { if (points % 2 == 1) halfRadius = (180-points) * radius / 500; else halfRadius = (222-points) * radius / 400; }

else halfRadius = radius / 2; } int p = points; points *= 2; int xCoord[] = new int[points]; int yCoord[] = new int[points]; int currentRadius; double twoPI = Math.PI * 2; double halfPI = Math.PI / 2; for (int k = 0; k < points; k++) { if (k % 2 == 0) currentRadius = radius; else currentRadius = halfRadius; xCoord[k] = (int) Math.round(Math.cos(twoPI * k/points - halfPI) * currentRadius) + centerX; yCoord[k] = (int) Math.round(Math.sin(twoPI * k/points - halfPI) * currentRadius) + centerY; }

int x = (p-5)/2+1; if (p >= 5 && p <= 51) switch(p % 4) { case 1 : yCoord[x] = yCoord[x+1] = yCoord[points-x-1] = yCoord[points-x]; break; case 2 : yCoord[x] = yCoord[x+1] = yCoord[points-x-1] = yCoord[points-x]; yCoord[x+3] = yCoord[x+4] = yCoord[points-x-4] = yCoord[points-x-3]; break; case 3 : yCoord[x+2] = yCoord[x+3] = yCoord[points-x-3] = yCoord[points-x-2]; } g.fillPolygon(xCoord,yCoord,points); long startDelay = System.currentTimeMillis(); long endDelay = 0; while (endDelay - startDelay < 250) endDelay = System.currentTimeMillis(); } g.setColor(new Color(210,180,140)); g.fillRect(0,500,1000,25); g.fillRect(0,600,1000,25); g.setColor(new Color(150,100,15));

for (int x = 2; x < 1000; x+=40) { Polygon picket = new Polygon(); picket.addPoint(x,650); picket.addPoint(x,500); picket.addPoint(x+18,450); picket.addPoint(x+36,500); picket.addPoint(x+36,650); g.fillPolygon(picket); long startDelay = System.currentTimeMillis(); long endDelay = 0; while (endDelay - startDelay < 250) endDelay = System.currentTimeMillis(); }

Primitive Data Types vs. Classes A simple/primitive data type can store only one single value. This means an int can only store one integer. A double.

Similar presentations

Presentation on theme: "Primitive Data Types vs. Classes A simple/primitive data type can store only one single value. This means an int can only store one integer. A double."— Presentation transcript:

Similar presentations

About project

Feedback

Log in

Auth with social network:

Primitive Data Types vs. Classes A simple/primitive data type can store only one single value. This means an int can only store one integer. A double.

Similar presentations

Presentation on theme: "Primitive Data Types vs. Classes A simple/primitive data type can store only one single value. This means an int can only store one integer. A double."— Presentation transcript:

Similar presentations

About project

Feedback