Download Chapter 3: Introduction to Objects and Input/Output

Chapter 3: Introduction to
Objects and Input/Output
Java Programming:
Program Design Including Data Structures
Chapter Objectives
 Learn about objects and reference variables
 Explore how to use predefined methods in a program
 Become familiar with the class String
 Learn how to use input and output dialog boxes in a program
 Explore how to format the output of decimal numbers with the String
method format(…)
 Become familiar with file input and output
Java Programming: Program Design Including Data Structures
2
Object and Reference Variables
 Declare a reference variable of a class type
 Allocate memory space for data
 Instantiate an object of that class type
 Store object address in a reference variable
Java Programming: Program Design Including Data Structures
3
Object and Reference Variables
(continued)
int x;
String str;
x = 45;
str = "Java Programming";
//Line
//Line
//Line
//Line
Java Programming: Program Design Including Data Structures
1
2
3
4
4
Object and Reference Variables
(continued)
String str;
str = "Hello there!";
Java Programming: Program Design Including Data Structures
5
Object and Reference Variables
(continued)
 Primitive type variables directly store data into their
memory space (int, long, double, float, boolean, …)
 Reference variables store the address of the object
containing the data
 An object is an instance of a class; use new to
instantiate an object
Java Programming: Program Design Including Data Structures
6
Using Predefined Classes and
Methods in a Program
 Many predefined packages, classes, and methods
 Library: A collection of packages
 Package: Contains several classes
 Class: Contains attributes & methods
 Method: A set of instructions
Java Programming: Program Design Including Data Structures
7
Using Predefined Classes and
Methods in a Program
To use a method you must know:
 Name of the class containing the method (Math)
 Name of the package containing the class
(java.lang)
 Name of the method (pow); it has two parameters
 Math.pow(x, y)
[ same as xy
Java Programming: Program Design Including Data Structures
]
8
Using Predefined Classes and
Methods in a Program
 Example method call:
import java.lang.*; //imports package
...
Math.pow(2, 3);
//calls power method
//in class Math
 Dot (.)operator: accesses the method in the class
Java Programming: Program Design Including Data Structures
9
Some Java classes
for a complete list see: http://java.sun.com/j2se/1.4.2/docs/api/
java.applet
java.awt
java.awt.color
java.awt.datatransfer
java.awt.dnd
java.awt.event
java.awt.font
java.awt.geom
java.awt.im
java.awt.im.spi
java.awt.image
java.awt.image.renderable
java.awt.print
java.beans
java.beans.beancontext
java.io
java.lang
java.lang.ref
java.lang.reflect
java.math
java.net
java.nio
java.nio.channels
java.nio.channels.spi
java.nio.charset
java.nio.charset.spi
java.rmi
java.rmi.activation
java.rmi.dgc
java.rmi.registry
java.rmi.server
Java Programming: Program Design Including Data Structures
java.security
java.security.acl
java.security.cert
java.security.interfaces
java.security.spec
java.sql
java.text
java.util
java.util.jar
java.util.logging
java.util.prefs
java.util.regex
java.util.zip
javax.accessibility
javax.crypto
…
10
Some Methods in java.lang.Math
for a complete list see: http://java.sun.com/
ABS(number)
ACOS(double)
ASIN(double)
ATAN(double)
ATAN2(double1, double2)
CEILING(double)
COS(double)
COT(double)
DEGREES(number) **
EXP(double)
FLOOR(double)
**
LOG(double)
LOG10(double)
**
MOD(integer1, integer2)
PI()
POWER(number, power)
RADIANS(number)
RAND(integer)
ROUND(number, places)
SIGN(number)
SIN(double)
SQRT(double)
TAN(double)
TRUNCATE (number, places)
not generally available
Java Programming: Program Design Including Data Structures
11
The class String
 String variables are reference variables
 Given:
String name;
 Equivalent statements:
name = new String("Lisa Simpson");
name = "Lisa Simpson";
name
Lisa Simpson
Java Programming: Program Design Including Data Structures
12
The class String
 String object is an instance of class String
 A String object with the value "Lisa Simpson" is
