Core Java appro ach for C\C++ programmer wanting Core Java offers a total immersion approach
to learn java. The course will use JDK(Java Development Kit) and covers all the new language features. This course inclues worked out examples illustrating new JDK features that are fully explained thoughout the course. Core Java has been carefully planned to help students create faster, smaller s maller and more efficient Java application.
J a v a Ev Ev o l u t i o n Java History • • • • • • • • • • • • • • •
Java is a general purpose , object-oriented programming language. The fastest growing programming language in the history of computing Developed by Sun Microsystems of USA in 1 991. Originally it is called Oak by James Gosling. Originally designed in 1991 for use in embedded consumer applications Java team which headed James Gosling developed a Web browser called “Hot Java” to locate and run applet programs on Internet in 1994. Oak was renamed “Java” in 1995. Redesigned in early 1995 with Internet application capabilities Introduced in May, 1995 and immediately supported by the Netscape Web browser. Rapidly overtaking C++ in popularity among commercial software developers Java established itself not only as a leader for Internet programming but also as a general purpose, object-oriented programming language. Java found its home in the heart of the modern p rogrammer. Java is the first programming language that is not tied to any particular hardware or operating system. Programs developed in java can be executed anywhere on any system. Therefore Java comes as a revolutionary technology b ecause it has brought in a fundamental shift in how we develop and use programs.
Java Features • • • • • •
Simple Object-oriented Distributed Interpreted Robust Secure
• • • • •
Architecture-neutral Portable High-performance Multithreaded Dynamic
Simple: Java is a simple language as it does not use pointers, preprocessor header files; go to statement and many more others.
Object oriented: In Java everything is object. All program code and data within objects and classes.
Distributed: Java is designed as a distributed language for creating applications on networks. It has ability to share both data and programs.
Interpreted: Interpreting means actually compiling the program line by line and generates the machine code. Java interpreter generates machine code that can be directly executed by the machine is that running the Java program.
Robust: Java is a robust language as it provides many safeguards to ensure reliable code. It has strict compile time and run time checking for data types.
Secure: No viruses can affect the Java program as Java ensures that program cannot gain access to memory locations without proper authorization. Java systems not only verify al l memory access but also ensure that no viruses are communicated with an applet.
Architecture-neutral: In Java, changes and upgrade in operating system, processors and system resources will not force any changes in Java programs.
Portable: Java programs can be easily moved from one computer system to another, anytime, and a nywhere. Java ensures portability in two ways. First, Java compiler generates bytecode instructions that can be implemented on any machin. Secondly the sizes of the primitive data type are machin-independent.
High-performance: Java performance is impressive for an interpreted language , mainly due to the use of intermediate bytecode.
Multithreaded: Java support multithreaded programs means handling multiple task simultaneously.
Dynamic: Java is capable of dynamically linking in new class libraries, methods and objects.
Benefits of J ava over C and C++ • Architecturally neutral. Once written, the same Java program can be run on any platform computer and operating system) that sup ports Java. • Entirely object-oriented. Existing code can be easily re-used and maintained. • Secure. Dangerous program actions are prohibited. • Supports Internet programming. Java apple ts are run by Web browsers. • Robust. Language features and packaged code support graphical programming, exception handling, networking, multi-threading, I/O, and more.
How Java works • To develop and distribute distribute a Java program 1. Programmer codes Java source statements 2. Java compiler converts source statements into bytecode (platf orm-independent object language) 3. Bytecode is copied to the target platform
• To execute a Java program 1. Platform-dependent Java Virtual Machine (JVM) software must be installed 2. A copy of the JVM is started 3. Each bytecode statement is interpreted (translated) by the JVM into platform-dependent machine language and executed under JVM control.
Distributed: Java is designed as a distributed language for creating applications on networks. It has ability to share both data and programs.
Interpreted: Interpreting means actually compiling the program line by line and generates the machine code. Java interpreter generates machine code that can be directly executed by the machine is that running the Java program.
Robust: Java is a robust language as it provides many safeguards to ensure reliable code. It has strict compile time and run time checking for data types.
Secure: No viruses can affect the Java program as Java ensures that program cannot gain access to memory locations without proper authorization. Java systems not only verify al l memory access but also ensure that no viruses are communicated with an applet.
Architecture-neutral: In Java, changes and upgrade in operating system, processors and system resources will not force any changes in Java programs.
Portable: Java programs can be easily moved from one computer system to another, anytime, and a nywhere. Java ensures portability in two ways. First, Java compiler generates bytecode instructions that can be implemented on any machin. Secondly the sizes of the primitive data type are machin-independent.
High-performance: Java performance is impressive for an interpreted language , mainly due to the use of intermediate bytecode.
Multithreaded: Java support multithreaded programs means handling multiple task simultaneously.
Dynamic: Java is capable of dynamically linking in new class libraries, methods and objects.
Benefits of J ava over C and C++ • Architecturally neutral. Once written, the same Java program can be run on any platform computer and operating system) that sup ports Java. • Entirely object-oriented. Existing code can be easily re-used and maintained. • Secure. Dangerous program actions are prohibited. • Supports Internet programming. Java apple ts are run by Web browsers. • Robust. Language features and packaged code support graphical programming, exception handling, networking, multi-threading, I/O, and more.
How Java works • To develop and distribute distribute a Java program 1. Programmer codes Java source statements 2. Java compiler converts source statements into bytecode (platf orm-independent object language) 3. Bytecode is copied to the target platform
• To execute a Java program 1. Platform-dependent Java Virtual Machine (JVM) software must be installed 2. A copy of the JVM is started 3. Each bytecode statement is interpreted (translated) by the JVM into platform-dependent machine language and executed under JVM control.
Java has two things: a programming language and a platform.
The Java P rogramming Language Java is a high-level programming language that is all of the follow ing: • Simple
• Architecture-neutral
• Object-oriented
• Portable
• Distributed
• High-performance
• Interpreted
• Multithreaded
• Robust
• Dynamic
• Secure
Java is also unusual in that each Java program is both compiled and interpreted. With a compiler, compiler, it translates translates a Java program into an intermediate intermediate language called Java bytecodes-bytecodes-the platform-independent codes interpreted by the Java interpreter. With an interpret interpreter, er, each Java bytecode instruction instruction is parsed parsed and run on the computer. computer. Compilation Compilation happens just once; interpretation occurs each time the program is executed. This figure show how it works.
The Java bytecodes bytecodes is the machine code instructions instructions for the Java Virtual Machine (Java VM). Every Every Java interpreter, whether it's a Java development tool or a Web browser that can run Java applets, is a n i mp mpl em ementa ti ti on on of th e Java VM . The Ja va va VM ca n al so so be impl em emen te ted in h ar ardwa re re. Java
bytecodes
help
make
"write
once,
run
anywhere"
possible.
One can compile your Java program into bytecodes on any platform that has a Java compiler. The
bytecodes can then be run on any implementation of the Java VM.
The Java Platform A pl atf orm i s the h ardwa re or soft ware en vi ronment i n wh ich a program runs. Th e Java platform differs from most other platforms in that it's a software-only platform that runs on top of other, hardware-based platforms. Most other platforms are described as a combination of hardware and operating system.
The Java platform has tw o components: • The Java Virtual Machine (Java VM) • The Java Application Programming Interface (Java API) The Java VM is the ba se for the Java platform and is ported onto various hardw are-based platforms. The Java API is a large collection of ready-made software components that provide many useful capabilities, such as graphical user interface (GUI) widgets. The Java API (application programming interface) is grouped into libraries (packages) of related components.
Java Development Kit The Java Development Kit comes w ith a collection of tools that are used for developing and running J ava programs. They include: • • • • • • •
appletviewer ( for viewing Java applet) javac (Java compiler) java (Java In terpreter) javap (Java disassembler) javah (for C header files) javadoc (for creating HTML documents) jdb (Java debugger)
The below figure depicts a Java program, such as an application or applet, that's running on the Java platform. As the figure shows, the Java API and Virtual Machine insulates the Java program from hardware dependencies.
HARDWAR E AND SOFTWA RE REQUIREMENTS Java is currently supported on Window 95, Window NT, Sun Solaries, Macintosh and UNIX machine. The minimum software and hardwa re requirement for 95 version of Java are as follows: • IBM-compatible 486 system • Minimum of 8 MB memory
• • • • •
Windows 95 software A Windows-compatible sound card A hard drive; A CD-ROM drive A Microsoft-compatible mouse
Disadvantages of Java • Not supported by all platforms (though third-party JVM software is usually available) • Slower in execution than compiled languages • Restricts or prohibits machine-level operations required by certain applications (operating systems, etc.)
Ov e r v i e w o f Ja v a La n g u a g e Developing the Java Application A Java application is a standalone Java program-- a program written in the Java la nguage that runs independently of any browser. Example:
/** * The HelloWorldApp class implements an application that * simply displays "Hello World!" to the standard output. */ class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); //Display the string. }
}
Comments in Java Code The bold characters in the following listing are comments. /** * The HelloW orldApp class implements an application that * simply displays "Hello W orld!" to the standard output. */
class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); / / Display the string. } } The Java language supports three kinds of comme nts:
/* The compiler ignores everything from /* to */ . /**
text
documentation
This indicates a documentation comment (doc comment, for short). The compilerignores this kind of comment, just like it ignores comments that use /* and */. // The compiler ignores everything from // to the end of the line
Defining a Class The first bold line in the follow ing listing begins a class definition block. /** * The HelloWorldApp class implements an application that * simply displays "Hello World!" to the standard output. */ class HelloWorldApp
{ public static void main(String[] args) { System.out.println("Hello World!"); //Display the string. } }
A class--the basic building block of an object-oriented language such as Java--is a template that describes the data and behavior associated with instances of that class. The data associated with a class or object is stored in variables; the behavior associated with a class or object is implemented with methods. Methods are similar to the functions or procedures in procedural languages such as C. In the Java language, the simplest form of a class definition is class name {
... } The keyword class begins the class definition for a class named name. The variables and methods of the class are embraced by the curly brackets that begin and end the class definition block. The "Hello World" application has no variables and has a single method named main.
The main Method The first bold line in the follow ing listing begins the definition of a main method . /** * The HelloWorldApp class implements an application that * simply displays "Hello World!" to the standard output. */ class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); //Display the string. } } Every Java application must contain a main method whose signature looks like this: public static void main( String[] args)
{
System.out.println("Hello World!"); //Display the string. } }
Every Java application must contain a main method whose signature looks like this: public static void main( String[] args)
The method signature for the main method contains three modifiers: • public indicates that the main method can be called by any object. • static indicates that the main method is a class method. • void indicates that the main method doesn't return any value.
How th e main Method Gets Called The main method in the Java language is similar to the main function in C and C++. When the Java interpreter executes an application (by being invoked upon the application's controlling class), it starts by calling the class's main method. The main method then calls all the other methods required to run your application. If you try to invoke the Java interpreter on a class that does not have a main method, the interpreter refuses to compile your program and displays an error message similar to this: In class NoMain: void main(String argv[]) is not defined
Arguments to the main Method Here the main method accepts a si ngle argument: an array of e lements of type String.
public static void main(String[] args) This array is the mechanism through which the runtime system passes information to your application. Each String in the array is called a command-line argument.
Using Classes and Objects The "Hello World" application is about the simplest Java program one can write that actually does something. Because it is such a simple program, it doesn't need to define any classes except for HelloWorldApp. The "Hello W orld" application does use another class--the System class--that is part of the API (application programming interface) provided with the Java environment. The System class provides system-independent access to system-dependent functionality. The bold code in the following listing illustrates the use of a class variable of the System class, and of an instance method.
/** * The HelloWorldApp class implements an application that * simply displays "Hello World!" to the standard output. */ class HelloWorldApp { public static void main(String[] args) { System.out.println("Hello World!"); //Display the string. } }
Using a Class Method or Variable Let's take a look at the first segment of the statemen t:
System.out .println("Hello World!"); The construct System.out is the full name of the out variable in the System class.
Using an Instance Method or Variable Methods and variables that are not class methods or class variables are known as instance methods and instance variables. While System's out variable is a class variable, it refers to an instance of the PrintStream class (a class provided with the Java development environment) that implements the standard output stream. When the System class is loaded into the application, it instantiates PrintStream and assigns the new PrintStream object to the out class variable. System.out.println ("Hello
World!");
This line of code displays "Hello World!" to the application's standard output stream
Java Program Structure A Java program may contain one or more section which is as follow: 1. Documentation sectio n (suggested) The documentation section comprises a set of comment line of the program, the author and other details, which the programmer would like to refer to at a later stage.
2. Package statement (Optional) This statement declares a package name and inform the compiler that the class defined here belong to this package. Ex : package student;
3. Im port Statement (Optional) This statement instructs the interpreter to load the s pecific class contained in the package. Ex : import student. test;
4. Interface Statement (Optional) An interface is like a class but include a group of method declarations.
5. Class Definitio ns (Optional) Classes are the primary and essential elements of Java program. These classes are used to map the object of real world problems.
6. Main Method Class (Essential) As every Java stand-alone program requires a main method as its starting point, this class is the essential part of the program.
Java Tokens The smallest individual units in a program are known as TOKEN. A java program is a collection of tokens, comments and white spaces. Java language includes five types of tokens They are:
1) 2) 3) 4) 5)
Reserved Keyword Identifiders Literals Operator Separators
Reserved Keyw ord Keywords have specific meaning and implement Java language has reserved 60 words as keywords.
specific
features
of
the
language.
Identifiers Identifiers are programmer-designed tokens. They are used methods, variables, objects, labels, packages, and interface in a program.
for
naming
class,
Literals Literal is a programming language term that essentially means that what you type is what you get. Numbers, characters, and strings are all examples of literals. Therefore literals 1) Are constants having no identifier? 2) Have their value specified within the program's source code? 3) Can only appear on the right side of an assignment operator (=) or within an expression? 4) Have a data type associated with them?
Java program has five major types of li terals: 1) 2) 3) 4) 5)
Integer Literals Floating type literals Character literals String literals Boolean Literals
Integer literals 1. 2. 3. 4.
Represent an integer value Can be expressed in decimal (the default), octal (base 8, or hexadecimal (base 16) Are not enclosed in any special characters Are automatically int (32 bits) unless the suffix 'L' is appended to make it long (64 bits)
Floating-point literals 1. 2. 3. 4.
Represent a real number (having a decimal point) Can be expressed as a standard decimal value or in scientific notation Are not enclosed in any special characters Are automatically double (64 bits) unless the suffix 'F' is appended to make it float (32 bits)
char literals 1. 2. 3. 4.
Represent a single Unicode character (16 bits) Must be enclosed within single quotes (apostrophes) Are often associated with a single key stroke Can represent special cha racters ("escape sequences") used for device control
String literals 1. Represent a string of characters, such as "Java is fun" 2. Must be enclosed in double quotes 3. Are automatically stored as String cla ss objects by the compiler. They wil l be covered later.
boolean literals 1. Can only have the value true or false 2. Can only be assigned to boolean variables
Constants 1. Are similar to variables but, once initialized, their contents may NOT be changed? 2. Are declared with the keyword final? 3. By convention, have all capital letters in their identifier. This makes them easier to see within the code.
Operators An operator is a symbols that takes one or more arguments and operates on them to produce a result.
Separators Separators are symbols used to indicate where groups of code are divided and arranged. They are basically define the shape and function of our code. Ex : {}, [], ; , . , () etc.
Co n s t a a n t , Va r i a b l e a n d D a t a t y p e Variables Variables are locations in memory in which values can be stored. Each one has a name, a type, and a value. Before we can use a variable, we have to declare it. After it is declared, we can then assign values to it.
Java actually has three kinds of variables: 1. instance variables, 2. class variables, 3. And local variables. Instance variables, are used to define the attributes of a particular object. Class variables are similar to instance variables, except their values apply to all that class's instances (and to the class itself) rather than having different values for each object. Local
variables
are
declared
and
used
inside
method
definitions,
Although all three kinds of variables are declared in much the same ways, class and instance variables are accessed and assigned in slightly different ways from local variables. Java does not have global variables-that is, variables that are global to all parts of a program. Instance and class variables can be used to communicate global information between and among objects.
Declaring Variables To use any variable in a Java program, we must first declare it. Variable declarations consist of a type and a variable name:
int myAge; String myName; boolean isTired;
Variable definitions can go anywhere in a method definition (that is, anywhere a regular Java statement can go), although they are most commonly declared at the beginning of the definition before they are used:
public static void main (String args[]) { int count; String title; boolean isAsleep; ... } We can string together variable names wi th the same type on one line:
int x, y, z; String firstName, LastName; We can also give each variable an initial value when we declare it:
int myAge, mySize, numShoes = 28; String myName = "eBIZ"; boolean isTired = true; int a = 4, b = 5, c = 6;
If there value
are multiple variables on applies to only
We can also group individual commas, as with the last example.
the the
same line last
variables
and
with only variable
initializers
on
one in
initializer a
the
same
the initial declaration. line
Rules on Variable Names Variable names in Java can start with a letter, an underscore (_), or a dollar sign ($). They cannot start with a number. After the first character, our variable names can include any letter or number. Symbols, such as %, *, @, and so on, are often reserved for operators in Java, so we should be careful when using symbols in variable names. The Java language uses the Unicode character set. The Java language is case sensitive, which means that uppercase letters are different from lowercase letters. This means that the variable X is different from the variable x, and a rose is not a Rose is not a ROSE.
Variable Types In addition to the variable name, each variable declaration must have a type, which defines what values that variable can hold.
The variable type can be one of three things : • One • The • An array
of name
the of
eight a
primitive class
data or
types interface
Pri mitive Data Types The eight primitive data types handle common types for integers, floating-point numbers, characters, and boolean values (true or false). They're called primitive because they're built into the system and are not actual objects, which makes them more efficient to use.
Integer Type There are four Java integer types, each with a different All are signed, which means they can hold either positive or negative numbers.
range
of
values.
using
Table 3.1. Integer typ es Type
Size
Range
byte
8 bits
-128 to 127
short
16 bits
-32,768 to 32,767
int
32 bits
-2,147,483,648 to 2,147,483,647
long
64 bits
-9,223,372,036,854,775,808 to 9,223,372,036,854,775,807
Floating-point type: Floating-point numbers are used for numbers with a decimal part. There are two floating-point types: float (32 bits, single precision) and double (64 bits, double precision).
Char type: The char type is used for individual characters. Because Java uses the Unicode character set, the char type has 16 bits of precision, unsigned.
Constants • Are similar to variables but, once initialized, their contents may NOT be changed? • Are declared with the keyword final? • By convention, have all capital letters in their identifier. This makes them easier to see within the code. Example 1: This program defines a number of constants and then displays some of their values.
public class App { public static void main(String[] args) { final final final final final final final
boolean YES = true; char DEPOSIT_CODE = 'D'; byte INCHES_PER_FOOT = 12; int FEET_PER_MILE = 5280; float PI = 3.14F; double SALES_TAX_RATE = .06; String ADDRESS = "119 Sout h Street";
// Display some of the values System.out.println(INCHES_PER_FOOT); System.out.println(ADDRESS); } }
Example 2: This program will not compile because an attempt is made to change the value of its constant.
public class App1 { public static void main(String[] args) {
final double SALES_TAX_RATE = .06; SALES_TAX_RATE = .04; // Display the sales tax rate System.out.println(SALES_TAX_RATE); } } Here the compiler error will occur like this
Op e r a t o r a n d Ex p r e s s io n Expressions and Operators Operators enable us to perform an evaluation or computation on a data object or objects. Operators applied to variables an d literals form expressions. An expression can be thought of as a programmatic equation. Therefore, an expression is a sequence of one or more data objects (operands) and zero or more operators that produce a result. An example of an expression follow s:
x In
=
y
this expression, x and
This expression states operator (/), and the
/
y are variables, 3
that the result is
is a
3;
literal, and = and / are operators.
y variable is divided by 3 using the division stored in x using the assignment operator (=).
Here the expression is described from right to left.
Operator Precedence Java expressions are typically evaluated from left to right, there still are many times w hen the result of an expression would be indeterminate without other rules. The following expression illustrates the problem:
x = 2 * 6 + 16 / 4
By using the left-to-right evaluation of the expression, the multiplication operation 2 * 6 is carried out first, which leaves a result of 12. The addition operation 12 + 16 is then performed, which gives a result of 28. The division operation 28 / 4 is then performed, which gives a result of 7. Finally, the assignment operation x = 7 is handled, in which the number 7 is assigned to the variable x. But--it's wrong! The problem is that using a simple left-to-right evaluation of expressions can yield inconsistent results, depending on the order of the operators. The solution to this problem lies in operator precedence, which determines the order in which operators are evaluated. Every Java operator has an associated precedence. Following In
this
is
a
list
of
list
of
all
operators,
the all
Java
the
operators
operators
in
from a
highest
particular
row
to
lowest
have
equal
precedence . precedence.
The precedence level of each row decreases from top to bottom. This means that the [] operator has a higher precedence than the * operator, but the same precedence as the () operator.
.
[]
()
++
-
!
*
/
%
+
-
<<
>>
>>>
<
>
<=
=
!=
~
>=
& ^ && || ?:
Evaluation of expressions still moves from left to right, but only when dealing with operators that have the same precedence. Otherwise, operators with a higher precedence are evaluated before operators with a lower precedence. Knowing thi s, take another look at the sample equation:
x = 2 * 6 + 16 / 4 Before using the left-to-right evaluation of the expression, first look to see whether any of the operators have differing precedence. Here the multiplication (*) and division (/) operators both have the highest precedence, followed by the addition operator (+), and then the assignment operator (=). Because the multiplication and division operators share the same precedence, evaluate them from left to right. Doing this, we first perform the multiplication operation 2 * 6 with the result of 12. Then we perform the division operation 16 / 4, which results in 4. After performing these two operations, the expression looks l ike this:
x = 12 + 4; Because the addition operator has a higher precedence than the assignment operator, we perform the addition operation 12 + 4 next, resulting in 16. Finally, the assignment operation x = 16 is processed, resulting in the number 16 being assigned to the variable x. As we can see, evaluating the expression using operator precedence yields a completely different result. Just to get the point across, take a look at another expression that uses parentheses for grouping purposes:
x = 2 * (11 - 7); Without the grouping parentheses, we w ould perform the multiplication operation first and then the subtraction operation. However, referring back to the precedence list, the () operator comes before all other operators. So the subtraction operation 11 - 7 is performed first, yielding 4 and the following expression:
x = 2 * 4; The rest of the expression is easily resolved with a multiplication operation and an assignment operation to yield a result of 8 in the variable x.
Integer Operators There are three types of operations that can be performed on integers: 1. 2. 3. And relational. Unary
act
operators
Binary Both
unary, binary,
act
operators unary
and
on
binary
on
integer
only
single
pairs operators
of typically
integer
numbers,
integer
numbers.
return
integer
results.
Relational operators, act on two integer numbers but return a Boolean result rather than an integer. Unary and binary integer operators typically return an int type. For all operations involving the types byte, short, and int, the result is always an int. The only exception to this rule is when one of the operands is a long, in which case the result of the operation is also of type long.
Unary Integer Operators Unary integer operators act on a single integer. Lists of the unary integer operators.
The unary integer operators. Description
Operator
Increment
++
Decrement
--
Negation
-
Bitwise complement
~
The increment and decrement operators (++ and --) increase and decrease integer ariables by 1. These operators can be used in either prefix or postfix form. A prefix operator takes effect before the evaluation of the expression it is in; a postfix operator takes effect after the expression has been evaluated. Prefix unary operators are placed immediately before the variable; postfix unary operators are placed immediately following the variable. Following are examples of each type of operator:
y = ++x; z = x--; In the first example, x is prefix incremented, which means that it is incremented before being assigned to y. In the second example, x is postfix decremented, which means that it is decremented after being assigned to z. Here z is assigned the value of x before x is decremented. The IncDec program, which uses both types of operators.
The IncDec class. class IncDec { public static void main (String args[])
{ int x = 8, y = 13; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("++x = " + ++x); System.out.println("y++ = " + y++); System.out.println("x = " + x); System.out.println("y = " + y); } } The IncDec program produces the follow ing results: x=8 y = 13 ++x = 9 y++ = 13 x=9 y = 14
Output The negation unary integer operator (-) is used to change the sign of an integer value.
x = 8; y = -x; In th is e xampl e, x i s a ssi gn ed th e l itera l val ue 8 and then i s ne gat ed a nd a ssi gne d to y. The resulting value of y is -8.
The Negation class. class Negation { public static void main (String args[]) { int x = 8; System.out.println("x = " + x); int y = -x; System.out.println("y = " + y); } }
Output The bitwise complement operator (~), which performs a bitwise negation of an integer value. Bitwise negation means that each bit in the number is toggled. In other words, all the binary 0s become 1s and all the binary 1s become 0s. Example:
x = 8; y = ~x; In this example, x is assigned the literal value 8 again, but it is bitwise complemented before being assigned to y. Well, without getting into the details of how integers are stored in memory, it means that all the bits of the variable x are flipped, yielding a decimal result of -9. This result has to do with the fact that negative numb ers are stored in memory using a meth od known as two's co mplement.
NOTE: Integer numbers are stored in memory as a series of binary bits that can each have a value of 0 or 1. A number is considered negative if the highest-order bit in the number is s et to 1. Because a bitwise complement flips all the bits in a number--including the high-order bit--the sign of a number is reversed.
The Bitwise Compleme nt class. class BitwiseComplement { public static void main (String args[]) { int x = 8; System.out.println("x = " + x); int y = ~x; System.out.println("y = " + y); } }
Output
Binary Integer Operators Binary integer operators act on pairs of integers. Lists of the binary in teger operators.
The binary integer operators. Description
Operator
Addition
+
Subtraction
-
Multiplication
*
Division
/
Modulus
%
Bitwise AND
&
Bitwise OR
|
Bitwise XOR
^
Left-shift
<<
Right-shift
>>
Zero-fill-right-shift
>>>
The Arithmetic program, which shows how the basic binary integer arithmetic operators work.
The Arithmetic class. class Arithmetic { public static void main (String args[]) { int x = 17, y = 5; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("x + y = " + (x + y));
System.out.println("x System.out.println("x System.out.println("x System.out.println("x }
- y = " + (x - y)); * y = " + (x * y)); / y = " + (x / y)); % y = " + (x % y));
} The results of running the Arithmetic program follo w : x y x x x x x
= 17 =5 + y = 22 - y = 12 * y = 85 /y=3 %y=2
Output The bitwise AND, OR, and XOR operators (&, |, and ^) all act on the individual bits of an integer. These operators are sometimes useful when an integer is being used as a bit field.
The Bitwise class. class Bitwise { public static void main (String args[]) { int x = 5, y = 6; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("x & y = " + (x & y)); System.out.println("x | y = " + (x | y)); System.out.println("x ^ y = " + (x ^ y)); } } The output of running Bitwise follows: x y x x x
=5 =6 &y=4 |y=7 ^y=3
In Bitwise, the variables x and y a re set to 5 and 6, which correspond to the binary numbers 0101 and 0110. The bitwise AND operation compares each bit of each number to see whether they are the same. It then sets the resulting bit to 1 if both bits being compared are 1; it sets the resulting bit to 0 otherwise. The result of the bitwise AND operation on these two numbers is 0100 in binary, or decimal 4. The bitwise OR operator sets the resulting bit to 1 if either of the bits being compared is 1. For these numbers, the result is 0111 binary, or 7 decimal.
Finally, the bitwise XOR operator sets resulting bits to 1 if exactly one of the bits being compared is 1 and 0 otherwise. For these numbers, the result is 0011 binary, or 3 decimal. The left-shift, right-shift, and zero-fill-right-shift operators (<<, >>, and >>>) shift the individual bits of an integer by a specified integer amount.
Following are some examples of how these operators are used: x << 3; y >> 7; z >>> 2; In the first example, the individual bits of the integer variable x are shifted to the left three places. In the second example, the bits of y are shifted to the right seven places. Finally, the third example shows z being shifted to the right two places, with zeros shifted into the two leftmost places.
The Shift class. class Shift { public static void main (String args[]) { int x = 7; System.out.println("x = " + x); System.out.println("x >> 2 = " + (x >> 2)); System.out.println("x << 1 = " + (x << 1)); System.out.println("x >>> 1 = " + (x >>> 1)); } } The output of Shift follows: x x x x
=7 >> 2 = 1 << 1 = 14 >>> 1 = 3
Output The number being shifted in this case is the d ecimal 7, which is represented in binary as 0111. The first right-shift operation shifts the bits two places to the right, resulting in the binary number 0001, or decimal 1. The next operation, a left-shift, shifts the bits one place to the left, resulting in the binary number 1110, or decimal 14. The last operation is a zero-fill-right-shift, which shifts the bits one place to the right, resulting in the binary number 0011, or decimal 3.
Relational Integer Operators The last group of integer operators is the relational operators, integers but return a type boolean. Lists of the relational integer operators.
which
The relational integer operators.
Description
Operator
all
operate
on
Less-than
<
Greater-than
>
Less-than-or-equal-to
<=
Greater-than-or-equal-to
>=
Equal-to
==
These operators all perform comparisons betw een integers. The Relational class class Relational { public static void main (String args[]) { int x = 7, y = 11, z = 11; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("z = " + z); System.out.println("x < y = " + (x < y)); System.out.println("x > z = " + (x > z)); System.out.println("y <= z = " + (y <= z)); System.out.println("x >= y = " + (x >= y)); System.out.println("y == z = " + (y == z)); System.out.println("x != y = " + (x != z)); } } The output of running Relational follows: x= 7 y = 11 z = 11 x < y = true x > z = false y <= z = true x >= y = false y == z = true x != y = true
Floating point Operators There are three types of operations that can be performed on floating-point numbers: 1. 2. 3. and relational
unary, binary,
Unary
operators
binary
operators
Both
unary
and
act act binary
only on floating-point
on
single
pairs operators
of
floating-point
numbers,
floating-point
numbers.
return
floating-point
results.
Relational
operators,
act
on
two
floating-point
numbers
but
return
a
boolean
result.
Unary and binary floating-point operators return a float type if both operands are of type float. If one or both of the operands are of type double, however, the result of the operation is of type double.
Unary Floatin g-Point Operators The unary floating point operators act on a single floating-point number. Lists of the unary floatingpoint operators.
The unary floating-point operators. Description
Operator
Increment
++
Decrement
--
The only two unary floating-point operators are the increment and decrement operators. These two operators respectively add and subtract 1.0 from their floating-point operand.
Binary Floating-Point Operators The binary floating-point operators act on a pair of floating-point numbers. Lists of the binary floating-point operators.
The binary floating-point operators. Description
Operator
Addition
+
Subtraction
-
Multiplication
*
Division
/
Modulus
%
The binary floating-point operators consist of the four traditional binary operations (+, -, *, /), along with the modulus operator (%).
The FloatMath class. class FloatMath { public static void main (String args[]) { float x = 23.5F, y = 7.3F; System.out.println("x = " + x); System.out.println("y = " + y); System.out.println("x + y = " + (x + y)); System.out.println("x - y = " + (x - y)); System.out.println("x * y = " + (x * y)); System.out.println("x / y = " + (x / y)); System.out.println("x % y = " + (x % y)); } } The output of FloatMath follows:
x y x x x x x
= 23.5 = 7.3 + y = 30.8 - y = 16.2 * y = 171.55 / y = 3.21918 % y = 1.6
Relational Floating-Poin t Operators The relational floating-point operators compare two floating-point operands, leaving a boolean result.
Boolean Operators Boolean operators act on boolean types and return a boolean result.
The boolean operators Description
Operator
Evaluation AND
&
Evaluation OR
|
Evaluation XOR
^
Logical AND
&&
Logical OR
||
Negation
!
Equal-to
==
Not-equal-to
!=
Conditional
?:
The evaluation operators (&, |, and ^) evaluate both sides of an expression before determining the result. The following code show s how the evaluation AND operator is necessary for the complete evaluation of an expression:
while ((++x < 10) && (++y < 15)) { System.out.println(x); System.out.println(y);
} The three boolean operators--negation, equal-to, and not-equal-to (!, ==, and !=) The negation operator toggles the value of a boolean from false to true or from true to false, depending on the original value. The equal-to operator simply determines whether two boolean values are equal (both true or both false). Similarly, the not-equal-to operator determines whether two boolean operands are unequal. The conditional boolean operator (? :) is the most unique of the boolean operators This operator also is known as the ternary operator because it takes three items: a condition and two expressions. The Condition
syntax
for ?
the
conditional
Expression1
operator :
follows: Expression2
The Condition, which itself is a boolean, is first evaluated to determine whether it is true or false. If Condition evaluates to a true result, Expression1 is evaluated. If Condition ends up being false, Expression2 is evaluated.
The Conditional class class Conditional { public static void main (String args[]) { int x = 0; boolean isEven = false; System.out.println("x = " + x); x = isEven ? 4 : 7; System.out.println("x = " + x); } } The results of the Conditional program follow : x=0 x=7
String Operator Ther e i s on ly one st ri ng opera to r for stri ng s wo rks strings together.
op era to r: th e concat ena ti on ope rator (+) . Th e concat en ati on v er y si mi la rly to th e a ddi ti on opera to r f or numb ers- -i t add s
The Concatenation class class Concatenation { public static void main (String args[]) { String firstHalf = "What " + "did "; String secondHalf = "you " + "say?"; System.out.println(firstHalf + secondHalf); } } The output of Concatenation follow s: What did you say?
In th e Conca tena ti on prog ra m, li tera l stri ng s a re conca tena te d to ma ke as si gn ment s to the two string variables, firstHalf and secondHalf, at time of creation. The two string variables are then concatenated within the call to the println() method.
Assignm ent Operators Assignment operators actually work w ith all the fundamental data types.
The assignment operators
Description
Operator
Simple
=
Addition
+=
Subtraction
-=
Multiplication
*=
Division
/=
Modulus
%=
AND
&=
OR
|=
XOR
^=
Examples:
x += 6; x *= (y - 3); In the first example, x and 6 are added and the result stored in In the second example, 3 is subtracted from y and the result is multiplied by The final result is then stored in x
x. x.
Arithmetic assignment operations 1. 2.
Combine arithmetic and assignment into a single operation to save coding time All five basic arithmetic operation s have a corresponding arithmetic assignment operator .
Operator
Operation
+=
Addition assignment
-=
Subtraction assignment
*=
Multiplication assignment
/=
%=
Division assignment Modulo (remainder) assignment
Example: This program reads a percentage value from the user (such as 5.5) and converts to the correct decimal equivalent (such as 0.055) by using the division assignment operator.
import java.util.*; import java.io.*; public class AppStr { public static void main(String[] args) { // Variable for holding a percentage entered by the user // Prompt for and read the percentage System.out.print("Enter a percentage in n.nn format: "); double percent; Scanner Keyboard = new Scanner(System.in); percent = Keyboard.nextDouble(); //percent = Keyboard.readDouble(); // Convert it to its decimal equivalent and display the result
percent /= 100; System.out.println("The decimal equivalent is " + percent); } }
Conversions Co n ve rs i on i s p er fo rm ed a u to ma ti ca l ly w h e n m i xe d n u me ri c t yp es a pp ea r w i th i n a n expression. Variables and constants are n ot altered, but their values are copied to intermediate areas o f l ar ge r s iz e o r p re ci si on t o p re ve n t p os si bl e d at a l os s d ur in g t he c al c ul a ti on . T h is i s known as a "w idening" conversion. The order of conversion (from narrowest to widest) is as follows. Memorize this table!
The data type resulting from an expression is that of the largest or most precise variable or constant appearing in the expression but is never smaller than int. Example: This program to convert a fah renheit temperature to celsius will NOT compile.
import java.util.*; import java.io.*; public class Conversion { public static void main(String[] args) { // Variables for holding fahrenheit and celsius temperatures float tempC; // Prompt for and read the fahrenheit temperature System.out.print("Enter the fahrenheit temperature (nn.n): "); Scanner Keyboard=new Scanner(System.in); double tempF; tempF= Keyboard.nextDouble(); // Convert to celsius and display the result tempC = 5 * (tempF - 32) / 9;
System.out.println("Celsius equivalent is " + tempC); } } Note: To fix the compile error in this code, tempC must be double or tempF must be float . After Correction changing the tempC into double th e result is.....
Casts
1. Are a programmer's way of telling the compiler to ignore possible loss of data or precision that might result from a conversion? 2. Should be used with caution. Data loss is not to be taken lightly. 3. The general syntax is
identifier = (data-type) expression; Example: This is a corrected version of the previous program that uses a cast to prevent the compile error.
import java.util.*; import java.io.*; public class Application { public static void main(String[] args) { // Variables for holding fahrenheit and celsius temperatures float tempC; // Prompt for and read the fahrenheit temperature System.out.print("Enter the fahrenheit temperature (nn.n): "); Scanner Keyboard=new Scanner(System.in); double tempF; tempF=Keyboard.nextDouble(); // Convert to celsius and display the result tempC = (float) (5 * (tempF - 32) / 9); System.out.println("Celsius equivalent is " + tempC); } }
Some thing on arithmetic expressions Arithmetic expressions can be large and complex with several variables, constants, and operators. The order in which operations are performed is the same as in mathematics (multiplication and division first, then addition and subtraction, working from left to right). To avoid confusion, good programmers keep their expressions as simple as possible and use parenthesis for clarity.
Boolean expressions and operations
Boolean expressions 1. Always result in a boolean value (either true or false) 2. Are used to resolve logic questions, such as determining if two variables have the same value? 3. May contain several different operators?
Comparison operators 1. Used to compare the values of two variables or constants 2. Require that the two operands be either both numeric (including char) or both boolean. A numeric value cannot be compared to a boolean value. 3. Frequently appear in if, for, while, and do-while statements (to be covered later)
Operator
Operation
<
Less than
<=
Less than or equal
>
Greater than
>=
Greater than or equal
==
Equal
!=
Not equal
Example: This program reads two numeric values from the user and displays the result of several comparisons involving the two numbers.
import java.util.*; import java.io.*; public class Aman { public static void main(String[] args) { // Variables for holding two numeric values entered by the user int x; double y; // Prompt for and read the two numeric values System.out.print("First number (integer): "); Scanner Keyboard=new Scanner(System.in); int x; x=Keyboard.nextInt((); System.out.print("Second number (floating-point): "); Scanner Keyboard=new Scanner(System.in); double y; y=Keyboard.nextDouble(); // Display information comparing the two values System.out.println(" System.out.println(" System.out.println(" System.out.println("
" " " "
+ + + +
x x x x
+ + + +
" " " "
<" <= >" >=
+y+" "+y+ +y+" "+y+
is " " is is " " is
+ (x "<" y)); " + (x <= y)); + (x > y)); " + (x >= y));
System.out.println(" " + x + " == " + y + " is " + (x == y)); System.out.println(" " + x + " != " + y + " is " + (x != y)); } }
Logical operators 1. Combine the results of two Boolean expressions into a single boolean value 2. Provide for complex logic. The following table shows the operators and how they can be used to combine the results of two Bool ean expressions X and Y:
Operator
Operation
Resulting value true if...
X and Y always evaluated?
&
AND
X and Y are both true
Yes
|
OR
either X or Y is true
Yes
^
XOR (exclusive OR)
X and Y have different values
Yes
&&
Conditional AND
X and Y are both true
No
||
Conditional OR
either X or Y is true
No\
The conditional AND ( && ) and OR ( || ) are sometimes called "short-circuit" operators because the second operand is not always evaluated depending on the value of the first operand. If the first operand is false, the result of an AND will always be false regardless of the value of the second operand. If the first operand is true, the result of an OR will always be true regardless of the value of the second operand. Example: The following program uses two values entered by the user to determine if a customer is entitled to free shipping. A customer receives free shipping if their order amount is greater than or equal to 100 and they are a pref erred customer.
import java.util.*; import java.io.*; public class Aman { public static void main(String[] args) { // Variables for holding order amount and valued customer data to be // entered by the user
// Variables for holding information about free shipping boolean isFree; // Prompt for and read order amount and valued customer data System.out.print("Order amount (floating-point): "); Scanner Keyboard= new Scanner(System.in); double amount; amount =Keyboard.nextDouble(); System.out.print("Valued customer? (Y)es or (N)o: "); Char valuedCust; valuedCust = Keyboard.nextChar(); // Determine and display information about free shipping. // Shipping is free if the order amount is greater than or equal $100 // AND the customer is a va lued customer.
isFree = (amount >= 100 && (valuedCust == 'Y' || valuedCust == 'y')); System.out.println(" Free shipping? " + isFree); } }
Certain logical operators can be combined w ith assignment 1. The operators are &= (AND equals), |= (OR equals), and ^= (XOR equals) 2. The left operand must be boolean
Example: The following program reads a boolean value from the user and displays its opposite value.
public class AppCer { public static void main(String[] args) { // Variable for holding a boolean value entered by the user boolean value; // Prompt for and read the boolean value System.out.print("Enter a boolean value (true or false): "); value = Keyboard.readBoolean(); // Determine the opposite value. If the value is false, XOR with // true results in true. If the value is true, XOR with true results // in false. value ^= true; // Display the new value of the value. System.out.println(" The opposite value is " + value); } } ***try this yourself
Bitwise operations Bitwise operations act upon individual bits within integer data. They are used to perform the logical operations AND, OR, and XOR (eXclusive OR), complementing (reversing all bits), and shifting (sliding bits to the left or right).
Logical bitwise operations 1. Use the standard boolean operators (&, |, and ^) to act upon two integer values. The short-circuit boolean operators (&& and ||) are not used for bitwise operations and will result in a compile error if attempted. 2. Produce an integer result (of size int or larger) that is the logical AND, OR, or XOR of two operands.
The rules for these operations are as follow s: Operation
Rule
&
If both corresponding operand bits are "on" the result bit is "on"
|
If either corresponding operand bit is "on" the result bit is "on"
^
If corresponding operand bits are different the result bit is "on"
The complement operator 1. Is unary (has a single operand)? 2. Uses the ~ operator to "flip" (reverse) the bits within an integer value. If a bit is "on" it is turned "off". If a bit is "off" it is turned "on". For example,
if byte a = 17; // Binary value: 0001 0001 Hex value: 11 byte b; after executing the statement b = (byte) ~a; variable b will have a value of -18 (because 0001 0001 reverses to 1110 1110). Once again, the cast is needed in order to store th e int value that results from the o peration. Example: The following program can be run to test complement operations.
import java.util.*; import java.io.*; public class Aman { public static void main(String[] args) { // Variable to be read from the user
// Prompt for and read an integer value System.out.print("Integer: "); Scanner Keyboard=new Scanner(System.in); int number; number=Keyboard.nextInt();
// Display the result of complementing the number System.out.println(" ~" + number + " = " + ~number); } }
D e ci s i o n m a k i n g , Br a n c h i n g a n d L o o p i n g Flow control w ith if and else The i f a nd e l se statements allow a block of code or a single statement to be ither executed or bypassed depending upon the result of a comparison operation.
They are an essential part of Java "flow control" by which execution may proceed along alternate logic paths within a program.
The if statement 1. Identifies a single statement or a block of statements to be executed if an expression evaluates to true. 2. Have two forms. The general syntax is either of the following:
if (expression) statement; or if (expression) { statements; }
The first form is often referred to as a "single statement if" . For example,
if (amountDue > 0) System.out.println("You owe " + amountDue); will display the message only if the value of amountDue is greater than zero. The logic path merges at the next statement in the program. The second form is often referred to as a "multiple statement if" . For example,
if (amountDue > 0) { totalDueFromAllCustomers += amountDue; System.out.println("You owe " + amountDue); } will add to the grand total and display the message only if the value of amountDue is greater than zero. The logic path merges at the first statement after the end of the statement block. 3) Can lure unsuspecting programmers into some nasty errors. For example,
if (amountDue > 0); System.out.println("You owe " + amountDue); will display the message no matter what value amountDue has.
The else statement 1) Defines an alternative and mutually exclusive logic path to be followed if the preceding if statement expression evaluates to false 2) Must always be paired with, and follow, an if statement. It can never be coded separately 3) Have two forms.
The general syntax is either of the following:
else statement; or else { statements; } The first form is often referred to as a "single statement else" . For example,
if (amountDue > 0) System.out.println("You owe " + amountDue); else System.out.println("You owe nothing"); will add to the grand total and display how much is owed if amountDue is greater than zero. Otherwise, the customerRating will be set to 'A' and the "You owe nothing" message will be displayed. The two logic paths are mutually exclusive and merge at the first statement after the end of the else block. 4) Can trap programmers who get sloppy. For example,
if (age < 65) System.out.println("Regular admission"); else; System.out.println("Senior admission"); will always display the "Senior admission" message no matter what value age has. The accidental semicolon after the else says that if the expression is false you want to do nothing. Logic then merges at the next statement, so the messag e is always displayed.
Nesting It is An if or an if-else can be coded within an if or an if-else. Example:
import java.util.*; import java.io.*; public class Aman { public static void main(String[] args) { System.out.print("Enter age: "); Scanner Keyboard= new Scanner(System.in); int age; age=Keyboard.nextInt(); if (age >= 10) { if (age < 65)
permitted.
{ System.out.println("$5 admission"); } else { System.out.println("$4 admission"); } } else { if (age < 5) { System.out.println("Free admission"); } else { System.out.println("$2 admission"); } } } }
Notes: 1. The program prompts for and reads a person's age from the user. 2. Based upon the value of age, it displays a different admission fee (under 5 is free, 5-17 is 2 dollars, 18-64 is 5 dollars, and 65 and over is 4 dollars).
Switch statements Flow control with if and else statements gets cumbersome when a variable must be tested for a large number of possible values, such as a menu selection that permits the user to enter an integer from 1 to 20. The solution to this problem is the switch statement.
The sw itch statement 1) Specifies an expression whose value is be tested. This is known as the "switch expression" and is typically the name of a single variable. 2) Defines a number of "cases", each associated with a different value. There may also be a "default" case that is not associated with a value. If the value of the switch expression is equal to the value of a case, the statements for that case will be executed. Otherwise, the statements of the default case will be executed. 3) General syntax:
switch (expression) { case value1: statements; break; case value2: statements; break; default: statements;
break; } It has a number subtleties and restrictions: 1. The switch expression must be a primitive of type int or able to be promoted to int. Specifically, it must be either byte, short, int, or char. Expressions of type boolean, long, float, and double will not compile. 2. The value specified on a case must be a constant of type int or must be able to be promoted to int (in other words a byte, short, int, or char). It must also be within the possible range of values of the switch expression. For example, if the switch variable is a byte, a case with a value of 200 would not compile because a byte may only have a value from -128 to 127. The value of a case may be an expression as long as the result is a constant. For example, case 5 + 1: would compile successfully. 3. The break statement is optional and will be covered in more detail in a later lesson. When encountered, it ends the execution of the switch statement. If omitted from a case, processing falls through to the next case (a sometimes undesirable result). 4. Although the compiler doesn't care, cases should be arranged in a high probability to low probability order to enhance processing efficiency. The default can be placed anywhere (even first). It may be nested. A switch can be coded within another switch or in either leg of an if-else. It can also contain if-else code. Example:
import java.util.*; import java.io.*; import java.lang.*; public class Aman { public static void main(String[] args) { // Variables // Prompt for and read data System.out.print("Enter customer's starting balance: "); Scanner Keyboard=new Scanner(System.in); Double balance; balance = Keyboard.readDouble(); System.out.print("Enter transaction amount: "); double amount; amount = Keyboard.readDouble(); System.out.println("Transaction codes are"); System.out.println(" " + "C - charge"); System.out.println(" " + "P - payment"); System.out.println(" " + "R - refund or return"); System.out.print("Enter transaction code: "); char code; code = Keyboard.readChar(); // Process based upon transaction code
switch (code) { case 'C': case 'c': balance += amount; System.out.println("New balance is " + Utility.moneyFormat(balance)); break; case 'P': case 'p': balance -= amount; System.out.println("New balance is " + Utility.moneyFormat(balance)); break; case 'R': case 'r': balance -= amount; System.out.println("New balance is " + Utility.moneyFormat(balance)); break; default: System.out.println("Invalid transaction code"); break; } } } ***try it with the help of under given suggestion. Notes: 1. The balance, code, and amount variables hold data entered by the user. 2. After all data has been read from the user, the transaction is processed by the switch statement with the transaction code (code) used as the switch expression. 3. Within the switch, if the value of code matches the value of a particular case, processing jumps to the statement block for that case, otherwise processing jumps to the statement block for the default. Processing will then continue until either a break statement is encountered or the end of the switch is reached. 4. Stacking two or more cases without at break statement constitutes an OR. For example,
case 'R': case 'r': will result in the same processing being performed if the value of code is either an uppercase or lowercase 'R'. 5. For transactions with a valid transaction code, the customer's new balance is displayed using the moneyFormat() method of my Utility class. If the transaction code is bad, an error message is displayed.
for, while, and do-w hile statements The ability to "loop" by executing one or more statements repetitively is an important part of programming. Loops reduce the number of statements a programmer must code and result in a smaller, more memory efficient program. In Java, looping is performed using the for, while, and do-while statements.
The for statement 1) It is useful when the number of passes (iterations) can be predetermined The general syntax
for (initialization; condition; update) { statements; } where:
initialization - represents the declaration of one or more local variables of the same data type. When loop processing is complete, all such variables are destroyed.
condition - represents a binary expression that, if true, allows the loop to continue. The condition is tested prior to each iteration. If no longer true, processing continues at the first statement after the closing brace of the for loop.
update - represents one or more expressions to be executed at the end of each iteration. The braces may be omitted if the loop consists of a single statement. This would constitute a "single statement for loop". Example 1: Counting to 10 with a local variable
for (int i = 1; i <= 10; i++) System.out.println(i); This is a single statement for loop. Local variable i is initialized to 1 before the first iteration and is used for loop control (its value determines when the loop will end). As long as i is less than or equal to 10, looping will continue. At the end of each iteration, i is incremented. Within each iteration, the current value of i is displayed. When the condition is no longer true, processing will continue at the next statement in the program and variable i will be destroyed. Example 2: Counting to 10 without a local variable
Counting to 10 without a local variable int i = 1; for (; i <= 10; i++) System.out.println(i); System.out.println("Now i is " + i); Here loop control variable i is initialized outside the loop, it will not be destroyed when the loop completes. Its final value (which will be 11) is displayed by the statement after the loop. Notice that when no initialization expression is coded, a place holding semicolon is still required. Example 3: Coding multiple initialization and update expressions
for (int i = 1, j = 10; i <= 10; i++, j--) System.out.println(i + " x " + j + " = " + (i * j)); This loop initializes two local variables, i and j, of the same data type before the first iteration. At the end of each iteration, i is incremented and j is decremented. Within each iteration, the product
of i and j is displayed. Notice that commas are used to separate multiple initialization and update expressions. It can be nested. For example, the following program generates a simple 9 x 9 multiplication table:
import java.io.*; public class Aman { public static void main(String[] args) { // This outer loop generates one row of the multiplication // table during each iteration. for (int row = 1; row <= 9; row++) { // This inner loop generates one column of the current row // of the multiplication table during each iteration. for (int column = 1; column <= 9; column++) { // If a one digit number is about to be displayed, preceed it // with four spaces. Otherwise, preceed it with three spaces. if ((row * column) < 10) { System.out.print(" "); } else { System.out.print(" "); } // Display the number. System.out.print((row * column)); } // End the current line. System.out.print(" "); } } }
The whi le statement 1) It Defines a block of code to be executed as long as a particular condition is met. The condition is tested prior to each iteration. It has the general syntax
while (condition) { statements; } where condition represents a binary expression that, if true, permits an iteration of the loop. If no longer
true, processing continues at the first statement after the closing brace of the whil e loop. The braces may be omitted if the loop consists of a single statement. This would constitute a "single statement while loop" . 1) It does not provide for initialization of variables or automatic update expressions. In spite of these limitations, a while loop can be used in place of nearly any for loop as shown by these examples: Example 1: Counting to 10 without a local variable
int i = 1; while (i <= 10) { System.out.println(i); i++; } Loop control variable i is initialized outside the loop. Prior to each iteration, the value of i is tested to determine if it is still less than or equal to 10. If so, the current value of i is displayed and i is incremented. Otherwise processing will jump to the first statement after the closing brace of the loop. Example 2: An endless loop
while (true) System.out.println("I won't end"); This is the preferred technique for launching an endless loop. Example 3: A small program using nested while loops to generate a 9 x 9 multiplication table:
import java.io.*; public class Aman { public static void main(String[] args) { // Initialize the row number. int row = 1; // This outer loop generates one row of the multiplication // table during each iteration. while (row <= 9) { // Initialize the column number. int column = 1; // This inner loop generates one column of the current row // of the multiplication table during each iteration. while (column <= 9) { // If a one digit number is about to be displayed, preceed it // with four spaces. Otherwise, preceed it with three spaces.
if ((row * column) < 10) { System.out.print(" "); } else { System.out.print(" "); } // Display the number. System.out.print((row * column)); // Increment the column number. column++; } // End the current line. System.out.print(" "); // Increment the row number. row++; } } }
The do-while statement 1) It defines a block of code to be executed as long as a particular condition is met. The condition is tested at the end of each iteration. It always guaranteed at least one pass through a do-while loop.
syntax do { statements; } while (condition); where condition represents a binary expression that, if true, permits another iteration of the loop to be performed. If no l onger true, processing continues at the next statement. The braces may be omitted if the loop consists of a single statement. This would constitute a "single statement do-while loop". It can be used in place of nearly any while loop as shown b y these examples: Example 1: Counting to 10 without a local variable
int i = 1; do { System.out.println(i); i++; } while (i <= 10); Loop control variable i is initialized outside the loop. Within the loop, the current value of i is displayed and i is incremented. At the end of each iteration, the value of i is tested to determine if it
is still less than or equal to 10. If so, the body of the loop is repeated. Otherwise processing will jump to the next statement. Example 2: An endless loop
do { System.out.println("I won't end"); } while(true); Example 3: A small program using nested do-while loops to generate a 9 x 9 multiplication table
import java.io.*; public class Aman { public static void main(String[] args) { // Initialize the row number. int row = 1; // This outer loop generates one row of the multiplication // table during each iteration. do { // Initialize the column number. int column = 1; // This inner loop generates one column of the current row // of the multiplication table during each iteration. do { // If a one digit number is about to be displayed, preceed it // with four spaces. Otherwise, preceed it with three spaces. if ((row * column) < 10) { System.out.print(" "); } else { System.out.print(" "); } // Display the number. System.out.print((row * column)); // Increment the column number. column++; } while (column <= 9); // End the current line.
System.out.print(" "); // Increment the row number. row++; } while (row <= 9); } }
Using break and continue At times, it is desirable to exit from a loop or short-circuit the current iteration of a loop. The break and continue statements make it happen.
The break statement 1) Can only appear within a loop or a switch statement. 2) Causes an immediate exit from a loop structure before the test condition is met. Once a break statement is encountered, the loop immediately terminates, skipping any remaining code. For example,
for (int x = 0; x < 10; x++) { if (x == 5) break; else System.out.print(" " + x); } will end prematurely when x takes on a value of 5. The output displayed wil l be:
01234 3) It may specify the label of the loop to be abandoned. This makes it possible to abandon a specific loop. For example,
outer: for (int i = 1; i <= 5; i++) { for (int j = 5; j >= 1; j--) { if (i == j) break outer; else System.out.println("i = " + i + ", j = " + j); } } will end the outer loop when i equals j. The output displayed wil l be:
i i i i
= = = =
1, 1, 1, 1,
j j j j
= = = =
5 4 3 2
4) It causes an immediate exit from a switch, skipping any remaining code. For example, if key is a char variable having a value entered by the user, the following statements will display w hether they entered an 'A' or a 'B':
switch (key) { case 'a': case 'A': System.out.println("You entered an 'A'"); break; case 'b': case 'B': System.out.println("You entered a 'B'"); break; default: System.out.println("You did not enter an 'A' or a 'B'"); break; }
The continue statement 1) Can only appear within a loop. 2) Skips all remaining statements within the loop and resumes with the next iteration. For example,
for (int x = 0; x < 10; x++) { if (x == 5) continue; else System.out.print(" " + x); } will short-circuit when x takes on a value of 5. The output displayed wil l be:
012346789 3)It may specify the label of the loop to be continued. This makes it possible to skip to the next iteration of the specified loop. For example,
outer: for (int i = 1; i <= 5; i++) { for (int j = 5; j >= 1; j--) { if (i == j) continue outer; else System.out.println("i = " + i + ", j = " + j); } } will short-circuit to the next iteration of the loop labeled outer when i equals j. The output displayed wil l be:
i = 1, j = 5
i i i i i i i i i
= = = = = = = = =
1, 1, 1, 2, 2, 2, 3, 3, 4,
j j j j j j j j j
= = = = = = = = =
4 3 2 5 4 3 5 4 5
Cl a s s O b j e c t a n d M e t h o d In troduction to Classes Definition: A class is a blueprint or prototype that defines the variables and methods common to all objects of a certain kind.
The Benefit of Classes Objects provide the benefit of modularity and information hiding. Classes provide the benefit of reusability. Software programmers use the same class, and thus the same code, over and over again to create many objects.
Defining Classes To define a class, we use the class keywo rd and the name of the class:
class MyClassName { ... } By default, classes inherit from the Object class. If this class is a subclass of another specific class (that is, inherits from another class), use extends to indicate the superclass of this class:
class myClassName extends mySuperClassName { ... }
Following is the code for a class called SimplePoint that represents a point in 2D space:
public class SimplePoint { public int x = 0; public int y = 0; } This segment of code declares a class-- a new data type really-- called SimplePoint. The SimplePoint class contains two integer member variables, x and y. The public keyword preceding the declaration for x and y means that any other class can f reely access these two members. We create an object from a class such as SimplePoint by instantiating the class. When we create a new SimplePoint object space is allocated for the object and its members x and y. In addition, the x and y members inside the object are initialized to 0 because of the assignment statements in the declarations of these two members.
Ex :
public { public public public }
class SimpleRectangle int width = 0; int height = 0; SimplePoint origin = new SimplePoint();
Here the segment of code declares a class SimpleRectangle-- that contains t wo integer members, width and height. SimpleRectangle also contains a third member, origin, whose data type is SimplePoint. Here the class name SimplePoint is used in a variable declaration as the variable's type. We can use the name of a class anywhere we can use the name of a primitive type. As with SimplePoint, when we create a new SimpleRectangle object, space is allocated for the object and its members, and the members are initialized according to their declarations. The initialization for the origin member creates a SimplePoint object with this code: new SimplePoint() as illustrated here:
This diagram shows the difference between primitive types and reference types
Class using constructor Here's a of SimpleRectangle, called Rectangle, that contains four constructors, a method to "move" the rectangle, a method to compute the area of the rectangle, and a finalize method to provide for clean up:
public class Rectangle { public int width = 0; public int height = 0; public Point origin; // four constructors public Rectangle() { origin = new Point(0, 0); } public Rectangle(Point p) { origin = p ; } public Rectangle(int w, int h) { this(new Point(0, 0), w, h); } public Rectangle(Point p, int w, int h) { origin = p ; width = w; height = h; } // a method for moving the rectangle public void move(int x, int y) { origin.x = x; origin.y = y; } // a method for computing the area of the rectangle public int area() { return width * height; } // clean up! protected void finalize() throws Throwable { origin = null; super.finalize(); }
} Here the four constructors allow for different types of initialization.
Object An object is a distinct instance of its class (an actual occurrence). It has its own set of variables (known as "instance variables") and methods (known as "instance methods"). When called, an object's instance methods automatically act upon its instance variables Java program creates many objects from a variety of classes. These objects interact with one another by sending each other messages. Through these object interactions, a Java program can implement a GUI, run an animation, or send and receive information over a network. Once an object has completed the work for which it was created, it is garbage-collected and its resources are recycled for use by other objects.
Creating Objects In Java, we create an object by creating an instance of a class or, in other words, instantiating a class. Ex :
Rectangle rect = new Rectangle();
The above single statement performs three actions: 1. Declaration: Rectangle rect is a variable declaration that declares to the compiler that the name rect will be used to refer to a Rectangle object. Here a class name is used as the variable's type. 2. Instantiation: new is a Java operator that creates the new object (allocates space for it). 3. Initialization: Rectangle() is a call to Rectangle's constructor, which initializes the object.
Declaring an Object Like other variable declarations, object declarations can also appea r alone, like this: Rectangle rect; Declarations notify the compiler that you will use name to refer to a variable whose type is type. Declarations do not create new objects. Rectangle rect does not create a new Rectangle object, just a variable named rect to hold a Rectangle object. To create a Rectangle object, or any other object, use the new operator.
Instantiating an Object The new operator instantiates a class by allocating memory for a new object of that type. new requires a single, postfix argument: a call to a constructor. Each Java class provides a set of constructors used to initialize new objects of that type. The new operator creates the object, and the constructor initializes it. Here's an example of using the new operator to create a Rectangle object:
new Rectangle(100, 200);
Here, Rectangle(100, 200) is the argument to n ew. The new operator returns a reference to the newly created object. This reference can be assigned to a variable of the appropriate type, as here.
Rectangle rect = new Rectangle(100, 200);
Ini tializing an Object The classes can provide one or more constructors to initialize a new object of that type. We can recognize a class's constructors because they have the same name as the class and have no return type. Here are the declarations for Rectangle's constructors:
public public public public
Rectangle(Point p) Rectangle(int w, int h) Rectangle(Point p, int w, int h) Rectangle()
If a class has multiple constructors, they all have the same name but a different number of arguments or different typed arguments. The compiler differentiates the constructors, and knows which one to call, depending on the arguments.
Using Objects Objects give us two w ays to do these things: 1. Manipulate or inspect its variables. 2. Call i ts methods.
Java provides an access control mechanism whereby classes can restrict or allow access to its variables and methods. A class should protect variables against direct manipulation by other objects if those manipulations could endanger the object's state. State changes should then be affected and therefore controlled by method calls.
Referencing an Object's Variables Assume we create a rectangle named rect as described in the previous section. To move rect to a new location, we w ould write:
rect.origin = new Point(15, 30); This statement moves the rectangle by setting its point of origin to a new position. rect.origin is the name of rect's origin variable. The Rectangle class has two other variables-- width and height-- that are accessible to objects outside of the class. We can use the same notation to access them and calculate the rectangle's area using this statement
area = rect.height * rect.width;; In general, to refer to an object's variables, append the name of the variable to an object reference with an intervening period (.):
objectReference.variable
The first part of the variable's name, objectReference, must be a reference to an object.
Calling an Object's Methods To move rect to a new location using its move method, we w rite this: rect.move(15, 30); This Java statement calls rect's move method with two integer parameters, 15 and 30. It moves the rect object because the rect method assigns new values to origin.x and origin.y, and is equivalent to the assignment statement used previously:
rect.origin = new Point(15, 30);
The notation used to call an object's method is similar to that used when referring to its variables: we append the method name to an object reference with an intervening period (.). Also, we provide any arguments to the method within enclosing parentheses. If the method does not require any arguments, use empty parentheses.
objectReference.methodName(argumentList); or objectReference.methodName();
Creating Classes The diagram lists the class and identifies the structure of th e code.
The Class Declaration
public The public modifier declares that the class can be used by any class regardless of its package.
abstract Declares that the class cannot be instantiated.
final Declares that the class cannot be subclassed.
class Name Of Class The class keyword indicates to the compiler that this is a class declaration and that the name of the class is NameOfClass.
extends Super The extends clause identifies Super as the superclass of the class, thereby inserting the class within the class hierarchy
implements Interfaces To declare that our class implements one or more interfaces, use the keyword implements followed by a comma-delimited list of the names of the interfaces implemented by the class
The Class Body The class body contains all of the code that provides for the life cycle of the objects created from it: 1. constructors for initializing new objects, 2. declarations for the variables that provide the state of the class and its objects, 3. methods to implement the behavior of the class and its objects, 4. And a finalize method to provide for cleaning up an object after it has done its job.
Variables and methods collectively are called members. Constructors are not m ethods. Nor are they mem bers.
Constructors for Classes All Java classes have constructors that are used to initialize a new object of that type. A constructor has the same name as the class. For example, The name of the Stack class's constructor is Stack, the name of the Rectangle class's constructor is Rectangle, and the name of the Thread class's constructor is Thread. Stack defines a single constructor:
public Stack() { items = new Vector(10); } A constructor uses its arguments to initialize the new object's state. When creating an object, choose the constructor whose arguments best reflect how we want to initialize the new object. When declaring constructors for our class, we use the following access specifiers in the constructor declaration to specify what other objects can create instances of our class:
private No other class can instantiate our class. Our class may contain public class methods (sometimes called factory methods), and those methods can construct an object and return it, but no other classes can.
protected Only subclasses of our class can c reate instances of it.
public Any class can create an instance of our class.
package Only classes within the same package as our class can construct an instance of it. Constructors provide a way to initialize a new object.
Implementing Methods Methods 1. Are named modules of code 2. May optionally receive one or more parameters (arguments) 3. May optionally return a single value 4. Are associated with either a class or an object of a class. The former are called "class methods" and are the focus of this lesson. The latter are called "instance methods" and will be covered in a later lesson.
Calling a class method • Involves the following general syntax for the call expression:
class-name.method-name(arguments) If the method is defined within the current class, the class name may be omitted and the general syntax for the call expression is:
method-name(arguments)
• Can occur anyw here the returned data type makes sense. Methods that return no value are called in a stand-alone statement. Methods that return a value are called within another expression. This method pushes an object, the one passed in as an argument, onto the top of the stack, and returns it.
Like a class, a method has two major parts: 1. method declaration 2. And method body.
The method declaration defines all of the method's attributes, such as access level, return type, name, and arguments, as illustrated here:
The method body is where all the action takes place. It contains the Java instructions that implement the method.
The Method Declaration At minimum, a method declaration has a name and a return type indicating the data type of the value returned by the method:
returnType methodName() { ... }
The Method Body The method body is w here all of the action of a method takes place; the method body contains all of the legal Java instructions that implement the method.
Returning a Value from a Method We declare a method's return type in its method declaration. Within the body of the method, we use the return operator to return the value. Any method that is not declared void must contain a return statement. The Stack class declares the isEmpty method, which returns a boolean:
public boolean isEmpty() { if (items.size() == 0) return true; else return false; }
The data type of the return value must match the method's return type; we can't return an Object type from a method declared to r eturn an integer. The isEmpty method returns either the boolean value true or false, depending on the outcome of a test. The isEmpty method returns a primitive type. Methods also can return a reference type. For example, Stack declares the pop method that returns the Object reference type:
public synchronized Object pop() { int len = items.size(); Object obj = null; if (len == 0)
throw new EmptyStackException(); obj = items.elementAt(len - 1); items.removeElementAt(len - 1); return obj; }
A Method's Name Java supports method name overloading so that multiple methods can share the same name. For example
class DataRenderer { void draw(String s) { ... } void draw(int i) { ... } void draw(float f) { ... } }
Overloaded methods are differentiated by the number and type of the arguments passed into the method. In the code sample, draw( String s) and draw(int i) are distinct and unique methods because they require different argument types. We cannot declare more than one method with the same name and the same number and type of arguments because the compiler cannot differentiate them. So, draw(String s) and draw(String t) are identical and result in a compiler error. A class may override a method in its superclass. The overriding method must have the same name, return type, and parameter list as the method it overrides.
Example of the Math class Different methods in the Math Class:
Sample programs The following small samples will help us understand how easy it is to use the class methods of the Math class: Example 1: Performing some miscellaneous mathematical calculations on a number
public class AppMath { public static void main(String[] args) { double x; char again; do { Utility.separator(50, '~'); System.out.print("Enter a number: "); x = Keyboard.readDouble(); Utility.skip(); System.out.println(" Ceiling = " + Math.ceil(x)); System.out.println(" Floor = " + Math.floor(x)); System.out.println(" Rounded = " + Math.round(x)); System.out.println(" Squared = " + Math.pow(x, 2)); System.out.println(" Square root = " + Math.sqrt(x)); Utility.skip(); System.out.print("Again? (Y/N): "); again = Keyboard.readChar(); }
while (again == 'Y' || again == 'y'); } }
A r r a y a n d St r i n g Arrays Introduction An array is a collection of items. Each slot in the array can h old an object or a primitive value. Arrays in Java are objects that can be treated just like other objects in the l anguage. An array is an indexed table of like values. While they can exist in more than one dimension, we are only interested in one-dimensional arrays as depicted by the following:
This array consists of five elements w here each is an integer value (217, 138, 92, 12, and 168).
To access a particular element within an array, its corresponding index (offset) is used. For example, the integer value at index location 3 within this array is 12. Notice that the indexes are zero based because the offset of the first element is always zero (you don't have to skip over any other elements to get there). While all programming languages include the ability to process arrays, Java provides enhanced integrity and other features not found in other languages.
Java arrays Java array require that all elements be of th e same data type. For example, We may create an array of char values, or an array of float values, or an array of boolean values, etc...
Java array are objects and must be declared like one. The general syntax is as follows:
data-type[] identifier = new data-type[n]; or data-type identifier[] = new data-type[n]; Where identifier is the array (object) reference and n is an integer expression that specifies how many elements are in the array. For example,
int[] myArray = new int[5]; Alternatively, a programmer may split the definition of the array reference and the instantiation of the array into two statements as follows:
int[] myArray; myArray = new int[5];
Using either technique, it is important to understand what is created. The following diagram may help:
The array reference (myArray) can be thought of as pointing to the array whose elements reside on the memory heap. Notes: 1. At the time an array reference is declared, it initially contains null (it doesn't point to anything). It doesn't receive a value until an array is assigned to it. 2. An array reference can only be assigned an array of the correct type. In the above example, myArray is declared to be a reference to an int array, so only an array of int values can ever be assigned to it. To attempt otherwise will result in a compile error. 3. An array reference may be reused to point to a different array (of the appropriate type). Like all objects, however, an array that can no longer be r eferenced will be garbage collected. 4. When instantiated, all array elements are automatically initialized to binary zeros. This means all elements of numeric arrays will be zero, all elements of boolean arrays will be false, and all elements of char arrays will be the null character.
Java array can be constructed from a value list. This is an alternative construction technique as shown by
char[] chars = {'a', 'b', 'c'}; This creates a three element array of characters. The first element is initialized to 'a', the second is initialized to 'b', and the third is initialized to 'c'. Notes: 1. The number of elements in the array is determined by the number of values in the list and the new keyword isn't coded. 2. When a value list is used, it can only be coded in the statement that declares the array reference.
In other words, the follow ing will not compile:
char[] chars; chars = {'a', 'b', 'c'};
Java array permit an element to be accessed via its unique index. For example,
int[] numbers = {12, 15, 3, 8 };
The following expression wil l reference the third element (an int wi th a value of 3)
numbers[2] Notes: 1. An index must be int or able to be widened to int to avoid a compile error. It may not be boolean, long, float, or double. 2. If an index is negative of exceeds the maximum valid index for the array, a runtime error occurs. The JVM will throw an ArrayIndexOutOfBoundsException. Catching and processing such exceptions is a topic in advanced Java.
Java array have a publicly available length field. This is an int constant representing the number of elements within the array. It is extremely useful when coding a loop to process all the elements within an array. For example, The following small program creates an array, loads it with some random numbers, and displays the array's contents:
public class AppArr { public static void main(String[] args) { double[] values = new double[10]; for (int i = 0; i < values.length; i++) { values[i] = Math.random(); } for (int i = 0; i < values.length; i++) { System.out.println(values[i]); } } }
Notes: 1. In an array object, length is a field and NOT a method. A common mistake is to code length() as you would with a String or StringBuffer object and get a compile error. 2. Because the for loops are limited by the length of the array, the code is very flexible. Changing the number of elements in the array declaration is all that is needed to work with a different sized array.
Object arrays Object array are declared with the class name as the type. For example
String[] names = new String[5];
Constructs an array of 5 String object references. It is important to understand that no String objects are created by this declaration. We have simply created an array of null object references which may later be assigned to individual String objects (as shown by the following diagram).
The statement
names[3] = new String("Hello World!"); would instantiate a String object and assign it to the fourth element in the names array (which would look like the following).
To display the value of this particular String object, one might code
System.out.println(names[3]); which retrieves the String object referenced b y the fourth element in the names array. Object array are arrays of object references. Each element is either the reference of an instantiated object or is null. The general syntax to access an instance method of the object being referenced is
array-identifier[index].method-name(arguments) For example, To determine the length of the encapsulated string in the fourth element of the names array one would code the expression
names[3].length() Object array can result in runtime errors if improperly used. In addition to an ArrayIndexOutOfBoundsException, it is possible for a NullPointerException to occur if an attempt is made to reference an object when the object reference is null. Example: Attempting to call an i nstance method of an object that doesn't exist.
public class AppObj { public static void main(String[] args) { String[] names = new String[5]; System.out.println("Length of first string: " + names[0].length()); } }
Object array can be constructed from a value list. This requires the instantiation or the existence of the objects to be referenced by each array element. For example,
String aString = new String("def"); String[] x = {new String("abc"), aString, "xyz"};
creates a three element array of String object references. The first element references a String object having the value " abc ", the second element references a String object having the value " def ", and the third references the String object in the literal pool having the value " xyz ".
Strings A sequence of character data is called a string and is implemented in the Java environment by the String class (a member of the java.lang package). The character-counting program uses Strings in two different places. The first is in the definition of the main() method:
String[] args This code explicitly declares an array, named args, that contains String objects. The empty brackets indicate that the length of the array is unknown at compilation time because the array is passed in at runtime. The second use of Strings in the example program is these two uses of literal strings (a string of characters between double quotation marks " and "):
"Input has " ... " chars." The compiler implicitly allocates a String object when it encounters a literal string. So, the program implicitly allocates two String objects one for each of the two literal strings shown previously.
String String[] arrayOfStrings = new String[10]; The elements in this array are reference types, that is, each element contains a reference to a String object.
At this point, enough memory has been allocated to contain the String references, but no memory has been allocated for the Strings themselves. If we attempted to access one of arrayOfStrings elements at this point, we would get a NullPointerException because the array is empty and contains no Strings and no String objects. We have to allocate the actual String objects separately:
for (int i = 0; i < arrayOfStrings.length; i ++) { arrayOfStrings[i] = new String("Hello " + i); objects are immutable--that is, they cannot be changed once they've been created. The java.lang package provides a different class, StringBuffer, which we can use to create and manipulate character data on the fly.
String Concatenation Java lets us concatenate strings together easily using the + operator. The example program uses this feature of the Java language to print its output. The following code snippet concatenates three strings together to produce its output:
"Input has " + count + " chars."
Two of the strings concatenated together are literal strings: "Input has " and " chars." The third string--the one in the middle--is actually an integer that first gets converted to a string and then is concatenated to the others.
Inheritance Introduction Inheritance is a concept in object-oriented programming w here all classes are arranged in a strict hierarchy. Each class in the h ierarchy has superclasses (classes above it in the hierarchy) and any number of subclasses (classes below it in the hierarchy). Subclasses inherit attributes and behavior from their superclasses In Java, as in object-oriented programming languages, classes can be derived from other classes. The derived class (the class that is derived from another class) is called a subclass. The class from which its derived is called the superclass.
In fact, in Java, all classes must be derived from some class. The top-most class, the class from which all other classes are derived, is the Object class defined in java.lang. Object is the root of a hierarchy of classes.
The subclass inherits state and behavior in the form of variables and methods from its superclass. The subclass can just use the items inherited from its superclass as is, or the subclass can modify or override it.
Definition:
A subclass is a class that derives from another class. A subclass inherits state and behavior from all of its ancestors.
Creating Subclasses For example, suppose that we wanted to create a subclass named SubClass of another class named SuperClass. We w ould write:
class SubClass extends SuperClass { ... }
This declares that SubClass is the subclass of the Superclass class. It also implicitly declares that SuperClass is the superclass of SubClass. A subclass also inherits variables and methods from its superclass's superclass, and so on up the inheritance tree. A Java class can have only one direct superclass. Java does not support multiple inheritance. Creating a subclass can be as simple as including the extends clause in your class declaration.
Member Variables In Subclass Inherit? Rule: A subclass inherits all of the member variables within its superclass that are accessible to that subclass (unless the member variable is hidden by the subclass). That is, subclasses 1. inherit those member variables declared as public or protected 2. inherit those member variables declared with no access specifier as long as the subclass is in the same package as the superclass. These variables are sometimes known as "friendly". 3. don't inherit a superclass's member variable if the subclass declares a member variable using the same name. The subclass's member variable is said to hide the member variable in the superclass. 4. don't inherit private member variables
Hiding Member Variables The member variables defined in the subclass hide member variables of the same name in the superclass. One interesting feature of Java member variables is that a class can access a hidden member variable through its superclass.
Consider this superclass and subclass pair: class Super { Number aNumber; } class Sub extends Super { Float aNumber; }
The aNumber variable in Sub hides aNumber in Super. But we can access aNumber from the superclass with:
super.aNumber super is a Java language keyword that allows a method to refer to hidden variables and overriden methods of the superclass.
Methods In Subclass Inherit? The rule that specifies which methods get inherited by a subclass is similar to that for member variables.
Rule: A subclass inherits all of the methods within its superclass that are accessible to that subclass (unless the method is overriden by the subcl ass).
That is, subclasses 1. inherit those methods declared as public or protected 2. inherit those methods declared with no access specifier as long as the subclass is in the same package as the superclass 3. don't inherit a superclass's method if the subclass declares a method using the same name. The method in the subclass is said to override the one in the superclass. 4. don't inherit private methods
Overriding Methods A subclass can either completely override the implementation for an inherited method or the subclass can enhance the method by adding functionality to it.
Methods a Subclass Cannot Override A subclass cannot override methods that are declared final in the superclass (by definition, final methods cannot be overriden). If you attempt to override a final method, the compiler will display an error message similar to this one and refuse to compile the program: FinalTest.java:7: Final methods can't be overriden. Method void iamfinal() i s final in class ClassWithFinalMethod.
void iamfinal() { ^ 1 error
Methods a Subclass Must Override Subclass must override methods that are declared abstract in the superclass, or the subclass itself must be abstract.
ABSTRACT CLASSES Abstract classes are those which can be used for creation of objects. However their methods and constructors can be used by the child or extended class. The need for abstract classes is that you can generalize the super class from which child classes can share its methods. The subclass of an abstract class which can create an object is called as "concrete class".
Following is an example
Abstract class A { abstract void method1(); void method2() { System.out.println("this is concrete method"); } } class B extends A { void method1() { System.out.println("B is implementation of method1"); } } class demo { public static void main(String arg[]) { B b=new B(); b.method1(); b.method2(); } }
The Benefits of Inh eritance • Subclasses provide specialized behaviors from the basis of common elements provided by the superclass. Through the use of inheritance, programmers can reuse the code in the superclass many times. • Programmers can implement superclasses called abstract classes that define "generic" behaviors. The abstract superclass defines and may partially implement the behavior but much of the class is undefined and unimplemented. Other programmers fill in the details with specialized subclasses.
Interfaces An interface is a collection of method names, without definitions, that can be a dded to classes to provide additional behavior not included with those methods the class defined itself or inherited from its superclasses. The problem with multiple inheritance is that it makes a programming language far more complex to learn, to use, and to implement. A Java interface is a collection of abstract behavior that can be mixed into any class to add to that class behavior that is not supplied by its superclasses. Specifically, a Java interface contains nothing but abstract method definitions and constants-no instance variables and no method implementations. Interfaces are implemented and used throughout the Java class library whenever a behavior is expected to be implemented by a number of disparate classes. The Java class hierarchy, for example, defines and uses the interfaces java.lang.Runnable java.util.Enumeration, java.util.Observable, java.awt.image.ImageConsumer, and java.aw t.image.ImageProducer.
Interfaces and Classes
Interfaces, like classes, are declared in source files, one interface to a file. Like classes, they also are compiled using the Java compiler into .class files. Interfaces complement and extend the power of classes, and the two can be treated almost exactly the same. One of the few differences between them is that an interface cannot be instantiated: new can only create an instance of a class.
Implementing and Using Interfaces The implements Keyw ord To use an interface, we include the implements keyword as part of our class definition
// java.applet.Applet is the superclass public class Neko extends java.applet.Applet implements Runnable { // but it also has Runnable behavior ... }
After our class implements an interface, subclasses of our class will inherit those new methods (and can override or overload them) just as if our superclass had actually defined them. If your class inherits from a superclass that implements a given interface, we don't have to include the implements keyword in your own class definition. Example-
interface Fruitlike { void decay(); void squish(); ... } class Fruit implements Fruitlike { private Color myColor; private int daysTilIRot; ... } interface Spherelike { void toss(); void rotate(); ... } class Orange extends Fruit implements Spherelike { . . . // toss()ing may squish() me (unique to me) }
Here the class Orange doesn't have to say implements Fruitlike because, by extending Fruit, it already has! Other Example-
class Sphere implements Spherelike { // extends Object private float radius; ... } class Orange extends Sphere implements Fruitlike { . .// users of Orange never need know about the change! }
Implementing Multiple I nterfaces To include multiple interfaces in a class, just separate their names w ith commas:
public class Neko extends java.applet.Applet implements Runnable, Eatable, Sortable, Observable { ... }
Creating and Extending Interfaces New I nterfaces To create a new interface,we declare it like this:
public interface Growable { ... } This is, effectively, the same as a class definition, with the word interface replacing the word class. Inside the interface definition we have methods and constants. The method definitions inside the interface are public and abstract methods; W e cannot declare a method inside an interface to be either private or protected. So, for example, here's a Growable interface with one method explicitly declared public and abstract (growIt()) and one implicitly declared as such (growItBigger())
public interface Growable { public abstract void growIt(); //explicity public and abstract void growItBigger(); // effectively public and abstract }
In addition to methods, interfaces can also have variables, but those variables must be declared public, static, and final (making them constant). As with methods, we can explicitly define a variable to be public, static, and final. Here's that same Growable de finition with two new variables:
public interface Growable {
public static final int increment = 10; long maxnum = 1000000; // becomes public static and final public abstract void growIt(); //explicitly public and abstract void growItBigger(); // effectively public and abstract } Interfaces, l ike classes, can belong to a package by adding a package statement to the first line of the class file. Interfaces can also import other interfaces and classes from other packages, just as classes can.
Methods Inside I nterfaces An actual implementation for the method in a class:
public class Orange extends Fruit { public germinate(Fruitlike self) { Orange theOrange = (Orange)self; ... } }
Extending Interfaces When one interface inherits from another interface, that "subinterface" acquires all the method definitions and constants that its "superinterface" defined. To extend an interface, we use the extends keyword just as you do in a class definition:
public interface Fruitlike extends Foodlike { ... }
In multiply inherited interfaces, the rules for managing method name conflicts are the same as for classes that use multiple interfaces; methods that differ only in return type will result in a compiler error.
Package Introduction Java provides a powerful means of grouping related classes and interfaces together in a single unit: packages Packages are groups of rel ated classes and interfaces. Packages provide a convenient mechanism for managing a large group of classes and interfaces while avoiding potential naming conflicts.
Packages are useful for several broad reasons: • They allow us to organize your classes into units. Just as we have folders or directories on your hard disk to organize your files and applications, packages allow us to organize your classes into groups so that we only use what we need for each program. • They reduce problems with conflicts in names. As the number of Java classes grows, so does the
likelihood that we'll use the same class name as someone else, opening up the possibility of naming clashes and errors if you try to integrate groups of classes into a single program. Packages allow you to "hide" classes so that conflicts can be avoided. • They allow you to protect classes, variables, and methods in larger ways than on a class-by-class basis, as you learned yesterday. we'll learn more about protections with packages later today. • They can be used to identify your classes. For example, if you implemented a set of classes to perform some purpose, we could name a package of those classes with a unique identifier that identifies you or your organization. The Java AP I itself is implemented as a group of packages.
Declaring Packages The syntax for the p ackage statement:
package Identifier; This statement must be placed at the beginning of a compilation unit (a single source file), before any class declarations. Every class located in a compilation unit with a package statement is considered part of that package Packages can be nested within other packages. When this is done, the Java interpreter expects the directory structure containing the executable classes to match th e package hierarchy.
Importing P ackages The import statement enables us to import classes from other packages into a compilation unit. We can import individual classes or entire packages of classes at the same time if we want. The syntax for the import statement follow s:
import Identifier; Identifier is the name of the class or package of classes we are importing. Other Example:
import java.awt.Color; import java.awt.*; The first statement imports the specific class Color, which is located in the java.awt package. The second statement imports all the classes in the java.awt package. Note that the following statement doesn't w ork:
import java.*; This statement doesn't work because we can't import nested packages with the * specification. This wildcard works only when importing all the classes in a particular package, which is still very useful.
There is one other way to import obj ects from other packages: explicit package referencing . By explicitly referencing the package name each time we use an object, we can avoid using an import statement. Using this technique, the declaration of the color member variable look like this:
java.awt.Color color;
Creating Our Ow n P ackages
The first step is to decide what the name of our package is going to be. The name we choose for our package depends on how we are going to be using those classes. Step two in creating packages is to create a directory structure on our disk that matches the package name. If your package has just one name (mypackage), we'll only have to create a directory for that one name. If the package name has several parts, however, we'll have to create directories within directories. For the package name edu.nonsense.eng.fooblitzky, we'll need to create an edu directory and then create a nonsense directory inside edu, an eng directory inside nonsense, and a fooblitzky directory inside eng. Our classes and source files can then go inside the fooblitzky directory.
Use package to Add Our Class to a P ackage The final step to putting our class inside packages is to add the package command to our source files. The package command says "this class goes inside this package," and is used like this:
package myclasses; package edu.nonsense.eng.fooblitzky; package java.awt;
The Java Language Package The Different Java Packages Eight packages comprise the standard Java development environment. The Java language package, also known as java.lang, contains classes that are core to the Java language. The classes in this package are grouped as follow:
Object The grand-daddy of all classes--the class from which all others inherit.
Data Type W rappers A collection of classes used to wrap variables of a primitive data type: Boolean, Character, Double, Float, Integer and Long. Each of these classes are subclasses of the abstract class Number.
Strings Two classes that implement character data. is a thorough lesson on the use of both types of strings.
System and Runtime These two classes provide let your programs use system resources. System provides a systemindependent programming interface to system resources and Runtime gives you direct systemspecific access to the runtime environment.
Threads The Thread, ThreadDeath and ThreadGroup classes implement the multi-threading capabilities so
important to the Java language. The java.lang package also defines the Runnable interface. Runnable makes it convenient for Java class to be active without subclassing the Thread class.
Classes The Class class provides a runtime description of a class and the ClassLoader class allows you to load classes into your program during runtime.
Math A library of math routines and values such as pi.
Exceptions, Errors and Throw able When an error occurs in a Java program, the program throws an object which indicates what the problem was and the state of the interpreter when the error occurred. Only objects that derive from the Throwable class can be thrown. There are two main subclasses of Throwable: Exception and Error. Exceptions are a form of Throwable that "normal" programs may try to catch. Errors are used for more catastophic errors--normal programs should not catch errors. The java.lang package contains the Throwable, Exception and Error classes, and numerous subclasses of Exception and Error that represent specific problems.
Processes Process objects represent the system process that is created when you use Runtime to execute system commands. The java.lang packages defines and implements the generic Process class. The compiler automatically imports this package for us. No other packages are automatically imported.
The Java I/ O Package The Java I/O Package (java.io) provides a set of input and output streams used to read and write data to files or other input and output sources.
The Java Utility Package This Java package, java.util, contains a collection of utility classes. Among them are several generic data structures (Dictionary, Stack, Vector, Hashtable) a useful object for tokenizing a string and another for manipulating calendar dates. The java.util package also contains the Observer interface and Observable class which allow objects to notify one another when they change. The java.util classes aren't covered separately in this tutorial a lthough some examples use these classes.
The Java Networking P ackage The java.net package contains classes and interface definitions that implement various networking capabilities. The classes in this package include a class that implement a URL, a connection to a URL, a socket connection, and a datagram packet. You can use these classes to implement client-server applications and other networking communication applications.
The Applet Package This package contains the Applet class -- the class that you must subclass if you're writing an applet. Included in this package is the AudioClip interface which provides a very high level abstraction of audio.
The Abstract Window Toolkit Packages Packages Three packages comprise the Abstract Window Toolkit: java.awt, java.awt.image, and java.awt.peer.
AWT Package The java.awt package provides GUI elements used to get input from and display information to the user such as windows, buttons, scrollbars, and text items.
AWT Image Package The java.awt.image package contains classes and interfaces for managing image data, such as setting the color model, cropping, color filtering, setting pixel values, and grabbing snapshots of the screen.
AWT Peer Package The java.awt.peer package contains classes and interfaces that connect platform-independent AWT components to their platform-dependent implementation (such as Motif widgets or Microsoft Windows controls).
Multithreading Introduction: Multithreading is a fundamental feature of the Java language specification. The creators of Java under understo stood od the import importanc ance e of multith multithrea reading ding and provid provided ed easy easy to use features features for applicat application ion develo developer pers. s. Two of these these feature features, s, the Thread Thread class class and the Runnable Runnable interface interface,, will be covere covered d shortly. Multithreading is not the same as multiprocessing. The latter involves the use of two or more processors processors (CPUs). (CPUs). Multithreading Multithreading involves involves the sharing of a single processor processor and the interleaving interleaving of CPU time as shown by the following diagram:
Beca Because use there there is only only one one proce process ssor, or, only one instru instruct ctio ion n can be exec execute uted d at a time time.. In a Java Java program, the decision as to which thread is currently executing is determined by the JVM. Multithreading is used to execute even the simplest Java program. Even if a program doesn't create its own threads, the Java Virtual Machine creates multiple threads to support the program. One thread thread performs performs the processing processing of the main() method. Other threads manage and monitor monitor system resources. The garbage collector, for example, is always running as a low-priority thread.
Thread A thread--sometimes known as an execution context or a lightweight process--is a single sequential flow of control within a process.
Definition: A thread is a single sequential flow of control within a program Example: The following program is a simple Java application that creates and starts two independent threads:
class TwoThreadsTest { public static void main (String[] args) { new SimpleThread("Jamaica").start(); new SimpleThread("Fiji").start(); } } class SimpleThread extends Thread { public SimpleThread(String str) { super(str); } public void run() { for (int i = 0; i < 10; i++) { System.out.println(i + " " + getName()); try { sleep((int)(Math.random() * 1000)); } catch (InterruptedException e) {
} } System.out.println("DONE! " + getName()); } }
A thread is similar to the sequential programs described above: a single thread also has a beginning, an end, a sequence, and at any given time during the runtime of the thread there is a single point of execution. The HotJava Web browser is an example of a multithreaded application. Within the HotJava browser we can scr scroll a page age while hile it's it's dow downlo nloadin ading g an app applet let or imag image e, play play anim animat atio ion n and and sound ound concurre concurrently, ntly, print a page in the background background while we download download a new page, or watch three sorting sorting algorithms race to the finish.
Thread Attributes Java threads are implemented by the Thread class, which is part of the java.lang package. The Thread class implements a system independent definition of Java threads. But under the hood, the actual implementation of concurrent operation is provided by a system-specific implementation.
The life of a thread In Java, Java, all thread threads s are objects objects that that are constr constructe ucted, d, pass pass betwee between n severa severall "state "states", s", and die in
keeping with the following diagram:
1. When initially constructed, the thread is New 2. When all resources the thread requires are available, it enters the Ready state. The thread is ready to use the CPU. 1. When selected by the JVM for processing, the thread enters the Running state. This is the state that all threads aspire to but only one is ever running at an instant in time. 2. When the thread thread requests requests to sleep sleep for an interval interval of time, time, must must wait for a resour resource ce (such as complet com pletion ion of I/O), I/O), or is suspen suspended ded by the JVM, it becomes becomes Blocked. Blocked. It gives gives up the CPU and will return to the Ready state when th e block is removed. 3. When When the thread thread com comple pletes tes its proces processing sing or is killed killed by the JVM, it enters enters the Dead state. state. The thread object will still exist, but will no longer be allowed to use the CPU.
Thread Body All of the a ction takes place in the thread's body--t body--the he thread's run() meth od. We can provide the body to a Thread Thread in one of two w ays: a. by subclassing the Thread class and overriding its run() method, b. by creating a Thread with a Runnable object as its target.
Creating the Thread The application in which an applet is running calls the applet's start() method when the user visits the applet's page. The Clock applet creates a Thread, clockThread, in its start() method and starts the thread.
public void start() { if (clockThread == null) { clockThread = new Thread(this, "Clock"); clockThread.start(); } } First, the start() method checks to see if clockThread is null. If clockThread is null, then the applet has just been loaded or has been previously stopped and a new thread must be created. Otherwise, the applet is already running. The applet creates a new thread with this invocation:
clockThread = new Thread(this, "Clock"); Here--the Clock applet--is the first argument to the thread constructor. The first argument to this Thread constructor must implement the Runnable interface and becomes the thread's target. When
constructed in this way, the clock thread gets its run() method from its target Runnable object--in this case, the Clock applet. The second argument is just a name for the thread. After a thread has been created and initialized, the runtime system calls its run() method. The code in the run() method implements the behavior for which the thread was created.
Stopping the Thread When we leave the page that displays the Clock applet, the application in which the applet is running calls the applet's stop() method. The Clock's stop() method sets the clockThread to nu ll. This tells the main loop in the run() method to terminate eventually resulting in the thread stopping and being garbage collected.
public void stop() { clockThread = null; } we can use clockThread.stop() instead, which would immediately stop the clock thread. However, the Thread class's stop() method has a sudden effect, which means that the run() method might be in the middle of some critical operation when the thread is stopped. For more complex run() methods, using Thread's stop() method might leave the program in an inconsistent or awkward state. For this reason, it's best to avoid using the Thread class's stop() method when possible. If we revisit the page, the start() method is called again, and the clock starts up again with a new thread.
The Run Method And finally the Clock's run() method implements the heart of the Clock applet and looks like this:
public void run() { // loop terminates when clockThread is set to null in stop() while (Thread.currentThread() == clockThread) { repaint(); try { Thread.sleep(1000); } catch (InterruptedException e) { } } }
Thread State Throughout its life, a Java thread is in one of several states. A thread's state indicates what the Thread is doing and what it is capable of doing at that time of its life: is it running? Is it sleeping? Is it dead?
The above diagram illustrates the various states that a Java thread can be in at any point during its life. It also illustrates which method calls cause a transition to another State.
New Thread The following statement creates a new thread but does not start it, thereby leaving the thread in the "New Thread" state.
Thread myThread = new MyThreadClass();
When a thread is in the "New Thread" state, it is merely an empty Thread object. No system resources have been allocated for it yet. Thus when a thread is in this state, we can only start the thread or stop it. Calling any method besides start() or stop() when a thread is in this state makes no sense and causes an IllegalThreadstateException.
Runnable Now consider these tw o lines of code:
Thread myThread = new MyThreadClass(); myThread.start(); The start() method creates the system resources necessary to run the thread, schedules the thread to run, and calls the thread's run() method. At this point the thread is in the "Runnable" state. This state is called "Runnable" rather than "Running" because the thread might not actually be running when it is in this state. Many computers have a single processor, making it impossible to run all "Runnable" threads at the same time. So, the Java runtime system must implement a scheduling scheme that shares the processor between all "Runnable" threads.
Not Runnable A thread enters the "Not Runnable" state when one of these four events occurs: 1. Someone invokes its sleep() method. 2. Someone invokes its suspend() method. 3. The thread uses its wait() method to wait on a condition variable. 4. The thread is blocking on I/O. For example, The bold line in the following code snippet puts the current thread to sleep for 10 seconds (10,000 milliseconds):
try
{ Thread.sleep(10000); } catch (InterruptedException e) { } During the 10 seconds that myThread is asleep; even if the processor becomes available myThread does not run. After the 10 seconds are up, myThread becomes "Runnable" again and, if the processor becomes available, runs. If a thread has been put to sleep, then the specified number of milliseconds must elapse before the thread becomes "Runnable" again. Calling resume() on a sleeping thread has no effect. The following indicates the escape route for every entrance into the "Not Runnable" state. 1. If a thread has been put to sleep, then the specified number of milliseconds must elapse. 2. If a thread has been suspended, then someone must call its resume() method. 3. If a thread is waiting on a condition variable, whatever object owns the variable must relinquish it by calling either notify() or notifyAll(). 4. If a thread is blocked on I/O, then the I/O must complete.
Dead A thread can die in two ways: either from natural causes, or by being killed (stopped). A thread dies naturally when its run() method exits normally. For example, The while loop in this method is a finite loop--it will iterate 100 times and then exit.
public void run() { int i = 0; while (i < 100) { i++; System.out.println("i = " + i); }} A thread with this run() method will die naturally after the loop and the run() method completes. We can also kill a thread at any time by calling its stop() method. The following code snippet creates and starts myThread then puts the current thread to sleep for 10 seconds. When the current thread wakes up, the bold line in the code segment kills myThread.
Thread myThread = new MyThreadClass(); myThread.start(); try { Thread.sleep(10000); } catch (InterruptedException e) { } myThread.stop(); The stop() method throws a ThreadDeath object at the thread to kill it. Thus when a thread is killed in this manner it dies asynchronously. The thread will die when it actually receives the ThreadDeath exception.
IllegalThreadStateException The runtime system throws an IllegalThreadStateException when we call a method on a thread and that thread's state does not allow for that method call.
For example, IllegalThreadStateException is thrown when we invoke suspend() on a thread that is not "Runnable" .
The isAlive() Method A final word about thread state: the programming interface for the Thread class includes a method called isAlive(). The isAlive() method returns true if the thread has been started and not stopped. Thus, if the isAlive() method returns false we know that the thread is either a "New Thread" or "Dead" . If the isAlive() method returns true, we know that the thread is either "Runnable" or "Not Runnable". We cannot differentiate between a "New Thread" and a "Dead" thread; nor can we differentiate between a "Runnable" thread and a "Not Runnable" thread.
Thread Priority A thread's priority tells the Java thread scheduler when this thread should run in relation to other threads. Some points 1. Most computers have only one CPU, thus threads must share the CPU with other threads. The execution of multiple threads on a single CPU, in some order, i s called scheduling. The Java runtime supports a very simple, deterministic scheduling algorithm known as fixed priority scheduling. 2. Each Java thread is given a numeric priority between MIN_PRIORITY and MAX_PRIORITY (constants defined in class Thread). At any given time, when multiple threads are ready to be executed, the thread with the highest priority will be chosen for execution. Only when that thread stops, or is suspended for some reason, will a l ower priority thread start executing. 3. Scheduling of the CPU is fully preemptive. If a thread with a higher priority than the currently executing thread needs to execute, the higher priority thread is immediately scheduled. 4. The Java runtime will not preempt the currently running thread for another thread of the same priority. In other words, the Java runtime does not time-slice. However, the system implementation of threads underlying the Java Thread class may support time-slicing. Do not write code that relies on time-slicing. 5. In addition, a given thread may, at any time, give up its right to execute by calling the yield() method. Threads can only yield the CPU to other threads of the same priority--attempts to yield to a lower priority thread a re ignored. 6. When all the "Runnable" threads in the system have the same priority, the scheduler chooses the next thread to run in a simple, non-preemptive, round-robin scheduling order.
Daemon Threads Daemon threads are those that provide a service for other threads in the system. Any Java thread can be a daemon thread.
Thread Group All threads belong to a thread group. ThreadGroup, a java.lang class, defines and implements the capabilities of a group of related threads. The ThreadGroup class manages groups of threads for Java applications. A ThreadGroup can contain any number of threads. The threads in a group are generally related in some way, such as who created them, what function they perform, or when they should be started and stopped. ThreadGroups can contain not only threads but also other ThreadGroups. The top most thread group in a Java application is the thread group named "main". We can create threads and thread groups in the "main" group. We can also create threads and thread groups in subgroups of "main" and so on.
The result is a root-like hierarchy of threads and thread groups.
The ThreadGroup class has methods that can be categorized as follow s: 1. Collection management Method:-methods that manage the collection of threads and subgroups contained in the thread group. 2. Method that Operate on the Group:-these methods set or get attributes of the ThreadGroup object. 3. Method that Operate on All Threads within a Group --this is a set of methods that perform some operation, such as start or resume, on all the threads and subgroups within the ThreadGroup. 4. Access Restriction Methods:-ThreadGroup and Thread allow the security manager to restrict access to threads based on group memb ership.
Collection Management Methods The ThreadGroup provides a set of methods that manage the threads and subgroups within the group and allow other objects to query th e ThreadGroup for information ab out its contents. For example, You can call ThreadGroup's activeCount() method to find out the number of active threads currently in the group. The activeCount() method is often used with the enumerate() method to get an array filled with references to all the active threads in a ThreadGroup. For example, The listCurrentThreads() method in the following example fills an array with all of the active threads in the current thread group and prints their names:
class EnumerateTest { void listCurrentThreads() {
ThreadGroup currentGroup = Thread.currentThread().getThreadGroup(); int numThreads; Thread[] listOfThreads; numThreads = currentGroup.activeCount(); listOfThreads = new Thread[numThreads]; currentGroup.enumerate(listOfThreads); for (int i = 0; i < numThreads; i++) { System.out.println("Thread #" + i + " = " + listOfThreads[i].getName()); } } } Other collection management methods provided by the ThreadGroup class include activeGroupCount() and li st().
Methods that Operate on the Group The ThreadGroup class supports several attributes that are set and retrieved from the group as a whole. These attributes include the maximum priority that any thread within the group can have, whether the group is a "daemon" group, the name of the group, and the parent of the group. The methods that get and set ThreadGroup attributes operate at the group level. That is, they inspect or change the attribute on the ThreadGroup object, but do not affect any of the threads within the group.
The following is a list of ThreadGroup methods that operate at the group level: 1. getMaxPriority(), and setMaxPriority() 2. getDaemon(), and setDaemon() 3. getName() 4. getParent(), and parentOf() 5. toString() So for example, when we use setMaxPriority() to change a group's maximum priority, we are only changing the attribute on the group object; we are not changing the priority of any of the threads within the group.
Consider this small program that creates a group and a thread w ithin that group:
class MaxPriorityTest { public static void main(String[] args) { ThreadGroup groupNORM = new ThreadGroup( "A group with normal priority"); Thread priorityMAX = new Thread(groupNORM, "A thread with maximum pr iority"); // set Thread's priority to max ( 10) priorityMAX.setPriority(Thread.MAX_PRIORITY); // set ThreadGroup's max priority to normal (5) groupNORM.setMaxPriority(Thread.NORM_PRIORITY); System.out.println("Group's maximum priority = " + groupNORM.getMaxPriority()); System.out.println("Thread's priority = " + priorityMAX.getPriority());
} } When the ThreadGroup groupNORM is created, it inherits its maximum priority attribute from its parent thread group. In this case, the parent group priority is the maximum (MAX_PRIORITY) allowed by the Java runtime system. Next the program sets the priority of the priorityMAX thread to the maximum allowed by the Java ru nti me sy st em. Th en the pro gra m l ow ers th e group' s maxi mu m to th e n orma l pri ori ty (NORM_PRIORITY). The setMaxPriority() method does not affect the priority of the priorityMAX thread, so that at this point, the priorityMAX thread has a priority of 10 which is greater than the maximum priority of its group groupNORM. This is the output from the program:
Group's maximum priority = 5 Thread's priority = 10
As we can see a thread can have a higher priority than the maximum allowed by its group as long as the thread's priority is set before the group's maximum priority is lowered. A thread group's maximum priority is used to limit a thread's priority when the thread is first created within a group or when you use setPriority() to change th e thread's priority. Note that setMaxPriority() does change th e maximum priority of all of its sub-threadgroups.
Methods that Operate on All Threads w ithin a Group The ThreadGroup class has three methods that allow us to modify the current state of all the threads within that group: 1. resume() 2. stop() 3. suspend() These methods apply the appropriate state change to every thread in the thread group and its subgroups.
Access Restriction Methods The ThreadGroup class itself does not impose any access restrictions, such as allowing threads from one group to inspect or modify threads in a different group. Rather the Thread and ThreadGroup classes cooperate with security managers (subclasses of the java.lang.SecurityManager class), which can impose access restrictions based on thread group membership. The Thread and ThreadGroup class both have a method, checkAccess(), which calls the current security manager's checkAccess() method. The security manager decides whether to allow the access based on the group membership of the threads involved. If access is not allowed, the checkAccess() method throws a SecurityException. Otherwise, checkAccess() simply returns. The following is a list of ThreadGroup methods that call ThreadGroup's checkAccess() before performing the action of the method. These are what are known as regulated accesses, that is, accesses that must be approved by the security manager before they can be completed. 1. ThreadGroup(ThreadGroup parent, String name) 2. setDaemon(boolean isDaemon) 3. setMaxPriority(int maxPriority) 4. stop() 5. suspend() 6. resume() 7. destroy()
This is a li st of the methods in the Thread class that call checkAccess() before proceeding: 1. constructors that specify a thread group 2. stop() 3. suspend()
4. 5. 6. 7.
resume() setPriority(int priority) setName(String name) setDaemon(boolean isDaemon)
We can define and implement our own access restrictions for thread groups by subclassing SecurityManager, overriding the appropriate methods, and installing it as the current security manager in our application.
The notifyAll() and wait() Methods The notifyAll() and wait() methods can be invoked only by the thread that holds the lock.
The notifyAll() method The notifyAll() method notifies all the threads waiting on the monitor held by the current thread and wakes them up. Example:
public synchronized int get() { while (available == false) { try { wait(); } catch (InterruptedException e) { } } available = false; notifyAll(); // notifies Producer return contents; } In the above example the Producer/Consumer example, the Consumer thread calls the get() m ethod, so the Consumer thread holds the monitor during the execution of get(). At the end of the get() method, the call to notifyAll() wakes up the Producer thread that is waiting to get the monitor. Now, the Producer thread can get the monitor and proceed. If multiple threads are waiting for a monitor, the Java runtime system chooses one of the waiting threads to run, making no commitments or guarantees about which thread will be chosen.
The wait() method The wait() method causes the current thread to wait (possibly forever) until another thread notifies it of a condition change. We use wait() in conjunction with notify() or notifyAll() to coordinate the activities of multiple threads using the same resources. Example:
public synchronized int get() { while (available == false) { try { wait(); // waits for notifyAll() call from Producer } catch (InterruptedException e) {
} } available = false; notifyAll(); return contents; } The Object class contains two other versions of the wait() method:
wait(long timeout) waits for notification or until the timeout period has elapsed--timeout is measured in milliseconds.
wait(long timeout, int nanos) waits for notification or until timeout milliseconds plus nanos nanoseconds have elapsed. It has a numbe r of methods, some of w hich are static.
Frequently used Method The most frequently used methods are the following:
Ex c e p t i o n H a n d l i n g Introduction Errors are a normal part of programming. Some of these errors are flaws in a program's basic design or implementation--these are called bugs. Other types of errors are not really bugs; rather, they are the result of situations like low memory or invalid filenames.
The way we handle the second type of error determines whether they become bugs . Java's exception-handling mechanism lets us handle errors without forcing us to spend most of our energy worrying about them.
What I s an Exception? As the name implies, an exception is an exceptional condition. An exception is something out of the ordinary. Most often, exceptions are used as a way to report error conditions. Exceptions provide notification of errors and a way to handle them. This control structure allows us to specify exactly where to handle specific types of errors.
If Exceptions than? The most common means of error checking is the f unction's return value. Consider the problem of calculating the retail cost of an item and displaying it. For this example, the retail cost is twice the wholesale cost:
int retailCost( int wholesale ) { if ( wholesale <= 0 ) { return 0 ; } return (wholesale * 2 ) ; } The retailCost() method takes the wholesale price of an item and doubles it. If the wholesale price is negative or zero, the function returns zero to i ndicate that an error has occurred.
The exception handling technique • Involves the use of the try, catch, and finally Java keywords • Consists of several steps
1. try a block of code that may result in an exception being "thrown" 2. Code one or more blocks designed to automatically catch and handle a specific type of exception if one occurs. At most, only one of these blocks can be called in a single pass through the code. If none of the specified exceptions occurs, none of the blocks will be executed. 3. Optionally code a block that will finally be run in ALL situations, whether an exception occurs or not
• Has the following general syntax:
try { statements that may result in an exception being thrown; } catch (exception-type1 reference) {
statements to handle the exception; } catch (exception-type2 reference) { statements to handle the exception; } other catch blocks... finally { statements to be ALWAYS executed; } Example: The following is a modified version of the "shell game" program presented earlier. It contains a try block and two catch blocks. One handles a NullPointerException and the other handles an ArrayIndexOutOfBoundsException. No finally block is specified, so logic comes together after the end of the last catch block.
public class AppExcep { public static void main(String[] args) { // Loop control variable. char again = 'y'; // Main loop. One array is entered and processed in each iteration. while (again == 'Y' || again =='y') { // Instantiate a three element array and load a single String // at a random element location. String[] strings = new String[3]; int randomIndex = (int) ((Math.random()*100) % strings.length); strings[randomIndex] = "Lucky"; // Ask the user to guess the element location. Utility.separator(50, '>'); System.out.print("Pick a number from 1 to " + strings.length + ": "); // "Try" to read their response, use it to index into the array, // and see if they win. try { // If they guess the element location, display a message. Otherwise, // an exception will occur. if (strings[Keyboard.readInt() - 1].equals("Lucky")) { Utility.skip(); System.out.println(" YOU WIN!!!"); } }
// This block is automatically executed if a NullPointerException // occurs to indicate a null array location. catch (NullPointerException err) { Utility.skip(); System.out.println(" Empty shell - YOU LOSE!!!"); } // If an ArrayIndexOutOfBoundsException occurs, this block is // automatically executed. It indicates an invalid number was // used as an index. catch (ArrayIndexOutOfBoundsException err) { Utility.skip(); System.out.println(" Invalid number - YOU LOSE"); } // Ask the user if they want to do it again and repeat the loop as // requested. Utility.separator(40, '='); System.out.print("Again? (Y/N): "); again = Keyboard.readChar(); } } }
Some Terminology Exception handling can be viewed as a nonlocal control structure. When a method throws an exception, its caller must determine whether it can catch the exception. If the calling method can catch the exception, it takes over and execution continues in the caller. Java exceptions are class objects subclassed from java.lang.Throwable. Because exceptions are class objects, they can contain both data and methods. In fact, the base class Throwable implements a method that returns a String describing the error that caused the exception. This is useful for debugging and if we want to give users a meaningful error message.
Throw an Exception The method instantiates an object of type Exception. The Exception constructor takes a String parameter. The string contains a message that can be retrieved when the exception is caught. The throw statement terminates the method and gives its caller the opportunity to catch i t:
if( correct > total ) { throw new Exception( "Invalid values" ) ; } if ( (float)correct / (float)total > 0.70 ) { returnCode = true ; } return returnCode ; }
Throw , try, and catch Blocks
To respond to an exception, the call to the method that produces it must be placed within a try block. A try block is a block of code beginning with the try keyword followed by a left and right curly brace. Every try block is associated with one o r more catch blocks. Here is a try block:
try { // method calls go here } If a method is to catch exceptions thrown by the methods it calls, the calls must be placed within a try block. If an exception is thrown, it is handled in a catch block. Different catch blocks handle different types of exceptions. This is a try block and a catch block set up to handle exceptions of type Exception:
try { // method calls go here } catch( Exception e ) { // handle exceptons here } When any method in the try block throws any type of exception, execution of the try block ceases. Program control passes immediately to the associated catch block. If the catch block can handle the given exception type, it takes over. If it cannot handle the exception, the exception is passed to the method's caller. In an application, this process goes on until a catch block catches the exception or the exception reaches the main() method uncaught and causes the application to terminate.
An Exceptional Example The gradeTest application.
import java.io.* ; import java.lang.Exception ; public class gradeTest { public static void main( String[] args ) { try { // the second call to passingGrade throws // an excption so the third call never // gets executed System.out.println( passingGrade( 60, 80 ) ) ; System.out.println( passingGrade( 75, 0 ) ) ; System.out.println( passingGrade( 90, 100 ) ) ; } catch( Exception e ) { System.out.println( "Caught exception --" + e.getMessage() ) ; }
} static boolean passingGrade( int correct, int total ) throws Exception { boolean returnCode = false ; if( correct > total ) { throw new Exception( "Invalid values" ) ; } if ( (float)correct / (float)total > 0.70 ) { returnCode = true ; } return returnCode ; } }
The second call to passingGrade() fails in this case because the method checks to see whether the number of correct responses is less than the total responses. When passingGrade() throws an exception, control passes to the main() method. In the example, the catch block in main() catches the exception and prints Caught exception - Invalid values.
Multiple catch Blocks In some cases, a method may have to catch different types of exceptions. Java supports multiple catch blocks. Each catch block must specify a different type of exception:
try { // method calls go here } catch( SomeExceptionClass e ) { // handle SomeExceptionClass exceptions here } catch( SomeOtherExceptionClass e ) { // handle SomeOtherExceptionClass exceptions here } When an exception is thrown in the try block, it is caught by the first catch block of the appropriate type. A method that ignores exceptions thrown by the method it calls.
import java.io.* ; import java.lang.Exception ; public class MultiThrow { public static void main( String[] args ) { try { fool() ; } catch( Exception e ) { System.out.println( "Caught exception " + e.getMessage() ) ; } }
static void fool() throws Exception { bar() ; } static void bar() throws Exception { throw new Exception( "Who cares" ) ; } }
In the example main() calls fool() which calls bar(). Because bar() throws an exception and doesn't catch it, fool() has the opportunity to catch it. The fool() method has no catch block, so it cannot catch the exception. In this case, the exception propagates up the call stack to fool()'s caller, main(). A method that catches and rethrows an exception.
import java.io.* ; import java.lang.Exception ; public class MultiThrowA { public static void main( String[] args ) { try { fool() ; } catch( Exception e ) { System.out.println( "Caught exception " + e.getMessage() ) ; } } static void fool() throws Exception { try { bar() ; } catch( Exception e ) { System.out.println( "Re throw exception -- " + e.getMessage() ) ; throw e ; } } static void bar() throws Exception { throw new Exception( "Who cares" ) ; } }
The fool() method calls bar(). The bar() method throws an exception and fool() catches it. In the example, fool() simply rethrows the exception, which is ultimately caught in the application's main() method. In a real application, fool() could do some processing and then rethrow the exception. This arrangement allows both fool() and main() to handle the exception.
The finally Clause Java introduces a new concept in exception handling: the finally clause. The finally clause sets apart a block of code that is always executed.
Example of a finally clause:
import java.io.* ; import java.lang.Exception ; public class MultiThrowFin { public static void main( String[] args ) { try { alpha() ; } catch( Exception e )} { System.out.println( "Caught exception " ) ; } finally() { System.out.println( "Finally. " ) ; } } } In normal execution (that is, when no exceptions are thrown), the finally block is executed immediately after the try block. When an exception is thrown, the finally block is executed before control passes to the caller. If alpha() throws an exception, it is caught in the catch block and then the finally block is executed. If alpha() does not throw an exception, the finally block is executed after the try block. If any code in a try block is executed, the finally block is executed as well.
The Throw able Class All exceptions in Java are subclassed from the class Throwable. If we want to create your own exception classes, we must subclass Throwable. Most Java programs do not have to subclass their own exception classes. Following is the publi c portion of the class definition of Throwable:
public class Throwable { public Throwable() ; public Throwable(String message) ; public String getMessage() public String toString() ; public void printStackTrace() ; public void printStackTrace( java.io.PrintStream s) ; private native void printStackTrace0( java.io.PrintStream s); public native Throwable fillInStackTrace(); } Java exceptions are Throwable objects (they are instances of Throwable or a subclass of Throwable). The Java packages contain numerous classes that derive from Throwable and thus, build a hierarchy of Throwable classes.
Types of Exceptions The methods of the Java API and the language itself also throw exceptions. These exceptions can be divided into tw o classes: Exception and Error. Both the Exception and Error classes are d erived from Throwable. Exception and its subclasses are used to indicate conditions that may be recoverable. Error and its subclasses indicate conditions that are generally not recoverable and that should cause your applet to terminate. The various packages included in the Java Development Kit throw different kinds of Exception and Error exceptions, as described in the following sections.
Different List of Exception java.awt Ex ceptions The AWT classes have members that throw one error and two exceptions: • AWTException (exception in AWT) • llegalComponentStateException (a component is not in the proper state for a requested o peration) • AWTErr (error in AWT)
java.awt.datatransfer Exception Classes of the AWT data transfer package may throw this exception: • UnsupportedFlavorException (data in improper format)
java.beans Exceptions The classes of the java.beans package throw the following e xceptions: • IntrospectionException (unable to resolve object during introspection) • PropertyVetoException (illegal property change)
java.io Ex ceptions The classes in the java.io package throw a variety of exceptions, Any classes that work with I/O are good candidates to throw recoverable exceptions. For example, activities such as opening files or writing to files are likely to fail from time to time. The classes of the java.io package do not throw errors at all.
The java.io exceptions.
The java.io exception hierarchy.
java.lang Exceptions
The java.lang package contains much of the core Java language. The exceptions subclassed from RuntimeException do not have to be declared in a method's throws clause. These exceptions are considered normal because nearly any method can throw them.
The java.lang exceptions.
The java.lang errors.
The java.lang exception hierarchy.
java.lang.reflect Exception The classes of java.lang.reflect throw the following ex ception: • InvocationTargetException (invoked method has thrown an exception)
java.net Exce ptions The java.net package handles network communications. Its classes most often throw exceptions to indicate connect failures and the like.
The java.net exceptions.
The java.net exception hierarchy.
java.rmi Error The Java Remote Method I nvocation classes allow Java objects to exist on remote machines. These classes throw the following error: • ServerError (remote server indicates error)
java.rmi E xceptions Java objects whose methods are invoked remotely through RMI may throw exceptions.
The java.rmi exceptio ns.
The java.rmi exception hierarchy.
java.rmi.server Exceptions RMI servers throw exceptions.
The java.rmi.server excepti ons.
java.security Exce ptions The Java security API allows users to implement security features in Java. The API includes support for digital signatures, data encryption, key management, and access control.
The java.security exception s.
The java.security exception hierarchy.
java.security.acl Exceptions The Java security access control list API allows Java developers to control access to specific
users. The classes of java.security.ac java.security.acll throw the follow ing e xceptions: • ACLNotFoundException (unable to find acc ess control list) • LastOwnerExcepti (attempt to delete last own er of ACL) • NotOwnerExcepti (only the owner may modify)
java.sql Exceptions The Java SQL API throw s the following exceptions: • DataTruncation (unexpected data truncation) • SQLException (SQL error--contains detailed SQL information) • SQLWarning (SQL warning)
java.text ja va.text Exception The Java text API throws the following exception: • FormatException (format or parsing error)
java.util Exceptions The classes of the java.util java.util package throw the follow ing exceptions: • EmptyStackException (no objects on stack) • MissingResourceException (resource missing) • NoSuchElementException (no more objects in collection) • TooManyListenersException (thrown by unicast event listeners) NOTE: Unic Unicas astt is Java Java term termin inol olog ogy y for for a sing single leto ton n serv server er obje object ct.. Sing Single leto tons ns are are obje object cts s that that can can be instantiated only once.
java.utils. ja va.utils.zip zip Exceptions The Java utilities zip API throw s the following exceptions: • DataFormatException (format error) • ZipException (Zip error)
Built-In Exceptions Here Here applicatio application n create creates s a method method and forces forces it to divide divide by zero. zero. The method method does not have have to explicitly throw an exception because the division operator throws an exception when required. An example of a built-in exception.
import java.io.* ; import java.lang.Exception ; public class DivideBy0 { public static void main( String[] args ) { int a = 2 ; int b = 3 ; int c = 5 ; int d = 0 ; int e = 1 ; int f = 3 ; try { System.out.println( a+"/"+b+" = "+div( a, b ) ) ; System.out.println( c+"/"+d+" = "+div( c, d ) ) ; System.out.println( e+"/"+f+" = "+div( e, f ) ) ; }
catch( Exception except ) { System.out.println( "Caught exception " + except.getMessage() ) ; } } static int div( int a, int b ) { return (a/b) ; } }
The output of this application is shown here:
2/3 = 0 Caught exception / by zero The first call to div() works fine. The second call fails because of the divide-by-zero error. Even though the application did not specify it, an exception was thrown--and caught.
Applet Introduction An applet is a small program program that is intended intended not to be run on its own, but rather to be embedded embedded inside or launched from within another application. The most common use of applets are the small programs launched from Web pages. Applets are graphical and event driven but, for security reasons, may never access the file system of the platform on which they are run.
How Applets and Applications Applications Are Differe Different nt Java applications are standalone Java programs that can be run by using just the Java interpreter, for example, from a command line. Java applets are run from inside a World Wide Web browser. A reference to an applet is embedded in a Web page using a special HTML tag. When a reader, using a Java-enabled browser, loads a Web page with an applet in it, the browser downloads that applet from a Web server and executes it on the local system (the one the browser is running on). (The Java interpreter is built into the browser and runs the compiled Java class file from there.) Becau Because se Java Java applet applets s run inside a Java Java browse browser, r, they they have have acces access s to the struc structur ture e the browser browser provides: an existing window, an event-handling and graphics context, and the surrounding user interface. A single Java program can be written to operate as both a Java application application and a Java applet. While we use different procedures and rules to create applets and applications, none of those procedures or rules conflict with each other. The features specific to applets are ignored w hen the program runs as an application, and vice versa.
Limitation of Applet The restrictions on applets include the followin g:
• Applets can't read or write to the reader's file system, which means they cannot delete files or test to see what programs you have install ed on the hard drive. • Applets can't communicate with any network network server other than the one that had originally originally stored the applet, to prevent the appl et from attacking another system from the reader's system. • Applets Applets can't run any programs programs on the reader's reader's system. For UNIX systems, this includes forking a process. • Applets can't load programs native to the local platform, including shared libraries such as DLLs.
The Applet class • Is part of the java.applet package • Is an extension of the Panel class
• Must be the superclass of any applet that is to be embedded in a W eb page or viewed by a Java applet viewer. The Applet class provides a standard interface betw een applets and their environment. • Is subclassed to define an applet. For example,
public class MyApplet extends Applet begins begins the definitio definition n of a class class named named MyApple MyApplett that inherits inherits all the feature features s of the Object, Object, Compon Component, ent, Container, Panel, and Applet classes. All that remains is to supply custom features that define application processing. • Has many methods. The most frequently frequently used are:
Other methods exist for retrieving image files, retrieving and playing audio clips, and more.
Major Applet Activities Applets have many different activities that correspond to various major events in the life cycle of the applet-for example, 1. initialization, 2. painting, 3. and mouse events. Each activity has a corresponding method, so when an event occurs, the browser or other Javaenabled tool calls those specific methods. There are five of the most important methods in an applet's execution: 1. initialization, 2. starting, 3. stopping, 4. destroying, 5. and painting.
Initialization Initialization occurs when the applet is first loaded (or reloaded), similarly to the main() method in applications. The initialization of an applet might include reading and parsing any parameters to the applet, creating any helper objects it needs, setting up an initial state, or loading images or fonts. To provide behavior for the initialization of our applet, override the init() method i n our applet class:
public void init() { ... } Starting After an applet is initialized, it is started. Starting is different from initialization because it can happen
many different times during an applet's lifetime, whereas initialization happens only once. Starting can also occur if the applet was previously stopped. For example, An applet is stopped if the reader follows a link to a different page, and it is started again when the reader returns to this page. To provide startup behavior for your applet, override the start() method:
public void start() { ... } Stopping
Stopping Stopping occurs when the reader leaves the page that contains a currently running applet, or you can stop the applet yourself by calling stop(). By default, when the reader leaves a page, any threads the applet had s tarted will continue running. By overriding stop(), you can suspend execution of these threads and then restart them if the applet is viewed again:
public void stop() { ... }
Destroying Destroying enables the applet to clean up after itself just before it is freed or the browser exits-for example, to stop and remove any running threads, close any open network connections, or release any other running objects. Generally, we won't want to override destroy() unless we have specific resources that need to be released-for example, threads that the applet has created. To provide clean-up behavior for your applet, override the destroy() method:
public void destroy() { ... }
Painting Painting is how an applet actually draws something on the screen, be it text, a line, a colored background, or an image. Painting can occur many thousands of times during an applet's life . We override the paint() method if your applet needs to have an actual appearance on the screen (that is, most of the time). The paint() method looks like this:
public void paint(Graphics g) { ... } paint() takes an argument, an instance of the class Graphics. This object is created and passed to paint by the browser,
import java.awt.Graphics;
A Simple Applet The Hello Again applet import java.awt.Graphics;
import java.awt.Font; import java.awt.Color; public class Aman extends java.applet.Applet { Font f = new Font("TimesRoman", Font.BOLD, 36); public void paint(Graphics g) { g.setFont(f); g.setColor(Color.red); g.drawString("Hello again!", 5, 40); } }
This applet implements the paint() method, one of the major methods described in the previous section (actually, it overrides the default implementation of paint(), which does nothing). Because the applet doesn't actually do much (all it does is print a couple words to the screen), and there's not really anything to initialize, you don't need a start(), stop(), init(), or destroy() method.
The life cycle of a Web page applet The processing of all W eb page applets is as follows: 1. The applet's init() method is automatically called when the page containing the applet is loaded by the browser or applet viewer. Its purpose is to perform applet initialization and it is called only once during the life of the applet. For a simple applet, this is the only required method. An applet does not need a main() method. If one exists, it is ignored. 2. The applet's start() method is automatically called after init() and every time the page is revisited. Its purpose is to resume suspended applet processing when the user returns to the page after surfing. 3. The applet's stop() method is automatically called when the user surfs to another page or when the browser is being shut down. Its purpose is to suspend applet processing. 4. The applet's destroy() method is automatically called after stop() when the browser or applet viewer is being shut down. Its purpose is to release all applet resources and it is called only once during the life of the applet.
A sample applet The following statements define a small applet that displays a message when the user clicks a button. The button may then be re-cli cked to clear the message:
import java.awt.*; import java.awt.event.*; import java.applet.*; public class Aman extends Applet i mplements ActionListener { Button b = new Button("Show message"); TextField message = new TextField("", 15); public void init() { resize(300, 100); setBackground(Color.lightGray); b.addActionListener(this); add(b); message.setFont(new Font("Serif", Font.ITALIC, 24)); message.setForeground(Color.red);
message.setEditable(false); add(message); } public void actionPerformed(ActionEvent e) { if (message.getText().length() == 0) { message.setText("Hello world!"); b.setLabel("Clear message"); } else { message.setText(""); b.setLabel("Show message"); } } } Notes: 1. By importing the java.applet package, accessing the Applet class is made easier 2. The applet needs no WindowListener interface because it isn't a window 3. Processing begins with the init() method. It immediately resizes the window to override any size specified by the applet's HTML tag .Everything else about the applet is virtually the same as we would see in an equivalent windows program (with the exception of window event handling which isn't needed). 4. NOTE: The procedure for compiling a Java applet is identical to the procedure for compiling a Java program. To test the applet's bytecode, however,we must launch the applet viewer program. This is done by entering the command: appletviewer App.php
Including an Applet on a Web P age After we create a class or classes that contain our applet and compile them into class files as we would any other Java program, we have to create a Web page that will hold that applet by using the HTML language. There is a special HTML tag for including applets in Web pages; Java-enabled browsers use the information contained in that tag to locate the compiled class files and execute the applet itself.
The
