Java Programming Basics

TRAINING REPORT CORE JAVA

DEPARTMENT OF ELECTRONICS AND COMMUNICATION ENGINEERING 1

CHAPTER 1

INTRODUCTION TO JAVA

1.1 The beginning of Java

Java is an object-oriented programming language developed by Sun Microsystems in 1991

and released in 1995 as a core component of Sun’s Java platform. The language derives

much of its syntax from C and C++, but has a simpler object model and fewer low level

facilities. The Java language was designed to be small, simple, and portable across

platforms and operating systems. The Java language was developed as part of a research

project to develop software for consumer electronics devices—television sets, VCRs,

toasters, and the other sorts of machines we can buy at any department store. Java’s goals

at that time were to be small, fast, efficient, and easily portable to a wide range of hardware

devices.

1.2 The family history of Java

Before going on to study Java, let’s take a brief look, through quotes, at the language on

which Java was based, travelling back over 30years to do so.

1.2.1 Where it starts: C

The earliest precursor of Java is C: a language developed by Ken Thompson at Bell Labs

in the early 1970s. C was used as a system programming language. C began achieving its

widespread popularity when Bell’s UNIX operating system was rewritten in C. Unix was

the first operating system written in high level language; it was distributed to universities

for free, where it become popular. Linux is currently a popular variant of UNIX. “C is a

general purpose programming language which feature economy of expression, modern

control flow and data structure, and a rich set of operators. C is not a “very high level”

language, nor a “big” one, and is not specialized to any particular area of application.

1.2.2 From C to C++

“A programming language serves two related purpose: it provide a vehicle for the

programmers to specify action to be executed, and it provides a set of concepts for the

programmers to use when thinking about what can be done. The first aspect ideally requires

a language that is “close to the machine,” so that all important aspect of the machine are



handled simply and efficiently in a way that is reasonably obvious to the programmer. The

C language was primarily designed with this in mind. The second aspect ideally requires a

language that is “close to the problem to be solved,” so that the concept of a solution can

be expressed directly and concisely. The facilities added to C to create C++ were primarily

designed with this in mind.”

1.3 Java as a successor to C++

“The Java programming language is a class-based, general purpose, concurrent, object-

oriented language. It is designed to be simple enough that many programmers can achieve

fluency in the language. The Java programming language is related to C and C++ but it is

organized rather differently, with a number of aspects of C and C++ omitted and a few

ideas from other languages included. It is intended to be production language, not a

research language, and so, as C.A.R. Hoare suggested in his classic paper on language

design, the design has avoided including new and untested features.

The Java programming language is a relatively high level language, in that detail of the

machine representation are not available through the language. It includes automatic

storage management, typically using a garbage collector, to avoid the safety problems.

High performance garbage collected implementation can have bounded pauses to support

system programming and real time application. The language does not includes any unsafe

construct, such as array accesses without checking, since such unsafe constructs would

cause a program to behave in an unspecified way.”

1.4 What is the Java Technology?

A programming language: - We can use java as a programming language. By using

this programming language we can develop different type of application for eg:

Console Application (CUI), Window Application (GUI) and Web Applications.

A development environment: - It provides a development environment in which we

can develop, check, debug and execute the applications.

An application environment: - It provides an environment in which application can

run or execute.

A deployment environment: - It provides a deployment environment in which we

can check application after deployment how application will react.



It is similar in syntax to C++.

1.5 Features of Java

Features of Java are as follows:

1. Compiled and Interpreted

2. Platform Independent and portable

3. Object- oriented

4. Robust and secure

5. Distributed

6. Familiar, simple and small

7. Multithreaded and Interactive

8. High performance

9. Dynamic and Extensible

1. Compiled and Interpreted

Basically a computer language is either compiled or interpreted. Java comes together both

these approach thus making Java a two-stage system. Java compiler translates Java code to

Byte-code instructions and Java Interpreter generate machine code that can be directly

executed by machine that is running the Java program.

2. Platform Independent and portable

Java supports the feature portability. Java programs can be easily moved from one

computer system to another and anywhere. Changes and upgrades in operating systems,

processors and system resources will not force any alteration in Java programs. This is

reason why Java has become a trendy language for programming on Internet which

interconnects different kind of systems worldwide. Java certifies portability in two ways.

First way is, Java compiler generates the byte-code and that can be executed on any

machine. Second way is, size of primitive data types are machine independent.

3. Object- oriented

Java is truly object-oriented language. In Java, almost everything is an Object. All program

code and data exist in objects and classes. Java comes with an extensive set of classes;

organize in packages that can be used in program by Inheritance. The object model in Java

is trouble-free and easy to enlarge.



4. Robust and secure

Java is a most strong language which provides many securities to make certain reliable

code. It is design as garbage –collected language, which helps the programmers virtually

from all memory management problems. Java also includes the concept of exception

handling, which detain serious errors and reduces all kind of threat of crashing the system.

Security is an important feature of Java and this is the strong reason that programmer use

this language for programming on Internet. The absence of pointers in Java ensures that

programs cannot get right of entry to memory location without proper approval.

5. Distributed

Java is called as Distributed language for construct applications on networks which can

contribute both data and programs. Java applications can open and access remote objects

on Internet easily. That means multiple programmers at multiple remote locations to work

together on single task.

6. Simple and small

Java is very small and simple language. Java does not use pointer and header files, go to

statements, etc. It eliminates operator overloading and multiple inheritance.

7. Multithreaded and Interactive

Multithreaded means managing multiple tasks simultaneously. Java maintains

multithreaded programs. That means we need not wait for the application to complete one

task before starting next task. This feature is helpful for graphic applications.

8. High performance

Java performance is very extraordinary for an interpreted language, majorly due to the use

of intermediate byte-code. Java architecture is also designed to reduce overheads during

runtime. The incorporation of multithreading improves the execution speed of program.

9. Dynamic and Extensible

Java is also dynamic language. Java is capable of dynamically linking in new class,

libraries, methods and objects. Java can also establish the type of class through the query

building it possible to either dynamically link or abort the program, depending on the reply.

Java program is support functions written in other language such as C and C++, known as

native methods.

These are various features of Java programming.



1.5 Comparison in Java and C++

Java C++

1

Java is true Object-oriented language. C++ is basically C with Object-oriented

Extension.

2

Java does not support operator

overloading

C++ supports operator overloading.

3

It supports labels with loops and

statement blocks

It supports goto statement

4

Java does not have template classes as in

C++.

C++ has template classes

5

Java does not support multiple

inheritance of classes but it supports

interface

C++ supports multiple inheritance of

classes.

