corejavaslides-12863050987442-phpapp02

7/27/2019 corejavaslides-12863050987442-phpapp02

1/175

JAVA FUNDAMENTALS

History

JDK and JRE

Byte Code and JVM (Java Virtual Machine)

Platform Independent

Applications and Applets

Principle of OOPs

First Java Application


2/175

History of JavaJava is a General Purpose, Object Oriented Programming Language

developed by Sun Microsystems of USA I 1991. Originally called Oak byGames Gosling, one of the invention of the language, java was designed

for the development of software for consumer electronic devices like

TVs, VCRs, toasters and such other electronic Machines.This goal had a

strong impact on the development team to make the language simple,

portable and highly reliable. The java team which included Patrick

Naughton discovered that the existing languages like C and C++ had

limitations in terms of both reliability and portability. However, they

modeled their new language Java on C and C++ but removed a number

of features of of C and C++ that were considered as source of problems

and thus made java really simple, reliable,portable and powerful

language.


3/175

Java Milestones :

1990 Sun Microsystems decided to develop special software that could be usedto manipulate consumer electronic devices. A team of Sun Microsystems

programmers headed by James Gosling was formed to undertake thistask.

1991 After exploring the possibility of most Object Oriented Programming

Language C++, the team announced a new language named Oak.1992 The team, known as a Green Project team by Sun, demonstrated the

application of their new language to control a list of home appliances

using a hand-held device with a tiny touch sensitive screen.1993 The World Wide Web(WWW) appeared on the internet and transformed

the text-based Internet into a Graphical-rich environment. The greenProject team came up with the idea of developing Web Applets(tinyprograms) using the new language that could run on all types ofcomputers connected to Internet.

1994 The team developed a web browser called HotJava to locate and runapplet programs on Internet. Hot Java demonstrated the power of thenew language, thus making it instantly popular among the Internet users.

1995 Oak was named Java, due to some legal snags. Java is just a name

and is not an acronym. Many popular companies including Netscape and

Microsoft announce to their support to Java.


4/175

1996 Java established itself not only a leader for Internet Programming but also asa general-purpose, object oriented programming language. Java found itshome.

The most striking feature of the language is that it is a platform-neutral language.Java is a first programming language that is not tied to any particular hardware oroperating system.

Features of Java :

Compiled and Interpreted. Platform-Independent and Portable Object-Oriented Robust and Secure Distributed

Familiar, Simple and Small Multithreaded and Interactive High Performance Dynamic and Extensible


5/175

JDK & JREJava Environment includes a large number of development tools and hundreds of classes and

methods. The development tools are part of the system known as Java Development Kit (JDK)and the classes and methods are part of the Java Standard Library (JSL), also known as the

Application Programming Interface (API).

JDK : Java Development Kit comes with a collection of tools that are used for developing and

running Java Programs. They include :

appletviewer-> Enables us to run Java Applets (Without using java compatible browser)

JavaJava Interpreter, which runs applets and applications by reading and interpreting bytecodefiles.

JavacThe Java compiler, which translates Java source code to byte code files that theinterpreter understad.

Javadoc Creates HTML-format documentation from Java source code files.JavahProduces header files for use with native methods.javapJava disassembler, which enables us to convert bytecode files into a program

description.

Jdb Java debugger, which helps us to find errors in our programs.


6/175

Byte Code & JVM(Java Virtual Machine)

Since platform-independence is a defining characteristic of Java, it is important to understand

how it is achieved. Programs exist in two forms; source code and object code. Source Code is

the textual version of the program that you write using a text editor. The programs printed in a

book are shown as source code. The executable form of a program is object code. The computer

can execute object code. Typically, object code is specific to a particular CPU. Therefore, it

cannot be executed on a different platform. Java removes this feature in a very elegant manner.

Like all computer languages, a java program begins with its source code. The difference is

what happens when a Java program is compiled. Instead of producing executable code, the Java

Compiler produces an object file that contains bytecode. Bytecodes are instructions that are not

for any specific CPU. Instead, they are designed to be interpreted by a Java Virtual Machine

(JVM). The key to Javas platform-independence comes from the fact that the same bytecodes

can be executed by any JVM on any platform. As long as there is a JVM implemented for a a

given environment, it can run any Java program. For example, Java programs can execute under

Windows 98,Solaris,IRIX, or any other platform for which a JVM can be implemented for that

platform. This would then allow any Java program to execute in that new environment.


7/175

Platform IndependentCompilation is the process of converting the code that you type into a language

that the computer understands-machine language. When you compile aprogram, the compiler checks for syntactical errors in code and lists all the

errors on the screen. You have to rectify the errors and recompile the program

to get the machine language code. The Java compiler compiles the code to

bytecode that is understood by the Java environment.

The bytecode is the result of compiling a Java program. You can execute thiscode on any platform. In other words, due to the bytecode compilation process

and interpretation by a browser, Java programs can be executed on a variety of

hardware and operating systems. The only requirement is that the system

should have a java-enabled Internet browser.The java compiler is written in

Java, and the interpreter is written in C. The Java Interpreter can execute Java

Code directly on any machine on which a Java interpreter has been installed.


8/175

Application and AppletsThere are two types of programs that can be built in Java Applications and applets.

Applications can be directly executed by a JVM. In fact, Java can be used to developprograms for all kinds of applications, Hot Java itself is a Java Application program.

Applets are small Java programs developed for Internet Applications. An applet located

on distant computer (Server) can be downloaded via Internet and executed on a local

computer (Client) using a Java enabled browser. We can develop applets for doing

everything from simple animated graphics to complex games and utilities. Since applets

are embedded in an HTML document and run inside a Web Page, creating and running

applets are more complex than creating application. Stand alone program can read and

write files and perform certain operations that applet can not do. An Applet can only run

within a Web Browser. The Web browser includes a JVM that provides an execution

environment for the applet. It is also possible to use a tool called the appletviewer to

run an applet. This utility is included in the Java Development Kit(JDK) and is used to

test applets. In this manner, an applet written by any developer in the world may be

dynamically downloaded from the Web Server and executed on a client PC orworkstation.


9/175

Java CompilerJava Program

Java Interpreter Machine Code

Virtual Machine

Bytecode

Source Code Bytecode

Virtual Machine Real Machine

Process of Compilation

Process of Converting bytecode into machine code


10/175

Java

Source

Code

Java Compiler

Java

Enabled

Browser

Java

Interpreter

Output Output

Application TypeApplet Type


11/175

Principal of OOPsObject Oriented Programming (OOP) attempts to emulate the real world in software systems.

The real world consists of objects, categorized in classes. In Object Oriented Programming,

classes have attributes, represented by data member. The attributes distinguish an object ofthe class. Classes have behaviors, which are represented by methods. The methods define

how an object acts or reacts.

Feature of Object Oriented Programming :

Information Encapsulation(Hiding) :- Objects provide the benefit of information hiding.

Electrical writing in a television should not be tempered with, and therefore should be hidden

from the user. Object Oriented programming allows you to encapsulate data that you do not

want users of the object to access. Typically, attributes of a class are encapsulated.Abstraction :-Abstraction allows us to focus on only those parts of an object that concern

us. Person operating the television does not need to know the intricacies of how it works. The

person just needs to know how to switch it on, change channels, and adjust the volume.All

the details that are unnecessary to users are encapsulated, leaving only a simple interface to

interact with. Providing users with only what they need to know is known as abstraction. i.e.

Abstraction lets us ignore the irrelevant details and concentrate on the essentials.


12/175

Inheritance :- Inheritance is the process by which objects of one class acquire the

properties of objects of another class. Inheritance supports the concept of

