7 streams and error handling in java

UCSC 2003. All rights reserved.No parts of this material may be reproduced and so
IT1202-Fundamentals Of Programming
(Using JAVA)
Streams & Error Handling in Java
Version 1.0

UCSC 2003. All rights reserved.No parts of this material ma
Input & output
• Most real applications of Java are not text
based, console programs. Rather they are
graphically oriented applets that rely upon
Java’s Abstract Window Toolkit (AWT) for
interactions with the user.
• Java support string flexible support for I/O
as it relates to files and network .
• Java’s I/O system is cohesive and
consistent.

Using command line arguments
• As you know Java applications are
standalone programs, so, it’s useful to
pass arguments or options to an
application.
• Arguments can be used to determine how
the application is going to run.
OR
• Enable a generic application to operate on
different kinds of input.
• Using program arguments can,
– Turn on debugging input.
– Indicate a filename to load.

• This caries based on the platform you’re
running.
• On Windows & UNIX can use command line.
• To pass arguments to a Java program on
Windows or Solaris, the arguments should
be appended to the command line when
the program is run.
eg:
Java MyProgram argumentOne 2 three
In thee three arguments were passed to a program.
argumentOne, the number 2 & three. Note that a space
Separates each of the arguments.
Passing Arguments to Java Applications

Passing Arguments to Java Applications…..
• To group arguments that include spaces,
the arguments should be surrounded with
“ ” marks.
• These quotation marks are not included in
the argument when it is sent to the
program & received using the main()
method.

• When an application is run with arguments,
Java stores the arguments as an array of as
strings & passes the array to the application’s
main() method.
eg:
public static void main(String arguments[]) {
// body of method
}
In here, arguments is the name of the array of strings that
contains list of arguments.
Handling Arguments in Java Application

Handling Arguments in Java Application…
• Inside the main() method, you can handle the
arguments your program was given,
– By iterating.
And
– Handling them in some manner.
eg:
class EchoArgs {
public static void main (String arguments[]) {
for (int i=0; i<arguments.length; i++) {
System.out.println(“Argument” + i + “:” +
arguments [i]);
}
}
}

• Eg:
– Input
java EchoArgs Wilhelm Niekro Hough 49
– Output
Argument 0: Wilhelm
Argument 1: Niekro
Argument 2: Hough
Argument 3: 49

• All arguments passed to a Java
application are stored in an array of
strings.
• To treat them as something other than
strings, you must convert them.
• The following program takes any number of
numeric arguments & returns the sum & the
average of those arguments.
class SumAverage {
public static void main(String args[]) {
int sum = 0;
for (int I = 0; i<args.length; i++) {
Sum += args[i];
}

System.out.println(“Sum is;” + sum);
System.out.println(“Average is:” +
(float) sum / args.length);
}
}
Output
SumAverage.java.6: Incompatible type for +=. Can’t convert
java.lang.String to int.
Sum += args[i];
• This error occurs the argument array is an array
of strings.

• You have to convert them from strings to
integers using a class method for the
Integer class called parseInt.
Sum += Integer.parseInt(args[i]);
• By applying the following inputs to the
example we can run the program.
• Input
Java SumAverage 123
• Output
Sum is : 6
Average is : 2

Streams: input stream, output stream &
error stream
• Is a path of communication between a
source of some information and
destination
• The source can be a file, computers
memory or the Internet
• Input Streams sends data from a source
into a program
• output streams sends data out of a
program to a destination

• Java programs perform I/O through streams.
• A stream is a path of communication between a
source of some information and destination and
a stream is linked to a physical device by the
Java I/O system.
• The source can be a file, computers memory or
the Internet.
• All streams behave in the same manner, even if
the actual physical devices to which they are
linked differ.
• Input Streams allows you to read data from a
source
• output streams allows you to write data to a
destination
Streams………

• Byte streams and character streams
– Java 2 defines two types of streams: Byte and
Character.
– Byte streams
• Byte streams provide a convenient means
for handling input and output of bytes.
• Byte streams are used when reading or
writing binary data.
-Character streams
• Character streams provide a convenient
means for handling input and output of
characters.
• They are unicode and therefore, can be
internationalized.
Streams………

• Using a Stream
– Whether you’re using a byte stream or a
character stream, the procedure for
using either in Java is largely the same.
– For an input stream, the first step is to
create an object that is associated with
the data source.
– After you have created a stream object,
you can read information from that
stream by using one of the object’s
methods. FileInputStream includes a
read() method that returns a byte read
from the file.
Streams………