6 Runs in a protected virtual machine. Exposes low-level system facilities.

7 There are no header files in Java. We have to use header file in C++

Table: - 1.1 Comparison in Java and C++

1.6 Java Virtual Machine

As we know that all programming language compilers convert the source code to machine

code. Same job done by Java Compiler to run a Java program, but the difference is that

Java compiler convert the source code into Intermediate code is called as byte-code. This

machine is called the Java Virtual machine and it exits only inside the computer memory.

Following figure shows the process of compilation.

Source Code Byte Code

Fig: - 1.1 Compilation process

Java

Program Java compiler Virtual Machine



The Virtual machine code is not machine specific. The machine specific code is generated.

By Java interpreter by acting as an intermediary between the virtual machine and real

machines shown below.

Virtual Machine Real Machine

Fig: - 1.2 Java Interpreter

Java Object Framework act as the intermediary between the user programs and the virtual

machine which in turn act as the intermediary between the operating system and the Java

Object Framework.

Operating System

Java Virtual Machine

Java Object Framework

Compiler and Interpreter

User Application Programs

Fig: -1.3 Layers of Interaction for Java programs

Byte

Code Java Interpreter Machine code

User



CHAPTER 2

JAVA LANGUAGE FUNDAMENTAL

2.1 Data Type

Data type specifies the size and type of values that can be stored in an identifier. The Java

language is rich in its data types. Different data types allow we to select the type appropriate

to the needs of the application.

Data types in Java are classified into two types:

1. Primitive—which include Integer, Character, Boolean, and Floating Point.

2. Non-primitive—which include Classes, Interfaces, and Arrays.

2.1.1 Primitive Data Types

1. Integer

Integer types can hold whole numbers such as 123 and −96. The size of the values that can

be stored depends on the integer type that we choose.

Type Size Range of values that can be stored

Byte 1 byte −128 to 127

Short 2 byte −32768 to 32767

Int 4 bytes −2,147,483,648 to 2,147,483,647

Long 8 bytes 9,223,372,036,854,775,808 to 9,223,372,036,854,755,807

The range of values is calculated as - (2n−1) to (2n−1) −1; where n is the number of bits

required. For example, the byte data type requires 1 byte = 8 bits. Therefore, the range of

values that can be stored in the byte data type is −(28−1) to (28−1)−1

= −27 to (27) -1

= −128 to 127

2. Floating Point

Floating point data types are used to represent numbers with a fractional part. Single

precision floating point numbers occupy 4 bytes and Double precision floating point

numbers occupy 8 bytes. There are two subtypes:

Type Size Range of values that can be stored

Float 4 bytes 3.4e−038 to 3.4e+038

Double 8 bytes 1.7e−308 to 1.7e+038



3. Character

It stores character constants in the memory. It assumes a size of 2 bytes, but basically it

can hold only a single character because char stores Unicode character sets. It has a

minimum value of ‘u0000′ (or 0) and a maximum value of ‘uffff’ (or 65,535, inclusive).

4. Boolean

Boolean data types are used to store values with two states: true or false.

2.2 Java Tokens

A token is the smallest element in a program that is meaningful to the compiler. These

tokens define the structure of the language. The Java token set can be divided into five

categories: Identifiers, Keywords, Literals, Operators, and Separators.

2.2.1 Identifiers

Identifiers are names provided by we. These can be assigned to variables, methods,

functions, classes etc. to uniquely identify them to the compiler.

2.2.2 Keywords

Keywords are reserved words that have a specific meaning for the compiler. They cannot

be used as identifiers. Java has a rich set of keywords. Some examples are: boolean, char,

if, protected, new, this, try, catch, null, threadsafe etc.

2.2.3 Literals

Literals are variables whose values remain constant throughout the program. They are also

called Constants. Literals can be of four types. They are:

a. String Literals: - String Literals are always enclosed in double quotes and are

implemented using the java.lang.String class. Enclosing a character string within double

quotes will automatically create a new String object. For example, String s = "this is a

string";. String objects are immutable, which means that once created, their values cannot

be changed.

b. Character Literals: - These are enclosed in single quotes and contain only one character.

c. Boolean Literals: - They can only have the values true or false. These values do not

correspond to 1 or 0 as in C or C++.

d. Numeric Literals: - Numeric Literals can contain integer or floating point values.

2.2.4 Operators



An operator is a symbol that operates on one or more operands to produce a result.

Operator Meaning Operator Meaning

+ Addition

– Subtraction

* Multiplication

÷ Division

% Modulus

< Less than

> Greater than

≤ Less than or equal to

≥ Greater than or equal to

== Equal

!= Not equal

&& Logical AND

¦¦ Logical OR

! Logical NOT

&= AND and assign

¦= OR and assign

<<= Left shift and assign

& AND

¦ OR

^ XOR

<< Left shift

>> Right shift

>>> Zero fill right shift

~ Complement

= Assignment

++ Increment

– – Decrement

+= Add and assign

–= Subtract and assign

*= Multiply and assign

÷= Divide and assign

%= Modulus and assign

>>= Right shift and assign

>>>= Zero fill right shift and assign

Table: 2.1 Operators

2.2.5 Separators

Separators are symbols that indicate the division and arrangement of groups of code. The

structure and function of code is generally defined by the separators. The separators used

in Java are as follows:

Parentheses ( ): - Used to define precedence in expressions, to enclose parameters in

method definitions, and enclosing cast types.

Braces { }: - Used to define a block of code and to hold the values of arrays.

Brackets [ ]: - Used to declare array types.

Semicolon; : - Used to separate statements.

Comma,: - Used to separate identifiers in a variable declaration and in the for statement.



Period. : - Used to separate package names from classes and subclasses and to separate a

variable or a method from a reference variable.

2.3 Variables

There are different types of variables in Java. They are as follows:

2.3.1 Instance Variables (Non-Static Fields)

Objects store their individual states in “non-static fields”, that is, fields declared without

the static keyword. Non-static fields are also known as instance variables because their

values are unique to each instance of a class. For example, the current Speed of one bicycle

is independent from the current Speed of another.

2.3.2 Class Variables (Static Fields)

A class variable is any field declared with the static modifier; this tells the compiler that

there is exactly one copy of this variable in existence, regardless of how many times the

class has been instantiated. A field defining the number of gears for a particular kind of

bicycle could be marked as static since, conceptually, the same number of gears will apply

to all instances. The code static int num Gears = 6; would create such a static field.

2.3.3 Local Variables

A method stores its temporary state in local variables. The syntax for declaring a local

variable is similar to declaring a field (for example, int count = 0;). There is no special

keyword designating a variable as local; that determination comes entirely from the

