Java

1
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
. 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

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.")
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
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)

//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) Lets 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 ()

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
• Lets look at Roses.java

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
21
Variables

• A variable can be given an initial value in the
  declaration

int sum 0 int base 32, max 149 // note
syntax

• When a variable is referenced in a program, its
  current value is used

• Look over PianoKeys.java (page 73) on your own.

22
Assignment

• An assignment statement changes the value of a
  variable
• The assignment operator is the sign

total 55

• The expression on the right is evaluated and the
  result is stored in the variable on the left

• 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.

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.")

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.

27
Numeric Primitive Data

• Default int is 32 bits but 45L or 45l gt
  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

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 Divis
ion / 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)

4
14 / 3 equals?
8 / 12 equals?
0

• 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?
-2
8 -12 equals?
8

16.0 4.0 equals invalid
operands
33
Operator Precedence

• Operators can be combined into complex
  expressions (variables or literals doesnt
  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
a b c - d / e
1
4
3
2
3
2
4
1
a / (b c) - d e
2
3
4
1
a / (b (c (d - e)))
4
1
2
3
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
answer sum / 4 MAX lowest
1
4
3
2
Whats this?
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.)
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
count count 1
Then the result is stored back into
count (overwriting the original value)
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 object

title new String ("Java Software Solutions")
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
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 //
pu
blic 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.toUpperCas
e() mutation3 mutation1.replace(E ,
X) mutation4 mutation1.substring(3,30)
// Print out results System.out.println
(Mutation 1 mutation1) System.out.printl
n (Mutation 2 mutation2) System.out.prin
tln (Mutation 3 mutation3) System.out.pr
intln (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

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 gt 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 werent explicitly
  imported and didnt 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!!!!
• Lets 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. //
i
mport 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.getCurrency
  Instance()
• // 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.getCurren
  cyInstance() and
• NumberFormat percent NumberFormat.getPerce
  ntInstance()
• 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
MoreStated a little differently

• We have requested a special kind of object from
  one of NumberFormats 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/Loftus import cs1.Keyboard // We will
not use this! import java.text.NumberFormat publi
c 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.getPercentInstanc
e() // 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/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
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