hierarchical classification. In OOP, the concept of inheritance provides the idea of

reusability. This means that we can add additional features to an existing class

without modifying it. This is possible by deriving a new class from the existing one.The new class will have the combined features of both the classes.

Polymorphism :- Polymorphism means One Interface, multiple implementations.

Shape

Ellipse Rectangle Triangle

The class Shape defines a method called getArea() that returns the area of a

shape. However, this method is not implemented by that class. Therefore, it is anabstract method and Shape is an abstract class.

This means that no objects of class Shape can be created. However, the

functionality of that class can be inheritated by its subclass. The various

subclasses of Shape like Ellipse,Rectangle,Triangle do implement the getArea()

method.


13/175

First Java Application Create the File

The first step to create the HelloWorld application is to copy the text fromlisting 7.1 into a file called HelloWorld.java using your favorite text editor (by

choosing Windows, NotePad, or SimpleText on the Macintosh). It is very

important to call the file HelloWorld.java, because the compiler expects the

file name to match the class identifier

Listing 7.1 The HelloWorld application.

public class HelloWorld {

public static void main(String args[]){System.out.println("Hello World!!");

}}


14/175

Class Declaration

The first line public class HelloWorld declares a class, which is an Object-Oriented

construct. As stated earlier Java is true Object-Oriented language and therefore,

everything must be placed inside a class. Class is a keyword and declares that anew class definition follows.

Opening Bace

Every class definition in Java begins with an opening brace { and ends with a

matching closing brace }, appearing in the last line in the example.

The main() method

Every java application program must include the main() method. This is starting

point for the interpreter to begin the execution of the program. A Java application

can have any number of classes but only one of them must include a main method

to initiate the execution.

Public : The Keyword public is an access specifier that declares the main method

as unprotected and therefore making it to accessible to all other classes.

Static : The keyword static which declares this method as one that belongs to the

entire Class and not a part of any Objects of the class.


15/175

The main must always be declared be declared as static since the interpreter uses

this method before any objects are created.

Void : The type modifier void states that the main method does not return any value.

All parameters to a method are declared inside a pair of parentheses. Here,

String args[] declares a parameter named args, which contains an array of objects

Of the class type String.

The Output Line

The only executable Statement in the program is

System.out.println("Hello World!!");

Since Java is a true Object Oriented Language, every method must be part of an

Object. The println method is a member of the out Object, which is static data

Member of the System class. This line prints

Hello World!!to the screen. The method println always appends a newline character to the end

of the string.


16/175

Compile the Code

To compile the program, you need to first install the JDK. Then, use the program

javac included with the JDK to convert the text in listing 7.1 to code which the

computer can run. To run javac, on a Macintosh drag the source file over the javacicon. On any other computer, type the line:

javac HelloWorld.java

at a command prompt. The javac program creates a file called HelloWorld.class

from the HelloWorld.java file. Inside this file (HelloWorld.class) is text known as

bytecodes which can be run by the Java interpreter.

Run the ProgramNow that you have compiled the program, you can run it by typing at the command

prompt:

java HelloWorld

After you do this, the computer should print to the screen

Hello World!!

That may not seem very interesting, but then it's a simple program. If you don't seethe Hello World!! on the screen, go back and make sure you have typed in the file

exactly as shown in listing 7.1, and make sure that you called the file

HelloWorld.java.


17/175

JAVA CONTROLS Variables and Constants

Arithmetic Operator and Expressions

Type Conversion in Java

Comments in Java(3 Types)

Javas Control Statements

o If

o If-else

o

Do-whileo While

o for

o Increment and Decrement Operators

o Escape Sequences Characters

o Relational and Logical Operators

o Ternary Operatorso Switch case

o Break

o Bitwise Operators

o Arrays-Single and Multidimensional


18/175

Variables and ConstantsConstants : Constants in Java refer to fixed values that do not change during the

execution of a program. Java supports several types of constants given in figure below :

Java Constant

Numeric Constant Character Constant

Integer Real Character String

Integer Constants : Refers to a sequence of digits. There are three types of

Integers, namely, decimal,octal and hexadecimal integer.

Decimal Integer consist of of a set of digits, 0 through 9, preceded by an optional

minus sign.

An octal integer constant consists of any combination of digits from the set 0

through 7, with a leading 0.

A sequence of digits preceded by ox or OX is considered as hexadecimal integer.

They may also include alphabets A through F.


19/175

Real Constants : Integer constant are inadequate to represent quantities that vary

continuously, such as distance, heights, temperature, prices and so on. These

quantities are represented by numbers containing fractional parts like 17.546.

Such numbers are called real.

The real number may also be expressed in exponential (or scientific ) notation.

For example, the value 215.65 may be written as 2.1565e2 in exponential

notation. e2 means multiply by 102. The general form is :

mantissa e exponent

mantissa is either a real number expressed in decimal notation or an integer. The

exponent is an integer with an optional plus or minus sign. The letter e separatingthe mantissa and the exponent can be written in either lowercase or uppercase.

Since the exponent causes the decimal point to float, this notation is said to

represent a real number in floating point form.


20/175

Single Character Constants : A single character constant (or simply character

constant ) contains a single character enclosed within a pair of single quote marks.

Examples of character constants are : 5 X ;

String Constant : A string constant is a sequence of characters enclosed betweendouble quotes. The characters may be alphabets,digits,special characters and

blank spaces. Example are : Hello Java 1997

Variable : A variable is an Identifier that denotes a storage location used to store a

data value. Unlike constants that remain unchanged during the execution of program.

Examples of variables : average,height,total_height.

Variable name may consist of alphabets,digits,the underscore(_) and dollor

characters.

Rules to write Variable/Identifier in Java :

They must not begin with digit

Upper and lowecase are distinct. This means that the variable Total is not the samas total or TOTAL.

It should not be a keyword.

White space is not allowed.

Variable names can be of any length.


21/175

Data TypesData Types in Java

Primitive (Intrinsic) Non-Primitive ( Derived)

Numeric Non-Numeric Classes Arrays

Integer Floating

PointCharacter Boolean

Interface

Integer Types

Java consists of four integer types: byte, short, int, and long, which are defined as 8-,16-, 32-, and 64-bit signed values as summarized in Table below :


22/175

The Java integer primitive types.

Type Bit Size Minimum Value Maximum Value

byte 8 -256 255short 16 -32,768 32,767

int 32 -2,147,483,648 2,147,483,647

long 64 -9,223,372,036,854,775,808 9,223,372,036,854,775,807

Integer literals can be specified in decimal, hexadecimal, or octal notation. To specify a decimal

value, simply use the number as normal. To indicate that a literal value is a long, you can append

either "L" or "l" to the end of the number. Hexadecimal values are given in base 16 and include

the digits 0-9 and the letters A-F. To specify a hexadecimal value, use 0x followed by the digits

and letters that comprise the value. Similarly, an octal value is identified by a leading 0 symbol.For examples of specifying integer literals, see Table 3.7.


23/175

Integer Long Octal Hexadecimal

0 0L 0 0x01 1L 01 0x1

10 10L 012 0xA

15 15L 017 0XF

16 16L 020 0x10

100 100L 0144 0x64

Table 3.7. Examples of integer literals.

Floating-Point Types

Support for floating-point numbers in Java is provided through two primitive types-float

and double, which are 32- and 64-bit values, respectively.

Similar to integer literals are Java's floating-point literals. Floating-point literals can be specified ineither the familiar decimal notation (for example, 3.1415) or exponential notation (for example, 6.02e23).

To indicate that a literal is to be treated as a single precision float, append either "f" or "F". To indicate that


24/175