location in which the variable is declared—between the opening and closing braces of a

method. As such, local variables are only visible to the methods in which they are declared;

they are not accessible from the rest of the class.

2.3.4 Parameters

They are the variables that are passed to the methods of a class.

2.4 Variable Declaration

Identifiers are the names of variables. They must be composed of only letters, numbers,

the underscore, and the dollar sign ($). They cannot contain white spaces. Identifiers may

only begin with a letter, the underscore, or the dollar sign. A variable cannot begin with a

number. All variable names are case sensitive.

2.4.1 Syntax



datatype1 variable1, datatype2 variable2, … datatypen variablen;

For example: int a, char ch;

2.4.2 Initialization

Variables can be assigned values in the following way: Variablename = value;

For example;

ch='a';

a=0;

2.5 Arrays

An array is a group of variables that share the same data type, and are referred to by a

common name. Arrays of any type can be created and may have one or more dimensions.

A specific element in an array is accessed by its index. The array index ranges from 0 to

n−1; therefore, in an array of size 10, the first element is stored at index 0 and the last or

the 10th element at index 9.

2.6 A simple java program

Syntax:

class class_name

{

public static void main(String args[])

{

//wer statement goes here

}

}

Example: -

class Employee

{


{

System.out.println(“Hello, This is simple java program”);

}

}



CHAPTER 3

OOPS CONCEPTS

3.1 OOPS Concept

Object-Oriented Programming system (OOPS) is a programming paradigm using "objects"

to design applications. An object is a thing which has its own identity. An object contains

both state and behavior. State of an object is the current data and behavior is implemented

as methods. An object in an OO language can be easily compared to a real world object.

Consider a car. A car has some properties like model, fuel type etc which are the state (or

properties) of that object. Similarly it will also have functions. Object-Oriented

Programming (OOP) has certain important features like Encapsulation, Polymorphism,

Inheritance and Abstraction. These features are also referred to as OOPS concepts. Java is

an object oriented language. Java, unlike some other languages, is considered as a pure

object oriented language as everything in java should be enclosed, basically inside a class.

There can be no global variables or functions. In addition to classes, we can have interfaces

as well. But we will restrict our discussion here to classes only.

3.2 Features of OOPS

1. Class

2. Object

3. Data abstraction

4. Data encapsulation

5. Inheritance

6. Polymorphism

3.3 Class

A class is nothing but a blueprint or a template for creating different objects which defines

its properties and behaviors. Java class objects exhibit the properties and behaviors defined

by its class. A class can contain fields and methods to describe the behavior of an object.

Methods are nothing but members of a class that provide a service for an object or perform

some business logic. Java fields and member functions names are case sensitive. Current



states of a class’s corresponding object are stored in the object’s instance variables.

Methods define the operations that can be performed in java programming.

A class has the following general syntax:

<class modifiers>class<class name>

<extends clause> <implements clause>

{

// Dealing with Classes (Class body)

<field declarations (Static and Non-Static)>

<method declarations (Static and Non-Static)>

<Inner class declarations>

<nested interface declarations>

<constructor declarations>

<Static initializer blocks>

}

Below is an example showing the Objects and Classes of the Cube class that defines 3

fields namely length, breadth and height. Also the class contains a member function

getVolume().

public class Cube

{

int length;

int breadth;

int height;

public int getVolume() {

return (length * breadth * height);

}

}

This is accomplished by stating the name of the object reference, followed by a period

(dot), followed by the name of the member inside the object.( objectReference.member ).

We call a method for an object by naming the object followed by a period (dot), followed

by the name of the method and its argument list, like this: objectName.methodName(arg1,

arg2, arg3). For example:



cubeObject.length=4;

cubeObject.breadth=4;

cubeObject.height=4;

cubeObject.getvolume()

3.3.1 Class Variables – Static Fields

We use class variables also known as Static fields when we want to share characteristics

across all objects within a class. When we declare a field to be static, only a single instance

of the associated variable is created common to all the objects of that class. Hence when

one object changes the value of a class variable, it affects all objects of the class. We can

access a class variable by using the name of the class, and not necessarily using a reference

to an individual object within the class. Static variables can be accessed even though no

objects of that class exist. It is declared using static keyword.

3.3.2 Class Methods – Static Methods

Class methods, similar to Class variables can be invoked without having an instance of the

class. Class methods are often used to provide global functions for Java programs. For

example, methods in the java.lang.Math package are class methods. We cannot call non-

static methods from inside a static method.

3.3.3 Instance Variables

Instance variables stores the state of the object. Each class would have its own copy of the

variable. Every object has a state that is determined by the values stored in the object. An

object is said to have changed its state when one or more data values stored in the object

have been modified. When an object responds to a message, it will usually perform an

action, change its state etc. An object that has the ability to store values is often said to

have persistence.

3.4 Object

An object is an instance of a class created using a new operator. The new operator returns

a reference to a new instance of a class. This reference can be assigned to a reference

variable of the class. The process of creating objects from a class is called instantiation. An

object encapsulates state and behavior. An object reference provides a handle to an object

that is created and stored in memory. In Java, objects can only be manipulated via



references, which can be stored in variables. Creating variables of our class type is similar

to creating variables of primitive data types, such as integer or float. Each time we create

an object, a new set of instance variables comes into existence which defines the

characteristics of that object. If we want to create an object of the class and have the

reference variable associated with this object, we must also allocate memory for the object

by using the new operator. This process is called instantiating an object or creating an

object instance. When we create a new object, we use the new operator to instantiate the

object. The new operator returns the location of the object which we assign o a reference

type.

Below is an example showing the creation of Cube objects by using the new operator.

public class Cube

{

int length = 10;

int breadth = 10;

int height = 10;

public int getVolume() {

return (length * breadth * height);

}

public static void main(String[] args) {

Cube cubeObj; // Creates a Cube Reference

cubeObj = new Cube(); // Creates an Object of Cube

System.out.println("Volume of Cube is : " + cubeObj.getVolume());

}

}

3.5 Data abstraction

Abstract means a concept or idea not associated with any specific instance and does not

have a concrete existence. Abstraction in Object Oriented Programming refers to the ability

to make a class abstract. Abstraction captures only those details about an object that are

relevant to the current perspective. Abstraction tries to reduce and factor out details so that

the programmer can focus on a few concepts at a time. Java provides interfaces and abstract

classes for describing abstract types. An interface is a contract or specification without any



implementation. An interface can't have behavior or state. An abstract class is a class that

cannot be instantiated. All other functionality of the class still exists. Abstract classes can

