1. Java – Software Solutions…. Chapter 2: Objects and Primitive Data

2. 2 Objects and Primitive Data Now we can explore some more fundamental programming concepts Chapter 2 focuses on: predefined objects primitive data the declaration and use of variables expressions and operator precedence creating and using objects class libraries

3. 3 Introductory Notions Need ability to create and use objects. Provide ‘services’ Objects are fundamental to writing programs in an OOP language. Objects ‘do’ all the things we want: Manipulate strings Make computations Do input/output Draw shapes…

4. 4  Introduction to Objects An object represents something with which we can interact in a program An object provides a collection of services that we can tell it to perform for us The services are defined by methods in a class that defines the object A class represents a concept, and an object represents the embodiment of a class A class can be used to create multiple objects

5. 5 Introduction to Objects Objects also manage data Maybe primitive; maybe complex (like integers, floats…) Most complex data consists if primitive data… A data type defines a set of values and operations that can be performed on those values. Think: integers; +, -, *, /, no division by zero…  Objects is defined by a class – an abstraction; a generalization. Objects are ‘instances’ of a class. Operations (methods) are defined by methods in the class. Methods – a collection of programming statements with a given name that perform some kind of operation

6. 6 Objects and Classes Bank Account A class (the concept) Class = BankAccount John’s Bank Account Balance: $5,257 An object (a realization) (an ‘instantiation’) Bill’s Bank Account Balance: $1,245,069 Mary’s Bank Account Balance: $16,833 Multiple objects from the same class. Has attributes (data). Has methods (operations) Classes ‘encapsulate’ attributes and methods.

7. 7 Inheritance One class can be used to derive another via inheritance Classes can be organized into inheritance hierarchies Bank Account Account Charge Account Savings Account Checkin g Account Think: Gender Men Women Mothers non-Mothers

8. 8 Using Objects The System.out object represents a destination to which we can send output In the Lincoln program, we invoked the println method of the System.out object: System.out.println ("Whatever you are, be a good one."); object methodinformation provided to the method (parameters) Notice the ‘notation’ for referencing the method: object.method We are SENDING A MESSAGE to the object, System.out. We are requesting that the object perform a ‘service’ for us by invoking. the services of its method, println.

9. 9 The print Method The System.out object provides another service as well The print method is similar to the println method, except that it does not advance to the next line Therefore anything printed after a print statement will appear on the same line See Countdown.java (page 65)Countdown.java Sending a message (fig. 2.2) main CountdownSystem.out println //println //lprint // others…

10. 10 Abstraction An abstraction hides (or suppresses) the right details at the right time. We ‘abstract out’ common characteristics. An object is abstract in that we don't have to think about its internal details in order to use it.  encapsulate attributes and methods and provide services (have ‘responsibilities’) to other objects through the sending of messages. For example, we don't have to know how the println method inside the object System.out actually works in order to invoke it. We know when we send a message to the object System.out (we send messages by invoking its ‘methods’) with the parameters (“ “) the object will print out the contents enclosed in quotes.

11. 11 Abstraction (continued) Of course, we have ‘levels’ of abstraction – germane to the problem at hand. Car Ford  Mustang  Red Mustang that belongs to ….. Are all levels of abstraction! Each is more and more specific, but all have the ‘is-a’ characteristics.  More later…..  Classes and their objects help us write complex software

12. 12 Character Strings Every character string is an object in Java, defined by the String class Every string literal, delimited by double quotation marks, represents a String object Two fundamental string operations: 1) The string concatenation operator (+) is used to append one string to the end of another It can also be used to append a number to a string A string literal cannot be broken across two lines in a program

13. 13 String Concatenation The plus operator (+) is also used for arithmetic addition The function that the + operator performs depends on the type of the information on which it operates If both operands are strings, or if one is a string and one is a number, it performs string concatenation If both operands are numeric, it adds them The + operator is evaluated left to right (associativity) Parentheses can be used to force the operation order See Addition.java (page 70); Let’s look at some code:Addition.java