it is to be treated as a double precision value, append either "d" or "D".

Java includes predefined constants, POSITIVE_INFINITY, NEGATIVE_INFINITY, and

NaN, to represent the infinity and not-a-number values.

The following list shows some valid floating-point literals:

43.3F,3.1415d,-12.123f,6.02e+23f,6.02e23d,6.02e-23f,6.02e23d

Boolean :- Java supports two Boolean literals-true and false.

Character Literals :-A character literal is a single character or an escape sequence enclosed insingle quotes, for example, 'b'. Escape sequences are used to indicate special characters or

actions, such as line feed, form feed, or carriage return. The available escape sequences ar shown

in Table 3.8.

String Literals

Although there is no string primitive type in Java, you can include string literals in yourprograms. Most applications and applets will make use of some form of string literal,

probably at least for error messages. A string literal consists of zero or more characters

(including the escape sequences shown in Table 3.8) enclosed in double quotes. As

examples of string literals, consider the following: "A String,"Column 1\tColumn 2


25/175

Table 3.8. Escape sequences.

Sequence Purpose

\b Backspace

\t Horizontal tab

\n Line feed

\f Form feed

\r Carriage return

\" Double quote

\' Single quote

\\ Backslash

\uxxxx Unicode character


26/175

Arithmetic Operators and ExpressionsAn expression is a operators and operands. It follows the rules of algebra and should

be familiar. Java allows several types of expressions. The arithmetic operators are

given below :

+ addition

-subtraction

*multiplication

/ division

% modulus

+= addition assignment

-=subtraction assignment

*=multiplication assignment

/=division assignment

%=modulus assignment

++increment,--decrement


27/175

An expression may appear on the right side of an assignment statement. For

example,

Int answer;

Answer=100*31;

Java expression may contain Variables, constants or both. For example assuming

that answer and count are variables, this expression is perfectly valid.

Answer=count-100;


28/175

Increment/Decrement Operators

The increment and decrement operators are used with one variable (they are known as

unary operators):

++ increment operator

-- decrement operatorFor instance, the increment operator (++) adds one to the operand, as shown in the next line

of code:

x++;

is the same as

x+=1;

The increment and decrement operators behave slightly differently based on the side of theoperand they are placed on. If the operand is placed before the operator (for example, ++x),

the increment occurs before the value is taken for the expression. So, in the following code

fragment, the result of y is 6:

int x=5;int y=++x; // y=6 x=6

If the operator appears after the operand, the addition occurs after the value is taken. So y is

5 as shown in the next code fragment. Notice that in both examples, x is 6 at the end of thefragment.

int x=5;int y = x++; //y=5 x=6

Similarly, the decrement operator (--) subtracts one from the operand, and the timing of this

is in relation to the evaluation of the expression that it occurs in.


29/175

The Relational Operators

The most intuitive comparative operators are those that fall into a category known

as relational operators. Relational operators include those standard greater-than

and less-than symbols you learned about back in third grade. Conveniently enough,

they work the same way as they did back in third grade, too. For instance, youknow that if you write (3>4), you wrote something wrong (false). On the other hand

(3

Republicans) is also valid. The complete list of relational operators is shown here:

Operator Boolean Result

< Less than Greater than

>= Greater than or equal to

The following two assignment statements produce identical results:

result1 = a+b < c*d ;

result2 = (a+b) < (c*d) ;Log ical Express ions

The third set of evaluation operators fall into a category known as logical

expressions. Logical expressions work a bit differently than the previous operators,

and are probably not something you covered in your third grade math class.


30/175

Logical expressions operate either on a pair of booleans, or on the individual bits of an

object. There are two types of logical operators which are divided roughly along these

lines:

Boolean operators. Only operate on Boolean values.

Bitwise operators. Operate on each bit in a pair of integral operands.

The Conditional-And and Conditional-Or Operators

There are two primary Boolean operators:

Logical-AND: &&

Logical-OR: ||

Oddly, in most computer languages, including Java, there is no Conditional-XORoperator.

When A isAnd when B is (A && B) (A || B)

false false false false

false true false true

true false false true

true true true true


31/175

The Condit io nal Operator

The conditional operator is the one ternary or triadic operator in Java, and

operates as it does in C and C++. It takes the following form:

expression1 ? expression2: expression3

In this syntax, expression1 must produce a Boolean value. If this value is true,then expression2is evaluated, and its result is the value of the conditional. If

expression1 is false, then expression3 is evaluated, and its result is the value of

the conditional.

Consider the following examples. The first is using the conditional operator to

determine the maximum of two values; the second is determining the minimum

of two values; the third is determining the absolute value of a quantity:BestReturn = Stocks > Bonds ? Stocks : Bonds ;

LowSales = JuneSales < JulySales ? JuneSales : JulySales ;

Distance = Site1-Site2 > 0 ? Site1-Site2 : Site2 - Site1 ;

In reviewing these examples, think about the precedence rules, and convince

yourself that none of the three examples requires any brackets in order to be

evaluated correctly.


32/175

Type Conversion in JavaImplicit Type Conversions

Java performs a number of implicit type conversions when evaluating expressions.

For unary operators (such as ++ or --), the situation is very simple: operands of typebyte or short are converted to int, and all other types are left as-is.

For binary operators, the situation is only slightly more complex. For operations involving only

integer operands, if either of the operands is long, then the other is also converted to long;

otherwise, both operands are converted to int. The result of the expression is an int, unless the

value produced is so large that a long is required. For operations involving at least one floating

point operand, if either of the operands is double, then the other is also converted to double andthe result of the expression is also a double; otherwise, both operands are converted to float, and

the result of the expression is also a float.

Fortunately, implicit conversions take place almost always without your wanting or needing to

know. The compiler handles all the details of adding bytes and ints together so you don't have to.

short Width;

long Length, Area;

Area = Length * Width;// In the division below, Area will be converted to a double,// and the

result of the calculation will be a double.


33/175

Conversions and the Cast Operator :

Normally with implicit conversion, the conversion is so natural that you don't even

notice. Sometimes though it is important to make sure a conversion occurs between two

types. Doing this type of conversion requires an explicit cast, by using the cast operator.

The cast operatorconsists of a type name within round brackets. It is a unary operatorwith high precedence and comes before its operand, the result of which is a variable of

the type specified by the cast, but which has the value of the original object. The

following example shows an example of an explicit cast:

float x = 2.0;

float y = 1.7;

x - ( (int)(x/y) * y)When x is divided by y in this example, the type of the result is a floating-point number.

However, value of x/y is explicitly converted to type int by the cast operator, resulting in

a 1, not 1.2. So the end result of this equation is that x equals 1.7.

Not all conversions are legal. For instance, boolean values cannot be cast to any other

type, and objects can only be converted to a parent class.

Casting and Converting IntegersThe four integer types can be cast to any other type except boolean. However,

casting into a smaller type can result in a loss of data, and a cast to a floating-

point number (float or double) will probably result in the loss of some precision,

unless the integer is a whole power of two (for example, 1, 2, 4, 8...).


34/175

Casting and Converting Characters

Characters can be cast in the same way 16-bit (short) integers are cast; that is,

you can cast it to be anything. But, if you cast into a smaller type (byte), you lose

some data. In fact, even if you convert between a character and a short you an

loose some data.If you are using the Han character set (Chinese, Japanese, or Korean), you can

lose data by casting a char into a short (16-bit integer), because the top bit will

be lost.

Casting and Converting Booleans

There are not any direct ways to cast or convert a Boolean to any other type.

However, if you are intent on getting an integer to have a 0 or 1 value based onthe current value of a Boolean, use an if-else statement, or imitate the following