have state and can be used to provide a skeletal implementation. Abstraction is simplifying

complex reality by modelling classes appropriate to the problem, and working at the most

appropriate level of inheritance for a given aspect of the problem. For example, Lassie the

Dog may be treated as a Dog much of the time, a Collie when necessary to access Collie-

specific attributes or behaviors, and as an Animal (perhaps the parent class of Dog) when

counting Timmy's pets. Abstraction is also achieved through Composition. For example, a

class Car would be made up of an Engine, Gearbox, Steering objects, and many more

components. To build the Car class, one does not need to know how the different

components work internally, but only how to interface with them, i.e., send messages to

them, receive messages from them, and perhaps make the different objects composing the

class interact with each other. Basically Data abstraction refers to the act of representing

important description without including the background details or explanations. Classes

use the concept of abstraction and are defined as a list of abstract attributes such as size,

cost and functions operate on these attributes. They summarize all the important properties

of the objects that are to be created. Classes use the concepts of data abstraction and it is

called as Abstract Data Type (ADT).

3.5.1 Abstract class

An abstract class is something which is incomplete and we cannot create instance of

abstract class. If we want to use it we need to make it complete or concrete by extending

it. A class is called concrete if it does not contain any abstract method and implements all

abstract method inherited from abstract class or interface it has implemented or extended.

By the way Java has concept of abstract classes, abstract method but a variable cannot be

abstract in Java. Popular example of abstract class in Java is ActionListener which has

abstract method called actionPerformed(ActionEvent ae). This method is called when an

ActionEvent is fired like when we click on JButton. Its common in java to attach

ActionListener with JButton by implementing abstract method

actionPerformed(ActionEvent ae) using Anonymous class, as shown in below Example :

JButton ok = new JButton("OK");

ok.addActionListener(new ActionListener(){



public void actionPerformed(ActionEvent ae){

//code to handle event

}

});

An abstract method in Java doesn't have body, it’s just a declaration. In order to use abstract

method we need to override that method in SubClass.

3.6 Data encapsulation

Encapsulation in Java is the process of wrapping up of data (properties) and behavior

(methods) of an object into a single unit; and the unit here is a Class (or interface).

Encapsulate in plain English means to enclose or be enclosed in or as if in a capsule. In

Java, a class is the capsule (or unit). In Java, everything is enclosed within a class or

interface, unlike languages such as C and C++, where we can have global variables outside

classes. Encapsulation enables data hiding, hiding irrelevant information from the users of

a class and exposing only the relevant details required by the user. We can expose our

operations hiding the details of what is needed to perform that operation. We can protect

the internal state of an object by hiding its attributes from the outside world (by making it

private), and then exposing them through setter and getter methods. Now modifications to

the object internals are only controlled through these methods.

Consider the example of a linked list’s getsize method. We might be now using a

variable named size that is updated on every insert / delete operation. Later we might decide

to traverse the list and find size every time someone ask for size. But if some code was

directly accessing the size variable, we would have to change all those code for this change.

However if we were accessing the size variable through a getsize method, other code can

still call that method and we can do our changes in that method. A setter is a method used

to change the value of an attribute and a getter is a method used to get the value of an

attribute. There is also a standard naming convention for getters and setters, but Java

compiler won't complain even otherwise.

Example: Consider a variable name and its getter and setter:

private String name;

public String getName()

{



return name;

}

public void setName(String name) {

this.name=name;

}

3.7 Inheritance

Inheritance is a mechanism wherein a new class is derived from an existing class. In Java,

classes may inherit or acquire the properties and methods of other classes. A class derived

from another class is called a subclass, whereas the class from which a subclass is derived

is called a superclass. A subclass can have only one superclass, whereas a superclass may

have one or more subclasses. The keyword “extends” is used to derive a subclass from the

superclass, as illustrated by the following syntax: class Name_of_subclass extends

Name_of superclass {//new fields and methods that would define the subclass go here} If

we want to derive a subclass Rectangle from a superclass Shapes, we can do it as follows:

class Rectangle extends Shapes { …. }. Java Inheritance defines an is-a relationship

between a superclass and its subclasses. This means that an object of a subclass can be used

wherever an object of the superclass can be used. Class Inheritance in java mechanism is

used to build new classes from existing classes. The inheritance relationship is transitive:

if class x extends class y, then a class z, which extends class x, will also inherit from class

y. For example a car class can inherit some properties from a General vehicle class. Here

we find that the base class is the vehicle class and the subclass is the more specific car

class. A subclass must use the extends clause to derive from a super class which must be

written in the header of the subclass definition. The subclass inherits members of the

superclass and hence promotes code reuse. The subclass itself can add its own new

behavior and properties. The java.lang.Object class is always at the top of any Class

inheritance hierarchy.

Example:

class Box

{

double width;

double height;



double depth;

Box() {

}

Box(double w, double h, double d) {

width = w;

height = h;

depth = d;

}

void getVolume() {

System.out.println("Volume is : " + width * height * depth);

}

}

public class MatchBox extends Box {

double weight;

MatchBox() {

}

MatchBox(double w, double h, double d, double m) {

super(w, h, d);

weight = m;

}

public static void main(String args[]) {

MatchBox mb1 = new MatchBox(10, 10, 10, 10);

mb1.getVolume();

System.out.println("width of MatchBox 1 is " + mb1.width);

System.out.println("height of MatchBox 1 is " + mb1.height);

System.out.println("depth of MatchBox 1 is " + mb1.depth);

System.out.println("weight of MatchBox 1 is " + mb1.weight);

}

}

3.7.1 ‘this’ and ‘super’ keywords

The two keywords, this and super to help we explicitly name the field or method that we



want. Using this and super we have full control on whether to call a method or field present

in the same class or to call from the immediate superclass. This keyword is used as a

reference to the current object which is an instance of the current class. The keyword super

also references the current object, but as an instance of the current class’s super class. The

this reference to the current object is useful in situations where a local variable hides, or

shadows, a field with the same name. If a method needs to pass the current object to another

method, it can do so using the this reference. Note that the this reference cannot be used in

a static context, as static code is not executed in the context of any object.

class Counter

{

int i = 0;

Counter increment()

{

i++;

return this;

}

void print()

{

System.out.println("i = " + i);

}

}

public class CounterDemo extends Counter

{

public static void main(String[] args)

{

Counter x = new Counter();

x.increment().increment().increment().print();

}

}

}



3.8 Polymorphism

The word ‘polymorphism’ literally means ‘a state of having many shapes’ or ‘the capacity

to take on different forms’. When applied to object oriented programming languages like

Java, it describes a language’s ability to process objects of various types and classes