instantiated
 The address of the object is stored in name
 new is unnecessary when instantiating Java strings
 String methods are called using the dot operator
theString.theMethod(…)
Java Programming: Program Design Including Data Structures
13
Commonly Used String Methods
sentence = “Programming with Java”
012345678901234567890
Java Programming: Program Design Including Data Structures
14
Commonly Used String Methods
(continued)
sentence = “Programming with Java”
012345678901234567890
Java Programming: Program Design Including Data Structures
15
Commonly Used String Methods
(continued)
sentence = “Programming with Java”
012345678901234567890
Java Programming: Program Design Including Data Structures
16
Commonly Used String Methods
(continued)
sentence = “Programming with Java”
012345678901234567890
Java Programming: Program Design Including Data Structures
17
Commonly Used String Methods
(continued)
public class PlayingWithStrings1
{
public static void main(String[] argv)
{
String sentence = "Programming with Java";
// same as: String sentence = new String("Programming with Java");
System.out.println
System.out.println
System.out.println
System.out.println
}
("sentence: " + sentence);
("sentence.charAt(3) " + sentence.charAt(3));
("sentence.indexOf('g') " + sentence.indexOf('g') );
("sentence.indexOf('a', 10) " + sentence.indexOf('a', 10));
}
sentence: Programming with Java
sentence.charAt(3) g
sentence.indexOf('g') 3
sentence.indexOf('a', 10) 18
Java Programming: Program Design Including Data Structures
18
Input/Output
 Input data
 Format output
 Output results
 Read from and write to files
Java Programming: Program Design Including Data Structures
19
Formatting Output with printf
 printf syntax (standard output device)
System.out.printf(formatString);
or
System.out.printf(formatString, argumentList);
 formatString specifies the format of the output
 argumentList is a list of arguments
 Constant values, variables, or expressions
 Arguments are separated with commas
Java Programming: Program Design Including Data Structures
20
Formatting Output with printf
(continued)
 Example using only the format string:
System.out.printf("Hello there!");
 Example using format string and argumentList:
System.out.printf(
"There are %.2f inches in %d centimeters. %n",
centimeters / 2.54,
centimeters);
 %.2f and %d are called format specifiers
 One-to-one correspondence between format specifiers and the
arguments in argumentList
Java Programming: Program Design Including Data Structures
21
Formatting Output with printf
(continued)
Example
public class Demo01 {
public static void main(String[] args) {
// formating output using good-old printf
int centimeters = 100;
System.out.printf(
"There are %.2f inches in %d centimeters. %n",
centimeters / 2.54, centimeters);
}
}
_______________________________________________
Output: There are 39.37 inches in 100 centimeters.
Java Programming: Program Design Including Data Structures
22
Formatting Output with printf
(continued)
 The first format specifier, %.2f, is matched with
the first argument, which is the expression
centimeters / 2.54
 The second format specifier, %d, is matched with
the second argument, which is centimeters
 The format specifier %n positions the insertion point
at the beginning of the next line (same as \n )
Java Programming: Program Design Including Data Structures
23
Formatting Output with printf
(continued)
 A format specifier for general, character, and
numeric types has the following syntax:
%[argument_index$][flags][width][.precision]conversion
 Expressions in square brackets are optional
 Optional argument_index is a (decimal) integer that
indicates argument position in the argument list
Java Programming: Program Design Including Data Structures
24
Formatting Output with printf
(continued)
public class DemoJ01 {
public static void main(String[] args) {
// formating output using good-old C printf
String fName = "Maria";
String lName = "Macarena";
System.out.printf(
"The Queen of rumba is %1$-10s %2$s. Viva %3$10s%n",
fName, lName, "Cuervo");
System.out.printf(
"The Queen of rumba is %1$10s %2$s. Viva %3$s%n",
fName, lName, "Cuervo");
}
}
The Queen of rumba is Maria
Macarena. Viva
Cuervo
The Queen of rumba is
Maria Macarena. Viva Cuervo
Java Programming: Program Design Including Data Structures
25
Formatting Output with printf
(continued)
 flags (optional) set of characters that modify the