code:

int j;boolean tf;...j = tf?1:0; // integer j gets 1 if tf is true, and 0 otherwise.

Conversion the other way can be done with zero to be equal to false, and

anything else equal to true as follows:

int j;boolean tf;...tf = (j!=0); // Boolean tf is true if j is not 0, false otherwise.


35/175

Comments in JavaJava supports three types of comment delimiters-the traditional /*

and */ of C, the // of C++, and a new variant that starts with /** and

ends with */.The /* and */ delimiters are used to enclose text that is to be treated as a

comment by the compiler. These delimiters are useful when you want to

designate a lengthy piece of code as a comment, as shown in the

following:

/* This is a comment that will span multiple source code lines. */

The // comment delimiter is borrowed from C++ and is used to indicate that

the rest of the line is to be treated as a comment by the Java compiler.This type of comment delimiter is particularly useful for adding comments

adjacent to lines of code, as shown in the following:

Date today = new Date(); // create an object with today's date

System.out.println(today); // display the date

Finally, the /** and */ delimiters are new to Java and are used to indicate that the enclosed text

is to be treated as a comment by the compiler, but that the text is also part of the automaticclass documentation that can be generated using JavaDoc


36/175

The Java comment delimiters are summarized in Table 3.1.

Table 3.1. Java comment delimiters.

Start End Purpose

/* */ The enclosed text is treated as a comment.

// (none

)

The rest of the line is treated as a comment.

/** */ The enclosed text is treated as a comment by the compiler but isused by JavaDoc to automatically generate documentation.


37/175

Java Control Statements

if

Selection Statement Iteration Statement Jump Statement

If-else switch

while do for

breakconti

nuereturn

Control

Statement


38/175

Selection Statement : These select one of several control flows. There are

three types of selection statement in Java : if,if-else, and switch.

If statement :

The if statement is a powerful decision making statement and is used to control

the flow of execution of statements. It is a two-way decision statement and is

used in conjunction with an expression. The general form is :

If(test expression)

{Statement-block;

}

Statement-x;

It allows the computer to evaluate the expression first and then, depending onwhether the value of the expression (relation or condition) is true or false. It

transfers the control to a particular statement.

If the statement is true then the Statement block will be executed;otherwise the

statement-block will be skipped and the execution will jump to the statement-x.

It should be remember that when the condition is true both the statement-block

and statement-x are executed in sequence.


39/175

Example :

Class Demo {

public static void main(String args[]) {

If(args.length==0)

System.out.println(You must have command line arguments); }}

If-else statement

if(test expression){

True-Block Statement(s);

}

Else

{

False-Block statement(s);

}

Statement-x;


40/175

If the test expression is true, then the true-block statement(s) executed

immediately following to the if statement, are executed; otherwise the false

statement(s) will be executed, not both.In both the cases, the control is

transferred subsequently to the statement-x.

Nesting of Ifelse Statement

If(test condition1)

{ if(test condition2) {

Statement-1; }

else {

Statement-2; }

}

else {

Statement-3; }

Statement-x;

If the condition-1 is false, the statement-3 will be executed; otherwise it

continues to perform the second test. If the condition-2 is true, the statement-1

will be evaluated;otherwise statement-2 will be evaluated and then control istransferred to the statement-x.


41/175

Switch Statement: The Java switch statement is ideal for testing a single

expression against a series of possible values and executing the code

associated with the matching case statement.

Switch(expression) {Case value-1:

block-1;

break;

Case value-2:

block-2;

break;

default:

default-block;

break; }

Statement-x;


42/175

Iteration Statement : These specify how and when looping will take place. There

are three types of Iteration statements: while, do and for

The for Statement

The first line of a for loop enables you to specify a starting value for a loopcounter, specify the test condition that will exit the loop, and indicate how the loop

counter should be incremented after each pass through the loop. This is definitely

a statement that offers a lot of bang for the buck. The syntax of a Java for

statement is as follows:

for (initialization; testExpression; incremement)

statementFor example, a sample for loop may appear as follows:

int count;

for (count=0; count


43/175

The while Statement

Related to the for loop is the while loop. The syntax for a while loop is as

follows:

while (booleanExpression)

statementAs you can tell from the simplicity of this, the Java while loop does not have

the built-in support for initializing and incrementing variables that its for loop

does. Because of this, you need to be careful to initialize loop counters prior

to the loop and increment them within the body of the while loop. For

example, the following code fragment will display a message five times:

int count = 0;

while (count < 5) {

System.out.println("Count = " + count);

count++;

}

The dowhile Statement

The final looping construct in Java is the dowhile loop. The syntax for a

dowhile loop is as follows:

do {

statement

} while (booleanExpression);


44/175

This is similar to a while loop except that a dowhile loop is guaranteed to execute

at least once. It is possible that a while loop may not execute at all depending on

the test expression used in the loop. For example, consider the following method:

public void ShowYears(int year) {

while (year < 2000) {System.out.println("Year is " + year);

year++;

}

}

This method is passed a year value, then loops over the year displaying a

message as long as the year is less than 2000. If year starts at 1996, thenmessages will be displayed for the years 1996, 1997, 1998, and 1999. However,

what happens if year starts at 2010? Because the initial test, year < 2000, will be

false, the while loop will never be entered. Fortunately, a dowhile loop can solve

this problem. Because a dowhile loop performs its expression testing after the

body of the loop has executed for each pass, it will always be executed at least

once. This is a very valid distinction between the two types of loop, but it can alsobe a source of potential errors. Whenever you use a dowhile loop, you should be

careful to consider the first pass through the body of the loop.


45/175

Jumping

Of course, it is not always easy to write all of your for, while and dowhile loops so

that they are easy to read and yet the loops terminate on exactly the right pass

through the loop. Java makes it easier to jump out of loops and to control other

areas of program flow with its break and continue statements.The break Statement

Earlier in this chapter, you saw how the break statement is used to exit a switch

statement. In a similar manner, break can be used to exit a loop

As an example of this, consider the following code:

int year = 1909;

while (DidCubsWinTheWorldSeries(year) == false) {

System.out.println("Didn't win in " + year);

if (year >= 3000) {

System.out.println("Time to give up. Go White Sox!");

break;

}}

System.out.println("Loop exited on year " + year);


46/175

This example shows a while loop that will continue to execute until it finds a year

that the Chicago Cubs won the World Series. Because they haven't won since

1908 and the loop counter year starts with 1909, it has a lot of looping to do. For

each year they didn't win, a message is displayed. However, even die-hard

Cubs fans will eventually give up and change allegiances to the Chicago WhiteSox. In this example, if the year is 3000 or later, a message is displayed and

then a break is encountered. The break statement will cause program control to

move to the first statement after the end of the while loop. In this case, that will

be the following line:

System.out.println("Loop exited on year " + year);

The continue StatementJust as a break statement can be used to move program control to immediately

after the end of a loop, the continue statement can be used to force program

control back to the top of a loop


47/175

ARRAYS

One Dimensional Array : is a list of variables of the same type that areaccessed through a common name. An Individual variable in the array is

called an array element. Arrays from a convenient way to handle groups ofrelated data.

To create an array, you need to perform two steps :

1. Declare Array

2. Allocate space for its elements.

General Form for declaring one dimensional array given below :

type varName[];

Here, type is a valid Java data type and varName is the name of the array. Like

int a[];

This creates a variable named a that refers to an integer array. But it does not

actually create storage for the array.

Second approach to allocate space for One Dimensional Array is


48/175

varName=new type[size];

Here varName is name of the array, type is a valid Java type, and size

specifies the number of elements in the array. You can see that the new

operator is used to allocate memory for the array.These two steps combines like

type varName=new type[size];

For example consider this declaration and allocation :

Int ia=new int[10];

Represents the structure of a one-dimensional array,here ia is array variable

name that can hold 10 integer values.

Multidimensional Array :

In addition to one dimensional we can create arrays of two or more

dimensions. In Java, Multidimensional array are implemented as arrays of

arrays. You need to perform two steps to work with multidimensional arrays : 1.

Declare the array and 2. allocate space for its elements.


49/175

The General form is given below :

Type varname = new type[size1][size2];

float a[][]=new float[2][2];

Here a is two dimensional array having 2 rows and 2 columns. i.e. size is 4,

we can store 4 elements in that array.


50/175

JAVA Classes and Methods

The General Form of a class Constructor and Method Overloading

The new Operator

Garbage Collection Finalize method

Command Line Arguments

The System Class


51/175

The General Form of ClassA class array contains three types of items : variable,methods, and constructors.

Variable represent its state. Method provide the logic that constitutes the

behavior defined by a class. The variable and methods can be both static and

instance variable. Constructors initialize the state of a new instance of a class.The Simplified form of a class is :

class clsName {

//instance variable declarations

type1 varName1=value1;

type2 varName2=value2;

..

//constructor

clsName(cparams1) {

// body of constructor

}


52/175

clsName(cparamsN) {

//body of constructor

}

//methods

rtype1 mthName(mparams1) {

//body of method

}

..

}

}