Using a Stream……….
• When you’re done reading information
from the stream, you call the close()
method to indicate that you’re done using
the stream.
• For an output stream, you begin by
creating an object that’s associated with
the data’s destination. BufferedReader
class can be used to create such text files.
• The write() method is the simplest method
to send information to the output stream’s
destination.
• A BufferedReader write() method can send
individual characters to an output stream.

Using a Stream………..
• The close() is called on an output stream
when you have no more information to
send.

Filtering a Stream
• A filter is a type of stream that modifies
the way an existing stream is handled.
• The procedure for using a filter on a
stream is basically as follows.
– Create a stream associated with a data source
or a data destination.
– Associate a filter with that stream.
– Read or write data from the filter rather than
the original stream.
• The methods you call on a filter are,
– read()
– write()

• A filter can associate with another filter.
Filtering a Stream………..

The predefined Stream
• All Java programs automatically import the
Java.lang package.
• This package defines a class called System,
which encapsulates severl aspects of the run-
time environment. E.g. current time and
settings of various properties associated with
the system.
• System also contains three predefined stream
variables ,in, out and err.

Reading Console Input
• In Java1.0, the only way to perform console input
was to use a byte stream.
• The predefined method of reading console input
for Java2 is to use a character- oriented stream.
• In Java, console input is accomplished by
reading from System.in.
• To obtain a character- based stream that is
attached to the console, you wrap system.in in a
BuffrerdReader object.

Byte stream
• All byte streams are either a subclass of
– InputStream
OR
– OutputStream
• These classes are abstract.
• Instead you can create through one of
their subclasses.
– FileInputStream & FileOutputStream
Byte streams stored in files on disk, CD-ROM or other
storage devices.
– DataInputStream & DataOutputStream
A filtered byte stream from which data such as
integers &
Floating-point numbers can be read.

• File Streams
– These are used to exchange data with files on
your disk drives, CD-ROMs or other storage
devices.
– You can send bytes to a file output stream &
receive bytes from a file input stream.
Byte stream……….

• File Input Streams
– A file input stream can be created with
the FileInputStream(String) constructor.
– The string argument should be the
name of the file.
– The following statement creates a file
input stream from the file scores.dat.
FileInputStream fis = new
FileInputStream(“scores.dat”);
– After you create a file input stream, you
can read bytes from the stream by
calling its read() method.

• To read more than one byte of data from
the stream, call its read(byte[], int, int)
method.

• File Output Streams
– A file output stream can be created with the
FileOutputStream(String) constructor.
– You can create a file output stream that
appends data after the end of an existing file
with the FileOutputStream(String, boolean)
constructor.
– The file output stream’s write(int) method is
used to write bytes to the stream.
– To write more than one byte, the
write(byte[],int,int) method can be used.

Data Streams
• When you need to work with data that isn’t
represented as bytes or characters, you
can use data input & data output streams.
• These streams filter an existing byte
stream so that each of the following
primitive types can be read or written
directly from the stream:
boolean, byte, double, float, int, long & short
• A data input stream is created with the
DataInputStream(InputStream)
constructor.

• A data output stream requires the
DataOutputStream(OutputStream)
constructor which indicates the
associated output stream.
Data Streams………

Input and Output
• Reading Characters.
– To read a character from a BufferedReader, use read().
– Each time read() is called it reds a character from the
input stream and returns it as an integer value.
• Readong Strings
– To read a string from the keyboard use readline() that is
a member of the BuffreredReader class.
• Writing Console Output
– Console output is most easily accomplished with
print() and println().

Input and Output
– These methods are defined by the class
PrintStream.
– PrintStream implements the low-level
method write().
– You will not use write() to perform sonsole
output (although doing so might be usefu
in some situations), because print() and
println() are subtantially easier to use.

Input and Output
• The PrintWriter class
– System.out is recommended mostly for debugging
purposes or sample programs, for real-world
programs, the recommended method of writing to
the console when using Java is through a
PrintWriter atream.
– Printwriter is one of the character- based classes.
– PrintWriter supports the print() and println()
methods for all types including object. Thus you
can use these methods in the same way as they
have been used with system.out.