output format
 width (optional) is an integer that indicates the
minimum number of characters to be written
 precision (optional) is an integer that restricts the
number of characters
 conversion (required) is a character that indicates
how the argument should be formatted
Java Programming: Program Design Including Data Structures
26
Formatting Output with printf
(continued)
Java Programming: Program Design Including Data Structures
27
Formatting Output with printf
(continued)
flag
meaning
Argument is represented in an "alternate form." This depends on the conversion type:
'-'
Result is left-aligned in the field. This flag is meaningless if no mandatory field
width is specified.
'^'
Result is centered in the field. This flag is meaningless if no mandatory field
width is specified.
'+'
Non-negative values begin with a plus character ('+').
' '
Non-negative values begin with a space character (' '). This flag is only useful
for signed conversion results (%d and %f).
'#'
conversion types
applicable
%d, %u, %o, %x, %X,
%z[n], %Z[n], %f, %e, %E,
%g, %G, %s, %c, %p
%d, %f
%o
Non-negative octal values are prepended with a zero ('0').
%x, %X
Hexadecimal values are prepended with the prefix "0x" or "0X".
%e, %E, %f
The integer portion of the result always ends with a decimal point ('.'), even if the
fractional portion is zero.
%g, %G
The fractional portion always appears, even if it is zero.
%c
If the character is special or unprintable, it is output in an escaped form. The output can
be surrounded by single quotes to form a syntactically valid Java character literal.
There is no alternate form for %s, %d, %u, %z[n], and %Z[n].
Java Programming: Program Design Including Data Structures
28
Formatting Output with printf
(continued)
Example:
public class Demo03 {
public static void main(String[] args) {
System.out.printf ("Characters: %c %c \n", 'a', 65);
System.out.printf ("Integrals: %d %d\n", 123, 999888777);
System.out.printf ("Preceding with blanks: %10d \n", 2007);
System.out.printf ("Preceding with zeros: %010d \n", 2007);
System.out.printf ("Explicit signs: %+10d \n", 2007);
System.out.printf ("Explicit signs: %+10d \n", -2007);
System.out.printf ("Some different radixes: %d %x %X %o %#x %#o \n",
77, 77, 77, 77, 77, 77);
System.out.printf ("floats: %4.2f %+.0e %E \n",
3.1416, 3.1416, 3.1416);
System.out.printf ("%s \n", "A string");
}
}
Java Programming: Program Design Including Data Structures
Characters: a A
Integrals: 123 999888777
Preceding with blanks:
2007
Preceding with zeros: 0000002007
Explicit signs:
+2007
Explicit signs:
-2007
Some different radixes: 77 4d 4D 115 0x4d 0115
floats: 3.14 +3e+00 3.141600E+00
A string
29
Parsing Numeric Strings
 A string consisting of only integers or decimal
numbers is called a numeric string
 To convert a string consisting of an integer to a
value of the type int, use:
Integer.parseInt(strExpression)
Integer.parseInt("6723") = 6723
Integer.parseInt("-823") = -823
Long.parseLong(strExpression)
Long.parseLong("1234567890123456723")
Java Programming: Program Design Including Data Structures
→
123456789012345
30
Parsing Numeric Strings
(continued)
 To convert a string consisting of a decimal number
to a value of the type float, use:
Float.parseFloat(strExpression)
Float.parseFloat("34.56") = 34.56
Float.parseFloat("-542.97") = -542.97
 To convert a string consisting of a decimal number
to a value of the type double, use:
Double.parseDouble(strExpression)
Double.parseDouble("345.78") = 345.78
Double.parseDouble("-782.873") = -782.873
Java Programming: Program Design Including Data Structures
31
Parsing Numeric Strings
(continued)
 Integer, Float, and Double are classes
designed to convert a numeric string into a number
(not the same as: int, float, double)
 These classes are called wrapper classes