The keyword class indicates that a class named clsName is being declared. This

name must follow the Java naming convention for identifiers. The instance

Variables named varName1 through varNameN included using the normal

variable declaration syntax. Each variable must be assigned a type shown as

type1 through typeN and may be initialized to value shown as value1 through


53/175

type1 through typeN and may be initialized to value shown as value1 through

valueN.

Constructors always have the same name as the class. They do not have return

values.

Method named mthName1 through mthNameN can be included. The return type ofthe methods are rType1 through rtypeN, and their Optional Parameter lists are

mparams1 through mparamsN.

Constructors

Often an object will require some form of initialization when it is created. To

accommodate this, Java allows you to define constructor for your classes. A

Constructor is a special method that creates and initializes an object of a particular

class. It has the same name as its class and may accept arguments. Constructor

does not have a return type. Instead, a constructor returns a reference to the

object that it creates.

Constructor Overloading

A class may have several constructors. This feature is called constructor

overloading. When constructors are overloaded each is still called by the name of

its class. However it must have a different parameter list. i.e. Signature of each

constructor must differ.


54/175

Method Overloading

Like Constructor, method can also be overloaded. This occurs when two or more

methods have the same name but different signature. Recall that the signature of

a method is a combination of its name and the sequence of the parameter types.

Method Overloading allows you to use the same name for a group of methods that

basically have the same purpose. The println() is an good example of this concept.

It has so many Overloaded forms.Each of these accepts one argument of a

different type. Another advantage of method overloading is that it provides an easy

way to handle default parameter values.

The New OperatorObjects are created using the new operator. The new Operator creates an

instance of a class. It is invoked as follows :

clsName obhRef=new clsName(args);

Here, clsName is the name of the class to instantiated. (Instantiated means to

create an instance.) A reference to the new object is assigned to a variable named

objRef. Notice the expression immediately to the right of the keyword new. This isknown as constructor. A constructor creates an instance of the class. It has the

same name as the class and may optionally have an argument list args.


55/175

Garbage Collection

Garbage collection is the mechanism that reclaims the memory resources of an

object when it is no longer referenced by a variable. It prevents programming

errors that could otherwise occur by incorrectly deleting or failing to delete

objects. An object becomes eligible for garbage collection when it is no longer

referenced by any Variable. However, the JVM determines exactly when this

task is performed.

finalize method :

Constructor method used to initialize an object when it is declared. This process

is known as initialization. Similarly, Java supports a concept called finalization,

which is just opposite to Initialization. We know that java run-time is an

automatic garbage collecting system. It automatically frees up the memory

resources used by the objects. But objects may hold other non-object resources

such as file descriptors or window system fonts. The garbage collector cannot

free these resources. In order to free these resources we must use a finalizer

method. This is similar to destructor of C++.The finalizer method is simply finalize() and can be added to any class. Java

calls that method whenever it is about to reclaim the space for that object. The

finalize method should explicitly define the tasks to be performed.


56/175

Command Line Arguments

All java application contain a static method named main().This method takes

one argument that is an array of String objects. These objects represent any

arguments that may have been entered by the user on the command line.The number of command line arguments is obtained via the expression

args.length. This is an int type. The individual arguments are accessed as

arg[0],args[1],args[2], and so forth.

The System Class

The system class defines several attributes relate to the run-timeenvironment. It has a static variable named out that contains a reference to a

PrintStream object. The print() and println() methods of that object display

their string arguments on the standard output. The static variable erralso

holds a reference to PrintStream object. This is the standard error stream.

The static variable in contains a reference to an InputStream object.

PrintStream and InputStream are classes that provide support for I/O.Another static method of the system class is exit(). It determines the current

application.

l d h d


57/175

Using Classes and Methods

Instance Methods and Variables Static keyword

Inner Class/Nested Classes

String Class Math Class

Wrapper Class

Instance Variables and Methods


58/175

Instance Variables and Methods

Each object has its own copy of all the instance variables defined by its class.

Thus an Instance variable relates to an instance (object) of its class. Instance

variable may be declared by using the following form :

type varName1;

Here, the name of the variable is varName1 and the required type is type.

Instance variables are initialized to default values during the creation of an object.

A Instance Method acts upon an object and can be declared, as follows:

rtype mthname(mparams) {

//body of method

}Here mthName is the name of the method and type is its return type.

Static Variables and Methods

A static variable is shared by all objects of its class and thus relates to the class

itself. A static variable may be declared by using the static keyword as a modifier

as follows:

static type varName1;Here the name of the variable ios varName1 and its type is type.

Static variables are initialized to default values when the class loaded into the

memory.

A static method may be declared by using the static keyword as a modifier A


59/175

A static method may be declared by using the static keyword as a modifier. A

static method acts relative to a class. It deos not act on specific objects of its

class. To declare a static method as :

static rtype mthName(mparams) {

//body of method

}

}

Here mthName is the name of the method and rtype is its return type an

optional list of parameter types shown as mparams may be specified.

String ClassStrings are class instantiated object and implemented using String Class.

String class expressed as :

String stringName=new String(string);

A string class defines a number of methods that allows you to accomplish a

variety of string manipulation tasks like compareTo() method used to sort an

array of strings in alphabetical order.


60/175

Math Class

Mathematical functions such as cos,sqrt, log etc. are frequently used to

analysis of real-life problems. Java supports these basic functions through

Math class defined in the java.lang package.The math function used as followsMath.function_name();

Like double y=Math.sqrt(x);

Wrapper Class

There are wrapper classes for each of the eight simple types defined by Java.These are Boolean, Character, Byte,Integer,Float,Long,Short and Double.

They encapsulate boolean,char,byte,int,float,long,short and double values.The

Benefit of using wrapper classes is that they provide methods to convert

strings to simple types. This is a very useful because it gives us a mechanism

by which to process user input.

I h i


61/175

Inheritance

Single and Multilevel

Call by value and Call by reference

Method Overriding

this and super keyword

Abstract and Final Classes

Class Inheritance


62/175

Class Inheritance

In Java, every class you declare will be derived from another class. You can

specify the class to derive from by using the extends keyword as follows:

