Upload
anissa-turner
View
247
Download
0
Embed Size (px)
Citation preview
Java – Software Solutions….
Chapter 2: Objects and Primitive Data
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
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
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
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
Objects and Classes
Bank Account
A class(the concept)
Class = BankAccount
John’s Bank AccountBalance: $5,257
An object(a realization)
(an ‘instantiation’)
Bill’s Bank AccountBalance: $1,245,069
Mary’s Bank AccountBalance: $16,833
Multiple objects
from the same class
. Has attributes (data). Has methods (operations)
Classes ‘encapsulate’ attributes and methods.
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
Checking
Account
Think: Gender
Men Women
Mothers non-Mothers
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.methodWe 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
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)
Sending a message (fig. 2.2)
main
Countdown System.out
println//println//lprint// others…
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
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
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
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:
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
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
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
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
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
backspacetab
newlinecarriage returndouble quotesingle quote
backslash
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
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
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.
int sum = 0;int base = 32, max = 149; // note syntax…
22
Assignment
An assignment statement changes the value of a variable The assignment operator is the = signtotal = 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….
The expression on the right is evaluated and the result is stored in the variable on the left
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
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
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
Numeric Primitive Data
Sizes and Ranges of storable values below. Use size as ‘appropriate’ but if in doubt, be
generous.Type
byteshortintlong
floatdouble
Storage
8 bits16 bits32 bits64 bits
32 bits64 bits
Min Value
-128-32,768-2,147,483,648< -9 x 1018
+/- 3.4 x 1038 with 7 significant digits+/- 1.7 x 10308 with 15 significant digits
Max Value
12732,7672,147,483,647> 9 x 1018
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
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
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
letterslowercase letterspunctuationdigitsspecial symbolscontrol characters
A, B, C, …a, b, c, …period, semi-colon, …0, 1, 2, …&, |, \, …carriage return, tab, ...
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
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
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
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
Operator Precedence
What is the order of evaluation in the following expressions?a + b + c + d + e
1 432a + b * c - d / e
3 241
a / (b + c) - d % e2 341
a / (b * (c + (d - e)))4 123
35
Assignment Revisited
The assignment operator has a lower precedence than the arithmetic operators
First the expression on the right handside of the = operator is evaluated
Then the result is stored in the variable on the left hand sideNOTE: the ‘assignment operator (again) IS an operator – (merelyhas lower precedence than arithmetic operators….)
answer = sum / 4 + MAX * lowest;
14 3 2
What’s this?
36
Assignment Revisited
The right and left hand sides of an assignment statement can contain the same variable
First, one is added to theoriginal 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
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
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
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
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
Creating Objects - Constructors
Generally, use new ‘operator’ to create an objecttitle = new String ("Java Software Solutions");
This calls the String constructorconstructor - 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
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
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
// *************************************************************************// 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 resultsSystem.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
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
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.langjava.appletjava.awtjavax.swingjava.netjava.utiljavax.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
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
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
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
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
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
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
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
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
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
//********************************************************************// 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
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
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
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
//********************************************************************// Price.java Author: Lewis/Loftusimport 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
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
//********************************************************************// CircleStats.java Author: Lewis/Loftusimport 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
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