parseInt: class Integer, converts a numeric
integer string into a value of the type int
parseFloat: class Float, converts a numeric
decimal string into an equivalent value of the type
float
parseDouble: class Double, converts a numeric
decimal string into an equivalent value of the type
double
Java Programming: Program Design Including Data Structures
32
Using Dialog Boxes for
Input/Output
 Use a graphical user interface (GUI)
 class JOptionPane
 Contained in package javax.swing
 showInputDialog, showMessageDialog
 Syntax:
str = JOptionPane.showInputDialog(strExpression)
 Program should end with System.exit(0);
(to terminate the JVM)
Java Programming: Program Design Including Data Structures
33
Using Dialog Boxes for
Input/Output
import javax.swing.*;
public class UsingDialogBoxes1
{
public static void main(String[] argv)
{
String str; int age;
str = JOptionPane.showInputDialog("Enter your name");
System.out.println ("You said " + str);
str = JOptionPane.showInputDialog("Enter your age");
age = Integer.parseInt(str);
System.out.println ("You said " + age);
}
}
Java Programming: Program Design Including Data Structures
You said maria macarena
You said 27
34
Parameters for the Method
showMessageDialog
Java Programming: Program Design Including Data Structures
35
JOptionPane Options for the
Parameter messageType
Java Programming: Program Design Including Data Structures
36
JOptionPane Example
Java Programming: Program Design Including Data Structures
37
Formatting the Output Using the
String Method format
Example 3-13
double x = 15.674;
double y = 235.73;
double z = 9525.9864;
int num = 83;
String str;
Java Programming: Program Design Including Data Structures
38
Formatting the Output Using the
String Method format
Example
public class DemoJ01 {
public static void main(String[] args) {
double payRate = 7.789;
String myResult;
System.out.println("The result is " + payRate);
myResult = String.format("The result is %.2f", payRate);
System.out.println(myResult);
}
}
The result is 7.79
The result is 7.789
Java Programming: Program Design Including Data Structures
39
File Input/Output

File: area in secondary storage that holds
info

You can initialize a Scanner object to input
sources other than the standard input device
by passing an appropriate argument in place
of the object System.in

Use class FileReader
Java Programming: Program Design Including Data Structures
40
File Input/Output (continued)


Suppose that the input data is stored in a file,
say prog.dat, and this file is on floppy disk A
Create a Scanner object inFile and initialize it to
the file a:\prog.dat:
Scanner inFile = new Scanner(new fileReader("a:\\prog.dat"));

Use inFile to input data from prog.dat
(Similar to using console)
Java Programming: Program Design Including Data Structures
41
File Input/Output (continued)
Java file I/O process:
1. Import necessary classes from the packages
java.util and java.io into the program
2. Create and associate appropriate objects with the
input/output sources
3. Use the appropriate methods associated with the
variables created in Step 2 to input/output data
4. Close the files
Java Programming: Program Design Including Data Structures
42
File Input/Output (continued)
Example 3-16
Suppose an input file, say employeeData.txt, consists of the following
data:
Emily Johnson 45 13.50
 To acquire the data you place a Scanner object on the disk file