Input and Output
• Reading and writing files
– Java provides a no. of classes and methods that
allow you to read and write files.
– In java, all files are byte-oriented and java
provides methods to read and write byte from
and to a file.
– Java allows you to wrap a byte-oriented file
system within a character-based object.
– Two of the most-often used stream classes are
FileInputStream and FileOutputStream, which
create byte streams linked to files.

Input and Output
• Creating an input file:-
FileInputStream (String fileName ) throws
FileNotFoundExeption
• Opening an output file:-
FileOutputStream (String fileName ) throws
FileNotFoundExeption
• Closing a file:-
Void close() throws IOException
• Read from a file
Void write(int byteval) throws IOException
This method writes the byte specified by the byteval to the file.

Error Handling
• A Java Exception is an object that
describes an exceptional (that is, error)
condition that has occurred in a piece of
code.
• Exceptions can be generated by the Java
run-time system, or they can e manually
generated by your code.
• Exceptions thrown by Java relate to
fundamental errors that violate the rules of
the Java language or the constraints of
the Java execution environment.

Error Handling Contd...
java .lang.Object
java .lang.Throwable
java .lang.Exception
IOException
RuntimeException
Java Exception
class hierarchy

• Handling Exceptions
– In many cases Java Compiler enforces
Exception Management when methods
that throw exceptions are used
– it is necessary to handle those
exceptions within the code, or that code
will not compile at all

• Protecting code and catching Exceptions
– To catch an Exception,
• Although the default exception handler provided by the Java
run-time system is useful for debugging, you will usually want
to handle an exception by your self.
• To guard against and handle a runtime error, protect your code
that contains an exception throwable method within a try block
• Test and deal with the exception within a catch block

Class DivideZero {
static int anyFunction (int x, int y) {
try {
int a = x / y;
return a;
}
catch (ArithmeticException e) {
System.out.println(“Division by Zero “);
}
}
Code is protected
using try Block
Exception is caught and handled
using catch block

• Displaying a description of an exception
– Throwable overrides the toString() . So it
returns a string containing a description of
the exception.
– E.g.
catch (ArithmeticException e) {
System.out.println(“Exception : “+e);
}
Exception is passed as an argument in a println() statement

• Multiple catch Clauses
– When more than one exception is raised
by a single piece of code you can
specify two or more catch clauses, each
catching a different type of exception .
– When you use multiple catch
statements , exception subclasses must
come before any of there superclasses.

• Nested Try Statements
– The try statement can be nested.
– Each time a try statement is entered ,
the context of that exception is pushed
on the stack.
– Nesting of try statements can occur in
less obvious ways when method calls
are involved.

• Throw clause
– It is possible for your program to throw an exception
using throw statement .
Throw ThrowableInstance
ThrowableInstance must be an object of type Throwable or a
subclass of Throwable.
Simple types, such as int or char, as well as non-Throwable
classes such as String and Obiect cannot be used as
exceptions.

• finally clause
– If there is a piece of code that should be
executed whether an exception occurs
or not then
• include it within the optional finally clause
of the try..catch block
• an example may be closing an open file.

• throws clause
– used to indicate that a method will throw an
exception.
– Used after the signature of a method (before
the opening curly bracket)
– if multiple Exceptions are thrown, include
them in throws clause separated by commas.
Public myMethod (int x, int y) throws Exception1,Exception
{

• throws clause contd…
– this clause also may be included in a
method that throws an exception which
you do not intend to do anything about.
– It makes sense that the method that
calls your method should handle the
exception in its code , not within your
method.

• Java’s built–in Exceptions
– Inside the standard package Java.lang, java defines
several exception classes.
– The most general of these exceptions are subclasses
of the standard tye RuntimeException.
– As Java.lang is implicitly imported in to all Java
programs, most exceptions derived from
RuntimeException are automatically available; they
need not be included in a method’s throw list.

• Defining and Generating Exceptions…
– You can define your own exceptions and throw
them as you would throw any standard exception.
– First You need to define a new exception class
• it should be a sub class of class throwable or any sub
class of throwable.
– Create a new Object of the defined class using
new and throw it

public class SunSpotException
extends Exception {
public SunSpotException() {}
public SunSpotExceotion(String msg) {
super(msg);
}
}
Throw new SunSpotException ( );
OR
throw new SunSpotException (“This is
to test”);
Defining Exception
Throwing

7 streams and error handling in java

More Related Content

What's hot

Viewers also liked

Similar to 7 streams and error handling in java

Recently uploaded

7 streams and error handling in java