public class ClassicCar extends Car {

// member methods and variables}

A derived class is commonly referred to as a subclass, while the class it is derived

from is commonly referred to as a superclass. The term immediate superclass is

used to describe the class from which a subclass is directly derived. In Figure 3.5,

for example, ClassicCar is a subclass of both Car and Object. Car and Object are

both superclasses of ClassicCar, but only Car is the immediate superclass of

ClassicCar.

Fig 3.5

Call By Value and Call By Reference (Argument Passing)


63/175

Call By Value and Call By Reference (Argument Passing)

All methods are passed by value. This means that copies of the arguments are

provided to a method. Any changes to those copies are not visible outside

method.

The situation when an array of objects are passed as an argument. In this case

the entire array or object is not actually copied.Instead, only a copy of the

reference is provided. Therefore any changes to the array or object are visible

outside the method. However the reference itself is passed by value.

Overriding Member Methods


64/175

Overriding Member Methods

When you create a subclass, you inherit all of the functionality of its superclass,

and then you can add or change this functionality as desired. As an example of

this, consider the altered declaration of a Car class in the following code:

public class Car {private int year;

private float originalPrice;

// calculate the sale price of a car based on its cost

public double CalculateSalePrice() {

double salePrice;

if (year > 1994)salePrice = originalPrice * 0.75;

else if (year > 1990)

salePrice = originalPrice * 0.50;

else

salePrice = originalPrice * 0.25;

return salePrice;}

// a public constructor

public Car(int year float originalPrice) {


65/175

public Car(int year, float originalPrice) {

this.year = year;

this.originalPrice = originalPrice;

}

}

ClassicCar is derived from Car, as follows:

public class ClassicCar extends Car {



return 10000;}

// a public constructor

public ClassicCar(int year, float originalPrice) {

super(year, originalPrice);

}

}

Because ClassicCar is derived from Car, it inherits all of the functionality of Car,


66/175

including its member variables year and originalPrice. The function

CalculateSalePrice appears in both class declarations. This means that the

occurrence of this function in ClassicCar overrides the occurrence of it in Car for

object instances of ClassicCar. As an example of how this works, consider the

following: ClassicCar myClassic = new ClassicCar(1920, 1400);

double classicPrice = myClassic.CalculateSalePrice();

Car myCar = new Car(1990, 12000);

double price = myCar.CalculateSalePrice();

The variable myClassic is of type ClassicCar and is constructed using that class's

constructorClass Modifiers

Classes that are created in Java can be modified by any of three class

modifiers. The Java class modifiers are public, final, and abstract. If no class

modifier is used, then the class may only be used within the package in which it

is declared. A public class is a class that can be accessed from other packages.

A class that is declared as final cannot be derived from, meaning it cannot havesubclasses.

The this Variable


67/175

public class Car {

String manufacturer;String model; int year;

int passengers; // a public constructor

public Car(String madeBy, String name, int yr, int pass,float cst) {

manufacturer = madeBy;

model = name;

year = yr;passengers = pass;

cost = cst;} }

All Java classes contain a hidden member variable named this. The this member

can be used at runtime to reference the object itself. One excellent use of this is in

constructors. It is very common to have a set of instance variables in a class that

must be set to values that are passed to a constructor. When you are doing this, it

would be nice to have code that was similar to the following:year = year;

Ideally the variable on the left could be the instance variable, and the variable on

the right could be the parameter passed to the constructor.

Here, we've had to come up with two names for each concept: the best variable


68/175

Here, we ve had to come up with two names for each concept: the best variable

names (manufacturer, model, and so on) are used as the instance variables in

the class declaration. The less satisfactory names are passed as parameters

so as to distinguish them from the instance variables. The assignment

statements are then very readable by Java but seem a little contrived to human

readers. Java's this keyword provides a very effective solution to this problem

in that the constructor can be written as follows:public class Car {

String manufacturer;

String model;

int year;int passengers;

float cost;



return cost * 1.5;

} // a public constructorpublic Car(String manufacturer, String model, int year,int passengers, float

cost) { this.manufacturer = manufacturer;

this.model = model;

this year = year;


69/175

In this case, the variables like this.year refer to the instance variables, whereasthe unqualified variables like year refer to the constructor's parameters.

this.year = year;

this.passengers = passengers;

this.cost = cost; } }

The super Variable


70/175

p

In the preceding declaration for ClassicCar, you may have noticed that the

constructor made use of a variable named super. Just as each object has a this

variable that references itself, each object (other than those of type Object itself)

has a super variable that represents the parent class. In this case, super(year,

originalPrice) invokes the constructor of the superclass Car.

Use of Super

Super is used to invoke the constructor method of the superclass.

Super may be only used within a subclass constructor method. The call to superclass constructor must appear as the first statement within the

subclass constructor.

The parameters in the super call must match the order and type of the inheritance

variable declared in the subclass.

Abstract Classes


71/175

Sometimes you may want to declare a class and yet not know how to define all of

the methods that belong to that class. For example, you may want to declare a

class called Mammal and include in it a member method called MarkTerritory.

However, you don't know how to write MarkTerritory because it is different for each

type of Mammal. Of course, you plan to handle this by deriving subclasses ofMammal, such as Dog and Human. But what code do you put in the MarkTerritory

function of Mammal itself?

In Java you can declare the MarkTerritory function of Mammal as an abstract

method. Doing so allows you to declare the method without writing any code for it

in that class. However, you can write code for the method in the subclass. If a

method is declared abstract, then the class must also be declared as abstract. For

Mammal and its subclasses, this means they would appear as follows:

abstract class Mammal {

abstract void MarkTerritory();

}

public class Human extends Mammal {

public void MarkTerritory() {

// mark territory by building a fence

}

}

public class GangMember extends Mammal {


72/175

p g {


// mark territory with graffiti

}

}

public class Dog extends Mammal {


// mark territory by doing what dogs do

}

}With the preceding declarations, the Mammal class contains no code for

MarkTerritory. The Human class could contain code that would mark territory by

building a fence around it, while the GangMember class could contain code that

would mark territory by spray-painting graffiti. The Dog class would mark territory

by raising the dog's leg and doing what dogs do to mark territory.

Final Variables Methods and Class


73/175

Final Variables, Methods and Class

All methods and variables can be overridden by default in subclasses. If we

wish to prevent the subclasses from overriding the members of the super class,

we can declare them as final using the keyword final as a modifier. For example

:final int SIZE=100;

final void showStatus()

Making a method final ensures that the functionality defined in this method will

never be altered in any way. Similarly the value of a final variable can never be

change.

Sometimes we may like to prevent a class being further subclassed for security

reasons. A class that can not be subclassed is called a final class. This is

achieved in Java using the keyword final as follows:

Final class AClass ( .)

Any attempt to inherit these classes will cause an error and the compiler will not

allow it.

STRINGS


74/175

STRINGSStrings represent a sequence of characters. The easiest way to represent a sequence

of characters in Java is by using a character array. Example : char charArray[]=new

char[4];

We can declare string using Characters but there is limitation that we can not use

functions related with strings using array like copy of an array is difficult. For that

Java provides String class using objects.

for that two classes are used String and StringBuffer. A Java String is an

instantiated object of the String class.

String stringName;

stringName=new String ("string");

String Array :

String itemArray[]=new String[3];//will create itemArray of size 3 to hold three

string constants.

String Methods :


75/175

The String Class defines a number of methods that allow us to accomplish a veriety of string

manipulation tasks.

s2=s1.toLowerCase; //converts the string s1 to all lowercase

s2=s1.toUpperCase; //converts the string s1 to all Uppercase

s2=s1.replace('x','y'); //Replace all occurance of x with y

s2=s1.trim() //Removes the white spaces at the beginning and end of the String s1.