through a single, uniform interface. Polymorphism in Java has two types: Compile time

polymorphism (static binding) and Runtime polymorphism (dynamic binding). Method

overloading is an example of static polymorphism, while method overriding is an example

of dynamic polymorphism. An important example of polymorphism is how a parent class

refers to a child class object. In fact, any object that satisfies more than one IS-A

relationship is polymorphic in nature. For instance, let’s consider a class Animal and let

Cat be a subclass of Animal. So, any cat IS animal. Here, Cat satisfies the IS-A relationship

for its own type as well as its super class Animal.

3.8.1 Static Polymorphism

In Java, static polymorphism is achieved through method overloading. Method overloading

means there are several methods present in a class having the same name but different

types/order/number of parameters. At compile time, Java knows which method to invoke

by checking the method signatures. So, this is called compile time polymorphism or static

binding. The concept will be clear from the following example:

class DemoOverload

{

public int add(int x, int y)

{ //method 1

return x+y;

}

public int add(int x, int y, int z)

{ //method 2

return x+y+z;

}

public int add(double x, int y)

{ //method 3

return (int)x+y;



}

public int add(int x, double y)

{ //method 4

return x+(int)y;

}

}

class Test

{


{

DemoOverload demo=new DemoOverload();

System.out.println(demo.add(2,3)); //method 1 called

System.out.println(demo.add(2,3,4)); //method 2 called

System.out.println(demo.add(2,3.4)); //method 4 called

System.out.println(demo.add(2.5,3)); //method 3 called

}

}

In the above example, there are four versions of add methods. The first method takes two

parameters while the second one takes three. For the third and fourth methods there is a

change of order of parameters. The compiler looks at the method signature and decides

which method to invoke for a particular method call at compile time.

3.8.2 Dynamic Polymorphism

Suppose a sub class overrides a particular method of the super class. Let’s say, in the

program we create an object of the subclass and assign it to the super class reference. Now,

if we call the overridden method on the super class reference then the sub class version of

the method will be called.

Have a look at the following example.

class Vehicle

{

public void move()

{



System.out.println(“Vehicles can move!!”);

}

}

class MotorBike extends Vehicle

{

public void move()

{

System.out.println(“MotorBike can move and accelerate too!!”);

}

}

class Test

{


{

Vehicle vh=new MotorBike();

vh.move(); // prints MotorBike can move and accelerate too!!

vh=new Vehicle();

vh.move(); // prints Vehicles can move!!

}

}

It should be noted that in the first call to move(), the reference type is Vehicle and the

object being referenced is MotorBike. So, when a call to move() is made, Java waits until

runtime to determine which object is actually being pointed to by the reference. In this

case, the object is of the class MotorBike. So, the move() method of MotorBike class will

be called. In the second call to move(), the object is of the class Vehicle. So, the move()

method of Vehicle will be called. As the method to call is determined at runtime, this is

called dynamic binding or late binding.

3.8.3 Overloading

Now let’s continue to discuss overloading and overriding. I have shown an image of a

overloaded truck. I specifically used this image and drawn a wrong mark on it. Because,

when I did some research on this topic using internet almost all web pages where ever



overloading is discussed this kind of overloaded truck image is used to explain the

meaning. Please get it right. Overloading is not adding more and more attributes and

interfaces to the object so that it looks bulkier. In fact, when we use overloading for the

outsiders view the object will look compact. That is putting more behaviour with same

interface. That is our object will look sleek.

Fig: 3.1 An example Before Overloading Fig: 3.2 An example after Overloading

I have shown two images, one is Harmonium, a classical music instrument from India. Just

for understanding it is a very trimmed version of piano. The other is a modern digital

keyboard. Harmonium is without overloading and keyboard is after overloading. In a

digital keyboard, keys are the interface, in programming method name. Speaker is the

output, in programming return type of the method. When the player presses the keys he

gives input to the method and gets output as music through the speakers. When different

input is given we get different output. Here the interface (method name, keys) is same and

output type is same. But the actual input (arguments, key press sequence) and output

(returned data, music) is different. This is overloading. Look at the whole object

(keyboard), how sleek it is after overloading.

Example:

public class OverloadExample

{


{

System.out.println(playMusic("C sharp","D sharp"));

System.out.println(playMusic("C","D flat","E flat"));

}



public static String playMusic(String c, String d)

{

return c+d;

}

public static String playMusic(String c, String d, String e){

return c+d+e;

}

}

3.8.4 Overriding

It is very simple and easy to understand. When we inherit an object, we don’t like certain

behavior and so we replace it with our own. Note the word replace. Because after

overriding the old behavior is completely obsolete. Now look at the image of a monster

truck. Here the old small four wheels are replaced with huge wheels to suit the current

need. This is overriding.

Fig: 3.3 an example of overriding

A java private method cannot be overridden because in first place it is not accessible to an

inheriting object. Final parameter in the overloaded method, has an interesting behavior.

Implicitly every object in Java is extended from Object class. Object has a method named

equals. This implementation compares the passed object with the current object and returns

true if the reference are same. In String class we don’t want this behavior. Therefore, equals

method of the Object class is overridden in String class with its own implementation. Here



the behavior is modified to check if the character sequence is same as the compared one

and returns true. This is a classic example of overriding.

Example:

public class BaseClass{

public void methodToOverride()

{

//Some code here

}

}

public class DerivedClass extends BaseClass{

public void methodToOverride()

{

//Some new code here

}

}



CHAPTER 4

EXCEPTION HANDLING

4.1 Introduction

An exception is an event, which occurs during the execution of the program, that an

interrupt the normal flow of the program‘s instruction. In other words, Exceptions are

generated when a recognized condition, usually an error condition, arises during the

execution of a method. Java includes a system for running exceptions, by tracking the

potential for each method to throw specific exceptions. For each method that could throw

an exception, our code must report to the Java compiler that it could throw that exact

exception. The compiler marks that method as potentially throwing that exception, and

then need any code calling the method to handle the possible exception. Exception handling

is basically use five keyword as follows:

Try

Catch

Throw

Throws

Finally

4.2 Overview

Exceptions are generated when an error condition occur during the execution of a method.

It is possible that a statement might throw more than one kind of exception. Exception can

be generated by Java-runtime system or they can be manually generated by code. Error-

Handling becomes a necessary while developing an application to account for exceptional

situations that may occur during the program execution, such as

Run out of memory

Resource allocation Error

Inability to find a file

Problems in Network connectivity

4.3 Exception and exception handling



Exceptions are generated when a recognized an error condition during the execution of a

program. Java includes a system for running exceptions, by tracking the potential for each