14. 14 //******************************************************************** // Facts.java Author: Lewis/Loftus // // Demonstrates the use of the string concatenation operator and the // automatic conversion of an integer to a string. //******************************************************************** public class Facts { //----------------------------------------------------------------- // Prints various facts. //----------------------------------------------------------------- public static void main (String[] args) { // Strings can be concatenated into one long string System.out.println ("We present the following facts for your " + "extracurricular edification:"); System.out.println (); // A string can contain numeric digits System.out.println ("Letters in the Hawaiian alphabet: 12"); // A numeric value can be concatenated to a string System.out.println ("Dialing code for Antarctica: " + 672); System.out.println ("Year in which Leonardo da Vinci invented " + "the parachute: " + 1515); System.out.println ("Speed of ketchup: " + 40 + " km per year"); } // end main } // end class Facts Everything prints out in a straight line. See page 68 in textbook….

15. 15 Overloading Operators Operators can be ‘overloaded’ Have different meanings depending on context. “+” can mean concatenation or addition depending…. Remember the + operator ‘associates’ left to right AND Remember parentheses always override the ‘normal’ hierarchical evaluation (later…)

16. 16 Escape Sequences 2) Second fundamental characteristic on Strings: the escape sequence. What if we wanted to print a double quote character? The following line would confuse the compiler because it would interpret the second quote as the end of the string System.out.println ("I said "Hello" to you."); This is a problem

17. 17 Escape sequences (continued) An escape sequence is a series of characters that represents a special character – usually a single character. An escape sequence begins with a backslash character ( \ ), which indicates that the character(s) that follow should be treated in a special way System.out.println ("I said \"Hello\" to you."); Discuss…

18. 18 Escape Sequences Some Java escape sequences: Make sure you understand these, especially \n, \t, \” and maybe a couple of others… Let’s look at Roses.java Escape Sequence \b \t \n \r \" \' \\ Meaning backspace tab newline carriage return double quote single quote backslash

19. 19 Public Directory for Roses.java //******************************************************************** // Roses.java Author: Lewis/Loftus // // Demonstrates the use of escape sequences. //******************************************************************** public class Roses { //----------------------------------------------------------------- // Prints a poem (of sorts) on multiple lines. //----------------------------------------------------------------- public static void main (String[] args) { System.out.println ("Roses are red,\n\tViolets are blue,\n" + "Sugar is sweet,\n\tBut I have \"commitment issues\",\n\t" + "So I'd rather just be friends\n\tAt this point in our " + "relationship."); } // end main } // end class Roses

20. 20 Variables A variable is a name for a location in memory A variable must be declared by specifying the variable's name and the type of information that it will hold int total; int count, temp, result; Multiple variables can be created in one declaration data type variable name

21. 21 Variables A variable can be given an initial value in the declaration When a variable is referenced in a program, its current value is used Look over PianoKeys.java (page 73) on your own.PianoKeys.java int sum = 0; int base = 32, max = 149; // note syntax…

22. 22 Assignment An assignment statement changes the value of a variable The assignment operator is the = sign total = 55; The value that was in total is overwritten You can only assign a value to a variable that is consistent with the variable's declared type See Geometry.java (page 74) – will do….Geometry.java The expression on the right is evaluated and the result is stored in the variable on the left