Scanner inFile = new Scanner
(new FileReader(“a:\\employeeData.txt"));
Java Programming: Program Design Including Data Structures
43
File Input/Output (continued)
Example 3-16 cont.
import java.io.*;
import java.util.*;
public class Demo04
{
public static void main (String[] argv) throws IOException, FileNotFoundException
{
Scanner inFile = new Scanner (new FileReader("c:\\employeeData.txt"));
String firstName, lastName;
double hoursWorked, payRate, wages;
//read single data row (later will learn how to use hasNext() for multiple records)
firstName = inFile.next();
lastName = inFile.next();
hoursWorked = inFile.nextDouble();
payRate = inFile.nextDouble();
wages = hoursWorked * payRate;
System.out.println ("ECHO. Here is what I read from the disk file\n");
System.out.printf("Name: %s %s Hours: %.2f Rate: %.2f Wages: %.2f",
firstName, lastName, hoursWorked, payRate, wages);
inFile.close();
}
//close the input file
}
ECHO. Here is what I read from the disk file
Name: Emily Johnson Hours: 45.00 Rate: 13.50 Wages: 607.50
Java Programming: Program Design Including Data Structures
44
Storing (Writing) Output in a File
 To store output in a file, use the
class PrintWriter
 Declare a PrintWriter variable and
associate this variable with the
destination
 Suppose the output is to be stored in
the file prog.out on floppy disk A
Java Programming: Program Design Including Data Structures
45
Storing (Writing) Output in a File
(continued)
 Consider the following statement:
PrintWriter outFile =
new PrintWriter("a:\\prog.out");
 Creates PrintWriter object outFile and
associates it with prog.out on floppy disk A
 Use print, println, printf, and flush with
outFile just as with the object System.out
Java Programming: Program Design Including Data Structures
46
Storing (Writing) Output in a File
(continued)
 The statement:
outFile.println("The paycheck is: $" + pay);
stores the output in prog.out
 Close input and output files using method close
inFile.close();
outFile.close();
 Closing the output file ensures that the buffer holding
the output will be emptied
Java Programming: Program Design Including Data Structures
47
Storing (Writing) Output in a File
(continued)
Example
import java.io.*;
public class Demo05
{
public static void main (String[] argv)
throws IOException, FileNotFoundException
{
PrintWriter outFile =
new PrintWriter("c:\\prog.out");
//PrintWriter outFile = new PrintWriter(System.out);
outFile.printf("%s %d %.2f", "Hermione Wrangler", 17, 1234.567);
outFile.close();
}
}
Hermione Wrangler 17 1234.57
Java Programming: Program Design Including Data Structures
48
Storing (Writing) Output in a File
(continued)
 Various errors can arise during program execution:
 Division by zero
 Inputting a letter for a number
 In such cases, we say that an exception has occurred
 If an exception occurs in a method, then the method
should either handle the exception or throw it for the
calling environment to handle
Java Programming: Program Design Including Data Structures
49
Storing (Writing) Output in a File
(continued)
 If an input file does not exist, the program throws a
FileNotFoundException
 If an output file cannot be created or accessed, the
program throws a FileNotFoundException
 Because we do not need the method main to handle
the FileNotFoundException exception, include a
command in the heading of main to throw the
FileNotFoundException exception
Java Programming: Program Design Including Data Structures
50
Skeleton of I/O Program
Java Programming: Program Design Including Data Structures
51
Programming Example: Movie
Ticket Sale and Donation to
Charity
 Input: Movie name, ticket prices, etc.
 Output:
Java Programming: Program Design Including Data Structures
52
Programming Example: Movie
Ticket Sale and Donation to
Charity (continued)
1. Import appropriate packages
2. Get inputs from user using
JOptionPane.showInputDialog
3. Perform appropriate calculations
4. Display output using
JOptionPane.showMessageDialog
Java Programming: Program Design Including Data Structures
53
Programming Example:
Student Grade
 Input: File containing student’s first name, last
name, five test scores
 Output: File containing student’s first name, last
name, five test scores, average of five test scores
Java Programming: Program Design Including Data Structures
54
Programming Example:
Student Grade (continued)
1. Import appropriate packages
2. Get input from file using the classes Scanner
and FileReader
3. Read and calculate the average of test scores
4. Write to output file using the class
PrintWriter
5. Close files
Java Programming: Program Design Including Data Structures
55
Chapter Summary
 Primitive type variables store data into their
memory space
 Reference variables store the address of the object
containing the data
 An object is an instance of a class
 Operator new is used to instantiate an object
 Garbage collection reclaims unused memory
Java Programming: Program Design Including Data Structures
56
Chapter Summary (continued)
 To use a predefined method, you must know its
name and the class and package it belongs to
 The dot (.) operator accesses a method in a class
 Methods of the class String are used to
manipulate input and output data
 Dialog boxes can accept data and show results
 Data can be read from and written to files
 Data can be formatted using the String method
format
Java Programming: Program Design Including Data Structures
57