method to throw specific exceptions

for each method that could throw an exception, our code must report to the Java

compiler that it could throw that exact exception.

the compiler marks that method as potentially throwing that exception, and then

need any code calling the method to handle the possible exception.

There are two ways to handle an exception:

we can try the "risky" code, catch the exception, and do something about it, after

which the transmission of the exception come to an end.

we can mark that this method throws that exception, in which case the Java runtime

engine will throw the exception back to the method.

So, if we use a method in our code that is marked as throwing a particular exception, the

compiler will not allow that code unless we handle the exception. If the exception occurs

in a try block, the JVM looks to the catch block(s) that follow to see if any of them

equivalent the exception type. The first one that matches will be executed. If none match,

then this methods ends, and execution jumps to the method that called this one, at the point

the call was made.

Fig: 4.1 a partial view of the Throwable family



4.4 Try…catch

If a method is going to resolve potential exception internally, the line of code that could

generate the exception is placed inside a try block. There may be other code inside the try

block, before and/or after the risky line(s) - any code that depends upon the risky code's

success should be in the try block, since it will automatically be skipped if the exception

occurs.

Syntax:

try

{

code

risky/unsafe code

code that depends on the risky code succeeding

}

There is usually at least one catch block immediately after the try block. A catch block

must specify what type of exception it will catch.

Syntax:

catch (ExceptionClassName exceptionObjectName)

{

code using methods from exceptionObjectName

}

There can be more than one catch block, each one marked for a correct exception class.

The exception class that is caught can be any class in the exception hierarchy, either a

general (base) class, or a very correct (derived) class. The catch block(s) must handle all

checked exceptions that the try block is known to throw unless we want to throw that

exception back to the method. It is possible to have a try block without any catch blocks if

we have a finally block but any checked exceptions still need to be caught, or the method

needs to declare that it throws them. If an exception occurs within a try block, execution

jumps to the first catch block whose exception class matches the exception that occurred.

Any steps remaining in the try block are skipped. If no exception occurs, then the catch

blocks are skipped If declare a variable within a try block, it will not exist outside the try

block, since the curly braces define the scope of the variable. We will often need that



variable later, if nowhere else other than the catch or finally blocks, so we would need to

declare the variable before the try. If we declare but don't initialize a variable before a try

block, and the only place we set a value for that variable is in the try block, then it is

possible when execution leaves the try ... catch structure that the variable never received a

value. So, we would get a "possibly uninitialized value" error message from the compiler,

since it actually keeps track of that sort of thing.Example:

public class demo

{


{

int ans1, ans2;

int a = 2, b = 2, c = 0;

try

{

ans1 = a/b;

System.out.println("a/b = " + ans1);

ans2 = a/c;

System.out.println("a/c = " + ans2);

}

catch(ArithmeticException e)

{

System.out.println("Arithmetic Exception!");

}

System.out.println("demo is over");

}

}

4.5 Throw

We can throw an exception explicitly using the throw statement. For example we need to

throw an exception when a user enters a wrong student ID or password. The throws clause

is used to list the types of exception that can be thrown in the execution of a method in a

program. The throw statement causes termination of the normal flow of control of the java



code and prevents the execution of the subsequent statements. The throw clause convey

the control to the nearest catch block handling the type of exception object throws. If no

such catch block exists, the program terminates. The throw statement accepts a single

argument, which is an object of the Exception class.

Syntax:

throw ThrowableObj

We can use the following code to throw the IllegalStateException exception:

class demo

{

static void tdemo()

{

try

{

throw new IllegalStateException ();

}

catch (NullPointerException e)

{

System.out.println ("Not Caught by the catch block inside tdemo ().");

}

}

public static void main (String args[ ])

{

try

{

tdemo();

}

catch(IllegalStateException e)

{

System.out.println("Exception Caught in:"+e);

}

} }



4.5 Throws

The throws statement is used by a method to specify the types of exceptions the method

throws. If a method is capable of raising an exception that it does not handle, the method

must specify that the exception have to be handled by the calling method. This is done

using the throws statement. The throws clause lists the types of exceptions that a method

might throw.

Syntax:

[< access specifier >] [< modifier >] < return type > < method name > [< arg list >]

[ throws <exception list >]

We can use the following code to use the throws statement.

class demo

{

static void throwMethod ( ) throws ClassNotFoundException

{

System.out.println ("In throwMethod ");

throw new ClassNotFoundException ( );

}

public static void main (String args [ ])

{

try

{

throwMethod ( );

}

catch ( ClassNotFoundException e)

{

System.out.println (" throwMethod has thrown an Exception :" +e);

}

}

}

4.6 Finally



To guarantee that a line of code runs, whether an exception occurs or not, use a finally

block after the try and catch blocks. The code in the finally block will almost always

execute, even if an unhandled exception occurs; in fact, even if a return statement is

encountered. If an exception causes a catch block to execute, the finally block will be

executed after the catch block or if an uncaught exception occurs, the finally block

executes, and then execution exits this method nand the exception is thrown to the method

that called this method.

Syntax:

try

{

risky code/ unsafe code block

}

catch (ExceptionClassName exceptionObjectName)

{

code to resolve problem

}

finally

{

code that will always execute

}

Example:

public class demo

{


{

try

{

System.out.println("Try Block before the error.");

System.out.println(1/0);

System.out.println("Try Block after the error.");

}



catch(java.lang.ArithmeticException e)

{

System.out.println("Catch Block");

System.out.println("A Stack Trace of the Error:");

e.printStackTrace();

//e.getMessage();

System.out.println("The operation is not possible.");

}

finally

{

System.out.println("Finally Block");

}

System.out.println("demo is over");

}

}



CHAPTER 5

MULTI-THREADING

5.1 The java thread model

Thread is a sequential path of execution of a program. In java we can create multiple

threads for the full utilization of the processor time. Java environment has been built around

the multithreading model. In fact all java class libraries have been designed keeping

multithreading in mind. If a thread goes off to sleep for some time, the rest program does

not get affected by this. Similarly, an animation loop can be fired that will not stop the

working of rest of the system. At a point of time a thread can be in any one of the following

states: new, ready, running, inactive and finished. A thread enters the new state as soon as

it is created. When it is started, it is ready to run. The start() method in turn calls the run()

method which makes the thread enter the running state. While running, a thread might get

blocked because some resource that it requires is not available, or it could be suspended on

purpose for some reason. In such a case the thread enters the state of being inactive. A

thread can also be stopped purposely because its time has been expired, then it enters the

state of ready to run once again. A thread that is in running state can be stopped once its

job has finished. A thread that is in inactive state can either be resumed, in which case it

