Java Certification Study Notes
Java Certification Study Notes
Disclaimers
No claims are made about the accuracy of this document and no responsibility is taken for any errors. The
exam objectives below are quoted, ‘as is’ from Sun Microsystems web site. This document can be used and
distributed as long as the purpose is not commercial.
This document has material collected from a lot of resources. I have listed some of the resources here. I’m
thankful to all those great people. Anything I forgot to mention is not intentional.
1. Java 1.1 Certification Study Guide by Simon Roberts and Philip Heller.
2. Java 2 Certification Study Guide by Simon Roberts, Philip Heller and Michael Ernst.
3. Java 2 Exam Cram by Bill Brogden
4. A Programmer’s guide to Java Certification by Khalid Azim Mughal and Rolf Rasmussen
5. Java Language Specification from Sun -
http://java.sun.com/docs/books/jls/second_edition/html/j.title.doc.html
6. Java tutorial from Sun - http://java.sun.com/docs/books/tutorial/index.html
7. Java API documentation from Sun - http://java.sun.com/j2se/1.3/docs/api/overview-summary.html
8. Marcus Green - http://www.jchq.net
9. Java Ranch Discussions and Archives - http://www.javaranch.com/
10. Maha Anna’s Resource Page - http://www.javaranch.com/maha/
11. Jyothi's page - http://www.geocities.com/SiliconValley/Network/3693/
12. Dylan Walsh’s exam revision page - http://indigo.ie/~dywalsh/certification/index.htm
13. And an ever-increasing list of web sites regarding SCJP certification.
This document is mostly organized like the RHE book, as far as the chapter names and the order. Various
facts, explanations, things to remember, tips, sample code are presented as you go along with each chapter.
Please remember that, as this document is prepared as a side-product along the path to my certification,
there may not be a logical order in everything, though I tried to put it that way. Some points might be
repeated, and some things might rely on a fact that was mentioned elsewhere.
If you find any errors or have something to say as feedback, please e-mail at [email protected]
Page 1 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Exam Objectives
• Write code to invoke overridden or overloaded methods and parental or overloaded constructors;
and describe the effect of invoking these methods.
• Write code to construct instances of any concrete class including normal top level classes, inner
classes, static inner classes, and anonymous inner classes.
Section 7 Threads
• Write code to define, instantiate, and start new threads using both java.lang.Thread and
java.lang.Runnable.
• Recognize conditions that might prevent a thread from executing.
• Write code using synchronized, wait, notify, or notifyAll, to protect against concurrent access
problems and to communicate between threads. Define the interaction between threads and
between threads and object locks when executing synchronized, wait, notify, or notifyAll.
Section 8 The java.awt PACKAGE
• Write code using component, container, and LayoutManager classes of the java.awt package to
present a GUI with specified appearance and resize behavior, and distinguish the responsibilities
of layout managers from those of containers.
• Write code to implement listener classes and methods, and in listener methods, extract information
from the event to determine the affected component, mouse position, nature, and time of the event.
State the event classname for any specified event listener interface in the java.awt.event package.
Section 9 The java.lang PACKAGE
• Write code using the following methods of the java.lang.Math class: abs, ceil, floor, max, min,
random, round, sin, cos, tan, sqrt.
• Describe the significance of the immutability of String objects.
Section 10 The java.util PACKAGE
• Make appropriate selection of collection classes/interfaces to suit specified behavior requirements.
Section 11 The java.io PACKAGE
• Write code that uses objects of the file class to navigate a file system.
• Write code that uses objects of the classes InputStreamReader and OutputStreamWriter to translate
between Unicode and either platform default or ISO 8859-1 character encoding and Distinguish
between conditions under which platform default encoding conversion should be used and
conditions under which a specific conversion should be used.
• Select valid constructor arguments for FilterInputStream and FilterOutputStream subclasses from
a list of classes in the java.io.package.
• Write appropriate code to read, write and update files using FileInputStream, FileOutputStream,
and RandomAccessFile objects.
• Describe the permanent effects on the file system of constructing and using FileInputStream,
FileOutputStream, and RandomAccessFile objects.
Page 3 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 4 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
13. All numeric data types are signed. char is the only unsigned integral type.
14. Object reference variables are initialized to null.
15. Octal literals begin with zero. Hex literals begin with 0X or 0x.
16. Char literals are single quoted characters or unicode values (begin with \u).
17. A number is by default an int literal, a decimal number is by default a double literal.
18. 1E-5d is a valid double literal, E2d is not (since it starts with a letter, compiler thinks that it’s an
identifier)
19. Two types of variables.
1. Member variables
• Accessible anywhere in the class.
• Automatically initialized before invoking any constructor.
• Static variables are initialized at class load time.
• Can have the same name as the class.
2. Automatic variables(method local)
• Must be initialized explicitly. (Or, compiler will catch it.) Object references can be initialized
to null to make the compiler happy. The following code won’t compile. Specify else part or
initialize the local variable explicitly.
Page 5 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 6 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
39. A class without a main method can be run by JVM, if its ancestor class has a main method. (main is
just a method and is inherited)
40. Primitives are passed by value.
41. Objects (references) are passed by reference. The object reference itself is passed by value. So, it can’t
be changed. But, the object can be changed via the reference.
42. Garbage collection is a mechanism for reclaiming memory from objects that are no longer in use, and
making the memory available for new objects.
43. An object being no longer in use means that it can’t be referenced by any ‘active’ part of the program.
44. Garbage collection runs in a low priority thread. It may kick in when memory is too low. No guarantee.
45. It’s not possible to force garbage collection. Invoking System.gc may start garbage collection process.
46. The automatic garbage collection scheme guarantees that a reference to an object is always valid while
the object is in use, i.e. the object will not be deleted leaving the reference “dangling”.
47. There are no guarantees that the objects no longer in use will be garbage collected and their finalizers
executed at all. gc might not even be run if the program execution does not warrant it. Thus any
memory allocated during program execution might remain allocated after program termination, unless
reclaimed by the OS or by other means.
48. There are also no guarantees on the order in which the objects will be garbage collected or on the order
in which the finalizers are called. Therefore, the program should not make any decisions based on
these assumptions.
49. An object is only eligible for garbage collection, if the only references to the object are from other
objects that are also eligible for garbage collection. That is, an object can become eligible for garbage
collection even if there are references pointing to the object, as long as the objects with the references
are also eligible for garbage collection.
50. Circular references do not prevent objects from being garbage collected.
51. We can set the reference variables to null, hinting the gc to garbage collect the objects referred by the
variables. Even if we do that, the object may not be gc-ed if it’s attached to a listener. (Typical in case
of AWT components) Remember to remove the listener first.
52. All objects have a finalize method. It is inherited from the Object class.
53. finalize method is used to release system resources other than memory. (such as file handles and
network connections) The order in which finalize methods are called may not reflect the order in which
objects are created. Don’t rely on it. This is the signature of the finalize method.
protected void finalize() throws Throwable { }
In the descendents this method can be protected or public. Descendents can restrict the exception list
that can be thrown by this method.
54. finalize is called only once for an object. If any exception is thrown in finalize, the object is still
eligible for garbage collection (at the discretion of gc)
55. gc keeps track of unreachable objects and garbage-collects them, but an unreachable object can
become reachable again by letting know other objects of its existence from its finalize method (when
called by gc). This ‘resurrection’ can be done only once, since finalize is called only one for an object.
56. finalize can be called explicitly, but it does not garbage collect the object.
57. finalize can be overloaded, but only the method with original finalize signature will be called by gc.
58. finalize is not implicitly chained. A finalize method in sub-class should call finalize in super class
explicitly as its last action for proper functioning. But compiler doesn’t enforce this check.
59. System.runFinalization can be used to run the finalizers (which have not been executed before) for the
objects eligible for garbage collection.
60. The following table specifies the color coding of javadoc standard. (May be not applicable to 1.2)
Member Color
Instance method Red
Static method Green
Final variable Blue
Constructor Yellow
Page 7 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
1. Unary operators.
1.1 Increment and Decrement operators ++ --
We have postfix and prefix notation. In post-fix notation value of the variable/expression is
modified after the value is taken for the execution of statement. In prefix notation, value of
the variable/expression is modified before the value is taken for the execution of statement.
Result
x = 5 ; y = 0 ; y = x++; will be x = 6, y = 5
Result
x = 5 ; y = 0 ; y = ++x; will be x = 6, y = 6
negative number to be positive. So don’t use it with negative numbers, if you want to preserve the
sign. Also don’t use it with types smaller than int. (Since types smaller than int are promoted to an
int before any shift operation and the result is cast down again, so the end result is unpredictable.)
• Shift operators can be applied to only integral types.
• -1 >> 1 is –1, not 0. This differs from simple division by 2. We can think of it as shift operation
rounding down.
• 1 << 31 will become the minimum value that an int can represent. (Value becomes negative, after
this operation, if you do a signed right shift sign bit is brought in from the left and the value
remains negative.)
• Negative numbers are represented in two’s complement notation. (Take one’s complement and add
1 to get two’s complement)
• Shift operators never shift more than the number of bits the type of result can have. ( i.e. int 32,
long 64) RHS operand is reduced to RHS % x where x is no of bits in type of result.
int x;
x = x >> 33 ;// Here actually what happens is x >> 1
4. Comparison operators – all return boolean type.
4.1 Ordinal comparisons - <, <=, > , >=
• Only operate on numeric types. Test the relative value of the numeric operands.
• Arithmetic promotions apply. char can be compared to float.
4.2 Object type comparison – instanceof
• Tests the class of an object at runtime. Checking is done at compile and runtime same as
the cast operator.
• Returns true if the object denoted by LHS reference can be cast to RHS type.
• LHS should be an object reference expression, variable or an array reference.
• RHS should be a class (abstract classes are fine), an interface or an array type, castable to
LHS object reference. Compiler error if LHS & RHS are unrelated.
• Can’t use java.lang.Class or its String name as RHS.
• Returns true if LHS is a class or subclass of RHS class
• Returns true if LHS implements RHS interface.
• Returns true if LHS is an array reference and of type RHS.
• x instanceof Component[] – legal.
• x instanceof [] – illegal. Can’t test for ‘any array of any type’
• Returns false if LHS is null, no exceptions are thrown.
• If x instanceof Y is not allowed by compiler, then Y y = (Y) x is not a valid cast
expression. If x instanceof Y is allowed and returns false, the above cast is valid but
throws a ClassCastException at runtime. If x instanceof Y returns true, the above cast is
valid and runs fine.
4.3 Equality comparisons - ==, !=
• For primitives it’s a straightforward value comparison. (promotions apply)
• For object references, this doesn’t make much sense. Use equals method for meaningful
comparisons. (Make sure that the class implements equals in a meaningful way, like for
X.equals(Y) to be true, Y instance of X must be true as well)
• For String literals, == will return true, this is because of compiler optimization.
5. Bit-wise operators - &, ^, |
• Operate on numeric and boolean operands.
• & - AND operator, both bits must be 1 to produce 1.
• | - OR operator, any one bit can be 1 to produce 1.
• ^ - XOR operator, any one bit can be 1, but not both, to produce 1.
• In case of booleans true is 1, false is 0.
• Can’t cast any other type to boolean.
6. Short-circuit logical operators - &&, ||
Page 9 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
9. General
• In Java, No overflow or underflow of integers happens. i.e. The values wrap around. Adding 1 to
the maximum int value results in the minimum value.
• Always keep in mind that operands are evaluated from left to right, and the operations are
executed in the order of precedence and associativity.
• Unary Postfix operators and all binary operators (except assignment operators) have left to right
assoiciativity.
• All unary operators (except postfix operators), assignment operators, ternary operator, object
creation and cast operators have right to left assoiciativity.
• Inspect the following code.
public class Precedence {
final public static void main(String args[]) {
int i = 0;
i = i++;
i = i++;
i = i++;
System.out.println(i); // prints 0, since = operator has the lowest precedence.
Page 10 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
System.out.println(array[c]);
System.out.println("index is " + index); // prints 3
}
}
Page 11 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Chapter 3 Modifiers
1. Modifiers are Java keywords that provide information to compiler about the nature of the code, data
and classes.
2. Access modifiers – public, protected, private
• Only applied to class level variables. Method variables are visible only inside the method.
• Can be applied to class itself (only to inner classes declared at class level, no such thing as
protected or private top level class)
• Can be applied to methods and constructors.
• If a class is accessible, it doesn’t mean, the members are also accessible. Members’ accessibility
determines what is accessible and what is not. But if the class is not accessible, the members are
not accessible, even though they are declared public.
• If no access modifier is specified, then the accessibility is default package visibility. All classes in
the same package can access the feature. It’s called as friendly access. But friendly is not a Java
keyword. Same directory is same package in Java’s consideration.
• ‘private’ means only the class can access it, not even sub-classes. So, it’ll cause access denial to a
sub-class’s own variable/method.
• These modifiers dictate, which classes can access the features. An instance of a class can access
the private features of another instance of the same class.
• ‘protected’ means all classes in the same package (like default) and sub-classes in any package can
access the features. But a subclass in another package can access the protected members in the
super-class via only the references of subclass or its subclasses. A subclass in the same package
doesn’t have this restriction. This ensures that classes from other packages are accessing only the
members that are part of their inheritance hierarchy.
• Methods cannot be overridden to be more private. Only the direction shown in following figure is
permitted from parent classes to sub-classes.
3. final
• final features cannot be changed.
• final classes cannot be sub-classed.
• final variables cannot be changed. (Either a value has to be specified at declaration or an
assignment statement can appear only once).
• final methods cannot be overridden.
• Method arguments marked final are read-only. Compiler error, if trying to assign values to final
arguments inside the method.
• Member variables marked final are not initialized by default. They have to be explicitly assigned a
value at declaration or in an initializer block. Static finals must be assigned to a value in a static
initializer block, instance finals must be assigned a value in an instance initializer or in every
constructor. Otherwise the compiler will complain.
• Final variables that are not assigned a value at the declaration and method arguments that are
marked final are called blank final variables. They can be assigned a value at most once.
• Local variables can be declared final as well.
4. abstract
• Can be applied to classes and methods.
• For deferring implementation to sub-classes.
• Opposite of final, final can’t be sub-classed, abstract must be sub-classed.
• A class should be declared abstract,
1. if it has any abstract methods.
Page 12 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Let’s say a sub-class has a static method which ‘overrides’ a static method in a parent class. If you
have a reference variable of parent class type and you assign a child class object to that variable
and invoke the static method, the method invoked will be the parent class method, not the child
class method. The following code explains this.
p = c;
p.doStuff(); // This will invoke Parent.doStuff(), rather than Child.doStuff()
}
}
class Parent {
static int x = 100;
public static void doStuff() {
System.out.println("In Parent..doStuff");
System.out.println(x);
}
}
Page 13 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Java classes use lot of native methods for performance and for accessing hardware Java is not
aware of.
• Native method signature should be terminated by a ‘;’, curly braces will provide a compiler error.
• native doesn’t affect access qualifiers. Native methods can be private.
• Can pass/return Java objects from native methods.
• System.loadLibrary is used in static initializer code to load native libraries. If the library is not
loaded when the static method is called, an UnsatisfiedLinkError is thrown.
7. transient
• Can be applied to class level variables only.(Local variables cannot be declared transient)
• Transient variables may not be final or static.(But compiler allows the declaration, since it doesn’t
do any harm. Variables marked transient are never serialized. Static variables are not serialized
anyway.)
• Not stored as part of object’s persistent state, i.e. not written out during serialization.
• Can be used for security.
8. synchronized
• Can be applied to methods or parts of methods only.
• Used to control access to critical code in multi-threaded programs.
9. volatile
• Can be applied to variables only.
• Can be applied to static variables.
• Cannot be applied to final variables.
• Declaring a variable volatile indicates that it might be modified asynchronously, so that all threads
will get the correct value of the variable.
• Used in multi-processor environments.
Modifier Class Inner classes Variable Method Constructor Free floating Code block
(Except local and
anonymous
classes)
public Y Y Y Y Y N
protected N Y Y Y Y N
(friendly) Y Y (OK for all) Y Y Y N
No access
modifier
private N Y Y Y Y N
final Y Y (Except Y Y N N
anonymous
classes)
abstract Y Y (Except N Y N N
anonymous
classes)
static N Y Y Y N Y (static initializer)
native N N N Y N N
transient N N Y N N N
synchronized N N N Y N Y (part of method, also
need to specify an
object on which a lock
should be obtained)
volatile N N Y N N N
Page 14 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Conversion of Primitives
1. 3 types of conversion – assignment conversion, method call conversion and arithmetic promotion
2. boolean may not be converted to/from any non-boolean type.
3. Widening conversions accepted. Narrowing conversions rejected.
4. byte, short can’t be converted to char and vice versa.
5. Arithmetic promotion
5.1 Unary operators
• if the operand is byte, short or char {
convert it to int;
}
else {
do nothing; no conversion needed;
}
5.2 Binary operators
• if one operand is double {
all double; convert the other operand to double;
}
else if one operand is float {
all float; convert the other operand to float;
}
else if one operand is long {
all long; convert the other operand to long;
}
else {
all int; convert all to int;
}
6. When assigning a literal value to a variable, the range of the variable’s data type is checked against the
value of the literal and assignment is allowed or compiler will produce an error.
cha r c = 3//; this will compile, even though a numeric literal is by default an int since the range of
char will accept the value
int a = 3;
cha r d = a//; this won’t compile, since we’re assigning an int to char
cha r e = - 1//; this also won’t compile, since the value is not in the range of char
f l oa t f = 1//
.3this
; won’t compile, even though the value is within float range. Here range is not
important, but precision is. 1.3 is by default a double, so a specific cast or f = 1.3f will work.
Page 15 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
8. Method call conversions always look for the exact data type or a wider one in the method signatures.
They will not do narrowing conversions to resolve methods, instead we will get a compile error.
Casting of Primitives
9. Needed with narrowing conversions. Use with care – radical information loss. Also can be used with
widening conversions, to improve the clarity of the code.
10. Can cast any non-boolean type to another non-boolean type.
11. Cannot cast a boolean or to a boolean type.
Page 16 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Compile-time Rules
• When old and new types are classes, one class must be the sub-class of the other.
• When old and new types are arrays, both must contain reference types and it must be legal to
cast between those types (primitive arrays cannot be cast, conversion possible only between
same type of primitive arrays).
• We can always cast between an interface and a non-final object.
Run-time rules
• If new type is a class, the class of the expression being converted must be new type or extend
new type.
• If new type is an interface, the class of the expression being converted must implement the
interface.
Page 17 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
1. Loop constructs
• 3 constructs – for, while, do
• All loops are controlled by a boolean expression.
• In while and for, the test occurs at the top, so if the test fails at the first time, body of the loop
might not be executed at all.
• In do, test occurs at the bottom, so the body is executed at least once.
• In for, we can declare multiple variables in the first part of the loop separated by commas, also we
can have multiple statements in the third part separated by commas.
• In the first section of for statement, we can have a list of declaration statements or a list of
expression statements, but not both. We cannot mix them.
• All expressions in the third section of for statement will always execute, even if the first
expression makes the loop condition false. There is no short –circuit here.
2. Selection Statements
• if takes a boolean arguments. Parenthesis required. else part is optional. else if structure provides
multiple selective branching.
• switch takes an argument of byte, short, char or int.(assignment compatible to int)
• case value should be a constant expression that can be evaluated at compile time.
• Compiler checks each case value against the range of the switch expression’s data type. The
following code won’t compile.
byte b;
switch (b) {
case 200: // 200 not in range of byte
default:
}
• We need to place a break statement in each case block to prevent the execution to fall through
other case blocks. But this is not a part of switch statement and not enforced by the compiler.
• We can have multiple case statements execute the same code. Just list them one by one.
• default case can be placed anywhere. It’ll be executed only if none of the case values match.
• switch can be nested. Nested case labels are independent, don’t clash with outer case labels.
• Empty switch construct is a valid construct. But any statement within the switch block should
come under a case label or the default case label.
3. Branching statements
• break statement can be used with any kind of loop or a switch statement or just a labeled block.
• continue statement can be used with only a loop (any kind of loop).
• Loops can have labels. We can use break and continue statements to branch out of multiple levels
of nested loops using labels.
• Names of the labels follow the same rules as the name of the variables.(Identifiers)
• Labels can have the same name, as long as they don’t enclose one another.
• There is no restriction against using the same identifier as a label and as the name of a package,
class, interface, method, field, parameter, or local variable.
4. Exception Handling
Page 18 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• An exception is an event that occurs during the execution of a program that disrupts the normal
flow of instructions.
• There are 3 main advantages for exceptions:
1. Separates error handling code from “regular” code
2. Propagating errors up the call stack (without tedious programming)
3. Grouping error types and error differentiation
• An exception causes a jump to the end of try block. If the exception occurred in a method called
from a try block, the called method is abandoned.
• If there’s a catch block for the occurred exception or a parent class of the exception, the exception
is now considered handled.
• At least one ‘catch’ block or one ‘finally’ block must accompany a ‘try’ statement. If all 3 blocks
are present, the order is important. (try/catch/finally)
• finally and catch can come only with try, they cannot appear on their own.
• Regardless of whether or not an exception occurred or whether or not it was handled, if there is a
finally block, it’ll be executed always. (Even if there is a return statement in try block).
• System.exit() and error conditions are the only exceptions where finally block is not executed.
• If there was no exception or the exception was handled, execution continues at the statement after
the try/catch/finally blocks.
• If the exception is not handled, the process repeats looking for next enclosing try block up the call
hierarchy. If this search reaches the top level of the hierarchy (the point at which the thread was
created), then the thread is killed and message stack trace is dumped to System.err.
• Use throw new xxxException() to throw an exception. If the thrown object is null, a
NullPointerException will be thrown at the handler.
• If an exception handler re-throws an exception (throw in a catch block), same rules apply. Either
you need to have a try/catch within the catch or specify the entire method as throwing the
exception that’s being re-thrown in the catch block. Catch blocks at the same level will not handle
the exceptions thrown in a catch block – it needs its own handlers.
• The method fillInStackTrace() in Throwable class throws a Throwable object. It will be useful
when re-throwing an exception or error.
• The Java language requires that methods either catch or specify all checked exceptions that can be
thrown within the scope of that method.
• All objects of type java.lang.Exception are checked exceptions. (Except the classes under
java.lang.RuntimeException) If any method that contains lines of code that might throw checked
exceptions, compiler checks whether you’ve handled the exceptions or you’ve declared the
methods as throwing the exceptions. Hence the name checked exceptions.
• If there’s no code in try block that may throw exceptions specified in the catch blocks, compiler
will produce an error. (This is not the case for super-class Exception)
• Java.lang.RuntimeException and java.lang.Error need not be handled or declared.
• An overriding method may not throw a checked exception unless the overridden method also
throws that exception or a super-class of that exception. In other words, an overriding method may
not throw checked exceptions that are not thrown by the overridden method. If we allow the
overriding methods in sub-classes to throw more general exceptions than the overridden method in
the parent class, then the compiler has no way of checking the exceptions the sub-class might
throw. (If we declared a parent class variable and at runtime it refers to sub-class object) This
violates the concept of checked exceptions and the sub-classes would be able to by-pass the
enforced checks done by the compiler for checked exceptions. This should not be allowed.
Page 19 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
IllegalArgumentException-->IllegalThreadStateException, NumberFormatException
IndexOutOfBoundsException-->ArrayIndexOutOfBoundsException, StringIndexOutOfBoundsException
Page 20 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Overloading Overriding
Signature has to be different. Just a difference in Signature has to be the same. (including the return
return type is not enough. type)
Accessibility may vary freely. Overriding methods cannot be more private than the
overridden methods.
Exception list may vary freely. Overriding methods may not throw more checked
exceptions than the overridden methods.
Just the name is reused. Methods are independent Related directly to sub-classing. Overrides the parent
methods. Resolved at compile-time based on class method. Resolved at run-time based on type of
method signature. the object.
Can call each other by providing appropriate Overriding method can call overridden method by
argument list. super.methodName(), this can be used only to access
the immediate super-class’s method. super.super won’t
work. Also, a class outside the inheritance hierarchy
can’t use this technique.
Methods can be static or non-static. Since the static methods don’t participate in overriding, since
methods are independent, it doesn’t matter. But if they are resolved at compile time based on the type of
two methods have the same signature, declaring reference variable. A static method in a sub-class can’t
one as static and another as non-static does not use ‘super’ (for the same reason that it can’t use ‘this’
provide a valid overload. It’s a compile time error. for)
• Variables can also be overridden, it’s known as shadowing or hiding. But, member variable
references are resolved at compile-time. So at the runtime, if the class of the object referred
by a parent class reference variable, is in fact a sub-class having a shadowing member
variable, only the parent class variable is accessed, since it’s already resolved at compile time
based on the reference variable type. Only methods are resolved at run-time.
System.out.println(s1.s); // prints S1
System.out.println(s1.getS()); // prints S1
Page 21 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
System.out.println(s2.s); // prints S2
Sys tem.ou t .p r in t ln ( s2 .ge tS ( ) ) ; / / pr in t s S2
s1 = s2;
class S1 {
public String s = "S1";
• Also, methods access variables only in context of the class of the object they belong to. If a
sub-class method calls explicitly a super class method, the super class method always will
access the super-class variable. Super class methods will not access the shadowing variables
declared in subclasses because they don’t know about them. (When an object is created,
instances of all its super-classes are also created.) But the method accessed will be again
subject to dynamic lookup. It is always decided at runtime which implementation is called.
(Only static methods are resolved at compile-time)
class S1 {
String s = "S1";
public String getS() {
return s;
}
void display() {
System.out.println(s);
}
Page 22 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• With OO languages, the class of the object may not be known at compile-time (by virtue of
inheritance). JVM from the start is designed to support OO. So, the JVM insures that the
method called will be from the real class of the object (not with the variable type declared).
This is accomplished by virtual method invocation (late binding). Compiler will form the
argument list and produce one method invocation instruction – its job is over. The job of
identifying and calling the proper target code is performed by JVM.
• JVM knows about the variable’s real type at any time since when it allocates memory for an
object, it also marks the type with it. Objects always know ‘who they are’. This is the basis of
instanceof operator.
• Sub-classes can use super keyword to access the shadowed variables in super-classes. This
technique allows for accessing only the immediate super-class. super.super is not valid. But
casting the ‘this’ reference to classes up above the hierarchy will do the trick. By this way,
variables in super-classes above any level can be accessed from a sub-class, since variables
are resolved at compile time, when we cast the ‘this’ reference to a super-super-class, the
compiler binds the super-super-class variable. But this technique is not possible with methods
since methods are resolved always at runtime, and the method gets called depends on the type
of object, not the type of reference variable. So it is not at all possible to access a method in a
super-super-class from a subclass.
• An inherited method, which was not abstract on the super-class, can be declared abstract in a
sub-class (thereby making the sub-class abstract). There is no restriction. In the same token, a
subclass can be declared abstract regardless of whether the super-class was abstract or not.
• Private members are not inherited, but they do exist in the sub-classes. Since the private
methods are not inherited, they cannot be overridden. A method in a subclass with the same
signature as a private method in the super-class is essentially a new method, independent from
super-class, since the private method in the super-class is not visible in the sub-class.
class PTSuper {
pub l i c vo id h i (//) Super-class
{ implementation always calls superclass hello
he l l o ( ) ;
}
pr i va te vo id he l l o//( )This { method is not inherited by subclasses, but exists in them.
// Commenting out both the methods in the subclass show this.
// The test will then print "hello-Super" for all three calls
// i.e. Always the super-class implementations are called
Sys tem.ou t .p r in t ln ( "he l l o - Super " ) ;
}
}
• Private methods are not overridden, so calls to private methods are resolved at compile time
and not subject to dynamic method lookup. See the following example.
class PolyA {
private int f() { return 0; }
public int g() { return 3; }
}
Inner Classes
• A class can be declared in any scope. Classes defined inside of other classes are known as
nested classes. There are four categories of nested classes.
1. Top-level nested classes / interfaces
• Declared as a class member with static modifier.
• Just like other static features of a class. Can be accessed / instantiated without an instance
of the outer class. Can access only static members of outer class. Can’t access instance
variables or methods.
• Very much like any-other package level class / interface. Provide an extension to
packaging by the modified naming scheme at the top level.
• Classes can declare both static and non-static members.
• Any accessibility modifier can be specified.
• Interfaces are implicitly static (static modifier also can be specified). They can have any
accessibility modifier. There are no non-static inner, local or anonymous interfaces.
2. Non-static inner classes
• Declared as a class member without static.
• An instance of a non-static inner class can exist only with an instance of its enclosing
class. So it always has to be created within a context of an outer instance.
• Just like other non-static features of a class. Can access all the features (even private) of
the enclosing outer class. Have an implicit reference to the enclosing instance.
• Cannot have any static members.
• Can have any access modifier.
3. Local classes
Page 26 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Defined inside a block (could be a method, a constructor, a local block, a static initializer
or an instance initializer). Cannot be specified with static modifier.
• Cannot have any access modifier (since they are effectively local to the block)
• Cannot declare any static members.(Even declared in a static context)
• Can access all the features of the enclosing class (because they are defined inside the
method of the class) but can access only final variables defined inside the method
(including method arguments). This is because the class can outlive the method, but the
method local variables will go out of scope – in case of final variables, compiler makes a
copy of those variables to be used by the class. (New meaning for final)
• Since the names of local classes are not visible outside the local context, references of
these classes cannot be declared outside. So their functionality could be accessed only via
super-class references (either interfaces or classes). Objects of those class types are
created inside methods and returned as super-class type references to the outside world.
This is the reason that they can only access final variables within the local block. That
way, the value of the variable can be always made available to the objects returned from
the local context to outside world.
• Cannot be specified with static modifier. But if they are declared inside a static context
such as a static method or a static initializer, they become static classes. They can only
access static members of the enclosing class and local final variables. But this doesn’t
mean they cannot access any non-static features inherited from super classes. These
features are their own, obtained via the inheritance hierarchy. They can be accessed
normally with ‘this’ or ‘super’.
4. Anonymous classes
• Anonymous classes are defined where they are constructed. They can be created
wherever a reference expression can be used.
• Anonymous classes cannot have explicit constructors. Instance initializers can be used to
achieve the functionality of a constructor.
• Typically used for creating objects on the fly.
• Anonymous classes can implement an interface (implicit extension of Object) or
explicitly extend a class. Cannot do both.
Syntax: new interface name() { } or new class name() { }
• Keywords implements and extends are not used in anonymous classes.
• Abstract classes can be specified in the creation of an anonymous class. The new class is
a concrete class, which automatically extends the abstract class.
• Discussion for local classes on static/non-static context, accessing enclosing variables,
and declaring static variables also holds good for anonymous classes. In other words,
anonymous classes cannot be specified with static, but based on the context, they could
become static classes. In any case, anonymous classes are not allowed to declare static
members. Based on the context, non-static/static features of outer classes are available to
anonymous classes. Local final variables are always available to them.
• One enclosing class can have multiple instances of inner classes.
• Inner classes can have synchronous methods. But calling those methods obtains the lock for
inner object only not the outer object. If you need to synchronize an inner class method based
on outer object, outer object lock must be obtained explicitly. Locks on inner object and outer
object are independent.
• Nested classes can extend any class or can implement any interface. No restrictions.
• All nested classes (except anonymous classes) can be abstract or final.
• Classes can be nested to any depth. Top-level static classes can be nested only within other
static top-level classes or interfaces. Deeply nested classes also have access to all variables of
the outer-most enclosing class (as well the immediate enclosing class’s)
• Member inner classes can be forward referenced. Local inner classes cannot be.
Page 27 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• An inner class variable can shadow an outer class variable. In this case, an outer class variable
can be referred as (outerclassname.this.variablename).
• Outer class variables are accessible within the inner class, but they are not inherited. They
don’t become members of the inner class. This is different from inheritance. (Outer class
cannot be referred using ‘super’, and outer class variables cannot be accessed using ‘this’)
• An inner class variable can shadow an outer class variable. If the inner class is sub-classed
within the same outer class, the variable has to be qualified explicitly in the sub-class. To fully
qualify the variable, use classname.this.variablename. If we don’t correctly qualify the
variable, a compiler error will occur. (Note that this does not happen in multiple levels of
inheritance where an upper-most super-class’s variable is silently shadowed by the most
recent super-class variable or in multiple levels of nested inner classes where an inner-most
class’s variable silently shadows an outer-most class’s variable. Problem comes only when
these two hierarchy chains (inheritance and containment) clash.)
• If the inner class is sub-classed outside of the outer class (only possible with top-level nested
classes) explicit qualification is not needed (it becomes regular class inheritance)
Page 28 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
// Example 1
}
}
class Outer {
String name = "Vel";
class Inner {
String name = "Sharmi";
class InnerInner {
class InnerInnerInner {
// error, variable is not inherited from the outer class, it can be just accessible
// System.out.println(this.name);
// System.out.println(InnerInner.this.name);
// System.out.println(InnerInnerInner.this.name);
class Outer2 {
static String name = "Vel";
static class Inner2 {
static String name = "Sharmi";
class InnerInner2 {
public void doSomething() {
System.out.println(name); // prints "Sharmi", inner-most hides outer-most
System.out.println(Outer2.name); // prints "Vel", explicit reference to Outer2's static variable
// System.out.println(this.name); // error, 'name' is not inherited
// System.out.println(super.name); // error, super refers to Object
Page 29 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
}
}
}
// Example 2
// This is legal
// OuterClass.InnerClass ic = new OuterClass().new InnerClass();
// ic.doSomething();
new OuterClass().doAnonymous();
}
}
class OuterClass {
final int a = 100;
private String secret = "Nothing serious";
Page 30 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 31 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 32 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Chapter 7 Threads
• JVM creates one user thread for running a program. This thread is called main thread. The main
method of the class is called from the main thread. It dies when the main method ends. If other user
threads have been spawned from the main thread, program keeps running even if main thread dies.
Basically a program runs until all the user threads (non-daemon threads) are dead.
• A thread can be designated as a daemon thread by calling setDaemon(boolean) method. This method
should be called before the thread is started, otherwise IllegalThreadStateException will be thrown.
• A thread spawned by a daemon thread is a daemon thread.
• Threads have priorities. Thread class have constants MAX_PRIORITY (10), MIN_PRIORITY (1),
NORM_PRIORITY (5)
• A newly created thread gets its priority from the creating thread. Normally it’ll be NORM_PRIORITY.
• getPriority and setPriority are the methods to deal with priority of threads.
• Java leaves the implementation of thread scheduling to JVM developers. Two types of scheduling can
be done.
1. Pre-emptive Scheduling.
Ways for a thread to leave running state -
• It can cease to be ready to execute ( by calling a blocking i/o method)
• It can get pre-empted by a high-priority thread, which becomes ready to execute.
• It can explicitly call a thread-scheduling method such as wait or suspend.
• A thread is only allowed to execute for a certain amount of time. After that, it has to contend for
the CPU (virtual CPU, JVM) time with other threads.
• This prevents a high-priority thread mono-policing the CPU.
• The drawback with this scheduling is – it creates a non-deterministic system – at any point in time,
you cannot tell which thread is running and how long it may continue to run.
• Mactinosh JVM’s
• Windows JVM’s after Java 1.0.2
• Different states of a thread:
1. Yielding
• Yield is a static method. Operates on current thread.
• Moves the thread from running to ready state.
• If there are no threads in ready state, the yielded thread may continue execution, otherwise it may
have to compete with the other threads to run.
• Run the threads that are doing time-consuming operations with a low priority and call yield
periodically from those threads to avoid those threads locking up the CPU.
2. Sleeping
• Sleep is also a static method.
• Sleeps for a certain amount of time. (passing time without doing anything and w/o using CPU)
• Two overloaded versions – one with milliseconds, one with milliseconds and nanoseconds.
• Throws an InterruptedException.(must be caught)
• After the time expires, the sleeping thread goes to ready state. It may not execute immediately
after the time expires. If there are other threads in ready state, it may have to compete with those
threads to run. The correct statement is the sleeping thread would execute some time after the
specified time period has elapsed.
• If interrupt method is invoked on a sleeping thread, the thread moves to ready state. The next time
it begins running, it executes the InterruptedException handler.
3. Suspending
• Suspend and resume are instance methods and are deprecated in 1.2
• A thread that receives a suspend call, goes to suspended state and stays there until it receives a
resume call on it.
• A thread can suspend it itself, or another thread can suspend it.
• But, a thread can be resumed only by another thread.
• Calling resume on a thread that is not suspended has no effect.
• Compiler won’t warn you if suspend and resume are successive statements, although the thread
may not be able to be restarted.
4. Blocking
• Methods that are performing I/O have to wait for some occurrence in the outside world to happen
before they can proceed. This behavior is blocking.
• If a method needs to wait an indeterminable amount of time until some I/O takes place, then the
thread should graciously step out of the CPU. All Java I/O methods behave this way.
• A thread can also become blocked, if it failed to acquire the lock of a monitor.
5. Waiting
• wait, notify and notifyAll methods are not called on Thread, they’re called on Object. Because the
object is the one which controls the threads in this case. It asks the threads to wait and then
notifies when its state changes. It’s called a monitor.
• Wait puts an executing thread into waiting state.(to the monitor’s waiting pool)
• Notify moves one thread in the monitor’s waiting pool to ready state. We cannot control which
thread is being notified. notifyAll is recommended.
• NotifyAll moves all threads in the monitor’s waiting pool to ready.
Page 34 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Blocked Waiting
Thread is waiting to get a lock on the monitor. Thread has been asked to wait. (by means of
(or waiting for a blocking i/o method) wait method)
Caused by the thread tried to execute some The thread already acquired the lock and
synchronized code. (or a blocking i/o method) executed some synchronized code before
coming across a wait call.
Can move to ready only when the lock is Can move to ready only when it gets notified
available. ( or the i/o operation is complete) (by means of notify or notifyAll)
Page 35 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• A thread owning the lock of an object can call other synchronous methods on the same object. (this is
another lock) Other threads can’t do that. They should wait to get the lock.
• Non-synchronous methods can be called at any time by any thread.
• Synchronous methods are re-entrant. So they can be called recursively.
• Synchronized methods can be overrided to be non-synchronous. synchronized behavior affects only the
original class.
• Locks on inner/outer objects are independent. Getting a lock on outer object doesn’t mean getting the
lock on an inner object as well, that lock should be obtained separately.
• wait and notify should be called from synchronized code. This ensures that while calling these methods
the thread always has the lock on the object. If you have wait/notify in non-synchronized code
compiler won’t catch this. At runtime, if the thread doesn’t have the lock while calling these methods,
an IllegalMonitorStateException is thrown.
• Deadlocks can occur easily. e.g, Thread A locked Object A and waiting to get a lock on Object B, but
Thread B locked Object B and waiting to get a lock on Object A. They’ll be in this state forever.
• It’s the programmer’s responsibility to avoid the deadlock. Always get the locks in the same order.
• While ‘suspended’, the thread keeps the locks it obtained – so suspend is deprecated in 1.2
• Use of stop is also deprecated, instead use a flag in run method. Compiler won’t warn you, if you have
statements after a call to stop, even though they are not reachable.
Page 36 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Object class is the ultimate ancestor of all classes. If there is no extends clause, compiler inserts
‘extends object’. The following methods are defined in Object class. All methods are public, if not
specified otherwise.
Method Description
boolean equals(Object o) just does a == comparison, override in descendents to provide meaningful comparison
final native void wait() Thread control. Two other versions of wait() accept timeout parameters and may throw
final native void notify() InterruptedException.
final native void notifyAll()
native int hashcode() Returns a hash code value for the object.
If two objects are equal according to the equals method, then calling the hashCode method
on each of the two objects must produce the same integer result.
protected Object clone() throws Creates a new object of the same class as this object. It then initializes each of the new
CloneNotSupportedException object's fields by assigning it the same value as the corresponding field in this object. No
constructor is called.
CloneNotSupportedException The clone method of class Object will only clone an object whose class indicates that it is
is a checked Exception willing for its instances to be cloned. A class indicates that its instances can be cloned by
declaring that it implements the Cloneable interface. Also the method has to be made public
to be called from outside the class.
Arrays have a public clone method.
int ia[ ][ ] = { { 1 , 2}, null };
int ja[ ][ ] = (int[ ] [ ])ia.clone();
A clone of a multidimensional array is shallow, which is to say that it creates only a single
new array. Subarrays are shared, so ia and ja are different but ia[0] and ja[0] are same.
final native Class getClass() Returns the runtime class of an object.
String toString Returns the string representation of the object. Method in Object returns a string consisting
of the name of the class of which the object is an instance, the at-sign character `@', and the
unsigned hexadecimal representation of the hash code of the object. Override to provide
useful information.
protected void finalize() throws Called by the garbage collector on an object when garbage collection determines that there
Throwable are no more references to the object.
Any exception thrown by the finalize method causes the finalization of this object to be
halted, but is otherwise ignored.
The finalize method in Object does nothing. A subclass overrides the finalize method to
dispose of system resources or to perform other cleanup.
Page 37 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• For ceil, if the argument is less than zero but greater than –1.0, then the result is a negative zero
• random – returns a double between 0.0(including) and 1.0(excluding)
• round returns a long for double, returns an int for float. (closest int or long value to the argument)
The result is rounded to an integer by adding ½ , taking the floor of the result, and casting the result to
type int / long.
(int)Math.floor(a + 0.5f)
(long)Math.floor(a + 0.5d)
• double rint(double) returns closest double equivalent to a mathematical integer. If two values are equal,
it returns the even integer value. rint(2.7) is 3, rint(2.5) is 2.
• Math.min(-0.0, +0.0) returns –0.0, Math.max(-0.0, +0.0) returns 0.0, -0.0 == +0.0 returns true.
• For a NaN or a negative argument, sqrt returns a NaN.
• Every primitive type has a wrapper class (some names are different – Integer, Boolean, Character)
• Wrapper class objects are immutable.
• All Wrapper classes are final.
• All wrapper classes, except Character, have a constructor accepting string. A Boolean object, created
by passing a string, will have a value of false for any input other than “true” (case doesn’t matter).
• Numeric wrapper constructors will throw a NumberFormatException, if the passed string is not a valid
number. (empty strings and null strings also throw this exception)
• equals also tests the class of the object, so even if an Integer object and a Long object are having the
same value, equals will return false.
• NaN’s can be tested successfully with equals method.
Float f1 = new Float(Float.NaN);
Float f2 = new Float(Float.NaN);
System.out.println( ""+ (f1 == f2)+" "+f1.equals(f2)+ " "+(Float.NaN == Float.NaN) );
The above code will print false true false.
• Numeric wrappers have 6 methods to return the numeric value – intValue(), longValue(), etc.
• valueOf method parses an input string (optionally accepts a radix in case of int and long) and returns a
new instance of wrapper class, on which it was invoked. It’s a static method. For empty/invalid/null
strings it throws a NumberFormatException. For null strings valueOf in Float and Double classes
throw NullPointerException.
• parseInt and parseLong return primitive int and long values respectively, parsing a string (optionally a
radix). Throw a NumberFormatException for invalid/empty/null strings.
• Numeric wrappers have overloaded toString methods, which accept corresponding primitive values
(also a radix in case of int,long) and return a string.
• Void class represents void primitive type. It’s not instantiable. Just a placeholder class.
• Passing null to indexOf or lastIndexOf will throw NullPointerException, passing empty string returns
0, passing a string that’s not in the target string returns –1.
• trim method removes all leading and trailing white-space from a String and returns a new String.
White-space means, all characters with value less than or equal to the space character – ‘\u0020’.
• String class is final.
• + and += operators are overloaded for Strings.
• reverse, append, insert are not String methods.
• String context means, ‘+’ operator appearing with one String operand. String concatenation cannot be
applied to StringBuffers.
• A new String buffer is created.
• All operands are appended (by calling toString method, if needed)
• Finally a string is returned by calling toString on the String Buffer.
• String concatenation process will add a string with the value of “null”, if an object reference is null and
that object is appearing in a concatenation expression by itself. But if we try to access its members or
methods, a NullPointerException is thrown. The same is true for arrays, array name is replaced with
null, but trying to index it when it’s null throws a NullPointerException.
Page 39 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• A collection (a.k.a bag or multiset) allows a group of objects to be treated as a single unit. Arbitrary
objects can be stored, retrieved and manipulated as elements of these collections.
• Collections Framework presents a set of standard utility classes to manage such collections.
1. It contains ‘core interfaces’ which allow collections to be manipulated independent of their
implementations. These interfaces define the common functionality exhibited by collections and
facilitate data exchange between collections.
2. A small set of implementations that are concrete implementations of the core interfaces, providing
data structures that a program can use.
3. An assortment of algorithms to perform various operations such as, sorting and searching.
• Collections framework is interface based, collections are implemented according to their interface
type, rather than by implementation types. By using the interfaces whenever collections of objects need
to be handled, interoperability and interchangeability are achieved.
• By convention each of the collection implementation classes provide a constructor to create a
collection based on the elements in the Collection object passed as argument. By the same token, Map
implementations provide a constructor that accepts a Map argument. This allows the implementation of
a collection (Collection/Map) to be changed. But Collections and Maps are not interchangeable.
• Interfaces and their implementations in Java 1.2
Collection
|
|__ Set (no dupes, null allowed based on implementation) HashSet
| |
| |__ SortedSet (Ordered Set) TreeSet
|
|__ List (ordered collection, dupes OK) Vector, ArrayList, LinkedList
Interface Description
Collection A basic interface that defines the operations that all the classes that maintain
collections of objects typically implement.
Set Extends Collection, sets that maintain unique elements. Set interface is defined in
terms of the equals operation
SortedSet Extends Set, maintain the elements in a sorted order
List Extends Collection, maintain elements in a sequential order, duplicates allowed.
Map A basic interface that defines operations that classes that represent mappings of
keys to values typically implement
SortedMap Extends Map for maps that maintain their mappings in key order.
However, requires the use of unique keys for storing data elements.
Interfaces
Data Structures Set SortedSet List Map SortedMap
used to implement
Hash Table HashSet HashMap (Nulls OK)
(Nulls OK) HashTable (No Nulls)
Resizable Array ArrayList (Nulls OK)
Vector(Nulls OK)
Balanced Tree TreeSet TreeMap
• Some of the operations in the collection interfaces are optional, meaning that the implementing class
may choose not to provide a proper implementation of such an operation. In such a case, an
UnsupportedOperationException is thrown when that operation is invoked.
Page 41 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 42 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
1. Objects can specify their natural order by implementing Comparable interface. Many if the
standard classes in Java API, such as wrapper classes, String, Date and File implement this
interface. This interface defines a single method:
int compareTo(Object o) – returns negative, zero, positive if the current object is less than,
equal to or greater than the specified object.
In this case a natural comparator queries objects implementing Comparable about their natural
order. Objects implementing this interface can be used:
• As elements in a sorted set.
• As keys in sorted map.
• In lists which can be sorted automatically by the Collections.sort() method.
2. Objects can be sorted by specific comparators, which implement Comparator interface. This
interface defines the following method:
int compare(Object o1, Object o2) – returns negative, zero, positive if the first object is less
than, equal to or greater than the second object. It is recommended that its implementation
doesn’t contradict the semantics of the equals() method.
Specific Comparators can be specified in the constructors of SortedSets and SortedMaps.
• All classes provide a constructor to create an empty collection (corresponding to the class). HashSet,
HashMap, HashTable can also be specified with an initial capacity as well as a load factor (the ratio of
number of elements stored to its current capacity). Most of the time, default values provide acceptable
performance.
• A Vector, like an array, contains items that can be accessed using an integer index. However, the size of
a Vector can grow and shrink as needed to accommodate adding and removing items after the Vector
has been created.
• Vector (5,10) means initial capacity 5, additional allocation (capacity increment) by 10.
• Stack extends Vector and implements a LIFO stack. With the usual push() and pop() methods, there is a
peek() method to look at the object at the top of the stack without removing it from the stack.
• Dictionary is an obsolete class. HashTable extends dictionary. Elements are stored as key-value pairs.
• Vector and HashTable are the only classes that are thread-safe.
• ArrayList (does what Vector does), HashMap(does what HashTable does), LinkedList and TreeMap are
new classes in Java 1.2
• In Java 1.2, Iterator duplicates the functionality of Enumeration. New implementations should consider
Iterator.
Method Description
public static Set singleton(Object o) Returns an immutable set containing only the specified object
public static List singletonList(Object o) Returns an immutable list containing only the specified object
public static Map singletonMap(Object Returns an immutable map containing only the specified key,
Page 43 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• The class Arrays, provides useful algorithms that operate on arrays. It also provides the static asList()
method, which can be used to create List views of arrays. Changes to the List view affects the array
and vice versa. The List size is the array size and cannot be modified. The asList() method in the
Arrays class and the toArray() method in the Collection interface provide the bridge between arrays
and collections.
Set mySet = new HashSet(Arrays.asList(myArray));
String[] strArray = (String[]) mySet.toArray();
• All concrete implementations of the interfaces in java.util package are inherited from abstract
implementations of the interfaces. For example, HashSet extends AbstractSet, which extends
AbstractCollection. LinkedList extends AbstractList, which extends AbstractCollection. These abstract
implementations already provide most of the heavy machinery by implementing relevant interfaces, so
that customized implementations of collections can be easily implemented using them.
• BitSet class implements a vector of bits that grows as needed. Each component of the bit set has a
boolean value. The bits of a BitSet are indexed by nonnegative integers. Individual indexed bits can be
examined, set, or cleared. One BitSet may be used to modify the contents of another BitSet through
logical AND, logical inclusive OR, and logical exclusive OR operations.
By default, all bits in the set initially have the value false. A BitSet has a size of 64, when created
without specifying any size.
• ConcurrentModificationException exception (extends RuntimeException) may be thrown by
methods that have detected concurrent modification of a backing object when such modification is not
permissible.
For example, it is not permssible for one thread to modify a Collection while another thread is iterating
over it. In general, the results of the iteration are undefined under these circumstances. Some Iterator
implementations (including those of all the collection implementations provided by the JDK) may
choose to throw this exception if this behavior is detected. Iterators that do this are known as fail-fast
iterators, as they fail quickly and cleanly, rather that risking arbitrary, non-deterministic behavior at an
undetermined time in the future.
Page 44 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Chapter 10 Components
• Java’s building blocks for creating GUIs.
• All non-menu related components inherit from java.awt.Component, that provides basic support for
event handling, controlling component size, color, font and drawing of components and their contents.
• Component class implements ImageObserver, MenuContainer and Serializable interfaces. So all AWT
components can be serialized and can host pop-up menus.
• Component methods:
• Container class extends Component. This class defines methods for nesting components in a container.
Component add(Component comp)
Component add(Component comp, int index)
void add(Component comp, Object constraints)
void add(Component comp, Object constraints, int index)
Container Description
Panel • Provides intermediate level of spatial organization and containment.
• Not a top-level window
• Does not have title, border or menubar.
• Can be recursively nested.
• Default layout is Flow layout.
Applet • Specialized Panel, run inside other applications (typically browsers)
• Changing the size of an applet is allowed or forbidden depending on the browser.
• Default layout is Flow layout.
Window • Top-level window without a title, border or menus.
• Seldom used directly. Subclasses (Frame and Dialog) are used.
• Defines these methods:
• void pack() – Initiates layout management, window size might be changed as a result
• void show() – Makes the window visible, also brings it to front
Page 45 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• void dispose() – When a window is no longer needed, call this to free resources.
Frame • Top-level window (optionally user-resizable and movable) with a title-bar, an icon and menus.
• Typically the starting point of a GUI application.
• Default layout is Border layout.
Dialog • Top-level window (optionally user-resizable and movable) with a title-bar.
• Doesn’t have icons or menus.
• Can be made modal.
• A parent frame needs to be specified to create a Dialog.
• Default layout is Border layout.
ScrollPane • Can contain a single component. If the component is larger than the scrollpane, it acquires
vertical / horizontal scrollbars as specified in the constructor.
• SCROLLBARS_AS_NEEDED – default, if nothing specified
• SCROLLBARS_ALWAYS
• SCROLLBARS_NEVER
• Top-level containers (Window, Frame and Dialog) cannot be nested. They can contain other containers
and other components.
• GUI components:
Page 46 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Orientation can be
Scrollbar.HORIZONTAL
Scrollbar.VERTICAL
TextField • Extends TextComponent TextField() – empty field Text event
• Single line of edit / display of text. TextField(int ncols) – size
• Scrolled using arrow keys. TextField(String text) – Action event –
initial text Enter key is
• Depending on the font, number of
TextField(String text, int pressed.
displayable characters can vary.
ncols) – initial text and size
• But, never changes size once created.
• Methods from TextComponent:
• String getSelectedText()
• String getText()
• void setEditable(boolean editable)
• void setText(String text)
TextArea • Extends TextComponent TextArea() – empty area Text event
• Multiple lines of edit/display of text. TextArea(int nrows, int
• Scrolled using arrow keys. ncols) – size
TextArea(String text) –
• Can use the TextComponent methods
initial text
specified above.
TextArea(String text, int
• Scroll parameter in last constructor form nrows, int ncols) – initial
could be text and size
TextArea.SCROLLBARS_BOTH,
TextArea.SCROLLBARS_NONE, TextArea(String text, int
TextArea.SCROLLBARS_HORIZONTAL_ONLY nrows, int ncols, int scroll)
TextArea.SCROLLBARS_VERTICAL_ONLY
• Pull-down menus are accessed via a menu bar, which can appear only on Frames.
Page 47 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 48 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 49 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 50 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Insets Insets insets External padding (border) around the (0,0,0,0) (top, left, bottom, right)
component.
Page 51 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Chapter 12 Events
• Java 1.0’s original outward rippling event model had shortcomings.
An event could only be handled by the component that originated the event or one of its
containers.
No way to disable processing of irrelevant events.
• Java 1.1 introduced new “event delegation model”.
A component may be told which objects should be notified when the component generates a
particular kind of event.
If a component is not interested in an event type, those events won’t be propagated.
• Both models are supported in Java 2, but the old model will eventually disappear. Both models should
not be mixed in a single program. If we do that, the program is most likely to fail.
• Event delegation model’s main concepts: Event classes, Event listeners, Explicit event enabling and
Event adapter classes.
Event Classes
• Events are Java objects. All the pertinent information is encapsulated in that object. The super class of
all events is java.util.EventObject.
• This java.util.EventObject class defines a method that returns the object that generated the event:
Object getSource()
• All events related to AWT are in java.awt.event package. AWTEvent is the abstract super class of all
AWT events. This class defines a method that returns the ID of the event. All events define constants to
represent the type of event.
int getID() – returns an int in the form of an integer value that identifies the type of event.
• It is useful to divide the event classes into Semantic events and Low-level events.
• Semantic Events –
These classes are used for high-level semantic events, to represent user interaction with GUI.
ActionEvent, AdjustmentEvent, ItemEvent, TextEvent
Page 52 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Page 53 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
int getX
int getY Return the position of the mouse within the originated component at
MouseEvent the time the event took place
Point getPoint
int getClickCount Returns the number of mouse clicks.
WindowEvent Window getWindow Returns a reference to the Window object that caused the event to be
generated.
Event Listeners
• Each listener interface extends java.util.EventListener interface.
• There are 11 listener interfaces corresponding to particular events. Any class that wants to handle an
event should implement the corresponding interface. Listener interface methods are passed the event
object that has all the information about the event occurred.
• Then the listener classes should be registered with the component that is the source/originator of the
event by calling the addXXXListener method on the component. Listeners are unregistered by calling
removeXXXListener method on the component.
• A component may have multiple listeners for any event type.
• A component can be its own listener if it implements the necessary interface. Or it can handle its
events by implementing the processEvent method. (This is discussed in explicit event enabling section)
• All registered listeners with the component are notified (by invoking the methods passing the event
object). But the order of notification is not guaranteed (even if the same component is registered as its
own listener). Also the notification is not guaranteed to occur on the same thread. Listeners should take
cautions not to corrupt the shared data. Access to any data shared between the listeners should be
synchronized.
• Same listener object can implement multiple listener interfaces.
• Event listeners are usually implemented as anonymous classes.
Event Type Event Source Listener Registration and removal Event Listener Interface
methods provided by the source implemented by a listener
ActionEvent Button addActionListener ActionListener
List removeActionListner
MenuItem
TextField
AdjustmentEvent Scrollbar addAdjustmentListener AdjustmentListener
removeAdjustmentListner
ItemEvent Choice addItemListener ItemListener
List removeItemListner
Checkbox
CheckboxMenuItem
TextEvent TextField addTextListener TextListener
TextArea removeTextListner
ComponentEvent Component add ComponentListener ComponentListener
remove ComponentListner
ContainerEvent Container addContainerListener ContainerListener
removeContainerListner
FocusEvent Component addFocusListener FocusListener
removeFocusListner
KeyEvent Component addKeyListener KeyListener
removeKeyListner
Page 54 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
addMouseListener MouseListener
removeMouseListner
MouseEvent Component
addMouseMotionListener MouseMotionListener
removeMouseMotionListner
WindowEvent Window addWindowListener WindowListener
removeWindowListner
Event Adapters
• Event Adapters are convenient classes implementing the event listener interfaces. They provide empty
bodies for the listener interface methods, so we can implement only the methods of interest without
providing empty implementation. They are useful when implementing low-level event listeners.
• There are 7 event adapter classes, one each for one low-level event listener interface.
Page 55 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Obviously, in semantic event listener interfaces, there is only one method, so there is no need for event
adapters.
• Event adapters are usually implemented as anonymous classes.
Page 56 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Chapter 13 Painting
• Some objects have default appearance. When they are created, OS decorates with a pre-defined
appearance.
• Some components don’t have any intrinsic appearance. These are Applet, Panel, Frame and Canvas.
For these objects paint() method is used to render them.
public void paint(Graphics g)
• The paint() method provides a graphics context (an instance of Graphics class) for drawing. This is
passed as a method argument.
• A Graphics object encapsulates state information needed for the basic rendering operations that Java
supports. This state information includes the following properties:
• The Component object on which to draw.
• A translation origin for rendering and clipping coordinates.
• The current clip.
• The current color.
• The current font.
• The current logical pixel operation function (XOR or Paint).
• The current XOR alternation color.
• We can use this Graphics object to achieve the following functionality:
1. Selecting a color – g.setColor(Color)
There are 13 predefined colors in Color class. Or create a new color using Color(R,G,B)
2. Selecting a Font – g.setFont(Font)
A Font is created by Font(String name, int style, int size)
3. Drawing and Filling – Various draw, fill methods
4. Clipping – g.setClip(Shape) or g.setClip(x, y, width, height)
• Graphics class is an abstract class. It cannot be created. But an instance can be obtained in 2 ways.
1. Every component has an associated graphics context. Get this using getGraphics method.
2. Given an existing Graphics object, call create() on that object to create a new one.
In both cases, after its use call dispose method on Graphics, to free the resources. We shouldn’t call
dispose on the graphics context passed into paint() method, since it’s just temporarily made available.
• JVM calls paint() spontaneously under 4 circumstances
1. After exposure
2. After de-iconification
3. Shortly after init returns (Applets only)
4. Browser returns to a page contains the Applet (Applets only)
• In all cases, clip region is set appropriately. If only a small portion is exposed, no time is wasted in
drawing already drawn pixels.
• Programs can also call paint(). But normally they achieve this by calling repaint(). Repaint() schedules
a call to update() method (every 100 ms in most platforms). This is to ensure that JVM is never
overwhelmed with the events.
• update() restores the component’s background color and calls paint(). If you don’t want to erase the
previously drawn content, override update() and just call paint() from it. (A common practice).
• Event handlers that need to modify the screen according to input events, usually store the state
information in instance variables and call repaint().
• Images can be created from empty (using createImage(int width, int height) method) or loaded from
external image files (using getImage() method in Toolkit class). Then they can be modified using the
graphics context associated with the image. They can be drawn on the component using the drawImage
method of the Graphics context of the component.
Page 57 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Between <APPLET> and </APPLET>, PARAM tags can be specified. These are used to pass
parameters from HTML page to the applet.
• <PARAM NAME = ”name” VALUE = ”value”>
• Applets call getParameter(name) to get the parameter. The name is not case sensitive here.
• The value returned by getParameter is case sensitive, it is returned as defined in the HTML page.
• If not defined, getParameter returns null.
• Text specified between <APPLET> and </APPLET> is displayed by completely applet ignorant
browsers, who cannot understand even the <APPLET> tag.
• If the applet class has only non-default constructors, applet viewer throws runtime errors while loading
the applet since the default constructor is not provided by the JVM. But IE doesn’t have this problem.
But with applets always do the initialization in the init method. That’s the normal practice.
• Methods involved in applet’s lifecycle.
Method Description
void init() This method is called only once by the applet context to inform the applet that it has
been loaded into the system. Always followed by calls to start() and paint() methods.
Same purpose as a constructor. Use this method to perform any initialization.
void start() Applet context calls this method for the first time after calling init(), and thereafter
every time the applet page is made visible.
void stop() Applet context calls this method when it wants the applet to stop the execution. This
method is called when the applet page is no longer visible.
void destroy() This method is called to inform the applet that it should relinquish any system resources
that it had allocated. Stop() method is called prior to this method.
Page 58 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
void paint(Graphics g) Applets normally put all the rendering operations in this method.
Page 59 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Chapter 15 I/O
• Inside JVM, text is represented in 16 bit Unicode. For I/O, UTF (UCS (Universal Character set)
Transformation Format) is used. UTF uses as many bits as needed to encode a character.
• Often programs need to bring in information from an external source or send out information to an
external destination. The information can be anywhere: in a file, on disk, somewhere on the network,
in memory, or in another program. Also, it can be of any type: objects, characters, images, or sounds.
• To bring in information, a program opens a stream on an information source (a file, memory or a
socket) and reads the information serially. Similarly, a program can send information to an external
destination by opening a stream to a destination and writing the information out serially.
• No matter where the information is coming from or going to and no matter what type of data is being
read or written, the algorithms for reading and writing data is pretty much always the same.
Reading Writing
open a stream open a stream
while more information while more information
read information write information
close the stream close the stream
• For this kind of general I/O Stream/Reader/Writer model is used. These classes are in java.io package.
They view the input/output as an ordered sequence of bytes/characters.
• We can create I/O chains of arbitrary length by chaining these classes.
• These classes are divided into two class hierarchies based on the data type (either characters or bytes)
on which they operate. Streams operate on bytes while Readers/Writers operate on chars.
• However, it's often more convenient to group the classes based on their purpose rather than on the data
type they read and write. Thus, we can cross-group the streams by whether they read from and write to
data "sinks" (Low level streams) or process the information as its being read or written (High level
filter streams).
• Low Level Streams/Data sink streams read from or write to specialized data sinks such as strings, files,
or pipes. Typically, for each reader or input stream intended to read from a specific kind of input
source, java.io contains a parallel writer or output stream that can create it. The following table gives
java.io's data sink streams.
Sink Character
Byte Streams Purpose
Type Streams
Use these streams to read from and write to memory.
CharArrayReader, ByteArrayInputStream, You create these streams on an existing array and then
CharArrayWriter ByteArrayOutputStream use the read and write methods to read from or write to
the array.
Memory Use StringReader to read characters from a String as it
lives in memory. Use StringWriter to write to a String.
StringReader, StringWriter collects the characters written to it in a
StringBufferInputStream
StringWriter StringBuffer, which can then be converted to a String.
StringBufferInputStream is similar to StringReader,
except that it reads bytes from a StringBuffer.
Implement the input and output components of a pipe.
PipedReader, PipedInputStream,
Pipe Pipes are used to channel the output from one program
PipedWriter PipedOutputStream
(or thread) into the input of another.
FileReader, FileInputStream, Collectively called file streams, these streams are used
File
FileWriter FileOutputStream to read from or write to a file on the native file system.
Page 60 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Processing streams perform some sort of operation, such as buffering or character encoding, as they
read and write. Like the data sink streams, java.io often contains pairs of streams: one that performs a
particular operation during reading and another that performs the same operation (or reverses it) during
writing. This table gives java.io's processing streams.
Character
Process Byte Streams Purpose
Streams
Buffer data while reading or writing, thereby
reducing the number of accesses required on
BufferedReader, BufferedInputStream,
Buffering the original data source. Buffered streams are
BufferedWriter BufferedOutputStream
typically more efficient than similar
nonbuffered streams.
Abstract classes, like their parents. They
FilterReader, FilterInputStream,
Filtering define the interface for filter streams, which
FilterWriter FilterOutputStream
filter data as it's being read or written.
A reader and writer pair that forms the bridge
between byte streams and character streams.
An InputStreamReader reads bytes from an
InputStream and converts them to characters
Converting
using either the default character-encoding or
between InputStreamReader,
N/A a character-encoding specified by name.
Bytes and OutputStreamWriter
Similarly, an OutputStreamWriter converts
Characters
characters to bytes using either the default
character-encoding or a character-encoding
specified by name and then writes those bytes
to an OutputStream.
Concatenates multiple input streams into one
Concatenation N/A SequenceInputStream
input stream.
Object ObjectInputStream,
N/A Used to serialize objects.
Serialization ObjectOutputStream
Read or write primitive Java data types in a
DataInputStream,
Data Conversion N/A machine-independent format. Implement
DataOutputStream
DataInput/DataOutput interfaces.
Counting LineNumberReader LineNumberInputStream Keeps track of line numbers while reading.
Two input streams each with a 1-character (or
byte) pushback buffer. Sometimes, when
reading data from a stream, you will find it
useful to peek at the next item in the stream in
Peeking Ahead PushbackReader PushbackInputStream order to decide what to do next. However, if
you do peek ahead, you'll need to put the item
back so that it can be read again and
processed normally. Certain kinds of parsers
need this functionality.
Contain convenient printing methods. These
are the easiest streams to write to, so you will
Printing PrintWriter PrintStream
often see other writable streams wrapped in
one of these.
Page 61 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Reader and InputStream define similar APIs but for different data types. For example, Reader contains
these methods for reading characters and arrays of characters:
int read() throws IOException
int read(char cbuf[]) throws IOException
abstract int read(char cbuf[], int offset, int length) throws IOException
InputStream defines the same methods but for reading bytes and arrays of bytes:
abstract int read() throws IOException
int read(byte cbuf[]) throws IOException
int read(byte cbuf[], int offset, int length) throws IOException
Also, both Reader and InputStream provide methods for marking a location in the stream, skipping
input, and resetting the current position.
Both Reader and InputStream are abstract. Subclasses should provide implementation for the read()
method.
• Writer and OutputStream are similarly parallel. Writer defines these methods for writing characters and
arrays of characters:
int write(int c) throws IOException
abstract int write(char cbuf[])throws IOException
int write(char cbuf[], int offset, int length) throws IOException
And OutputStream defines the same methods but for bytes:
abstract int write(int c) throws IOException
int write(byte cbuf[]) throws IOException
int write(byte cbuf[], int offset, int length) throws IOException
Both Writer and OutputStream are abstract. Subclasses should provide implementation for the
write() method.
DataInputStream(InputStream in)
DataOutputStream(OutputStream out)
BufferedInputStream(InputStream in)
BufferedInputStream(InputStream in, int size)
BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size)
Page 62 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
InputStreamReader(InputStream in)
InputStreamReader(InputStream in, String encodingName) throws
UnsupportedEncodingException
OutputStreamWriter(OutputStream out)
OutputStreamWriter (OutputStream out, String encodingName) throws
UnsupportedEncodingException
PrintWriter(Writer out)
PrintWriter(Writer out, boolean autoflush)
PrintWriter(OutputStream out)
PrintWriter(OutputStream out, boolean autoflush)
BufferedReader(Reader in)
BufferedReader(Reader in, int size)
BufferedWriter(Writer out)
BufferedWriter (Writer out, int size)
• OutputStreamWriter and InputStreamReader are the only ones where you can specify an encoding
scheme apart from the default encoding scheme of the host system. getEncoding method can be used to
obtain the encoding scheme used.
• With UTF-8 Normal ASCII characters are given 1 byte. All Java characters can be encoded with at
most 3 bytes, never more.
• All of the streams--readers, writers, input streams, and output streams--are automatically opened when
created. You can close any stream explicitly by calling its close method. Or the garbage collector can
implicitly close it, which occurs when the object is no longer referenced.
• Closing the streams automatically flushes them. You can also call flush method.
• New FileWriter(“filename”) or FileOutputStream(“filename”) will overwrite if “filename” is existing
or create a new file, if not existing. But we can specify the append mode in the second argument.
• Print writers provide the ability to write textual representations of Java primitive values. They have to
be chained to the low-level streams or writers. Methods in this class never throw an IOException.
• PrintStream and PrintWriter classes can be created with autoflush feature, so that each println method
will automatically be written to the next available stream. PrintStream is deprecated.(though
System.out and System.err are still of this type)
• System.in is of InputStream type.
• System.in, System.out, System.err are automatically created for a program, by JVM.
• Use buffered streams for improving performance.BufferedReader provides readLine method.
Page 63 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
Constructor Description
File(File dir, String name) Creates a File instance that represents the file with the specified name in the
specified directory
File(String path) Creates a File instance that represents the file whose pathname is the given
path argument.
File(String path, String Creates a File instance whose pathname is the pathname of the specified
name) directory, followed by the separator character, followed by the name argument.
• File methods
Method Description
boolean canRead() Tests if the application can read from the specified file.
boolean canWrite() Tests if the application can write to this file.
boolean delete() Deletes the file specified by this object.
boolean exists() Tests if this File exists.
String getAbsolutePath() Returns the absolute pathname of the file represented by this object.
String getCanonicalPath() Returns the canonical form of this File object's pathname.
.. and . are resolved.
String getName() Returns the name of the file represented by this object.
String getParent() Returns the parent part of the pathname of this File object, or null if the
name has no parent part.
String getPath() Returns the pathname of the file represented by this object.
boolean isAbsolute() Tests if the file represented by this File object is an absolute pathname.
boolean isDirectory() Tests if the file represented by this File object is a directory.
boolean isFile() Tests if the file represented by this File object is a "normal" file.
long lastModified() Returns the time that the file represented by this File object was last
modified.
long length() Returns the length of the file (in bytes) represented by this File object.
String[] list() Returns a list of the files in the directory specified by this File object.
String[] list(FilenameFilter) Returns a list of the files in the directory specified by this File that satisfy the
specified filter.
FileNameFilter is an interface that has a method accept().
This list method will call accept for each entry in the list of files and only
returns the files for which accept returns true.
boolean mkdir() Creates a directory whose pathname is specified by this File object.
boolean mkdirs() Creates a directory whose pathname is specified by this File object,
Page 64 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])
Study Notes for Sun Certified Programmer for Java 2 Platform
• Instances of the file descriptor class serve as an opaque handle to the underlying machine-specific
structure representing an open file or an open socket.
• Applications should not create their own file descriptors
• RAF Constructors
Constructor Description
RandomAccessFile(File file, String mode) Creates a random access file stream to read from, and
throws FileNotFoundException, optionally to write to, the file specified by the File argument.
IllegalArgumentException, SecurityException
RandomAccessFile(String name, String mode) Creates a random access file stream to read from, and
throws FileNotFoundException, optionally to write to, a file with the specified name.
IllegalArgumentException, SecurityException
• The mode argument must either be equal to "r" or "rw", indicating either to open the file for input or
for both input and output.
Method Description
long getFilePointer() throws Returns the offset from the beginning of the file, in bytes, at which the next read
IOException or write occurs.
void seek(long pos) throws Sets the file-pointer offset, measured from the beginning of this file, at which
IOException the next read or write occurs. The offset may be set beyond the end of the file.
Setting the offset beyond the end of the file does not change the file length. The
file length will change only by writing after the offset has been set beyond the
end of the file.
long length() throws Returns the length of this file, measured in bytes.
IOException
Page 65 of 65
Last Modified on 10/14/084:53 A10/P10
©2000 Velmurugan Periasamy ([email protected])