23. 23 Geometry example… /******************************************************************** // Geometry.java Author: Lewis/Loftus // // Demonstrates the use of an assignment statement to change the // value stored in a variable. //******************************************************************** public class Geometry { //----------------------------------------------------------------- // Prints the number of sides of several geometric shapes. //----------------------------------------------------------------- public static void main (String[] args) { int sides = 7; // declaration with initialization System.out.println ("A heptagon has " + sides + " sides."); sides = 10; // assignment statement System.out.println ("A decagon has " + sides + " sides."); sides = 12; System.out.println ("A dodecagon has " + sides + " sides."); } }

24. 24 Constants A constant is an identifier that is similar to a variable except that it holds one value while the program is active The compiler will issue an error if you try to change the value of a constant during execution In Java, we use the final modifier to declare a constant final int MIN_HEIGHT = 69; Note: constants are written in caps to distinguish themselves from other ‘variables’ whose values can change. give names to otherwise unclear literal values facilitates updates of values used throughout a program prevent inadvertent attempts to change a value (Discuss: final float RATE = 0.15; only change value…)

25. 25 Primitive Data There are exactly eight primitive data types in Java Four represent integers:  byte, short, int, long (no fractions) Two represent floating point numbers:  float, double (contain decimals) One represents characters: char One represents boolean values: boolean All have different ‘sizes’ and ‘ranges’…..

26. 26 Numeric Primitive Data Sizes and Ranges of storable values below. Use size as ‘appropriate’ but if in doubt, be generous. Type byte short int long float double Storage 8 bits 16 bits 32 bits 64 bits 32 bits 64 bits Min Value -128 -32,768 -2,147,483,648 < -9 x 10 18 +/- 3.4 x 10 38 with 7 significant digits +/- 1.7 x 10 308 with 15 significant digits Max Value 127 32,767 2,147,483,647 > 9 x 10 18

27. 27 Numeric Primitive Data Default: int is 32 bits; but 45L or 45l => long Default: for decimal data: assumes all literals are type double. To make ‘float’  45.6F or 45.6f Can say, if desired, 45.6D or 45.6d, but unnecessary.

28. 28 Characters A char variable stores a single character from the Unicode character set A character set is an ordered list of characters, and each character corresponds to a unique number The Unicode character set uses sixteen bits per character, allowing for 65,536 unique characters It is an international character set, containing symbols and characters from many world languages Character literals are delimited by single quotes: 'a' 'X' '7' '$' ',' '\n'  ‘7’ is not equivalent to 7 is not equivalent to “7”

29. 29 Characters The ASCII character set is older and smaller than Unicode, but is still quite popular Has evolved to eight-bits per byte.  (char is a ‘primitive data type’; String is a class) Because String is a class, it has many methods (operations) that can be performed on String objects!) The ASCII characters are a subset of the Unicode character set, including: uppercase letters lowercase letters punctuation digits special symbols control characters A, B, C, … a, b, c, … period, semi-colon, … 0, 1, 2, … &, |, \, … carriage return, tab,...

30. 30 Boolean A boolean value represents a true or false condition A boolean also can be used to represent any two states, such as a light bulb being on or off The reserved words true and false are the only valid values for a boolean type boolean done = false;

31. 31 2.5 Arithmetic Expressions (p. 80) An expression is a combination of one or more operands and their operators Arithmetic expressions compute numeric results and make use of the arithmetic operators: Addition+ Subtraction- Multiplication* Division/ Remainder% (modulus operator in C) If operands are mixed, results are ‘promoted.’ 4.5 + 2 = 6.5 (double) Sometimes called “widened.”

32. 32 Division and Remainder If both operands to the division operator ( / ) are integers, the result is an integer (the fractional part is discarded) If both or either parts are floating point, results are floating point. 14/3.0 = 14.0/3 = 14.0/3.0 = 3.5 The remainder operator (%) returns the remainder after dividing the second operand into the first and takes the sign of the numerator; only integers also 14 / 3 equals? 8 / 12 equals? 4 0 -14 % 3 equals? 8 % -12 equals? -2 8 16.0 % 4.0 equals invalid operands

33. 33 Operator Precedence Operators can be combined into complex expressions (variables or literals – doesn’t matter) result = total + count / max - offset; Operators have a well-defined precedence which determines the order in which they are evaluated Multiplication, division, and remainder are evaluated prior to addition, subtraction, and string concatenation Arithmetic operators with the same precedence are evaluated from left to right (‘associate left to right’) Parentheses can be used to force the evaluation order Can be nested too…..

34. 34 Operator Precedence What is the order of evaluation in the following expressions? a + b + c + d + e 1432 a + b * c - d / e 3241 a / (b + c) - d % e 2341 a / (b * (c + (d - e))) 4123

35. 35 Assignment Revisited The assignment operator has a lower precedence than the arithmetic operators First the expression on the right hand side of the = operator is evaluated Then the result is stored in the variable on the left hand side NOTE: the ‘assignment operator (again) IS an operator – (merely has lower precedence than arithmetic operators….) answer = sum / 4 + MAX * lowest; 1432 What’s this?

36. 36 Assignment Revisited The right and left hand sides of an assignment statement can contain the same variable First, one is added to the original value of count Then the result is stored back into count (overwriting the original value) count = count + 1; KNOW THE OPERATOR PRECEDENCE TABLE ON PAGE 82. It will grow significantly!

37. 37 Data Conversions Sometimes it is convenient to convert data types For example, we may want to treat an integer as a floating point value during a computation Be careful with conversions. Can lose information! (Why is one byte not enough to store 1000?) Widening conversions; safest; tend to go from a small data type to a larger one (such as a short to an int ) (more space (magnitude) normally; can lose precision – (int or long to float; long to double…) WHY? Narrowing conversions can lose information; they tend to go from a large data type to a smaller one (such as an int to a short ) (Can lose magnitude & precision!)

38. 38 Data Conversions In Java, data conversions can occur in three ways: assignment conversion arithmetic promotion casting Assignment conversion occurs when a value of one type is assigned to a variable of another Only widening (promoting) conversions can happen via assignment Arithmetic promotion happens automatically when operators in expressions convert their operands. But be aware that this does NOT change the permanent value! Only changes it for the calculation.

39. 39 Data Conversions Casting is the most powerful, and dangerous, technique for conversion Both widening and narrowing conversions can be accomplished by explicitly casting a value To cast, the type is put in parentheses in front of the value being converted For example, if total and count are integers, but we want a floating point result when dividing them, we can cast total : result = (float) total / count; DISCUSS!

40. 40 2.6 Creating Objects (p. 87) A variable holds either a primitive type or a reference to an object A class name can be used as a type to declare an object reference variable String title; No object is created with this declaration Object reference variables hold memory addresses of object (point to the objects) The object itself must be created separately

41. 41 Creating Objects - Constructors Generally, use new ‘operator’ to create an object title = new String ("Java Software Solutions"); constructor This calls the String constructor - a special method that sets up the object. So, this statement allocates space for an object and initializes it via its constructor. (Constructor method is the same name as the class.) Creating an object is called instantiation An object is an instance of a particular class (here, String) Can combine these operations: (FREQUENTLY DONE!) of creating a reference variable and also the object itself with value in a single declaration… String title = new String (“Java Software Solutions”); The ‘object reference variable’ (title) stores the address of where the object physically resides in memory.

42. 42 Creating Objects Because strings are so common, we don't have to use the new operator to create a String object title = "Java Software Solutions"; This is special syntax that works only for Strings Once an object has been instantiated, we can use the dot operator to invoke its methods (format: object.method() ) title.length() as in count = title.length(); (returns integer value of number of characters in the string, title – assigns that number to count. (assumes int count; ) Remember: the Constructor IS a method in all classes. When an object is created, its ‘constructor’ is called to set it up, initialize values, etc…. (Much more later on constructors)

43. 43 String Methods The String class has several methods that are useful for manipulating strings. (Recall, classes have attributes and methods) Many of the methods return a value, such as an integer - like length() or a new String object… Some return a new String or a boolean value...when the lengths of strings are compared or their values are compared…. See the list of String methods on page 89 and in Appendix M

44. 44 // ************************************************************************* // String Manipulation Example // ************************************************************************* public class StringManipulation { // ------------------------------------------------------ // Prints a string and several mutations of it // ------------------------------------------------------ public static void main (String [ ] args ); { String phrase = new String (“Change is inevitable”); // what does this do? String mutation1, mutation2, mutation3, mutation4; // what does this do? System.out.println (“Original string: \”” + phrase + \”” ); System.out.println (“Length of string: “ + phrase.length() ); mutation1 = phrase.concat (“, except from vending machines. “); // Note: many methods of objects of type String return new objects!! // See page 89. This is what is going on here…. mutation2 = mutation1.toUpperCase(); mutation3 = mutation1.replace(‘E’, ‘X’); mutation4 = mutation1.substring(3,30); // Print out results System.out.println (“Mutation #1: “ + mutation1); System.out.println (“Mutation #2: “ + mutation2); System.out.println (“Mutation #3: “ + mutation3); System.out.println (“Mutation #4: “ + mutation4); System.out.println (“Mutated length: “ + mutation1.length()); }// end of main procedure } // end of public class StringManipulation

45. 45 2.7 Class Libraries (p.91) A class library is a collection of classes that we can use when developing programs The Java standard class library is part of any Java development environment – but NOT part of Java language. Other class libraries can be obtained through third party vendors, or you can create them yourself Class library = clusters of related classes, called Java APIs or Application Programmer Interface. Look these over!!! Many “APIs” like the Java Database API which contains sets of classes that help us when we are dealing with databases. Java Swing API – helps us when we are dealing with GUIs…

46. 46 Packages Classes of the Java standard class library are organized into packages The package organization is more fundamental and language-based than the API names. Use packages extensively!!!! Some packages in the standard class library are: Package java.lang java.applet java.awt javax.swing java.net java.util javax.xml.parsers Purpose General support // Always get this. No need to import Creating applets for the web Graphics and graphical user interfaces Additional graphics capabilities and components Network communication Utilities - will use this a lot XML document processing

47. 47 The import Declaration To use class(es) from a package, we must ‘import’ the package. import java.util.*; (imports package and all of its classes) Or you can import only the class you are interested in: import java.util.Random; ( imports the class Random from the package, util) Import all classes in a particular package, you can use the * wildcard character. (Need > 1? Import entire package.)

48. 48 The import Declaration All classes of the java.lang package are imported automatically into all programs So, String and System weren’t explicitly imported… and didn’t need to import them in earlier examples. The Random class is part of java.util package Among other things, java.util package has a Random class that generates pseudorandom numbers if needed. (very popular class)

49. 49 Random Class from java.util package Be certain to study figure 2.12 and listing 2.9 for public class RandomNumbers. Be sure to understand how this works!  Note: There is a Random class in java.util. Generates a ‘pseudo random number’ Seeded! Some Random methods: (page 96) Random () – Constructor; creases a new pseudorandom number generator. float nextFloat() – returns a random number between 0.0 and 1.0 (exclusive) (Can cast to get an int, …) int nextInt () – returns a random number ranging over all positive and negative values int nextInt (int num) Returns a random number in range of 0 to num-1.

50. 50 2.8 Class Methods (p. 98) Some methods can be invoked through the class name, instead of through an object of the class Means you can use them directly and do not have to have objects of that class declared to get methods! Called class methods or static methods (have class variables too…) Method must be defined as static in the class though….and note (p. 99) all methods are static and ‘double.’ The Math class contains many static methods, providing various mathematical functions, such as absolute value, trigonometry functions, square root, etc. temp = Math.cos(90) + Math.sqrt(delta); Note: there is a random() static method in Math class. cos is a class or static method. Notation: class.method. Note: double temp;

51. 51 The Keyboard Class The Keyboard class is NOT part of the Java standard class library It is provided by the authors of the textbook to make reading input from the keyboard easy Details of the Keyboard class - Chapter 5 The Keyboard class is part of a package called cs1 – created by authors. It contains several static methods for reading particular types of data BUT: we are going to do the real deal!

52. 52 Keyboard Input The Keyboard class introduced in Chapter 2 facilitates capturing input from the keyboard The Keyboard class was written by the authors of the book; hence, not commonly available to Java users. The Keyboard class hides various aspects of Java input processing Keyboard class obscured how Java really does keyboard input/output.

53. 53 Reading Keyboard Input Java I/O is accomplished using objects that represent streams of data A stream is an ordered sequence of bytes The System.out object represents a standard output stream, which defaults to the monitor screen This is always ‘character’ output… Reading keyboard input is much more complicated Recognize that input data coming from the keyboard is always in a character format (as are almost all files we process…) E.g., 567 (entered on keyboard…) is the character 5 followed by character 6 followed by the character 7. It is NOT 567!... If we WANT 567, we must convert these characters to an integer!

54. 54 BufferedReader Class and its methods p. 287-288 The input stream is made up of multiple objects: BufferedReader in = new BufferedReader (new InputStreamReader (System.in)); The System.in (object passed as a parameter) object is used by the InputStreamReader object to create an InputStreamReader object The InputStreamReader object is then used as a parameter by BufferedReader to create a BufferedReader object – which is named ‘in.’  This creates an input stream that treats input as characters and buffers them so that input can be read one line at a time The readLine method of the BufferedReader class (invoked via in.readLine() reads an entire line of input as a String

55. 55 Wrapper Classes We have methods called “Wrapper class methods” (many of these are static methods or class methods….) that can be used to convert text (character) input into desired numeric input Problems that arise in reading or converting a value manifest themselves as “Exceptions.” The throws clause of a method header indicates what exceptions it may throw. (Much more later on these…) I/O and exceptions are explored further in Chapter 8 All ‘primitive data types’ have Wrapper classes!!!! Let’s look at some code…

56. 56 //******************************************************************** // Wages2.java Author: Lewis/Loftus from Chapter 5 examples…. // Demonstrates the use of Java I/O classes for keyboard input. //******************************************************************** import java.io.*;  import java.text.NumberFormat;  public class Wages2 { // Reads pertinent information and calculates wages. public static void main (String[] args) throws IOException { BufferedReader in = new BufferedReader (new InputStreamReader (System.in)); // creates a standard input stream object (a BufferedReader object) in a useful form…. // name if input stream object is ‘in.’ ‘in’ is an object of type (class) BufferedReader. // Creates an input stream that accepts input as characters and buffers the input so that it // can be read one line at a time. ‘in’ now has all the methods defined in BufferedReader. String name;// what does this do? int hours;// what does this do? double rate, pay; System.out.print ("Enter your name: "); name = in.readLine (); // The readLine method of ‘in’, an object of class BufferedReader, reads an entire line of // input as a String (line terminated by ‘Enter’ ). To treat input as an integer (next statement…), // we must convert the input String into a numeric form, that is, an integer. Consider: System.out.print ("Enter the number of hours worked: "); hours = Integer.parseInt (in.readLine()); // parseInt is a static method of the Integer wrapper class – used to convert String input to int. System.out.print ("Enter pay rate per hour: "); rate = Double.parseDouble (in.readLine()); // ditto for parseDouble – a static method (class method) for the Double wrapper class.

57. 57 Continuing… System.out.println (); pay = hours * rate; NumberFormat fmt = NumberFormat.getCurrencyInstance(); // Whoa! NumberFormat is a class!!! // fmt is a ‘formatter object’ returned by the static class, getCurrencyInstance(). // This formatter object, fmt, returned by getCurrencyInstance() has a method // we will use, namely ‘format.’ See below. System.out.println (name + ", your pay is: " + fmt.format(pay)); }// end main } // end Wages2 So, we need to discuss NumberFormat and DecimalFormat classes.

58. 58 2.9 Formatting Output (p. 103) Remember: some classes contain static (class) methods (and attributes too). (more later in course) The NumberFormat class (in java.text package) has several static methods; Two of these static methods ‘return’ a ‘formatter object’ of type NumberClass as NumberFormat money = NumberFormat.getCurrencyInstance(); and NumberFormat percent = NumberFormat.getPercentInstance(); Since ‘money’ is an object of type NumberFormat, it ‘gets’ everything in NumberFormat, including a format method – SEE PAGE 104 top! This format method is invoked through a formatter object (money.format(argument) ) and returns a String (page 104…) that contains the number formatted in the appropriate manner. (See outputs, page 105)

59. 59 More…Stated a little differently… We have requested a special kind of object from one of NumberFormat’s static methods (getCurrencyInstance) Will explain why we do this later… Two such static methods from which we can request objects are getCurrencyInstance and getPercentInstance(). These methods, when invoked, return a special kind of object – called a ‘formatter’ object. When such an object is called using its ‘format’ method (see top page 104) the argument is formatted appropriately (getCurrencyInstance() produces an output that looks like dollars and cents; getPercentInstance() produces an output with a % sign. These objects use the ‘format’ method defined in NumberFormat, since each of these formatter objects “is_a” NumberFormat object. (Inheritance)

60. 60 //******************************************************************** // Price.java Author: Lewis/Loftus import cs1.Keyboard; // We will not use this! import java.text.NumberFormat; public class Price { public static void main (String[] args) // purged comments for space….. { final double TAX_RATE = 0.06; // 6% sales tax int quantity; double subtotal, tax, totalCost, unitPrice; System.out.print ("Enter the quantity: "); quantity = Keyboard.readInt(); // we will use BufferedReader object ‘in’ ….. System.out.print ("Enter the unit price: "); unitPrice = Keyboard.readDouble(); // we will use BufferedReader and Double wrapper class… subtotal = quantity * unitPrice; tax = subtotal * TAX_RATE; totalCost = subtotal + tax; // Print output with appropriate formatting  NumberFormat fmt1 = NumberFormat.getCurrencyInstance(); // returns an object – a ‘formatter’ object NumberFormat fmt2 = NumberFormat.getPercentInstance(); // returns an object – a ‘formatter’ object… // fmt1 and fmt2 are objects of type NumberFormat and each have a method ‘format’ to perform // formatting…..Their responsibilities are to format currency or percentages respectively… System.out.println ("Subtotal: " + fmt1.format(subtotal)); System.out.println ("Tax: " + fmt1.format(tax) + " at " + fmt2.format(TAX_RATE)); System.out.println ("Total: " + fmt1.format(totalCost)); } // end main } // end Price class

61. 61 More on Formatting Output The DecimalFormat class can be used to format a floating point value in generic ways For example, you can specify that the number should be printed to three decimal places Unlike the NumberFormat class with its static methods, the use of DecimalFormat requires instantiating objects in the usual way. The constructor of the DecimalFormat class takes a string that represents a pattern for the formatted number. (Means, when the object is created, it is given an initial value by the Constructor, and this value is an alphanumeric ‘pattern.’) These ‘patterns’ can be quite involved. More later.

62. 62 //******************************************************************** // CircleStats.java Author: Lewis/Loftus import cs1.Keyboard; import java.text.DecimalFormat; public class CircleStats { //----------------------------------------------------------------- // Calculates the area and circumference of a circle given its // radius. //----------------------------------------------------------------- public static void main (String[] args) { int radius; double area, circumference; System.out.print ("Enter the circle's radius: "); radius = Keyboard.readInt();// we will use BufferedReader objects… and Wrappers… area = Math.PI * Math.pow(radius, 2); //look at the static Math attributes and methods! circumference = 2 * Math.PI * radius; // Round the output to three decimal places DecimalFormat fmt = new DecimalFormat ("0.###"); //fmt is an object of type DecimalFormat // string 0.### indicates that at least one digit should be to the left of the decimal, and // should be a zero if the integer position of the value is zero. Also indicates that the // fractional part should be rounded to three digits. System.out.println ("The circle's area: " + fmt.format(area)); //Where did this ‘format’ come from??? System.out.println ("The circle's circumference: " + fmt.format(circumference)); } // end main } // end CircleStats

63. 63 Summary Chapter 2 has focused on: predefined objects primitive data the declaration and use of variables expressions and operator precedence creating and using objects class libraries Read way Java does Keyboard class…. NumberFormat and DecimalFormat classes