s1.equals(s2) //Returns true if s1 is equal to s2

s1.equalsIgnoreCase(s2) //Returns true if s1=s2, ignoring the case of characters.s1.length() //Gives the Length of s1

s1.charAt(n) //Gives nth character of s1

s1.compareTo(s2) //Returns negative if s1s2, and zero if s1 is equal to s2

s1.concat(s2) //concatenates s1 and s2

s1.substring(n) //Gives substring starting from nth character

s1.subsctring(n,m) //Gives substring starting from nth charater upto mth (not including mth)


76/175

g( , ) g g p ( g )

String.ValueOf(p) //Creates a string object of the parameter p (simple type or object)

p.toString(); //creates a string representation of the object p

s1.indexOf('x') //Gives the position of the first occurence of 'x' in the string s1.s1.indexOf('x','n') // Gives the position of the 'x' that occurs after nth position in the string s1.

String.valueOf(variable) //Converts the parameter value to string representation.

String Buffer Class :

StringBuffer is a peer class of String. While String creates strings of fixed length, StringBuffer

creates strings of flexible length that can be modified in terms of both length and content. We can

insert characters and substrings in the middle of a string, or append another string to the end.

s1.setCharAt(n,'x')//Modifies the nth character to x

s1.append(s2)//Appends the string s2 to s1 at the end

s1.insert(n,s2)//Inserts the string s2 at the position n of the string s1.

s1.setLength(n)//Sets the length of the string s1 to n. If ns1.length()

zeros are added to s1.

Vectors :


77/175

Java does not support the concept of variable arguments to a function. This feature can be achieved

in Java through the use of the Vector class contained in the java.util package. This class can be used

to create a generic dynamic array known as vector that can hold objects of any type and any number.

The objects do not have to be homogenious . Arrays can be eaisly implemented as vectors. Vectorsare created like arrays as follows :

Vector intVect = new Vector();//declaring without size

Vector intVect = new Vector(3);//declaring with size

Vectors possess a number of advantages over arrays :

1. It is convenient to use vectors to store objects.

2. A vector can be used to stroe a list of objects that may vary in size.

3. We can add and delete objects from the list as the list as and when required.

A major constraints in using vectors is that we can not directly store simple data types in a vector.

we can only store objects. Therefore, we need to convert simple types to objects. This can be doneusing the wrapper classes discussed in the next section.The vector class supports a number of

methods that can be used to manipulate the vectors created.

list.addElement(item)//Adds the item specified to the list at the end


78/175

list.elementAt(10)//Gives the name of the 10th object

list.size()//Gives the number of objects present

list.removeElement(item)//Removes the specified item from the list

list.removeElementAt(n)//Removes the item stored in the nth position of the list.

list.removeAllElements()//Removes all the element in the list

list.copyInto(array)//Copies all items from list to array

list.insertElementAt(item,n)//Inserts the item at nth position.

Wrapper Classes

Vectors not handled primitive data types like int,long,char and double. Primitive data types may

be converted object types by using the wrapper classes contained in the java.lang package.

Wrapper class for convering primitive data types are given below

Simple type Wrapper Class


79/175

p yp pp

boolean Boolean

char Character

double Doublefloat Float

int Integer

long Long

The Wrapper classes have number of unique methods for handling primitive data types and

objects.

Converting Primitive Numbers to Object Numbers Using Constructor Methods :

Integer IntVal=new Integer(i);//Primitive integer to Integer Objects here i as primitive data values.

Converting Object Numbers to primitive Numbers using typeValue() method

int i=IntVal.intValue();//Object to primitive integer

Converting Numbers to Strings Using toString() method

str=Integer.toString(i);//Primitive integer to string

Converting String Objects to Numeric Objects using the Static Method valueOf()


80/175

IntVal=Integer.valueOf(str);//converts string to Integer objects

Converting Numeric Strings to Primitive Numbers using Parsing Method

int i=Integer.parseInt(str);//converts string to primitive integer.

Input and Output in Java


81/175

Input and Output in Java

Files in Java

The Path Name

While dealing with the files, a source of confusion for a beginner in

Java programming is the path name. For example, consider the

following path name on a Unix/Linux machine:

/java/scjp/temp

The first forward slash represents the root directory. This path name

in Windows machines may be written as

C:\java\scjp\temp

Constructors for the File Class


82/175

File(String pathname)

Creates an instance of the File class by converting the path nameString to an abstract path name.

File(String parent, String child)

Creates an instance of the File class by concatenating the child

String to the parent String, and converting the combined String to an

abstract path name.

File(File parent, String child)

Creates an instance of the File class by constructing an abstractpath name from the abstract path name of the parent File, and the

String path name of child.

Example:


83/175

p

File f1 = new File("java/scjp");

File f2 = new File("java/scjp", "temp/myProg.java");

File f3 = new File(f1, "temp/myProg.java");

An instance of the File class is immutable. This means that once you

have created a File object by providing a path name, the abstract

path name represented by this object will never change.

When you create an instance of the File class, no real file is created

in the file system.

Methods Of File Class:


84/175

boolean canRead():

boolean canWrite():

boolean createNewFile():boolean delete():

boolean exists():

String getAbsolutePath():

String getCanonicalPath():

String getName():String getParent():

boolean isAbsolute():

boolean isDirectory():

boolean isFile():

String[] list():

String[] listFiles():

boolean mkDir():

boolean mkDirs():

Understanding Streams


85/175

g

Whether the source or destination is a file or a socket, any read or

write is performed in three simple steps:

1. Open the stream.

2. Until there is more data, keep reading in a read,

or writing in a write.

3. Close the stream.

The Low-Level Streams


86/175

A low-level input stream reads data and returns it in bytes, and a

low-level output stream accepts data as bytes and writes the output

in bytes. Two examples of low-level streams are represented by theclasses FileInputStream and FileOutputStream, which are

subclasses ofInputStream and OutputStream, respectively.

The FileInputStream Class

The FileInputStream class is designed for reading image files as it

reads a stream of raw bytes.

Constructors:FileInputStream(File file)

FileInputStream (String name)

Methods of FileInputStream


87/175

p

int read() throws IOException: Returns the next byte of data, or -1

if the end of the file is reached

int read(byte[] bytes) throws IOException: Reads bytes.length

number of bytes from the stream into an array, and returns the

number of bytes read, or -1 if the end of the file is reached

int read(byte[] bytes, int offset, int len) throws IOException:

Reads up to a total of len bytes (starting from offset) into an array,

and returns the number of bytes read, or1 if the end of the file is

reached

void close(): Closes the input stream and releases any system

resources assigned to the stream

The FileOutputStream Class


88/175

The FileOutputStream class is meant for writing streams of rawbytes into files, such as image files.

Constructors:FileOutputStream(File file)

FileOutputStream (String name)

Methods of FileOutputStream

void write(int b) throws IOException: Writes the passed-in byte tothe stream

void write(byte[] bytes) throws IOException: Writes bytes.lengthnumber of bytes from the passed-in array to the stream

void write(byte[] bytes, int offset, int len) throws IOException:

Writes up to a total of len bytes (starting from offset) from thepassed-in array to the stream

void close(): Closes the output stream and releases any systemresources assigned to the stream


89/175

The High-Level Streams


90/175

When the unit of information you are interested in is a high-level data

type such as a float, an int, or a String, and you dont want to deal with

bytes directly, you can work with high-level streams.

Two examples of high-level streams are DataInputStream and

DataOutputStream.

DataInputStream class


91/175

DataInputStream class

constructor for the DataInputStream class is:

public DataInputStream(InputStream in)

Methods ofDataInputStream class

