Transcript CS 116 - IIT Computer Science Department

CS 116
OBJECT ORIENTED PROGRAMMING II
LECTURE 2
GEORGE KOUTSOGIANNAKIS
Copyright: 2014 Illinois Institute of Technology/George Koutsogiannakis
1
OOP Review
• In previous lectures we discussed:
– User defined template classes
• Default constructor/ non default constructor(s).
• Accessor mutator methods.
• toString method.
• Equals method
• Other methods as required by the specification.
– Client classes
– How to use a static instance variable.
– Receiving inputs from user via command line and via the scanner
object
Note: You must bring your text to the lectures
2
OOP Review
• Today we want to review:
– Using the scanner object to read text files.
– Scope of variables within the class.
– Formatting Numbers.
3
Reading Text Files with Scanner Object
• We need the services of the java.io package and
specifically two classes out of that package:
– File class
– IOException class
• Therefore we need to import those library classes
import java.io.File;
import java.io.IOException;
Note: Alternatively one can import all the library classes out of
package java.io by typing:
import java.io.*;
4
Reading Text Files with Scanner Object
• Trying to open a file for reading (or writing) can cause problems
(called exceptions) for various reasons of which some are:
–
–
–
–
File does not exist.
File name was misspelled
File is corrupted.
The part of the O.S. that finds files and opens them for reading and writing
does not work.
– The java program we wrote has other problems.
– The java run time environment is corrupted
– Other reasons
• Therefore , we need to catch the exception ,if it happens, so that
we don’t crash our program or the system.
5
Reading Text Files with Scanner Object
• Within the method that needs to open the file for reading
write the following code:
try
{
//code to open the file for reading and
//capturing the read items goes here.
}
catch (IOException ioe)
{
System.out.println(“Something went wrong”);
}
6
Reading Text Files with Scanner Object
• try and catch are keywords
• Inside the try block:
try
{
File myfile = new File(“NameOfTextFile.txt”);
Scanner scan= new Scanner(myfile);
//The above code tells the system to find the file we are //looking for and
associates the scanner object with that file.
//Other code
}
catch (IOException ioe)
{
System.out.println(“Error Occurred”);
}
7
Reading Text Files with Scanner Object
• Continue inside the try block by creating a loop that keeps
reading data until there is no more data to be read.
• The scanner class has methods that allow us to read one
String at a time or one line at a time (as one String).
– Look up the scanner class and its methods in the API.
8
Scanner Class hasNext Method
This method detects the end of the input values one String at a time (one
token).
Return type
Boolean
Method name and argument list
hasNext( )
returns true if there is more data to read;
returns false when the end of the file is reached
The hasNext method eliminates the need for a priming read because the
method looks ahead for input.
• An IOException may be generated if we encounter problems reading
the file. Java requires us to acknowledge that these exceptions may
be generated.
• Note that there is another method called hasNextLine() which
returns a boolean and can sense the end of data line by line.
9
Scanner Class hasNext… Methods
• Each method returns true if the next token in the
input stream can be interpreted as the data type
requested, and false otherwise.
Return type
Method name and argument list
boolean
hasNextInt( )
boolean
hasNextDouble( )
boolean
hasNextFloat( )
boolean
hasNextByte( )
boolean
hasNextShort( )
boolean
hasNextLong( )
boolean
hasNextBoolean( )
boolean
hasNext( )
10
Example Reading From File
import java.io.File;
import java.io.IOException;
Import java.util.Scanner;
public class ReadFile {
public static void main(String[] args) {
String str=“ “;
int count=0;
try
{
File myFile=new File(“text.txt”);
Scanner scan=new Scanner(myFile);
while(scan.hasNextLine())
{
str=scan.nextLine();
System.out. println(str);
count++;
// Note that if we want the individual Strings (tokens) inside each line, we need to use the StringTokenizer object
to tokenize the line read during each iteration!!!!
}
} //end of try block of code!!!!!!
catch(IOException ioe)
{ System.out.println(“The file can not be read”); }
System.out.println(“The number of strings tokens read is:”+count);
}
}
11
StringTokenizer
• In the previous example we captured one line of data at a time, from the
text file.
• The String str has the value of the entire line during each cycle in the while
loop (its value changes to the next line during the next cycle).
• Now, we may be interested in the individual Strings that make up the
entire line. Therefore when we capture the line we may want to break it
up into individual tokens. To do that we would need to create another
loop inside the loop while(scan.hasNextLine()).
• The reason for that is that we don’t know how many tokens are in one line
(presumably the programmer does not know the content of the text file that
his/her program is reading).
12
StringTokenizer
•
•
•
Modifying the program for the StringTokenizer:
First at the top we need to import the library package java.util which contains the
StringTokenizer class.
Then we modify the while loop as follows:
while(scan.hasNextLine())
{
str=scan.nextLine();
StringTokenizer strtok=new StringTokenizer(str, “,”);
while(strtok.hasMoreTokens())
{
String tokenstr=strtok.nextToken();
//Now, do what you want with the String tokenstr. You may have to
//parse it to another data type depending on what data type you expect.
}
System.out. println(str);
count++;
}
13
StringTokenizer
• Look up the StringTokenizer class in the API
NOW.
• Questions:
– What does the parameter count measure?
– What is the meaning of the “ , ” in the constructor
of StringTokenizer?
– Can we have any delimiter? What about using
space as a delimiter?
14
Class Scope
• In the previous example the String str was
declared at the top of the main method.
– Therefore we say that the String str has method
scope. That means that the value held by the
identifier str can be seen anywhere from within
the method.
– If, for example, we had declared str inside the
while loop :
15
Class Scope
while(scan.hasNextLine())
{
String str=scan.nextLine();
System.out. println(str);
count++;
// Note that if we want the individual Strings (tokens) inside each line, we need to use the
StringTokenizer object to tokenize the line read during each iteration!!!!
}
Then trying to access the value of str outside the while loop would had caused an error, because the
variable’ s str scope is limited to the while loop in this case
• The same problem arises if we declared String str at the top of
the try block and then try to access it outside the try block:
16
Class Scope
try
{
String str=“ “;
File myFile=new File(“text.txt”);
Scanner scan=new Scanner(myFile);
while(scan.hasNextLine())
{
str=scan.nextLine();
System.out. println(str);
count++;
// Note that if we want the individual Strings (tokens) inside each line, we need to use the
StringTokenizer object to tokenize the line read during each iteration!!!!
}
Trying to access str outside the try block will cause an error. The scope of str is limited within the
try block. Note that accessing str inside the while loop is O.K. because the while loop is part of
the try block.
17
Class Scope
• What if we declared the String str outside the main method?
public class ReadFile {
String str=“ “;
public static void main(String[] args) {
int count=0;
try
{
File myFile=new File(“text.txt”);
Scanner scan=new Scanner(myFile);
………………………………………………
}// end of main method
public static void anotherMethod() {
}
}//end of class
18
Class Scope
• Notice that in this case we have included
another method in the class besides the main.
• Since the String str is declared outside any
method but inside the class , we say that the
variable str has class scope:
– That means that its value can be seen and it is accessible
by any method in the class!!
19
Formatting Numbers
• In this lecture we would discuss only two
types of formatting:
– Formatting a double data type to restrict the
number of decimal points.
– Formatting a decimal number to convert it to a
particular currency like US dollars.
• The first action is done with library class:
DecimalFormat from package java.text
(must import java.text.DecimalFormat)
20
Formatting Numbers
– Create an object of DecimalFormat and in the constructor define the
pattern of decimal points as a String
DecimalFormat df=new DecimalFormat(“0.00”);
The object df can convert double data types to the accuracy of only
two decimal points in this example pattern.
– Suppose we have the decimal data type
double mydoubletype
The code below converts the data type mydoubletype into a new data
type of double type but with a precision of only two decimal points:
double newdoubletype= df.format(mydoubletype);
21
Formatting Numbers
• The conversion to currency is done with library class
NumberFormat of package java.text
(import java.text.NumberFormat;)
– For US dollars: create an object like this:
NumberFormat form=NumberFormat.getCurrencyInstance();
– Use the object form as follows:
String strversionofdouble=form.format(mydoublenumber);
Notice that the double number held by identifier mydouublenumber is
converted into two decimal points and the $ sign is placed in front of
it. It then it gets assigned to a String type.
If we want the String strversionofdouble converted back to a double we
need to parse it
22
Text Book Reading
• Chapter 6 section 3.2
• The subject of scope is dispersed throughout
the text : pages 223, 281, 331, 334-335, 375.
• NumberFormat pages 146-147
• DecimalFormat 112, 113, 119-124.
23