enters the ready state again, or it can be stopped in which case it enters the finished state.

5.2 Multithreading

Multithreading is a process of executing multiple threads simultaneously. So at this point

we will ask ourselves what a thread is. A thread is a lightweight subprocess, a smallest unit

of processing. It is a separate path of execution. It shares the memory area of process. So

in short, Multithreading is a technique that allows a program or a process to execute many

tasks concurrently (at the same time and parallel). It allows a process to run its tasks in

parallel mode on a single processor system. Java provides built-in support for

multithreaded programming. A multithreaded program contains two or more parts that can

run concurrently. Each part of such a program is called a thread, and each thread defines a

separate path of execution. A multithreading is a specialized form of multitasking.

Multitasking threads require less overhead than multitasking processes. I need to define

another term related to threads: process: A process consists of the memory space allocated



by the operating system that can contain one or more threads. A thread cannot exist on its

own; it must be a part of a process. A process remains running until all of the non-daemon

threads are done executing. Multithreading enables you to write very efficient programs

that make maximum use of the CPU, because idle time can be kept to a minimum. In Java,

the Java Virtual Machine (JVM) allows an application to have multiple threads of

execution running concurrently. It allows a program to be more responsible to the user.

When a program contains multiple threads then the CPU can switch between the two

threads to execute them at the same time.

Fig: 5.1 an example of multithreading

In this diagram, two threads are being executed having more than one task. The task of

each thread is switched to the task of another thread.

5.3 Thread Priorities

Every Java thread has a priority that helps the operating system determine the order in

which threads are scheduled. Java priorities are in the range between MIN_PRIORITY (a

constant of 1) and MAX_PRIORITY (a constant of 10). By default, every thread is given

priority NORM_PRIORITY (a constant of 5). Threads with higher priority are more

important to a program and should be allocated processor time before lower -priority

threads. However, thread priorities cannot guarantee the order in which threads execute

and very much platform dependent.

5.4 Creating Thread

Java defines two ways in which this can be accomplished:

You can implement the Runnable interface.

You can extend the Thread class itself.



5.4.1 Implementing the java.lang.Runnable Interface

The procedure for creating threads by implementing the Runnable Interface is as follows:

A Class implements the Runnable Interface, override the run() method to define

the code executed by thread. An object of this class is Runnable Object.

Create an object of Thread Class by passing a Runnable object as argument.

Invoke the start( ) method on the instance of the Thread class.

The following program demonstrates the thread creation implementing the Runnable

interface:

class MyThread1 implements Runnable{

Thread t;

String s=null;

MyThread1(String s1){

s=s1;

t=new Thread(this);

t.start();

}

public void run(){

System.out.println(s);

}

}

public class RunableThread{

public static void main(String args[]){

MyThread1 m1=new MyThread1("Thread started....");

}

}

There are two reasons for implementing a Runnable interface preferable to extending the

Thread class:

1. If you extend the Thread Class, that means that subclass cannot extend any other Class,

but if you implement Runnable interface then you can do this.

2. The class implementing the Runnable interface can avoid the full overhead

of Thread class which can be excessive.



5.4.2 Extending the java.lang.Thread Class

For creating a thread a class have to extend the Thread Class. For creating a thread by this

procedure you have to follow these steps:

Extend the java.lang.Thread Class.

Override the run( ) method in the subclass from the Thread class to define the code

executed by the thread.

Create an instance of this subclass. This subclass may call a Thread class

constructor by subclass constructor.

Invoke the start( ) method on the instance of the class to make the thread eligible

for running.

The following program demonstrates a single thread creation extending the "Thread" Class:

class MyThread extends Thread{

String s=null;

MyThread(String s1){

s=s1;

start();

}

public void run(){

System.out.println(s);

}

}

public class RunThread{

public static void main(String args[]){

MyThread m1=new MyThread("Thread started....");

}

}

5.5 Basic control of thread

5.5.1 Test thread

Syntax:

Is Alive()



5.5.2 Access thread

Syntax:

getPriority()

setPriority()

5.5.3 Put thread on hold

Syntax:

Thread.sleep() //static method

Join()

Thread.yield() //static method

5.5.4 The join method

Syntax:

Public static void main(String args[])

{

Thread t=new Thread(new Runner());

t.start();

// Do stuff in parallel with the order thread for a while

// Wait here for the other thread to finish

Try {

t.join();

} catch (InterruptedException e) {

// the other thread came back early

}

// Now continue in this thread

}



CHAPTER 6

STREAM

6.1 Stream

A stream is a path of communication between the source of some information and its

destination. That information, an un-interpreted byte stream, can come from any “pipe

source,” the computer’s memory, or even from the Internet. In fact, the source and

destination of a stream are completely arbitrary producers and consumers of bytes,

respectively. Therein lies the power of the abstraction. You don’t need to know about the

source of the information when reading from a stream, and you don’t need to know about

the final destination when writing to one. General-purpose methods that can read from any

source accept a stream argument to specify that source; general methods for writing accept

a stream to specify the destination. Arbitrary processors (or filters) of data have two stream

arguments. They read from the first, process the data, and write the results to the second.

These processors have no idea of either the source or the destination of the data they are

processing. Sources and destinations can vary widely: from two memory buffers on the

same local computer, to the ELF transmissions to and from a submarine at sea, to the real-

time data streams of a NASA probe in deep space. By decoupling the consuming,

processing, or producing of data from the sources and destinations of that data, you can

mix and match any combination of them at will as you write your program. In the future,

when new, previously nonexistent forms of source or destination (or consumer, processor,

or producer) appear, they can be used within the same framework, with no changes to your

classes. New stream abstractions, supporting higher levels of interpretation “on top of” the

bytes, can be written completely independently of the underlying transport mechanisms for

the bytes themselves. At the pinnacle of this stream framework are the two abstract classes,

InputStream and OutputStream. If you turn briefly to the diagram for java.io in Appendix

B, These classes is a virtual cornucopia of categorized classes, demonstrating the wide

range of streams in the system, but also demonstrating an extremely well-designed

hierarchy of relationships between these streams, one well worth learning from. Let’s begin

with the parents and then work our way down this bushy tree.

There are two types of Streams in java , InputStream and OutputStream.



6.2 Input Streams

All the methods you will explore today are declared to throw IOExceptions. This new

subclass of Exception conceptually embodies all the possible I/O errors that might occur

while using streams. Several subclasses of it define a few, more specific exceptions that

can be thrown as well. For now, it is enough to know that you must either catch an

IOException, or be in a method that can “pass it along,” to be a well-behaved user of

streams.