boolean readBoolean() throws IOException byte readByte() throws IOException

char readChar()throws IOException

double readDouble() throws IOException

float readFloat() throws IOException

int readInt() throws IOException long readLong() throws IOException

short readShort() throws IOException


92/175

Readers and Writers


93/175

To read data in text format,Java offers so-called reader and writer

streams. Note that some authors do not refer to readers and writers

as streams. All the classes corresponding to reader and writerstreams are subclasses of the Reader and Writer classes and are

used to read character streams.

Low-Level Readers and WritersThe low-level reader streams read data and return it in characters,

and low-level output streams accept data as characters and write

the output in characters. Two examples of low-level reader and

writer streams are FileReader and FileReader.

The FileReader Class


94/175

Constructors for the FileReader Class

FileReader(File file)

FileReader(String name)

Methods of the FileReader Class

int read() throws IOException: Returns the next character ofdata, or -1 if the end of the file is reached

int read(char[] cbuf) throws IOException: Reads charactersfrom the stream into the array cbuf, and returns the number ofcharacters read, or -1 if the end of the file is reached

int read(char[] cbuf, int offset, int len) throws IOException:Reads up to a total of len characters (starting from offset) into the

array cbuf, and returns the number of chars read, or1 if the endof file is reached

void close(): Closes the input stream and releases any systemresources assigned to the stream

The FileWriter Class


95/175

Constructors for the FileWriter Class

FileWriter(File file)

FileWriter(String name)

Methods of the FileWriter Class

void write(int c) throws IOException: Writes the passed-insingle character to the stream

void write(char[] ch) throws IOException: Writes ch.lengthnumber of characters from the passed-in array to the stream

void write(String str) throws IOException: Writes the passed-in string to the stream

void write(char[] cbuf, int offset, int len) throws IOException:

Writes up to a total of len characters (starting from offset) fromthe passed in array to the stream

void write(String str, int offset, int len) throws IOException:


96/175

Writes up to a total of len characters (starting from offset) from the

passed-in string to the stream

void flush() throws IOException: Flushes the stream, which

means the remaining (buffered) data that you have written to the

stream is sent out to the file before closing

void close(): Closes the output stream and releases any system

resources assigned to the stream

Example Code:

1 import java io *;


97/175

1. import java.io. ;

2. public class FileByteCopier {

3. public static void main(String[] args) throws IOException {

4. File inputFile = new File("scjp.txt"); 5. File outputFile = new File("scjpcopy.txt");

6. FileReader in = new FileReader(inputFile);

7. FileWriter out = new FileWriter(outputFile);

8. int c;

9. while ((c = in.read()) != -1)out.write(c);

10. in.close();

11. out.flush();

12. out.close();

13. }

14.}

High-Level Readers and Writers


98/175

g

As you know, you can use DataInputStream and DataOutputStream

to read and write the primitive types in binary format. Similarly, you

can read and write characters in character streams in big chunks

(buffers) and in text format by using the BufferedReaderand

BufferedWriterclasses, respectively.

BufferedReader and BufferedWriter Classesconstructors:

BufferedReader(Reader in);

BufferedReader(Reader in, int size);

BufferedWriter(Writer out);

BufferedWriter(Writer out, int size);

Example Code:

1. import java.io.*;


99/175

1. import java.io. ;

2. public class FileBufferCopier {

3. public static void main(String[] args) throws IOException {

4. File inputFile = new File("scjp.txt"); 5. File outputFile = new File("scjpcopy.txt");

6. BufferedReader in = new BufferedReader(newFileReader(inputFile));

7. BufferedWriter out = new BufferedWriter(newFileWriter(outputFile));

8. String line; 9. while ((line = in.readLine()) != null){

10. out.write(line);

11. out.newLine();

12. }

13. in.close(); 14. out.close();

15. }

16.}

The PrintWriter Class


100/175

The PrintWriter class, a subclass of the Writer class.

Constructor for the PrintWriter class:

PrintWriter (Writer out, true)

The most commonly used methods of the PrintWriter class are

public void print() and public void println()


101/175

Exceptions During I/O Operations

Object Streams and Serialization


102/175

Java offers high-level streams ObjectInputStream and

ObjectOutputStream, which, when chained to low-level streams

such as FileInputStream and FileOutputStream, can be used byprograms to read and write objects. The process of writing an object

to somewhere is called ob ject serial ization, and the process of

reading a serialized object back into the program is called

deserial ization.

The goal here is to save the state of an object.

To make the objects of a class serializable, the class must

implement the interface Serializable:


103/175

implement the interface Serializable:

class MySerialClass implements Serializable

{

// body of the class

}

The Serializable interface is an empty interface (i.e. no methods aredeclared inside it) and is used to just tag a class for possible

serialization.

Writing with ObjectOutputStream


104/175

To write an object to a file, you use the ObjectOutputStream to write

it to a low-level stream, which in turn will write it to the file. For

example, consider the following code fragment:

FileOutputStream out = new FileOutputStream("objectStore.ser");

ObjectOutputStream os = new ObjectOutputStream(out);

os.writeObject("serialOut"); os.writeObject(new MySerialClass());

os.writeObject("End of storage!");

os.flush();

following are saved in serialization:


105/175

The values of the instance variables of the serialized object.

The class description of the object, which includes the class name,the serial version unique ID, a set of flags describing theserialization method, and a description of the data fields.

All the objects that a serialized object refers to through object

reference variables. That means those objects must be serializable;otherwise, you will get a compiler error.

Reading with ObjectInputStream


106/175

The objects can be read back in the same order in which they were

stored.

Here is a code fragment that reads inthe String and the Date objects

that were written to the file named objectStore.ser in the previous

example:

FileInputStream in = new FileInputStream("objectStore.ser");

ObjectInputStream is = new ObjectInputStream(in);

String note = (String)is.readObject();

MySerialClass serialIn1 = (MyClassSerial)is.readObject();

MySerialClass serialIn2 = (MyClassSerial)is.readObject();

Note the following points about serialization:


107/175

If a class is serializable, then all the subclasses of this superclass

are implicitly serializable even if they dont explicitly implement theSerializable interface.

If you want to serialize an array (or some other collection), each ofits elements must be serializable.

Static variables are not saved as part of serialization. Recall that thepurpose of serialization is to save the state of an object, and a staticvariable belongs to the class and not to an object of the class.

Multithreading

Multitheading is specialized form of multitasking like windows and other os uses multitasking


108/175

Multitheading is specialized form of multitasking. like windows and other os uses multitasking

technique i.e. they handled more than one process at a time, the same thing we can do in Java

using multithreading technique.

A thread is similar to a program that has a single flow of control. It has a beginning, a body, andan end,and executes commands sequentially. Java enables us to use multiple flows of control in

developing programs.

Each flow of control is represented by thread that runs parallel to others. i.e. a program that

contains multiple flows of control is known as multithreaded program.Threads in Java are

subprograms of a main application program and share the same memory space, known as

lightweight threads or lightweight process.Threds running in parallel does not mean that they actually run at the same time. Since all the

threads are running on the same processor, the flow of execution is shared between the threads.

The Java interpreter handles the switching of control between the threads in such a way that it

appears they are running concurrently.

Creating Threads :

Threads are implemented in the form of objects that contain a method called run(). The run()

method

is the heart and soul of any thread.

public void run()

{


109/175

{

....

(statements for implementing threads)

}

The run() method should be invoked by an object of the concerned thread. This can be achieved

by

creating the thread and initiating it with the help of another thread method called start().

corejavaslides-12863050987442-phpapp02

Documents

Transcript of corejavaslides-12863050987442-phpapp02