6.2.1 read()

The most important method to the consumer of an input stream is the one that reads bytes

from the source. This method, read(), comes in many flavors, and each is demonstrated in

an example in today’s lesson. Each of these read()methods is defined to “block” (wait)

until all the input requested becomes available. Don’t worry about this limitation; because

of multithreading, you can do as many other things as you like while this one thread is

waiting for input. In fact, it is a common idiom to assign a thread to each stream of input

(and for each stream of output) that is solely responsible for reading from it (or writing to

it). These input threads might then “hand off” the information to other threads for

processing. This naturally overlaps the I/O time of your program with its compute time.

Here’s the first form of read():

InputStream s = getAnInputStreamFromSomewhere();

byte[] buffer = new byte[1024]; // any size will do

if (s.read(buffer) != buffer.length)

System.out.println(“I got less than I expected.”);

This form of read()attempts to fill the entire buffer given. If it cannot (usually due to

reaching the end of the input stream), it returns the actual number of bytes that were read

into the buffer. After that, any further calls to read()return -1, indicating that you are at the

end of the stream. Note that the ifstatement still works even in this case, because -1! =

1024(this corresponds to an input stream with no bytes in it all).

6.2.2 skip()

What if you want to skip over some of the bytes in a stream, or start reading a stream from

other than its beginning? A method similar to read()does the trick:



if (s.skip(1024) ! = 1024)

System.out.println(“I skipped less than I expected”);

This skips over the next 1024bytes in the input stream. skip()takes and returns a long

integer,

because streams are not required to be limited to any particular size. The default

implementation

of skip in this release simply uses read():

public long skip(long n) throws IOException {

byte[] buffer = new byte[(int) n];

return read(buffer);

}

6.2.3 available()

If for some reason we would like to know how many bytes are in the stream right now, we

can ask:

if (s.available() < 1024)

System.out.println(“Too little is available right now.”);

This tells we the number of bytes that we can read() without blocking. Because of the

abstract nature of the source of these bytes, streams may or may not be able to tell you a

reasonable answer to this question. For example, some streams always return 0. Unless you

use specific subclasses of InputStream that you know provide a reasonable answer to this

question, it’s not a good idea to rely upon this method. Remember, multithreading

eliminates many of the problems associated with blocking while waiting for a stream to fill

again. Thus, one of the strongest rationales for the use of available() goes away.

6.2.4 mark() and reset()

Some streams support the notion of marking a position in the stream, and then later

resetting the stream to that position to reread the bytes there. Clearly, the stream would

have to “remember” all those bytes, so there is a limitation on how far apart in a stream the

mark and its subsequent reset can occur. There’s also a method that asks whether or not

the stream supports the notion of marking at all. Here’s an example:

InputStream s = getAnInputStreamFromSomewhere();

if (s.markSupported()) { // does s support the notion?



. . . // read the stream for a while

s.mark(1024);

. . . // read less than 1024 more bytes

s.reset();

. . . // we can now re-read those bytes

}

else {

. . . // no, perform some alternative

}

When marking a stream, you specify the maximum number of bytes you intend to allow to

pass before resetting it. This allows the stream to limit the size of its byte “memory.” If this

number of bytes goes by and you have not yet reset(), the mark becomes invalid, and

attempting to reset()will throw an exception. Marking and resetting a stream is most

valuable when you are attempting to identify the type of the stream (or the next part of the

stream), but to do so, you must consume a significant piece of it in the process. Often, this

is because you have several black-box parsers that you can hand the stream to, but they

will consume some (unknown to you) number of bytes before making up their mind about

whether the stream is of their type. Set a large size for the read limit above, and let each

parser run until it either throws an error or completes a successful parse. If an error is

thrown, reset()and try the next parser.

6.2.5 close()

Because you don’t know what 531sources an open stream rep531sents, nor how to deal

with them properly when you’re finished reading the stream, you must usually explicitly

close down a stream so that it can release these 531sources. Of course, garbage collection

and a finalization method can do this for you, but what if you need to reopen that stream

or those resources before they have been freed by this asynchronous p5ocess? At best, this

is annoying or confusing; at worst, it introduces an unexpected, obscure, and difficult-to-

track-down bug. Because you’re interacting with the outside world of external 531sources,

it’s safer to be explicit about when you’re finished using them:

InputStream s = alwaysMakesANewInputStream();

try {



. . . // use s to your heart’s content

}

finally {

s.close();

}

Get used to this idiom (using finally); it’s a useful way to be sure something (such as

closing the stream) always gets done. Of course, you’re assuming that the stream is always

successfully created. If this is not always the case, and nullis sometimes returned instead,

here’s the correct way to be safe:

InputStream s = tryToMakeANewInputStream();

if (s != null) {

try {

. . .

}

finally {

s.close();

}

}

All input streams descend from the abstract class InputStream.

6.3 Output Stream

Output streams are, in almost every case, paired with a “brother” InputStream that you’ve

already learned. If an InputStream performs a certain operation, the “brother”

OutputStream performs the inverse operation.

6.3.1 write()

The most important method to the producer of an output stream is the one that writes bytes

to the destination. This method, write(), comes in many flavors, each demonstrated in an

example below.

OutputStream s = getAnOutputStreamFromSomewhere();

byte[] buffer = new byte[1024]; // any size will do

fillInData(buffer); // the data we want to output

s.write(buffer);



You also can write a “slice” of your buffer by specifying the offset into the buffer, and the

length desired, as arguments to write():

s.write(buffer, 100, 300);

This writes out bytes 100through 399and behaves otherwise exactly the same as the

previous write() method. In fact, in the current release, the default implementation of the

former version

of write()uses the latter:

public void write(byte[] buffer) throws IOException {

write(buffer, 0, buffer.length);

}

Finally, you can write out bytes one at a time:

while (thereAreMoreBytesToOutput()) {

byte b = getNextByteForOutput();

s.write(b);

}

6.3.2 flush()

Because you don’t know what an output stream is connected to, you might be required to

“flush” your output through some buffered cache to get it to be written (in a timely manner,

or at all). OutputStream’s version of this method does nothing, but it is expected that

subclasses that require flushing (for example, BufferedOutputStream and PrintStream) will

override this version to do something nontrivial.

6.3.3 close()

Just like for an InputStream, you should (usually) explicitly close down an OutputStream

so that it can release any resources it may have reserved on your behalf. (All the same notes

and examples from InputStream’s close() method apply here, with the prefix In replaced

everywhere by Out.) All output streams descend from the abstract class OutputStream. All

share the previous few methods in common.

Java Programming Basics

Technology

Transcript of Java Programming Basics