Easy to Learn Java

ACKENOWLEDGEMENTS

The Author is grateful to God, his parents, teachers and student. Writing this requires sincere efforts, hardwork and blessings of omnipresent God and other who motivated me to write.

anurag RANA

OVERVIEW

CORE JAVA

1. Introduction

2. Data Types

3. Operators

4. Control Statements

5. Introduction to Class

6. Classes and Methods

7. Inheritance

8. Interfaces

9. Packages

10. Wrapper Class

11.String & StringBuffer

12. Exception Handling

13. Multithread

14. Java awt & Events

CONTENTS

1.Introduction

a. History

b. Features of Java

c. Tokens

d. Java Literals

2.Data Types

a. Introduction

b. What is data type?

c. Variables

d. Array

3.Operators

a. Introduction to operator

b. Arithmetic operators

c. Bitwise Operators

d. Relational Operators

e. Boolean Logical Operators

f. Assignment Operator

g. The ? Operator

4.Control Statements

a. Selection Statements

b. If selection statements

c. Switch selection statement

d. Looping statements

e. Jump Statements

5.Introduction to Class

a. What is class?

b. Declaring Objects

c. Introduction to method

d. Constructor

e. Keywords

f. Access Control

6.Classes and Methods

a. Method overloading

b. Constructor overloading

c. More about method

d. Call by value

e. Call by reference

f. Recursion

g. Nested class

h. Command Line Argument

7.Inheritance

a. Inheritance

b. Super & final

c. Method overriding

d. Multilevel Inheritance

e. Dynamic Method Dispatch

f. Abstract Classes

g. Object Class

h. Polymorphism

8.Interfaces

a. Introduction

b. Defining interfaces

c. Implementing interfaces

d. Interface variables

e. Extending interfaces

9.Packages

a. Introduction

b. Vector class

c. Random class

d. Date class

e. Calendar & Gregorian class

f. Math Class

g. Hashtable

10. Wrapper Class

a. Introduction

b. Byte

c. Short

d. Integer

e. Long

f. Double

g. Float

h. Character

i. Boolean

11. String & StringBuffer

a. String Handling

b. Methods & Examples

c. StringBuffer

12. Exception Handling

a. Introduction

b. Try and catch

c. Finally

d. Throw

e. Throws

13.Multithreading

a. Introduction to thread

b. The Main Thread

c. Thread Life Cycle

d. Creating Thread

e. Thread Priority

CORE JAVA

History of java:

In 1991, Sun Microsystems was attempting to develop a new technology for programming next generation smart appliances.

The original plan was for the Star7 operating system to be developed in C++ but rejected the idea for several reasons. As a result we have new language that was better for the purposes of the Green project than C++ developed by Gosling. He called the language Oak in honor of a tree that could be seen from his office window.

James Gosling was part of Green, an isolated research project at Sun that was studying how to put computers into everyday household items like thoughtful toasters, sagacious Salad Shooters and lucid lamps. The group also wanted these devices to communicate with each other.

In January 1995, The meeting, arranged by Kim Polese (marketing person) where about a dozen people got together to brainstorm with James Gosling, a vice president and fellow of Sun, and the author of Oak, the final suggest names were Silk, DNA, Ruby, WRL and Java by the team in meeting But the other names could not trademark. So finally JAVA was the name chosen because it sounded the coolest and decided to go ahead with it and name was first suggested by Chris Warth.

Features of Java:

Object-oriented

Java support the all the features of object oriented programming language such as Abstraction, Encapsulation, Inheritance, Polymorphism and Dynamic binding etc. So with the help of these features user can reduce the complexity of the program develops in JAVA. Java gave a clean, usable, realistic approach to objects so we can say that the object model in Java is simple and easy to extend.

Platform Independent / Portable

Java makes it possible to have the assurance that any result on one computer with Java can be replicated on another. So the code is run in the different platform has a same result.

Simple and Powerful

Java inherits the C/C++ syntax and many of the object-oriented features of C++.so we can say that Java was designed to be easy to learn and use. java provides a small number of clear ways to achieve a given task. Unlike other programming systems that they provide dozens of complicated ways to perform a simple task.

Secure

Java Compatible Browser, anyone can safely download Java applets without the fear of viral infection or malicious intent because of its key design principle. So anyone can download applets with confidence that no harm will be done and no security will be violated. Java achieves this protection by confining a Java program to the Java execution environment and by making it inaccessible to other parts of the computer.

Robust

Most programs in use today fail for one of the two reasons:

(i) MEMORY MANAGEMENT MISTAKES

For example, in C/C++, the programmer must manually allocate and free all dynamic memory. This sometimes leads to problems, because programmers will either forget to free memory that has been previously allocated or, sometimes try to free some memory that another part of their code is still using. Java virtually eliminates these problems by managing memory allocation (with the help of new operator) and deallocation. (deallocation is completely automatic, because Java provides garbage collection for unused objects.)

(ii) MISHANDLED EXCEPTIONAL CONDITIONS

With the help of Exception Handling (try……….catch block), the programmer can easily handle an error or exception so user can prevent the program by automatically stop the execution when an exception found.

Thus, the ability to create robust programs was given a high priority in the design of Java.

Multithreaded

Java supports programming, which allows the user to write programs that perform many functions simultaneously. The two or more part of the program can run concurrently then each part of such a program is called a Thread and this type of programming is called multithreaded programming. Each thread defines a separate path of execution. Thus, multithreading is a specialized form of multitasking.

Architecture-neutral

The Java designers worked hard in achieving their goal “write once; run anywhere, anytime, forever” and as a result the Java Virtual Machine was developed. Java is Architecture-neutral it generates bytecode that resembles machine code, and are not specific to any processor.

Interpreted and High performance

The source code is first compile and generates the code into an intermediate representation called Java bytecode which is a highly optimized set of instruction code. This code can be interpreted on any system that has a Java Virtual Machine and generates the machine code. Java bytecode was carefully designed by using a just-in-time compiler so that it can be easily translated into native machine code for very high performance. Most of the earlier cross-platform solutions are run at the expense of performance.

Distributed

Java allows the object can access the information across the network with the help of RMI (Remote Method Invocation) means this allowed objects on two different computers to execute procedures remotely. So this feature supports the client/server programming.

Dynamic

Java programs carry with them substantial amounts of run-time type information that is used to verify and resolve accesses to objects at run time. This makes it possible to dynamically link code in a safe and perfect manner.

Token:

A token is the smallest element of a program that is meaningful to the compiler. (Actually, this definition is true for all compilers, not just the Java compiler.) These tokens define the structure of the Java language. When you submit a Java program to the Java compiler, the compiler parses the text and extracts individual tokens.

Java tokens can be broken into five categories: identifiers, keywords, literals, operators, and separators. The Java compiler also recognizes and subsequently removes comments and whitespaces.

Identifiers :

Identifiers are tokens that represent names. These names can be assigned to variables, methods, and classes to uniquely identify them to the compiler. “Identifiers means a sequence of uppercase(A,B,C,……,Y,Z) and lowercase(a,b,c,…..,y,z) letters, numbers(0,1 ,2,……,9), or the underscore(_) and dollar-sign($) characters and must not begin with a number.”

Valid and invalid Java identifiers.

Valid	Invalid
HelloWorld	Hello World (uses a space)
Hi_JAVA	Hi JAVA! (uses a space and punctuation mark)
value3	3value(begins with a number)
Tall	short (this is a Java keyword)
$age	#age (does not begin with any other symbol except _ $ )

NOTE : For Java identifiers, you should follow a few stylistic rules to make Java programming easier and more consistent. It is standard Java practice to name multiple-word identifiers in lowercase except for the beginning letter of words in the middle of the name. For example, the variable firstValue is in correct Java style; the variables firstvalue, FirstValue, and FIRSTVALUE are all in violation of this style rule. Another more critical naming issue regards the use of underscore and dollar-sign characters at the beginning of identifier names. Using either of these characters at the beginning of identifier names is a little risky because many C libraries use the same naming convention for libraries, which can be imported into your Java code. A good use of the underscore character is to use it to separate words where you normally would use a space (Hi_JAVA).

Keywords :

“It is a special type of reserved word for a specific purpose which cannot be use as a identifier means cannot be used as names for a variable, class, or method.”

There are 49 reserved keywords currently defined in the Java language (see the following table).

abstract	double	int	switch
assert	else	interface	synchronized
boolean	extends	long	this
break	false	native	throw
byte	final	new	transient
case	finally	package	true
catch	float	private	try
char	for	protected	void
class	goto	public	volatile
const	if	return	while
continue	implements	short
default	import	static
do	instanceof	super

The keywords const and goto are reserved but not used. In the early days of Java,several other keywords were reserved for possible future use. In addition to the keywords, Java reserves the following: true, false, and null. These are values defined by Java. You may not use these words for the names of variables, classes, and so on.

Separators :

Separators are used to inform the Java compiler of how things are grouped in the code. For example, items in a list are separated by commas much like lists of items in a sentence. The most commonly used separator in Java is the semicolon. As you have seen, it is used to terminate statements.

Symbol	Name	Purpose
;	Semicolon	Terminates statements.
,	Comma	Separates consecutive identifiers in a variable declaration. Also used to chain statements together inside a for statement.
{ }	Braces	Used to contain the values of automatically initialized arrays. Also used to define a block of code, for classes, methods, and local scopes.
( )	Parentheses	Used to contain lists of parameters in method definition and invocation. Also used for defining precedence in expressions, containing expressions in control statements. Also used for surrounding cast types.
[ ]	Brackets	Used to declare array types. Also used when dereferencing array values.
.	Period	Used to separate package names from subpackages and classes Also used to separate a variable or method from a reference variable.

Comments and Whitespaces :

The comments and whitespaces are removed by the Java compiler during the tokenization of the source code. White space consists of spaces, tabs, and linefeeds. All occurrences of spaces, tabs, or linefeeds are removed by the Java compiler, as are comments. Comments can be defined in three different ways, as shown in Table.

Types of comments supported by Java.

Type	Syntax	Usage	Example
Single-line	// comment	All characters after the // up to the end of the line are ignored.	//This is a Single-line style comment.
Multiline	/* comment */	All characters between /* and */ are ignored.	/* This is a Multiline style comment.
Documentation	/** comment */	Same as /* */, except that the comment can be used with the javadoc tool to create automatic documentation.	/** This is a javadoc style comment. */

Literals :

A constant value in Java is created by using a literal representation of it.

For example, Here are some literals :

integer literal value : 100

floating-point literal value : 98.6

character literal value : ‘X’

string literal value : “This is a test”

A literal can be used anywhere a value of its type is allowed.

Integer Literals :

Integer literals are the primary literals used in Java programming. They come in a few different formats: decimal, hexadecimal, and octal. These formats correspond to the base of the number system used by the literal. Decimal (base 10) literals appear as ordinary numbers with no special notation. Hexadecimal numbers (base 16) appear with a leading 0x or 0X. Octal (base 8) numbers appear with a leading 0 in front of the digits.

For example, an integer literal for the decimal number 12 is represented in Java as 12 in decimal, 0xC in hexadecimal, and 014 in octal. Integer literals default to being stored in the int type, which is a signed 32-bit value. If you are working with very large numbers, you can force an integer literal to be stored in the long type by appending an l or L to the end of the number, as in 79L. The long type is a signed 64-bit value.

Floating-Point Literals :

Floating-point literals represent decimal numbers with fractional parts, such as 3.1415. They can be expressed in either standard or scientific notation, meaning that the number 143.85 also can be expressed as 1.4385e2. Unlike integer literals, floating-point literals default to the double type, which is a 64-bit value. You have the option of using the smaller 32-bit float type if you know the full 64 bits are not required. You do this by appending an f or F to the end of the number, as in 5.6384e2f.

Boolean Literals :

Boolean literals are certainly welcome if you are coming from the world of C/C++. In C, there is no boolean type, and therefore no boolean literals. The boolean values true and false are represented by the integer values 1 and 0. Java fixes this problem by providing a boolean type with two possible states: true and false. Not surprisingly, these states are represented in the Java language by the keywords true and false. Boolean literals are used in Java programming about as often as integer literals because they are present in almost every type of control structure. Any time you need to represent a condition or state with two possible values, a boolean is what you need. The two boolean literal values: true and false.

Character Literals :

Character literals represent a single Unicode character and appear within a pair of single quotation marks. Special characters (control characters and characters that cannot be printed) are represented by a backslash (\) followed by the character code.

Example of a special character is \n, which forces the output to a new line when printed. Table shows the special characters supported by Java.

Description	Representation
Backslash	\\
Continuation	\
Backspace	\b
Carriage return	\r
Form feed	\f
Horizontal tab	\t
Newline	\n
Single quote	\'
Double quote	\"
Unicode character	\udddd
Octal character	\ddd

An example of a Unicode character literal is \u0048, which is a hexadecimal representation of the character H. This same character is represented in octal as \110.

String Literals :

String literals represent multiple characters and appear within a pair of double quotation marks. String literals are implemented in Java by the String class. This arrangement is very different from the C/C++ representation of strings as an array of characters. When Java encounters a string literal, it creates an instance of the String class and sets its state to the characters appearing within the double quotes.

Operators:

Operators means specify an evaluation to be performed on a data (Operands).

First Java program :

Demonstrating program that displays the text,” Hello Java World! First JAVA program.....” on the console.

public class FirstProg

{ //This is a first java program.

public static void main(String[] args)

{

System.out.println("Hello Java World! First JAVA program.....");

}

Explanation :

public :

A keyword of the Java language that indicates that the element that follows should be made available to other Java elements. Public keyword indicates that the FirstProg class is a public class, which means other classes can use it.

class :

Java keyword that indicates that the element being defined here is a class. All Java programs are made up of one or more classes.

A class definition contains code that defines the behavior of the objects created and used by the program.

FirstProg :

An identifier that provides the name for the class being defined here. While keywords, such as public and class, are words that are defined by the Java programming language, identifiers are words that you create to provide names for various elements you use in your program. In this program, the identifier FirstProg provides a name for the public class being defined here.

{ :

The opening brace marks the beginning of the body of the class. The end of the body is marked by the closing brace. Everything that appears within these braces belongs to the class. As you work with Java, you’ll find that it uses these braces a lot.

//This is a first java program. :

This is a comment. Like most other programming languages, Java lets you enter a remark into a program’s source file. The contents of a comment are ignored by the compiler. Instead, a comment describes or explains the operation of the program to anyone who is reading its source code. In this case, the comment describes the program and reminds you that the source file should be called FirstProg.java. Of course, in real applications, comments generally explain how some part of the program works or what a specific feature does.

public :

The public keyword is used again, this time to indicate that a method being declared here should have public access. That means classes other than the FirstProg class can use it. All Java programs must have at least one class that declares a public method named main. The main method contains the statements that are executed when you run the program.

static :

Execute any elements (properties) without an object means before the object creating then it must declare a static so compiler directly execute those static elements.Here the main method is executed before the any object is creating so it must declare a static. The keyword static allows main( ) to be called without having to instantiate a particular instance of the class. This is necessary since main( ) is called by the Java interpreter before any objects are made. Java language requires that you specify static when you declare the main method.

void :

In Java, a method is a unit of code that can calculate and return a value.

main :

Identifier that provides the name for this method. Java requires that this method be named main because main( ) is the method called when a Java application begins. Besides the main method, you can also create additional methods with whatever names you want to use.

(String[] args) :

It’s called a parameter list, and it’s used to pass data to a method. Java requires that the main method must receive a single parameter that’s an array of String objects. By convention, this parameter is named args. If you don’t know what a parameter, a String, or an array is, don’t worry about it You have to write (String[] args) on the declaration for the main methods in all your programs. In this case, args receives any command-line arguments present when the program is executed. This program does not make use of this information.

System.out.println(“Hello Java World! First JAVA program..........”); :

Statement in the entire program. It calls a method named println that belongs to the System.out object. System is a predefined class, it is automatically included in your programs that provides access to the system and out is the output stream that is connected to the console. The println method displays a line of text on the console. The text to be displayed is passed to the println method as a parameter in parentheses following the word println. In this case, the text is the string literal Hello Java World! First JAVA program................ enclosed in a set of double quotation marks. As a result, this statement displays the text on the console.

Note: In Java, statements end with a semicolon. Because this is the only statement in the program, this line is the only one that requires a semicolon. Java is case-sensitive. Thus, Main is different from main.

javac FirstProg.java

This command creates a class file named FirstProg.class that contains the Java bytecodes compiled for the FirstProg class. Now run the program by entering this command:

java FirstProg

Output :

Hello Java World! First JAVA program................

DATA TYPE IN JAVA

Data types in java:

For storing different type of data we have data types. Java defines eight types of data: byte, short, int, long, float, double, char and boolean.

Integers:This group includes byte, short, int, and long, which are for signed and unsigned number including zero.

Floating-point numbers:This group includes float and double, which can store numbers with fractional precision.

Characters:This group includes char, which represents symbols in a characterset, like letters and numbers.

Boolean:This group includes boolean, which is a special type for representing true/false values.

NOTE: The data types mentioned above are primitive data types. Java also support reference data types like Array, Class and Interface.

1. Integers:

Java defines four integer types: byte, short, int, and long. All of these can have signed unsigned or zero value. Java does not support unsigned, positive-only integers.

Name Width (in bits) Range

long 64 –9,223,372,036,854,775,808 to 9,223,372,036,854,775,807

int 32 –2,147,483,648 to 2,147,483,647

short 16 –32,768 to 32,767

byte 08 –128 to 127

Note: Divide width with 8 to get size in Bytes; the table mentioned above is providing width and range of the integer data type. Width is the size the data type will occupy in the program if you write int a,b; than a and b both will occupy 32 bits (4 bytes) in memory.

1.1 byte

The smallest integer type is byte. This is a signed 8-bit type that has a range from –128 to 127

Exp. byte b1;

Variables of type byte are especially useful when we’re working with a stream of data from a network or file.

1.2 short

Short is a signed 16-bit type. It has a range from –32,768 to 32,767 so if you are sure that your value will not more than the range of Short data type than and only we recommended to use this.

Exp short s1,s2;

1.3 int

The most commonly used integer type is int. It is a signed 32-bit type that has a range from –2,147,483,648 to 2,147,483,647.

Exp. int a, b;

1.4 long

long is a signed 64-bit type and is useful for those occasions where an int type is not large enough to hold the desired value. The range of a long is quite large. This makes it useful when big, whole numbers are needed.

Prog.No.:- 1

//Demonstrate the integer data type

public class ITesst

{

public static void main(String[] args)

{

byte b1=50,b2=0; //declare and define the byte variable

short s1=10,s2=20; //declare and define the short variable

int i1=-555,i2=123; //declare and define the int variable

long l1=100000,l2=2033; //declare and define the long variable

System.out.print("The value of different variables");

System.out.println(" of type integers is.........");

System.out.println("byte integers : " + "b1 = " +b1 +" and b2 = " +b2);

System.out.println("short integers : " + "s1 = " +s1 +" and s2 = " +s2);

System.out.println("int integers : " + "i1 = " +i1 +" and i2 = " +i2);

System.out.println("long integers : " + "l1 = " +l1 +" and l2 = " +l2);

}

Output :

C:\java> javac ITest.java

C:\java> java ITest

The value of different variables of type integers is.........

byte integers : b1 = 50 and b2 = 0

short integers : s1 = 10 and s2 = 20

int integers : i1 = -555 and i2 = 123

long integers : l1 = 100000 and l2 = 2033

2. Floating-Point Types:

Floating-point numbers, also known as real numbers, are used when evaluating expressions that require fractional precision.

For example, calculations such as square root, or transcendental such as sine and cosine, result in a value whose precision requires a floating-point type.

Name Width in Bits Approximate Range

double 64 4.9e–324 to 1.8e+308

float 32 1.4e-045 to 3.4e+038

2.1 float

Float specifies a single-precision value that uses 32 bits of storage. Single precision is faster on some processors and takes half as much space as double precision, but will become imprecise when the values are either very large or very small. When you require to store floating point value use float and double.

Ex. float r, pi;

2.2 double

Double precision, as denoted by the double keyword, uses 64 bits to store a value. Double

precision is actually faster than single precision on some modern processors that have been optimized for high-speed mathematical calculations.

Prog.No.:- 2

//Demonstrate floating point data type.

public class FTest

{

public static void main(String[] args)

{

float f1=1.2f,f2=123.2f; //declare and define the float variable

double d1=1.234,d2=23.4512; //declare and define the double variable

System.out.print("The value of different variables");

System.out.println(" of type floating point is........");

System.out.println("float value : " + "f1 = " +f1 +" and f2 = " +f2);

System.out.println("double value : " + "d1 = " +d1 +" and d2 = " +d2);

}

Output :

C:\java> javac FTest.java

C:\java> java FTest

The value of different variables of type floating point is........

float value : f1 = 1.2 and f2 = 123.2

double value : d1 = 1.234 and d2 = 23.4512

3. Characters:

Data type used to store characters is char.

NOTE: However, C/C++ programmers beware: char in Java is not the same as char in C or C++. In C/C++, char is an integer type that is 8 bits wide. This is not the case in Java. Java uses Unicode to represent characters. Unicode defines a fully international character set that can represent all of the characters found in all human languages. In Java char require 16-bit. The range of a char is 0 to 65,536. There are no negative chars. The standard set of characters known as ASCII still ranges from 0 to 127. The extended 8- bit character set, ISO-Latin-1, ranges from 0 to 255. Since Java is designed to allow applets to be written for worldwide use, it makes sense that it would use Unicode to represent characters.

Prog.No.:- 3

//Demonstrate char data type.

public class CharTest

{

public static void main(String[] args)

{

char ch1, ch2; // declare the char variable

ch1 = 88; // code for X

ch2 = 'Y'; // define the char variable

System.out.print("The value of type");

System.out.println(" character variable is........");

System.out.print("char data type : ch1 = "+ ch1 +" and ch2 = "+ch2);

}

Output :

C:\java> javac CharTest.java

C:\java> java CharTest

The value of type character variable is........

char data type : ch1 = X and ch2 = Y

4. Boolean:

Java has a simple type, called boolean, for logical values. It can have only one of two possible values, true or false. This is the type returned by all relational operators, such as a < b.

Exp. boolean b; So here the value of b is either true or false.

Prog.No.:- 4

//Demonstrate boolean data type.

public class BoolTest

{

public static void main(String[] args)

{

boolean b; //declare the boolean variable

b = false; //define the boolean variable

System.out.print("The value of type");

System.out.println(" boolean variable is........");

System.out.println("boolean data type : b is " + b);

b = true; //define the boolean variable

System.out.println("boolean data type : b is " + b);

// a boolean value can control the if statement

if(b) System.out.println("This is executed.");

b = false;

if(b) System.out.println("This is not executed."); //never execute

// outcome of a relational operator is a boolean value

System.out.println("100 > 9 is " + (10 > 9));

}

Output :

C:\java> javac BoolTest.java

C:\java> java BoolTest

The value of type boolean variable is........

boolean data type : b is false

boolean data type : b is true

This is executed.

100 > 9 is true

VARIABLES IN JAVA

The variable is the basic unit of storage in a Java program. A variable is defined by the combination of a type, an identifier and an optional initialize. Type is a data type or the name of a class or interface (class and interface will discussed further).for identify the type of variable identifier is a variable name and optional initializer means users directly initialize the value to the variable if they want.

Declare Variable

Syntax for declaring a variable is...

type identifier1=val , identifier2;

Exp.

int a=100, b; //initialize a and declare b.

byte z = 22; // initialize z.

double pi = 3.14159; // declares an approximation of pi.

char x = 'x'; // the variable x has the value 'x'.

Dynamic Initialization

Java allows variables to be initialized dynamically.

Prog.No.:- 5

public class VariableTest

{

public static void main(String[] args)

{

int l = 10;

int b = 20;

int a;

a = l * b;

System.out.println("normal initaialization : area is = "+a);

int area = l * b; // it’s a dynamic initialization of variable name area

System.out.println("dynamic initaialization : area is = "+area);

}

Output :

C:\java> javac VariableTest.java

C:\java> java VariableTest

Normal initialization: area is = 200

`Dynamic initialization: area is = 200`

The Scope and Lifetime of Variables

Every variable have scope and life time throughout the program. Here we study when the new scope will be create for how long time (Life time). A block is begun with an opening curly brace and ended by a closing curly brace. A block defines a scope. We use so many variables in our program and declared these variables at the at the start of the main( ) method. Most other computer languages define two general categories of scopes: global and local. However, these traditional scopes do not fit well with Java’s strict, object oriented model.

Prog.No.:- 6

// Demonstrate variable scope.

class Scope

{

public static void main(String args[])

{

int x; // known to all code within main

x = 10;

if(x == 10)

{ // start new scope

int y = 20; // known only to this block

// x and y both known here.

System.out.println("x and y: " + x + " " + y);

}

y = x+10; // Error! y not known here

// x is still known here.

System.out.println("x is " + x);

}

Here we initialize variable x in main block but the variable y is initialized in if block so scope of variable y is limited to if block. So we will get error on line no. 14 because we are trying to access variable y which is outside of its scope.

Array:

It is a group of variables with same data types.

Java has three reference data types:

Data Type	Description
Array	A collection of several items of the same data type. For example names of student.
Class	A collection of variables and methods.
Interface	An abstract class created to implement multiple inheritance in JAVA.

We have one dimensional and multidimensional array in java. It works differently compare to C and C++ language. We declare one char type array and size of that array is 10. So we have 10 different char type variables like ch[0] to ch[9]. Value in the square bracket is called index of the array and index value of any array always start from 0.

Arrays can be declared in three ways:

	Description	Syntax	Example
Only Declaration	Just declares the array.	data type identifier[]	char ch[ ]; declares a character array named ch.
Declaration and creation	Declares and allocates memory for the array elements using the reserved word ‘new’.	data type identifier[] =new data type[size];	char ch[] = new char[10]; declares an array ch to store 10 characters.
Declaration, creation and initialization	Declares the array, allocates memory for it and assigns initial values to its elements.	data type identifier[] = {value1, value2, ….ValueN};	char ch[] ={‘A’,’B’,’C’,’D’}; declares an array ch to store 4 pre-as signed character values.

Syntax of One dimensional array :

Declaration syntax : type var-name[ ];

Exp.

int month[ ];

Here we just declare month variable of type int array. But actually or physically no array exists. To link this array into actual physical array of integers we have to use new keyword.

Syntax: array-var = new type[size];

Exp.

month = new month[12];

So obtaining an array is a two-step process. First, you must declare a variable of the desired array type. Second, you must allocate the memory that will hold the array, using new, and assign it to the array variable. Thus, in Java all arrays are dynamically allocated. Now we have 12 different int type variable month[0] to month[11]. It is possible to combine the declaration of the array variable with the allocation of the array itself like... int month[] = new int[12];

Array declare either primitive or class.

char [] s;

Point [] p;

Declaring array with the bracket to left, the bracket apply to all variables to the right of the brackets.

int a[], b;// a is array and b is int type variable.

int [] a, b; // a and b both are int type array.

In java array is an object even when the array is made up of primitive type and as with other class type, the declaration does not create the object itself. Instead, the declaration of an array creates a reference that we can use to refer to an array. Actual memory used by the array elements is allocated dynamically either by new statement or by an array initializer.

EX:-

public char [] createArray()

{

char [] s;

s= new char[26]; // create 26 char value array.

for(int i=0; i<26;i++)

{

S[i]=(char)(‘A’+i);

}

return s;

}

Char[]

Execution Stack

createArray

this

main

Heap Memory

Fig. 1

NOTE:- Indexes the individual array elements always begins from 0 and must be maintained in the legal

Range: greater than 0 or equal to 0 and less than the array length. Any attempt to access an array element outside these bounds causes a runtime exception.

Creating Reference Array:-

P=new Point[10]; // create an array of the 10 references of type Point. However, it does not create 10 Point objects.

public char [] createArray()

{

Point [] p ;

p= new Point[10];

for(int i=0; i<10;i++)

{

p[i]=new Point(i, i+1);

}

return p;

}

Execution Stack Point []

createArray

this

main

Heap Memory

Fig. 2

Initializing Arrays:-

When we create an array every element is initialized. In case of char, each value is initialized to the null(‘\u0000’) character. In case of array p each value is initialized to null, indicating that it does not refer to a Point object. After the assignment P[0]=new Point(), the first element of the array refer to real Point object.

NOTE:-

Initializing all variables i including elements of arrays is essential to the security of the system. We must not use variables in an uninitialized state.

Multidimensional array :

Declaration syntax : type var-name[ ][ ];

Exp.

int mat[ ][ ] = new int[4][5];

In Java, multidimensional arrays are actually arrays of arrays. To declare a multidimensional array variable, specify each additional index using another set of square brackets. This allocates a 4 by 5 array and assigns it to mat. Internally this matrix is implemented as an array of arrays of int. conceptually.

Fig. 3[Indexing of multi dimensional array]

OPERATOR IN JAVA

Operator: It is a symbol that tells the computer to perform mathematical and logical calculation.

Java supports basically 6 types of operators.

1. Arithmetic operator

2. Bitwise operator

3. Relational operator

4. Boolean Logical operator

5. Assignment operator

6. Conditional operator

Arithmetic operator

Prog. No.:- 7

public class ArithmeticTest

{

public static void main(String[] args)

{

System.out.println("..............Arithmetic operators.................");

System.out.println();

int a = 10;

int b = 3;

int c = 20;

int d = 30;

int e = 40;

int f = 50;

int i = 10;

int j = 5;

int m = 30;

int l = 3;

int o = 25;

int v = 6;

int z = 27;

int r = 8;

int add = a + b;

int sub = a - b;

int mul = a * b;

int div = a / b;

int mod = a % b;

System.out.println("<-------Basic Arithmetic operators------->");

System.out.println("Addition of a and b : a + b = 10 + 3 = "+add);

System.out.println("Subtraction of a and b : a - b = 10 - 3 = "+sub);

System.out.println("Multiplication of a and b : a * b = 10 * 3 = "+mul);

System.out.println("Division of a and b : a / b = 10 / 3 = "+div);

System.out.println("Modulus of a and b : a % b = 10 % 3 = "+mod);

System.out.println();

System.out.println("<-------Increment Operator------->");

// c = 20, d = 30

// post_incr = c++ => post_incr = c then c = c + 1 => post_incr = 20 and c = 20 + 1 = 21

// pre_incr = ++d => d = d + 1 then pre_incr = d => d = 30 + 1 = 31 and pre_incr = 31

System.out.println("Before Post-Increment of c = "+c);

int post_incr = c++;

System.out.println("Post-Increment of c : c++ = 20++ = "+post_incr);

System.out.println("After Post-Increment of c = "+c);

System.out.println("Before Pre-Increment of d = "+d);

int pree_incr = ++d;

System.out.println("Pree-Increment of d : ++d = ++30 = "+pre_incr);

System.out.println("After Pre-Increment of d = "+d);

System.out.println();

System.out.println("<-------Decrement Operator------->");

/* e = 40, f = 50

* post_decr = e-- => post_decr = e then e = e - 1 => post_decr = 40 and c = 40 - 1 = 39

* pre_decr = --f => f = f - 1 then pre_decr = f => f = 50 - 1 = 49 and pre_decr = 49

System.out.println("Before Post-Decrement of c = "+e);

int post_decr = e--;

System.out.println("Post-Decrement of e : e-- = 40-- = "+post_decr);

System.out.println("After Post-Decrement of e = "+e);

System.out.println("Before Pre-Decrement of f = "+f);

int pree_decr = --f;

System.out.println("Pree-Decrement of f : --f = --50 = "+pre_decr);

System.out.println("After Pre-Decrement of f = "+f);

System.out.println();

System.out.println("<-------Assignment Operators------->");

System.out.println("Addition Assignment of a and b : a += b means 10+=3 => a = a + b => a = 10 + 3 = "+(a+=b));

System.out.println("Subtraction Assignment of i and j : i -= j means 10-=5 => i = i - j => i = 10 - 5 = "+(i-=j));

System.out.println("Multiplication Assignment of m and l : m *=l means 30*=3 => m = m * l => m = 30 * 3 = "+(m*=l));

System.out.println("Division Assignment of o and v : o /= v means 25/=6 => o = o / v => o = 25 / 6 = "+(o/=v));

System.out.println("Modulus Assignment of z and r : z %= r means 27%=8 => z = z % r => z = 27 % 8 = "+(z%=r));

}

Output :

C:\java> javac ArithmeticTest.java

C:\java> java ArithmeticTest

..............Arithmetic operators.................

<-------Basic Arithmetic operators------->

Addition of a and b : a + b = 10 + 3 = 13

Subtraction of a and b : a - b = 10 - 3 = 7

Multiplication of a and b : a * b = 10 * 3 = 30

Division of a and b : a / b = 10 / 3 = 3

Modulus of a and b : a % b = 10 % 3 = 1

<-------Increment Operator------->

Before Post-Increment of c = 20

Post-Increment of c : c++ = 20++ = 20

After Post-Increment of c = 21

Before Pree-Increment of d = 30

Pree-Increment of d : ++d = ++30 = 31

After Pree-Increment of d = 31

<-------Decrement Operator------->

Before Post-Decrement of c = 40

Post-Decrement of e : e-- = 40-- = 40

After Post-Decrement of e = 39

Before Pree-Decrement of f = 50

Pree-Decrement of f : --f = --50 = 49

After Pree-Decrement of f = 49

<-------Assignment Operators------->

Addition Assignment of a and b : a += b means 10+=3 => a = a + b => a = 10 + 3 = 13

Subtraction Assignment of i and j : i -= j means 10-=5 => i = i - j => i = 10 - 5 = 5

Multiplication Assignment of m and l : m *=l means 30*=3 => m = m * l => m = 30 * 3 = 90

Division Assignment of o and v : o /= v means 25/=6 => o = o / v => o = 25 / 6 = 4

Modulus Assignment of z and r : z %= r means 27%=8 => z = z % r => z = 27 % 8 = 3

Bitwise operator

Prog. No.:- 8

public class BitewiseTest

{

public static void main(String[] args)

{

System.out.println("..............Bitewise operators.................");

System.out.println("<-------Bitewise Logical Operators------->");

String binary[] = {"0000", "0001", "0010", "0011", "0100", "0101", "0110", "0111",

"1000", "1001", "1010", "1011", "1100", "1101", "1110", "1111"};

int a = 2; // 0 + 0 + 2 + 0 or 0010 in binary

int b = 7; // 0 + 4 + 2 + 1 or 0111 in binary

int c = a | b; //Bitwise AND operator

int d = a & b; //Bitwise OR operator

int e = a ^ b; //Bitwise XOR(exclusive OR) operator

int f = ~a & a ; //Bitwise unary NOT operator, a = 0010 so ~a = 1101 hence f = ~a & a = 1101 & 0010 = 0000

int g = (~a & b) | (a & ~b);

System.out.println("The binary value of a = " + binary[a]);

System.out.println("The binary value of b = " + binary[b]);

System.out.println("The Bitwise OR : a | b = " + binary[c] + " and Decimal value = "+c);

System.out.println("The Bitwise AND : a & b = " + binary[d] + " and Decimal value = "+d);

System.out.println("The Bitwise XOR(exclusive OR) : a ^ b = " + binary[e] + " and Decimal value = "+e);

System.out.println("The Bitwise unary NOT : ~a & a = " + binary[f] + " and Decimal value = "+f);

System.out.println("~a&b|a&~b = " + binary[g]+ " and Decimal value = "+g);

System.out.println();

System.out.println("<-------Bitewise Shift Operators------->");

System.out.println("The original binary value of a = " +binary[a] + " and Decimal value of a = "+a);

a = a << 2; //Bitwise Left shift operator

System.out.println("The Left shift : a = a << 2 means a = 0010 << 2 hence a = "+binary[a] + " and Decimal value of a = "+a);

System.out.println("The original binary value of b = " +binary[b] + " and Decimal value of b = "+b);

b = b >> 2; //Bitwise Right shift operator

System.out.println("The Right shift : b = b >> 2 means b = 0111 >> 2 hence b = "+binary[b] + " and Decimal value of b = "+b);

int u = -1;

System.out.println("The original decimal value of u = " +u);

u = u >>> 30; //Bitwise Unsigned Right shift operator

System.out.println("The Unsigned Right shift : u = u >>> 30 means u = 11111111 11111111 11111111 11111111 >>> 30 hence u = "+binary[u] + " and Decimal value of u = "+u);

System.out.println();

System.out.println("<-------Bitewise Assignment Operators------->");

int p = 5;

System.out.println("The original binary value of p = " +binary[p] + " and Decimal value of p = "+p);

p >>= 2; //Bitewise shift Right Assignment Operator

System.out.println("The Bitewise Shift Right Assignment Operators : p >>= 2 means p = p >> 2 hence p = 0101 >> 2 so p = "+binary[p] + " and Decimal value of p = "+p);

/*Same as you can check Bitwise AND assignment,Bitwise OR assignment,Bitwise exclusive OR assignment,

Shift right zero fill assignment,Shift left assignment */

}

Output :

C:\java> javac BitewiseTest.java

C:\java> java BitewiseTest

..............Bitewise operators.................

<-------Bitewise Logical Operators------->

The binary value of a = 0010

The binary value of b = 0111

The Bitwise OR : a | b = 0111 and Decimal value = 7

The Bitwise AND : a & b = 0010 and Decimal value = 2

The Bitwise XOR(exclusive OR) : a ^ b = 0101 and Decimal value = 5

The Bitwise unary NOT : ~a & a = 0000 and Decimal value = 0 ~a&b|a&~b = 0101 and Decimal value = 5

<-------Bitewise Shift Operators------->

The original binary value of a = 0010 and Decimal value of a = 2

The Left shift : a = a << 2 means a = 0010 << 2 hence a = 1000 and Decimal value of a = 8

The original binary value of b = 0111 and Decimal value of b = 7

The Right shift : b = b >> 2 means b = 0111 >> 2 hence b = 0001 and Decimal value of b = 1

The original decimal value of u = -1

The Unsigned Right shift : u = u >>> 30 means u = 11111111 11111111 11111111 11111111 >>> 30 hence u = 0011 and Decimal value of u = 3

<-------Bitewise Assignment Operators------->

The original binary value of p = 0101 and Decimal value of p = 5

The Bitewise Shift Right Assignment Operators : p >>= 2 means p = p >> 2 hence p = 0101 >> 2 so p = 0001 and Decimal value of p = 1

Relational operator

Prog. No.:- 9

public class RelationalTest

{

public static void main(String[] args)

{

System.out.println("..............Relational operators.................");

int mark = 70;

if(mark != 0) // != Not equal to

{

if(mark == 65 | mark > 65) // == Equal to, > Greater than

System.out.println("Congratulation ,You got a distinction and you got " + mark + " marks........");

else if (mark < 65 & 60 <= mark) // < Less than, <= Less than or equal to

System.out.println("Congratulation ,You got a First class and you got " + mark + " marks........");

else if (mark < 60 & mark >= 50)

System.out.println("You got a Second class and you got " + mark + " marks........");

else if (50 > mark & mark >= 40) // > Greater than, >= Greater than or equal to

System.out.println("You got a Third class and you got " + mark + " marks........");

else

System.out.println("You are failed and you got " + mark + " marks........");

}

else

System.out.println("Please give the valid mark...............");

}

Output :

C:\java> javac RelationalTest.java

C:\java> java RelationalTest

..............Relational operators.................

Congratulation ,You got a distinction and you got 70 marks........

Boolean Logical operator

Prog. No.:- 10

public class Boolean_LogicalTest

{

public static void main(String[] args)

{

System.out.println("..............Boolean Logical Operators.................");

System.out.println("<---------Basic Boolean Logical Operators--------->");

boolean a = false;

boolean b = true;

boolean c = a | b; //Logical AND operator

boolean d = a & b; //Logical OR operator

boolean e = a ^ b; //Logical XOR(exclusive OR) operator

boolean f = (!a & b) | (a & !b);

boolean g = !a; //Logical unary NOT operator

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

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

System.out.println("Boolean Logical OR : a | b = " + c);

System.out.println("Boolean Logical AND : a & b = " + d);

System.out.println("Boolean Logical XOR(exclusive OR) : a ^ b = " + e);

System.out.println("(!a & b) | (a & !b) = " + f);

System.out.println("!a = " + g);

System.out.println();

System.out.println("<---------Boolean Logical Assignment Operators--------->");

System.out.println("Before apply assignment operator, the value of a = "+a);

a &= b; //

System.out.println("After apply assignment operator : a &= b means a = a & b hence now the value of a : "+a);

/*Same as you can check Boolean OR assignment,Boolean exclusive OR assignment,

Boolean Equal to and Boolean Not equal to */

}

Output :

C:\java> javac Boolean_LogicalTest.java

C:\java> java Boolean_LogicalTest

..............Boolean Logical Operators.................

<---------Basic Boolean Logical Operators--------->

a = false

b = true

Boolean Logical OR : a | b = true

Boolean Logical AND : a & b = false

Boolean Logical XOR(exclusive OR) : a ^ b = true

(!a & b) | (a & !b) = true

!a = true

<---------Boolean Logical Assignment Operators--------->

Before apply assignment operator, the value of a = false

After apply assignment operator : a &= b means a = a & b hence now the value of a : false

Prog. No.:- 11

public class Boolean_ShortCircuitTest

{

public static void main(String[] args)

{

System.out.println("<---------Boolean Short-Circuit Operators--------->");

int i = 10;

int j = 20;

if (i != 10 && ++j/i>0)

{

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

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

}

System.out.println("In Short-circuit AND operator(&&): ");

System.out.println("Not checked the second condition in IF-BLECK if first condition is false.........");

System.out.println("So,the value of j = "+j);

//Same as you can check Short-circuit OR operator(||)

}

Output :

C:\java> javac Boolean_ShortCircuitTest.java

C:\java> java Boolean_ShortCircuitTest

<---------Boolean Short-Circuit Operators--------->

In Short-circuit AND operator(&&):

Not checked the second condition in IF-BLECK if first condition is false.........

So,the value of j = 20

Assignment operator

var = expression;

int x, y, z;

x = y = z = 50; // set x, y, and z to 50

Prog. No.:- 12

public class Assignment_OperatorTest

{

public static void main(String[] args)

{

System.out.println("<------------Assignment Operator------------->");

int x,y,z,sum;

x = y = z = 50; //The Assignment Operator which assign the value to a varible

sum = x + y + z;

System.out.println("x + y + z = "+sum);

}

Output :

C:\java> javac Assignment_OperatorTest.java

C:\java> java Assignment_OperatorTest

<------------Assignment Operator------------->

x + y + z = 150

Conditional operator

It is also known as ternary operator or conditional operator.

Syntax:- expression1 ? expression2 : expression3

b = a < 0 ? -a : a;

Prog. No.:- 13

public class TernaryTest

{

public static void main(String[] args)

{

int a, b;

a = 50;

b = a < 0 ? -a : a; // get absolute value of a

System.out.println("The Absolute value of "+ a + " is " + b);

a = -10;

b = a < 0 ? -a : a; // get absolute value of a

System.out.println("The Absolute value of "+ a + " is " + b);

}

Output :

C:\java> javac TernaryTest.java

C:\java> java TernaryTest

The Absolute value of 50 is 50

The Absolute value of -10 is 10

SCANNER

Import java.uti.Scanner because the Scanner class is inside util package of java library. Than we create reference (object) of class Scanner named s. "System.in" This is the predefine library which allow user to enter value in any variable at run time through keyboard. We can say same as scanf() in c and cin >> in c++.

Now in Scanner class there are so many different different methods for scaning different type of values.

In-built methods of Scanner class for scanning different types of values.

1. nextByte() for scanning byte type value.

2. nextShort() for scanning short type value.

3. nextInt() for scanning int type value.

4. nextLong() for scanning long type value.

5. nextFloat() for scanning floting point value.

6. nextDouble() for scanning double type value.

7. next() for scanning a string.

Prog. No.:- 14

import java.util.Scanner;

public class ScannerTest

{

public static void main(String[] args)

{

Scanner s = new Scanner(System.in); // Here we initialize object s for Scanner class.

System.out.print("Enter the first value a : ");

int a = s.nextInt(); // Scan int type value

System.out.print("Enter the second value b : ");

int b = s.nextInt(); // Scan int type value

int sum = a + b;

System.out.println("The addition of a and b : a + b = "+sum);

}

}Output :

C:\java> javac ScannerTest.java

C:\java> java ScannerTest

Enter the first value a : 5

Enter the second value b : 6

The addition of a and b : a + b = 11

CONTROL STATEMENTS IN JAVA

Selection Statements

If selection statements

Switch selection statement

Looping statements

Jump Statements

Selection Statements

Java supports two selection statements: if and switch. These statements allow you to control the flow of your program’s execution based upon conditions known only during run time.

if in java:

The if statement is Java’s conditional branch statement. It can be used to route program execution through two different paths.

Syntax :

if (condition)

{

statement1;

}

When the condition is true the Statement within the if is executed. After that execution continues with the next statement after the if statement. If the condition is false then the statement within the if is not executed and the execution continues with the statement after the if statement.

Prog. No.:- 15

import java.util.Scanner;

class larger

{

public static void main(String args[])

{

int x1,x2,x3;

int large;

Scanner s = new Scanner(System.in);

System.out.println("Enter value for x1 : ");

x1=s.nextInt();

System.out.println("Enter value for x2 : ");

x2=s.nextInt();

System.out.println("Enter value for x3 : ");

x3=s.nextInt();

large = x1;

if (x2 > large)

large = x2;

if (x3 > large)

large = x3;

System.out.println("\n\n\tLargest number = " + large);

}

Output :

C:\java> javac larger.java

C:\java> java larger

Largest number = 20

NOTE: The number of statement in if block is only one than parentheses are optional but if it’s more than one than parentheses are compulsory. And if we enter the same value in x1, x2 and x3 in above program than largest number is x1 because our both condition will be false because here we checked only > not >=.

EX.

if (condition)

{

Statement 1;

Statement 2;

}

Same as above, except that here multiple statements are executed if the condition Is true.

if else :

Syntax :

if (condition)

{

statement1;

}

else

{

statement2;

}

if else work like this: If the condition is true, then statement1 is executed. Otherwise, statement2 is executed. In no case will both statements be executed.

Prog. No.:- 16

import java.util.Scanner;

class result

{

public static void main(String args[])

{

Scanner s = new Scanner(System.in);

System.out.println("Enter marks : ");

int marks = s.nextInt();

if (marks<40)

System.out.println("\nThe student has failed .. ");

else

System.out.println("\nThe student has Passed .. ");

}

Output :

C:\java> javac result.java

C:\java> java result

The student has passed...

if-else-if Ladder :

Syntax :

if(condition)

statements;

else if(condition)

statemenst;

else if(condition)

statements;

...

else

statements;

The if statements are executed from the top down. As soon as one of the conditions controlling the if is true, the statement associated with that if is executed, and the rest of the ladder is bypassed. If none of the conditions is true, then the final else statement will be executed. The final else acts as a default condition; that is, if all other conditional tests fail, then the last else statement is performed. If there is no final else and all other conditions are false, then no action will take place.

Prog. No.:- 17

import java.util.Scanner;

class Day

{

public static void main(String args[])

{

Scanner s = new Scanner(System.in);

System.out.println("Enet day between 0 to 6 Day = ");

int day = s.nextInt();

if (day == 0)

{

System.out.println("\n Sunday");

}

else if (day == 1)

{

System.out.println("\n Monday");

}

else if (day == 2)

{

System.out.println("\n Tuesday");

}

else if (day == 3)

{

System.out.println("\n Wednesday");

}

else if (day == 4)

{

System.out.println("\n Thursday");

}

else if (day == 5)

{

System.out.println("\n Friday");

}

else

{

System.out.println("\n Saturday");

}

Output :

C:\java> javac Day.java

C:\java> java Day

Tuesday

Nested if :

A nested if is an if statement that is the target of another if or else.

Syntax :

if(condition)

{

if(condition)

statements....

else

statements....

}

else

{

if(condition)

statements....

else

statements....

}

Prog. No.:- 18

import java.util.Scanner;

class MaxValue

{

public static void main(String args[])

{

int a,b,c;

int max=0;

Scanner s = new Scanner(System.in);

System.out.println("Enter value for a : ");

a=s.nextInt();

System.out.println("Enter value for b : ");

b=s.nextInt();

System.out.println("Enter value for c : ");

c=s.nextInt();

if (a>b)

{

if(a>c)

max=a;

else //This else is associate with this if(a>c)

max=c;

}

else //This else is associate with this if(a>b)

{

if(b>c)

max=b;

else //This else is associate with this if(b>c)

max=c;

}

System.out.println("\n max value = " +max);

}

Output :

C:\java> javac MaxValue.java

C:\java> java MaxValue

max value = 15

switch :

The switch statement is Java’s multi branch statement. It provides an easy way to dispatch execution to different parts of your code based on the value of an expression. It is difficult to understand large number of if else..if statements. So we have switch statement.

Syntax :

switch (expression)

{

case value 1 :

statement 1 ; break;

case value 2 :

statement 2 ; break;

...

case value N :

statement N ; break;

default :

statements ; break;

}

The expression must be of type byte, short, int, or char; each of the values specified in the case statements must be of a type compatible with the expression. Each case value must be a unique literal (constant, not a variable). Duplicate case values are not allowed. The value of the expression is compared with each ‘case’ values. If a match is found, the corresponding statement or statements are executed. If no match is found, statement or statements in the default case are executed. Default statement is optional. If default statement is absent, then if no matches are found, then the switch statement completes without doing anything. The break statement is used inside the switch to terminate a statement sequence.

Prog. No.:- 19

import java.util.Scanner;

public class Calculator

{

public static void main(String[] args)

{

int a,b,ch;

double ans;

Scanner s = new Scanner(System.in);

System.out.print("Enter a : ");

a=s.nextInt();

System.out.print("Enter b : ");

b=s.nextInt();

System.out.println("Enter 1 for addition");

System.out.println("Enter 2 for subtraction");

System.out.println("Enter 3 for multiplication");

System.out.println("Enter 4 for division");

System.out.print("Enter your choice : ");

ch=s.nextInt();

switch(ch)

{

case 1:

ans=a+b;

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

break;

case 2:

ans=a-b;

System.out.println("a - b = " + ans);

break;

case 3:

ans=a*b;

System.out.println("a * b = " + ans);

break;

case 4:

ans=a/b;

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

break;

default:

System.out.println("Enter correct choice");

}

Output :

C:\java> javac Calculator.java

C:\java> java Calculator

Enter a : 5

Enter b : 6

Enter 1 for addition

Enter 2 for subtraction

Enter 3 for multiplication

Enter 4 for division

Enter your choice : 3

a * b = 30.0

Looping statements

Java’s repetition (iteration) statements are for, while, and do-while. These statements create what we commonly call loops. A loop repeatedly executes the same set of instructions until a termination condition is met.

1. for :

The for loop repeats a set of statements a certain number of times until a condition is matched.
It is commonly used for simple iteration. The for loop appears as shown below.

Syntax :

for (initialization; condition; expression)

{

Set of statements;

}

In the first part a variable is initialized to a value.
The second part consists of a test condition that returns only a Boolean value. The last part is an expression, evaluated every time the loop is executed.

Prog. No.:- 20

class ForTest

{

public static void main(String args[])

{

int i;

for (i=0;i<10;i++)

{

System.out.println("\nHELLO ! This is java For Loop.");

}

Output :

C:\java> javac ForTest.java

C:\java> java ForTest

HELLO ! This is java For Loop.

2. while :

The while loop executes a set of code repeatedly until the condition returns false.

Syntax :

while (condition)

{

body(statements) of the loop

}

Where <condition> is the condition to be tested. If the condition returns true then the statements inside the <body of the loop> are executed.
Else, the loop is not executed.

Prog. No.:- 21

class WhileTest

{

public static void main(String args[])

{

int i=1;

while(i<=10)

{

System.out.println("\n" + i);

i++;

}

Output :

C:\java> javac WhileTest.java

C:\java> java WhileTest

3. do while :

The do while loop is similar to the while loop except that the condition to be evaluated is given at the end.
Hence the loop is executed at least once even when the condition is false.

Syntax :

{

body of the loop

} while (condition);

In do while loop semicolon(;) is compulsory after while.

NOTE : for and while loops are entry control loop because here conditions are checked at entry time of loop but do while loop is exit control loop because the condition is checked at exit time.

Prog. No.:- 22

class DowhileTest

{

public static void main(String args[])

{

int i = 1;

int sum = 0;

{

sum = sum + i;

i++;

}while (i<=10);

System.out.println("\n\n\tThe sum of 1 to 10 is .. " + sum);

}

Output :

C:\java> javac DowhileTest.java

C:\java> java DowhileTest

The sum of 1 to 10 is .. 55

Nested loops :

Java allows loops to be nested. That is, one loop may be inside another. It can help you to scan and print multi dimensional array as well as in so many other application or program.

Prog. No.:- 23

Class NestedTest

{

public static void main(String args[])

{

int i, j;

for(i=0; i<10; i++)

{

for(j=i; j<10; j++)

{

System.out.print(".");

}

System.out.println();

}

Output :

C:\java> javac NestedTest.java

C:\java> java NestedTest

..........

.........

........

.......

......

.....

....

...

Jump Statements

Java supports three jump statements: break, continue, and return. These statements transfer control to another part of your program.

1. break.

2. continue.

3. return.

The break statement

This statement is used to jump out of a loop.
Break statement was previously used in switch – case statements.
On encountering a break statement within a loop, the execution continues with the next statement outside the loop.
The remaining statements which are after the break and within the loop are skipped.
Break statement can also be used with the label of a statement.

statementName : SomeJavaStatement

When we use break statement along with label as

break statementName;

The execution continues with the statement having the label. This is equivalent to a goto statement of c and c++

Prog. No.:- 24

class BreakTest

{

public static void main(String args[])

{

int i = 1;

while (i<=10)

{

System.out.println("\n" + i);

i++;

if (i==5)

{

break;

}

Output :

C:\java> javac BreakTest.java

C:\java> java BreakTest

Break to a label

Prog. No.:- 25

class BreakT

{

public static void main (String args[])

{

boolean t=true;

{

System.out.println("Before the break");

if(t)

break b;

System.out.println("This will not execute");

}

System.out.println("This will not execute");

}

System.out.println("This is after b");

}

Output :

C:\java> javac BreakT.java

C:\java> java BreakT

Before the break

This is after b

Continue statement

This statement is used only within looping statements.
When the continue statement is encountered, the next iteration starts.
The remaining statements in the loop are skipped. The execution starts from the top of loop again.

Prog. No.:- 26

class ContinueTest

{

public static void main(String args[])

{

for (int i=1; i<1=0; i++)

{

if (i%2 == 0)

continue;

System.out.println("\n" + i);

}

Output :

C:\java> javac ContinueTest.java

C:\java> java ContinueTest

The return statement

The last control statement is return. The return statement is used to explicitly return from a method.
That is, it causes program control to transfer back to the caller of the method.
The return statement immediately terminates the method in which it is executed.

Prog. No.:- 27

class ReturnTest

{

public static void main(String args[])

{

boolean t = true;

System.out.println("Before the return.");

if(t)

return; // return to caller

System.out.println("This won't execute.");

}

Output :

C:\java> javac ReturnTest.java

C:\java> java ReturnTest

Before the return.

NOTE : the if(t) statement is necessary. Without it, the Java compiler would flag an “unreachable code” error, because the compiler would know that the last println( ) statement would never be executed. To prevent this error, the if statement is used here to trick the compiler for the sake of this demonstration.

INTRODUCTION TO CLASS IN JAVA

Class

Class is a collection of data members and member functions.

Data members

Data members are nothing but simply variables that we declare inside the class so it called data member of that particular class.

Member functions

Member functions are the function or you can say methods which we declare inside the class so it called member function of that particular class. The most important thing to understand about a class is that it defines a new data type. Once defined, this new type can be used to create objects of that type. Thus, a class is a template for an object, and an object is an instance of a class. Because an object is an instance of a class, you will often see the two words object and instance used interchangeably.

Syntax of class:

class classname

{

type instance-variable1;

type instance-variable2;

//....

type instance-variableN;

type methodname1(parameter-list)

{

// body of method

}

type methodname2(parameter-list)

{

// body of method

}

// ...

type methodnameN(parameter-list)

{

// body of method

}

When we define a class, you declare its exact form and nature. We do this by specifying the data that it contains and the code that operates on that data. The data, or variables, defined within a class are called instance variables. The code is contained within methods.

NOTE : C++ programmers will notice that the class declaration and the implementation of the methods are stored in the same place and not defined separately.

Prog. No.:- 28

public class Coordinate

{

int x = 0;

int y = 0;

void displayPoint()

{

System.out.println("Printing the coordinates");

System.out.println(x + " " + y);

}

public static void main(String args[])

{

MyPoint obj; // declaration

obj = new MyPoint(); // allocation of memory to an object

obj.x=10; //access data member using object.

obj.y=20;

obj.displayPoint(); // calling a member method

}

Output :

C:\java> javac Coordinate.java

C:\java> java Coordinate

Printing the coordinates

10 20

Here x and y are data members of class MyPoint and displayPoint() is a member function of the same class.

Syntax:

accessing data member of the class: objectname.datamember name;

accessing methods of the class: objectname.method name();

So for accessing data of the class: we have to use (.) dot operator.

NOTE: we can use or access data of any particular class without using (.) dot operator from inside that particular class only.

How to declare object of class in java?

Syntax of object:

classname objectname; \\ declaration of object.

objectname = new classname(); \\ allocate memory to object (define object).

or we can directly define object like this

classname objectname = new classname();

Prog. No.:- 29

class Box

{

double width;

double height;

double depth;

}

class BoxTest

{

public static void main(String args[])

{

Box mybox1 = new Box();

Box mybox2 = new Box();

double vol;

// assign values to mybox1's instance variables

mybox1.width = 10;

mybox1.height = 20;

mybox1.depth = 15;

/* assign different values to mybox2's instance variables */

mybox2.width = 3;

mybox2.height = 6;

mybox2.depth = 9;

// compute volume of first box

vol = mybox1.width * mybox1.height * mybox1.depth;

System.out.println("Volume is " + vol);

// compute volume of second box

vol = mybox2.width * mybox2.height * mybox2.depth;

System.out.println("Volume is " + vol);

}

Output :

C:\java> javac BoxTest.java

C:\java> java BoxTest

Volume is 3000.0

Volume is 162.0

In program we can understand that each object has its own copies of the instance variables. This means that if you have two Box objects, each has its own copy of depth, width, and height. It is important to understand that changes to the instance variables of one object have no effect on the instance variables of another.

Assigning Object Reference Variables :

Suppose

Box b1 = new Box();

Box b2 = b1;

Here b1 is the object of class Box. And we assign b1 to b2 by b2=b1.

Here we did not use new keyword for b2 so b1 and b2 will both refer to the same object. The assignment of b1 to b2 did not allocate any memory or copy any part of the original object. It simply makes b2 refer to the same object as does b1.Thus, any changes made to the object through b2 will affect the object to which b1 is referring, since they are the same object.

NOTE: When you assign one object reference variable to another object reference variable, you are not creating a copy of the object, you are only making a copy of the reference.

INTRODUCTION OF METHOD

Classes usually consist of two things instance variables and methods.

Methods are defined as follows:

· Return type

· Name of the method

· A list of parameters

· Body of the method.

Syntax:

return type method name (list of parameters)

{

//Body of the method

}

return type specifies the type of data returned by the method. This can be any valid data type including class types that you create. If the method does not return a value, its return type must be void, Means you can say that void means no return. Methods that have a return type other than void return a value to the calling routine using the following form of the return statement:

return value;

The list of parameter is a sequence of type and identifier pairs separated by commas. Parameters are essentially variables that receive the value of the arguments passed to the method when it is called. If the method has no parameters, then the parameter list will be empty.

Class which have methods and data members both

Prog. No.:- 30

import java.util.Scanner;

class Box1

{

double width;

double height;

double depth;

void volume() // display volume of a box

{

System.out.print("Volume is : ");

System.out.println(width * height * depth);

}

class Box1Test

{

public static void main(String args[])

{

Box box1 = new Box(); // defining object box1 of class Box

Scanner s = new Scanner(System.in);

System.out.print(“Enter Box Width : ”);

box1.width = s.nextDouble();

System.out.print(“Enter Box Height : ”);

box1.height = s.nextDouble();

System.out.print(“Enter Box Depth : ”);

box1.depth = s.nextDouble();

// display volume of box1

box1.volume(); // calling the method volume

}

Output:

C:\java> javac Box1Test.java

C:\java> java Box1Test

Enter Box Width : 15

Enter Box Height : 20

Enter Box Depth : 10

Volume is : 3000.00

Width, height and depth are data members of class Box and void volume () is method of class Box. Method has no parameter and no return value.

Program in different way

Prog. No.:- 31

import java.util.Scanner;

class Box2

{

double width;

double height;

double depth;

double volume()

{

return width * height * depth;

}

class Box2Test

{

public static void main(String args[])

{

double vol;

Box box1 = new Box(); // defining object box1 of class Box

Scanner s = new Scanner(System.in);

System.out.print(“Enter Box Width : ”);

box1.width = s.nextDouble();

System.out.print(“Enter Box Height : ”);

box1.height = s.nextDouble();

System.out.print(“Enter Box Depth : ”);

box1.depth = s.nextDouble();

// display volume of box1

vol = box1.volume(); // calling the method volume

System.out.println("Volume is : " +vol);

}

Output:

C:\java> javac Box2Test.java

C:\java> java Box2Test

Enter Box Width : 15

Enter Box Height : 20

Enter Box Depth : 10

Volume is : 3000.00

In program volume() method has return type double so we took one vol variable. It is a local variable of class BoxDemo and it catches the returned value by volume method of class Box. One thing must keep in mind that the data type of vol and return type of volume() method always be same

Prog. No.:- 32

import java.util.Scanner;

class Box3

{

double width;

double height;

double depth;

double volume(double w, double h, double d)

{

return width * height * depth;

}

class Box3Test

{

public static void main(String args[])

{

double vo,wth,ht,dth;

Box box1 = new Box(); // defining object box1 of class Box

Scanner s = new Scanner(System.in);

System.out.print(“Enter Box Width : ”);

wth = s.nextDouble();

System.out.print(“Enter Box Height : ”);

ht = s.nextDouble();

System.out.print(“Enter Box Depth : ”);

dth = s.nextDouble();

// display volume of box1

vol = box1.volume(wth,ht,dth); // calling the method volume

System.out.println("Volume is : " +vol);

}

Output:

C:\java> javac Box3Test.java

C:\java> java Box3Test

Enter Box Width : 15

Enter Box Height : 20

Enter Box Depth : 10

Volume is : 3000.00

In program volume() method has three parameters as well as double return type. One thing must keep in mind that in defining and calling of method, the sequence of data type of parameter must be same in both.

CONSTRUCTOR IN JAVA

Java supports a special type of methods, called constructor that enables an object to initialize itself when it is created. Constructors have the same name as the class it-self. Constructors do not specify a return type, not even void. This is because they return the instance of the class itself. A constructor is automatically called when an object is created.

Syntax:

Constructor_name([arguments])

{

// body

}

Constructors are generally of two types.

1. Non-Parameterized

2. Parameterized

Non-Parameterized

Prog. No.:- 33

// Non - parameterised constructor

class Point1

{

int x;

int y;

Point1() //constructor of class

{

x = 10;

y = 20;

}

void display()

{

System.out.println("\n\n\t-----Printing the coordinates-----");

System.out.println("\t\t\t" + x + " " + y);

}

class Point1Test

{

public static void main(String args[])

{

Point1 p1 = new Point1(); // constructor will be call automatically from here

p1.display();

Output:

C:\java> javac Point1Test.java

C:\java> java Point1Test

-----Printing the coordinates-----

10 20

Parameterized

Prog. No.:- 34

// parameterised constructor

import java.util.Scanner;

class Point2

{

int x;

int y;

Point2(int a, int b)

{

x = a;

y = b;

}

void display()

{

System.out.println("\n\n\t-----Printing the coordinates-----");

System.out.println("\t\t\t" + x + " " + y);

}

class Point2Test

{

public static void main(String args[])

{

int i,k;

Scanner s = new Scanner(System.in);

System.out.print("Enter int value for i : ");

i = s.nextInt();

System.out.print("Enter int value for k : ");

k = s.nextInt();

Point2 p1 = new Point2(i,k);

p1.display();

}

Output:

C:\java> javac Point2Test.java

C:\java> java Point2Test

Enter int value for i : 10

Enter int value for k : 20

-----Printing the coordinates-----

10 20

KEYWORDS IN JAVA

We are going to learn few regularly used keywords.

1. new

2. this

3. static

4. super

5. final

new:

The new keyword dynamically allocates memory for an object.

Syntax:

claas_name object _name = new class_name();

EX.

Box b1 = new Box();

Box b2 = new Box();

We have already seen so many programs in which we used new keyword for creating objects.

this:

This keyword is the name of a reference that refers to a calling object itself. One common use of the this keyword is to reference a class` hidden data fields. We can have local variables, including formal parameters to methods which overlap with the names of the class` instance variables. The local variable hides the instance variable so we use this keyword. Another common use of this keyword is to enable a constructor to invoke another constructor of the same class. java requires that the this(arg-list) statement appear first in the constructor before any other statements.

Prog. No.:- 35

public class This_Test

{

public static void main(String[] args)

{

abc a1 = new abc(); //call non parameterize constructor

}

class abc

{

int x,y;

abc()

{

this(10,20); //this will call another constructor

}

abc(int x,int y)

{

this.x=x+5; //it will set class` member x

this.y=y+5; //it will set class` member y

System.out.println("local method`s x = " +x);

System.out.println("local method`s y = " +y);

Print_data();

}

public void Print_data()

{

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

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

}

Output :

C:\java> javac This_Test.java

C:\java> java This_Test

local method`s x = 10

local method`s y = 20

x = 15

y = 25

static :

A class member must be accessed with the use of an object of its class but sometimes we want to define a class member that will be used independently without creating any object of that class. It is possible in java to create a member that can be used by itself, without reference to a specific instance. To create such a member, precede its declaration with the keyword static. When a member is declared static, it can be accessed before any objects of its class are created, and without reference to any object. One can declare both methods and variables to be static. The most common example of a static member is main(). Main () is declared as static because it must be called before any object exist. Instance variables declared as static are actually, global variables. When objects of its class are declared, no copy of a static variable is made. Instead, all instances of the class share the same static variable.

Method declared as static have several restrictions:

1. Can call only other static methods.

2. Only access static data.

3. Cannot refer to this or super in any way.

One can also declare a static block which gets executed exactly once, when the class is first loaded.

Prog. No.:- 36

public class Static_Test

{

public static void main(String[] args)

{

display(40); //call static method

}

static int i = 5;

static int j;

int k = 10;

static void display(int a)

{

System.out.println("a = "+a); // here a = 40

System.out.println("i = "+i); // here i = 5

System.out.println("j = "+j); // here j = 50( because of static block j = i * 10 = 5 * 10 =50 )

//System.out.println("k = "+k); //can,t make a static reference to the non-static field k

}

static

{

System.out.println("Static block initialized..........");

j = i * 10;

}

Output :

C:\java> javac Static_Test.java

C:\java> java Static_Test

Static block initialized..........

a = 40

i = 5

j = 50

super :

super keyword is used to call a superclass constructor and to call or access super class members(instance variables or methods).

Syntax of super :

=> super(arg-list)

When a subclass calls super() it is calling the constructor of its immediate superclass. super() must always be the first statement executed inside a subclass constructor.

=> super.member

Member can be either method or instance variables. This second form of super is most applicable to situation in which member names of a subclass hide member of superclass due to same name.

Prog. No.:- 37

class A1

{

public int i;

A1()

{

i=5;

}

class B1 extends A1

{

int i;

B1(int a,int b)

{

super(); //calling super class constructor

//now we will change value of superclass variable i

super.i=a; //accessing superclass member from subclass

i=b;

}

void show()

{

System.out.println("i in superclass = " + super.i );

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

}

public class Usesuper

{

public static void main(String[] args)

{

B1 b = new B1(10,12);

b.show();

}

Output :

C:\java> javac Usesuper.java

C:\java> java Usesuper

i in superclass = 10

i in subclass = 12

The instance variable i in B1 hides the i in A, super allows access to the i defined in the superclass. Super can also be used to call methods that are hidden by a subclass.

final :

final keyword can be use with variables, methods and class.

=> final variables

When we want to declare constant variable in java we use final keyword.

Syntax : final variable name = value;

=> final method

Syntax: final methodname(arg)

When we put final keyword before method than it becomes final method. To prevent overriding of method final keyword is used, means final method can’t be override.

=> final class

A class that can not be sub classed is called a final class. This is archived in java using the keyword final as follow. Any attempt to inherit this class will cause an error and compiler will not allow it.

Syntax : final class class_name { ... }

Prog. No.:- 38

final class aa

{

final int a=10;

public final void ainc()

{

a++; // The final field aa.a cannot be assigned

}

class bb extends aa // The type bb cannot subclass the final class aa

{

public void ainc() //Cannot override the final method from aa

{

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

}

public class Final_Test

{

public static void main(String[] args)

{

bb b1 = new bb();

b1.ainc();

}

Output:

C:\java> javac Final_Test.java

Error:………………………….

Above program have no output will be there because all the comments in above program are errors. Remove final keyword from class than you will get error like final method can not be override

ACCESS CONTROL IN JAVA

Access can control what parts of a program can access the member of a class. By controlling access, one can prevent misuse. Allowing access to data only through a well-defined set of methods, one can prevent misuse of that data. Thus, when correctly implemented, a class creates “black box”. How a member can be accessed is determined by the access specifier that modifies its declaration. Java provides a set to access specifiers. Some aspects of access control are related to inheritance or packages.

Java’s access specifiers are:

public:

o When a member of a class is specified by the public specifier, then that member can be accessed by any other code.

o The public modifier makes a method or variable completely available to all classes.

o when the class is defined as public, it can be accessed by any other class.

private:

o To hide a method or variable from other classes, private modifier is used.

o A private variable can be used by methods in its own class but not by objects of any other class.

o Neither private variables nor private methods are inherited by subclass.

o The only place these variables and methods can be seen is from within their own class.

protected:

o protected applies only when inheritance is involved.

o If we want to allow an element to be seen outside your current package, but only to classes that are inherited from our class directly, then declare that element as protected.

default:

o We have seen that when no access control modifier is specified, it is called as default access.

o Classes written like this are not accessible in other package.

o Any variable declared without a modifier can be read or changed by any other class in the same package.

o Any method declared the same way can be called by any other class in the same package.

o When a member does not have an explicit access specification,

o It is visible to subclasses as well as to other classes in the same package.

The following table summarizes the levels of access control:

Access	Public	Protected	Default	Private
From the same class	Yes	Yes	Yes	Yes
From any class in the same package	Yes	Yes	Yes	No
From any class outside the package	Yes	No	No	No
From a sub - class in the same package	Yes	Yes	Yes	No
From a sub - class outside the same package	Yes	Yes	Yes	No

METHOD OVERLOADING IN JAVA

Method overloading:

A class can contain any number of methods. Methods can be with parameter and without parameter. The parameter in a method are called type signature. It is possible in java to define two or more methods within the same class that share the same name, but with different parameter declarations (type signatures). When this is the case, the methods are said to be overloaded, and the process is referred to as method overloading. Overloading methods demonstrate the concept of polymorphism. When an overloaded method is invoked, java uses the type and/or number of arguments as its guide to determine which version of the overloaded method to call. Thus, overloaded methods must differ in the type and/or number of their parameters. Overloaded methods may have different return types. When java encounters a call to an overloaded method, it simply executes the version of the method whose parameters match the arguments used in the call.

Prog. No.:- 39

//METHOD OVERLOADING

public class MethodOver

{

int n1;

int n2;

MethodOver()

{

n1 = 10;

n2 = 20;

}

void square()

{

System.out.println("The Square is " + n1 * n2);

}

void square(int p1)

{

n1 = p1;

System.out.println("The Square is " + n1 * n2);

}

void square(int p1, int p2)

{

n1 = p1;

n2 = p2;

System.out.println("The Square is " + n1 * n2);

}

public static void main(String args[])

{

MethodOver obj1 = new MethodOver();

obj1.square(); //call non parameterise method

obj1.square(4); //call method which has 1 argument

obj1.square(7,8); //call method which has 2 argument

}

Output :

C:\java> javac MethodOver.java

C:\java> java MethodOver

The Square is 200

The Square is 80

The Square is 56

We can see that there are 3 square methods with different argument. It’s called method overloading.

CONSTRUCTOR OVERLOADING IN JAVA

Constructors having the same name with different parameter list is called constructor overloading.

Prog. No.:- 40

class Point

{

int x;

int y;

Point(int a, int b)

{

x = a;

y = b;

}

class Circle

{

int originX;

int originY;

int radius;

//Default Constructor

Circle()

{

originX = 5;

originY = 5;

radius = 3;

}

// Constructor initializing the coordinates of origin and the radius.

Circle(int x1, int y1, int r)

{

originX = x1;

originY = y1;

radius = r;

}

Circle(Point p, int r)

{

originX = p.x;

originY = p.y;

radius = r;

}

void display()

{

System.out.println("--Center at " + originX + " and " + originY);

System.out.println("Radius = " + radius);

}

public static void main(String args[])

{

Circle c1 = new Circle();

Circle c2 = new Circle(10,20,5);

Circle c3 = new Circle(new Point(15,25),10);

c1.display();

c2.display();

c3.display();

}

Output :

C:\java> javac Circle.java

C:\java> java Circle

--Center at 5 and 5

Radius = 3

--Center at 10 and 20

Radius = 5

--Center at 15 and 25

Radius = 10

NOTE:- Above program is quite complicated here i am giving you perfect flow of program. First of all note one thing that new ClassName() this is a short syntax of creating object of any class. And we all know that when we create object the constructor of that class will be called automatically. So in our program first of all due to syntax Circle c1 = new Circle(); non parameterize constructor will be called for object c1 so we get output like Center at 5 and 5 Radius = 3 in c1.display(). Next due to syntax Circle c2 = new Circle(10,20,5); constructor which has 3 arguments will be called for object c2 so we get output like Center at 10 and 20 Radius = 5 in c2.display(). Now when we define object c3 our syntax is like Circle c3 = new Circle(new Point(15,25),10); so first of all it will create object for Point class so constructor of point class will be called and it will set parameter x and y. Then constructor of circle class which has Point class object as an argument along with one int argument will be called and set all parameter as per program and we get output like Center at 15 and 25 Radius = 10 in c3.display().

We can also write

Point p1 = new Point(15,25);

Circle c3 = new Circle(p1,10);

MORE ABOUT METHOD

Passing Objects as a Parameter to Method.

We have seen that methods can take parameters as input and process them. It is also common to pass objects as a parameter to methods.

Prog. No.:- 41

class PassObj

{

int n1;

int n2;

// constructor

PassObj()

{

n1 = 0;

n2 = 0;

}

PassObj(int p1, int p2)

{

n1 = p1;

n2 = p2;

}

void multiply(PassObj p1)

{

int temp;

temp = p1.n1 * p1.n2;

System.out.println("Multiplication is " + temp);

}

public static void main(String args[])

{

PassObj obj1 = new PassObj(5,6);

PassObj obj2 = new PassObj();

obj2.multiply(obj1);

}

Output :

C:\java> javac PassObj.java

C:\java> java PassObj

Multiplication is 30

Method overloading with object as a parameter.

Prog. No.:- 42

class MetObjOv

{

int n1;

int n2;

// constructor

MetObjOv()

{

n1 = 0;

n2 = 0;

}

MetObjOv(int x, int y)

{

n1 = x;

n2 = y;

}

void multiply(MetObjOv p1)

{

n1 = p1.n1;

n2 = p1.n2;

System.out.println("There is nothing to multiply ");

System.out.println("n1 = "+n1+"\tn2 = " +n2);

}

void multiply(MetObjOv p1, MetObjOv p2)

{

n1 = p1.n1 * p2.n1;

n2 = p1.n2 * p2.n2;

System.out.println("Multiplication of two objects ");

System.out.println("n1 = " + n1 + "\tn2 = " + n2 );

}

public static void main(String args[])

{

MetObjOv obj1 = new MetObjOv(5,6);

MetObjOv obj2 = new MetObjOv(6,5);

MetObjOv obj3 = new MetObjOv();

obj3.multiply(obj1);

obj3.multiply(obj1, obj2);

}

Output :

C:\java> javac MetObjOv.java

C:\java> java MetObjOv

There is nothing to multiply

n1 = 5 n2 = 6

Multiplication of two objects

n1 = 30 n2 = 30

Return an Object.

A method can return any type of data, including class type (object) that you create.

Prog. No.:- 43

class RetObj

{

int n1;

int n2;

// constructor

RetObj()

{

n1 = 0;

n2 = 0;

}

RetObj(int x, int y)

{

n1 = x;

n2 = y;

}

RetObj multiply(RetObj p1, RetObj p2)

{

n1 = p1.n1 * p2.n1;

n2 = p1.n2 * p2.n2;

return (this);

}

void display()

{

System.out.println("An Example of returning an Object ");

System.out.println("n1 = "+n1+"\tn2 = " +n2);

}

public static void main(String args[])

{

RetObj obj1 = new RetObj(5,6);

RetObj obj2 = new RetObj(6,5);

RetObj obj3 = new RetObj();

obj3 = obj3.multiply(obj1, obj2);

obj3.display();

}

Output :

C:\java> javac RetObj.java

C:\java> java RetObj

An Example of returning an Object

n1 = 30 n2 = 30

RetObj multiply(RetObj p1, RetObj p2) This is the syntax in our program which has return type object. obj3 = obj3.multiply(obj1, obj2); this is the syntax which calls method multiply and return object, it will store in obj3.

THERE ARE TWO TYPES OF CALLING METHOD AND THOSE ARE

1. call by value

2. call by reference

CALL BY VALUE

In call by value when we call any method we pass value as method parameter so changing in local variables of the method doesn't`t affect the original variables of class.This method copies the value of an argument into the formal parameter of the subroutine. Therefore, changes made to the parameter of the subroutine have no effect on the argument. In java, when we pass a primitive type to a method, it is passed by value. Thus, what occurs to the parameter that receives the argument has no effect outside the method.

Prog. No.:- 44

class Value

{

int a,b;

Value(int i,int j)

{

a = i ;

b = j;

}

void call(int a, int b)

{

a = a * 2;

b = b * 2;

}

public class CallBy_Value

{

public static void main(String[] args)

{

Value v = new Value(10,20);

System.out.println("a and b before call............");

System.out.println("a = "+v.a);

System.out.println("b = "+v.b);

v.call(v.a,v.b); // CALL BY VALUE

System.out.println("a and b after call............");

System.out.println("a = "+v.a);

System.out.println("b = "+v.b);

}

Output :

C:\java> javac CallBy_Value.java

C:\java> java CallBy_Value

a and b before call............

a = 10

b = 20

a and b after call............

a = 10

b = 20

We can see that after calling method we change value of a and b but it will not affect the original value of class` members because of call by value. We pass value v.a and v.b as parameter and it will change local method`s a and b variables.

Call by reference :

We pass reference as parameter in function calling. We all know that reference means object so we pass object as parameter. A reference to an argument (not value of argument) is passed to the parameter. Inside the subroutine, this reference is used to access the actual argument specified in the call. This means that changes made to the parameters will affect the argument used to call the subroutine. When we pass an object to a method, the situation changes, because objects are passed by call-by-reference. When we create a variable of a class type, we are only creating a reference to an object. Thus, when you pass this reference to a method, the parameter that receives it will refer to the same object as that referred to by the argument. This effectively means that objects are passed to method do affect the object used as an argument.

Prog. No.:- 45

class Reference

{

int a,b;

Reference(int i,int j)

{

a = i ;

b = j;

}

void call(Reference r)

{

r.a = a * 2;

r.b = b * 2;

}

public class CallBy_Reference

{

public static void main(String[] args)

{

Reference r = new Reference(10,20);

System.out.println("a and b before call............");

System.out.println("a = "+r.a);

System.out.println("b = "+r.b);

r.call(r); // CALL BY REFERENCE

System.out.println("a and b after call.............");

System.out.println("a = "+r.a);

System.out.println("b = "+r.b);

}

Output :

C:\java> javac Reference.java

C:\java> java Reference

a and b before call............

a = 10

b = 20

a and b after call.............

a = 20

b = 40

We can see that after calling method value of original a and b is changed because of call by reference. We pass "r" reference (Object) as parameter in method calling. So changes inside method will affect original variable of class.

RECURSION

Recursion is the process of defining something in terms of itself. When function calls itself is called recursion. A method that calls itself is said to be recursive.

Prog. No.:- 46

import java.util.Scanner;

class Factorial

{

// this is a recursive function

int fact(int n)

{

int result;

if(n==1)

return 1;

result = fact(n-1) * n; //From here function call it self (fact(n-1))

return result;

}

public class Recursion

{

public static void main(String args[])

{

int x;

Scanner s = new Scanner(System.in);

System.out.print("Enter int no = ");

x = s.nextInt();

Factorial f = new Factorial();

System.out.println("Factorial of" + x + " is " + f.fact(x));

}

Output :

C:\java> javac Recursion.java

C:\java> java Recursion

Enter int no = 7

Factorial of7 is 5040

The method fact is recursive because it calls itself.The whole precess something like this result = fact(7-1) * 7 and so on until it returns 1. So one thing is sure that we have to take care that in every recursive process there must be a terminate condition to come out from recursion.

NESTED CLASS

It is possible to define a class within another class; such classes are known as nested classes.

The scope of a nested class is bounded by the scope of its enclosing class.

That means, if class B is defined within class A, then B is known to A, but not outside A.

If A is nesting class B, then A has access to all the members of B, including private members. But the B does not have access to the members of nested class.

There are two types of nested classes:

1. Static

2. Non – Static

Static nested class

A static nested class is one which has the static modifier, as it is static it must access the member of its enclosing class through an object. That means it cannot refer to member of its enclosing class directly.

Non – Static nested class

Non – Static nested class is known as inner class. It has access to all of its variables and methods of its outer class and can refer to them directly. An inner class is fully within the scope of its enclosing class.

Prog. No.:- 47

class InnerTest

{

class Contents

{

private int i = 16;

public int value()

{

return i;

}

class Destination

{

private String label;

Destination(String whereTo)

{

label = whereTo;

}

public void ship(String dest)

{

Contents c = new Contents(); // create object of inner class Contents

Destination d = new Destination(dest); // create object of inner class Destination

System.out.println("Shipped " + c.value() + " item(s) to " + dest);

}

public static void main(String args[])

{

Inner1 p = new Inner1();

p.ship("Congo"); //call ship method of outer class "inner1"

}

Output :
C:\java> javac InnerTest.java

C:\java> java InnerTest

Shipped 16 item(s) to Congo

Let us see one more example

Prog. No.:- 48

class OuterTest

{

int outer_x = 100;

void test()

{

Inner inner = new Inner();

inner.display();

}

// this is an inner class

class Inner

{

int y = 10; // y is local to Inner

void display()

{

System.out.println("display: outer_x = " + outer_x);

}

void showy()

{

System.out.println(y); // error, y not known here!

}

class InnerClassDemo

{

public static void main(String args[])

{

Outer outer = new Outer();

outer.test();

}

Here, y is declared as an instance variable of Inner. Thus it is not known outside of that class and it cannot be used by showy( ).

COMMAND LINE ARGUMENT

We will want to pass information into a program when you run it. This is accomplished by passing command-line arguments to main( ). A command-line argument is the information that directly follows the program’s name on the command line when it is executed. To access the command-line arguments inside a Java program is quite easy—they are stored as strings in the String array passed to main( ).

Prog. No.:- 49

class CommandLine

{

public static void main(String args[])

{

for(int i=0; i < args.length; i++)

System.out.println("args[" + i + "]: " +args[i]);

}

Try executing this program, as shown here:

java CommandLine this is a test 100 -1

When you do, you will see the following output:

args[0]: this

args[1]: is

args[2]: a

args[3]: test

args[4]: 100

args[5]: -1

But first of all you should have the basic knowledge about command line and how any java program run through command prompt.

INHERITANCE IN JAVA

Inheritance :

The derivation of one class from another class is called Inheritance. A class that is inherited is called a superclass. The class that does the inheriting is called as subclass. A subclass inherits all instance variables and methods from its superclass and also has its own variables and methods. One can inherit the class using keyword extends.

Syntax :

Class subclass-name extends superclass-name

{

// body of class.

}

In java, a class has only one super class. Java does not support Multiple Inheritance. One can create a hierarchy of inheritance in which a subclass becomes a superclass of another subclass. However, no class can be a superclass of itself.

Prog. No.:- 50

class A //superclass

{

int num1; //member of superclass

int num2; //member of superclass

void setVal(int no1, int no2) //method of superclass

{

num1 = no1;

num2 = no2;

}

class B extends A //subclass B

{

int multi; //member of subclass

void mul() //method of subclass

{

multi = num1*num2; //accessing member of superclass from subclass

}

class InheritTest

{

public static void main(String args[])

{

B subob = new B();

subob.setVal(5,6); //calling superclass method throgh subclass object

subob.mul();

System.out.println("Multiplication is " + subob.multi);

}

Output :

C:\java> javac InheritTest.java

C:\java> java InheritTest

Multiplication is 30

Note : Private members of super class is not accessible in subclass, super class is also called parent class or base class, subclass is also called child class or derived class.

Method Overriding:

Defining a method in the subclass that has the same name, same arguments and same return type as a method in the super class and it hides the super class method is called method overriding. Now when the method is called, the method defined in the subclass is invoked and executed instead of the one in the super class.

Prog. No.:- 51

class Xsuper

{

int y;

Xsuper(int y)

{

this.y=y;

}

void display()

{

System.out.println("super y = " +y);

}

class Xsub extends Xsuper

{

int z;

Xsub(int z , int y)

{

super(y);

this.z=z;

}

void display()

{

System.out.println("super y = " +y);

System.out.println("sub z = " +z);

}

public class TestOverride

{

public static void main(String[] args)

{

Xsub s1 = new Xsub(100,200);

s1.display();

}

Output :

C:\java> javac TestOverride.java

C:\java> java TestOverride

super y = 200

sub z = 100

The method display () defined in the subclass is invoked.

Overloading VS Overriding:

Method overloading is compile time polymorphism. Method overriding is run time polymorphism. Overloading a method is a way to provide more than one method in one class which has same name but different argument to distinguish them. Defining a method in the subclass that has the same name, same arguments and same return type as a method in the super class is called method overriding.

MULTILEVEL INHERITANCE IN JAVA

Prog. No.:- 52

class Student

{

int rollno;

String name;

student(int r, String n)

{

rollno = r;

name = n;

}

void dispdatas()

{

System.out.println("Rollno = " + rollno);

System.out.println("Name = " + name);

}

class Marks extends Student

{

int total;

marks(int r, String n, int t)

{

super(r,n); //call super class (student) constructor

total = t;

}

void dispdatam()

{

dispdatas(); // call dispdatap of student class

System.out.println("Total = " + total);

}

class Percentage extends Marks

{

int per;

percentage(int r, String n, int t, int p)

{

super(r,n,t); //call super class(marks) constructor

per = p;

}

void dispdatap()

{

dispdatam(); // call dispdatap of marks class

System.out.println("Percentage = " + per);

}

class Multi_Inherit

{

public static void main(String args[])

{

percentage stu = new percentage(1912, "SAM", 350, 50); //call constructor percentage

stu.dispdatap(); // call dispdatap of percentage class

}

Output :

C:\java> javac Multi_Inherit.java

C:\java> java Multi_Inherit

Rollno = 1912

Name = SAM

Total = 350

Percentage = 50

It is common that a class is derived from another derived class. The class student serves as a base class for the derived class marks, which in turn serves as a base class for the derived class percentage. The class marks is known as intermediated base class since it provides a link for the inheritance between student and percentage.

The chain is known as inheritance path. When this type of situation occurs, each subclass inherits all of the features found in all of its super classes. In this case, percentage inherits all aspects of marks and student. To understand the flow of program read all comments of program.

Q:- When a class hierarchy is created, in what order are the constructors for the classes that make up the hierarchy called?

Ans: Constructors are called in order of derivation, from super class to subclass. Further, since super ( ) must be the first statement executed in a subclass’ constructor, this order is the same whether or not super ( ) is used. If super ( ) is not used, then the default or parameter less constructor of each super class will be executed. As you can see from the output the constructors are called in order of derivation. If you think about it, it makes sense that constructors are executed in order of derivation. Because a super class has no knowledge of any subclass, any initialization it needs to perform is separate from and possibly prerequisite to any initialization performed by the subclass. Therefore, it must be executed first

Prog. No.:- 52

class X

{

X()

{

System.out.println("Inside X's constructor.");

}

class Y extends X // Create a subclass by extending class A.

{

Y()

{

System.out.println("Inside Y's constructor.");

}

class Z extends Y // Create another subclass by extending B.

{

Z()

{

System.out.println("Inside Z's constructor.");

}

public class CallingCons

{

public static void main(String args[])

{

Z z = new Z();

}

Output:

C:\java> javac CallingCons.java

C:\java> java CallingCons

Inside X's constructor.

Inside Y's constructor.

Inside Z's constructor.

DYNAMIC METHOD DISPATCH

Dynamic Method Dispatch:

Dynamic method dispatch is the mechanism by which a call to an overridden method is resolved at run time, rather than compile time. Dynamic method dispatch is important because this is how Java implements run-time polymorphism. Method to execution based upon the type of the object being referred to at the time the call occurs. Thus, this determination is made at run time. In other words, it is the type of the object being referred to (not the type of the reference variable) that determines which version of an overridden method will be executed.

Prog. No.:- 53

class A

{

void callme()

{

System.out.println("Inside A's callme method");

}

class B extends A

{

// override callme()

void callme()

{

System.out.println("Inside B's callme method");

}

class C extends A

{

// override callme()

void callme()

{

System.out.println("Inside C's callme method");

}

public class Dynamic_disp

{

public static void main(String args[])

{

A a = new A(); // object of type A

B b = new B(); // object of type B

C c = new C(); // object of type C

A r; // obtain a reference of type A

r = a; // r refers to an A object

r.callme(); // calls A's version of callme

r = b; // r refers to a B object

r.callme(); // calls B's version of callme

r = c; // r refers to a C object

r.callme(); // calls C's version of callme

}

Output :

C:\java> javac Dynamic_disp.java

C:\java> java Dynamic_disp

Inside A's callme method

Inside B's callme method

Inside C's callme method

Reference of type A, called r, is declared. The program then assigns a reference to each type of object to r and uses that reference to invoke callme( ). As the output shows, the version of callme( ) executed is determined by the type of object being referred to at the time of the call.

Abstract Classes :

When the keyword abstract appears in a class definition, it means that zero or more of its methods are abstract. An abstract method has no body. Some of the subclass has to override it and provide the implementation. Objects cannot be created out of abstract class. Abstract classes basically provide a guideline for the properties and methods of an object. In order to use abstract classes, they have to be sub classed. There are situations in which you want to define a super class that declares the structure of a given abstraction without providing a complete implementation of every method. That is, sometimes you want to create a super class that only defines generalized form that will be shared by all of its subclasses, leaving it to each subclass to fill in the details. One way this situation can occur is when a super class is unable to create a meaningful implementation for a method.

Syntax :

abstract type name(parameter-list);

As you can see, no method body is present. Any class that contains one or more abstract methods must also be declared abstract. To declare a class abstract, you simply use the abstract keyword in front of the class keyword at the beginning of the class declaration. There can be no objects of an abstract class. That is, an abstract class cannot be directly instantiated with the new operator. Any subclass of an abstract class must either implement all of the abstract methods of the super class, or be itself declared abstract.

Prog. No.:- 54

abstract class shape

{

double dim1;

double dim2;

shape(double a, double b)

{

dim1 = a;

dim2 = b;

}

abstract double area();

}

class rectangle extends shape

{

rectangle(double a, double b)

{

super(a,b);

}

double area()

{

System.out.println("Area of rectangle.");

return dim1*dim2;

}

class triangle extends shape

{

triangle(double a, double b)

{

super(a,b);

}

double area()

{

System.out.println("Area of triangle.");

return dim1*dim2/2;

}

public class AbstractTest

{

public static void main(String args[])

{

rectangle r = new rectangle(10,20);

triangle t = new triangle(10,6);

System.out.println(r.area());

System.out.println(t.area());

}

Output:

C:\java> javac AbstractTest.java

C:\java> java AbstractTest

Area of rectangle.

200.0

Area of triangle.

30.0

OBJECT CLASS

Object class:

There is one special class, Object, defined by Java. All other classes are subclasses of Object. That is, Object is a super class of all other classes. This means that a reference variable of type Object can refer to an object of any other class. Every class in java is descended from the java.lang.Object class. If no inheritance is specified when a class is defined, the super class of the class is Object by default.

public class circle { ... }

is equivalent to

public class circle extends Object { ... }.

Methods of Object class

METHOD	PURPOSE
Object clone()	Creates a new object that is the same as the object being cloned.
boolean equals(Object obj_name)	Determines whether one object is equal to another
Void finalize()	Called before an unused object is recycled
Class getClass( )	Obtains the class of an object at run time.
int hashCode( )	Returns the hash code associated with the invoking object.
void notify( )	Resumes execution of a thread waiting on the invoking object.
void notifyAll( )	Resumes execution of all threads waiting on the invoking object.
String toString( )	Returns a string that describes the object.
void wait( ) void wait(long milliseconds) void wait(long milliseconds, int nanoseconds)	Waits on another thread of execution.

The methods getclass(), notify(), notifyall() and wait() are declared as final. We may override the others.

tostring()

?public String tostring(). It returns a String that describes an object.

?It consisting class name, an at (@) sign and object memory address in hexadecimal.

EX :

Circle c1 = new Circle();

System.out.println(c1.tostring());

It will give O/P like Circle@15037e5

We can also write System.out.println(c1);

POLYMORPHISM

Polymorphism:

An object of a sub class can be used whenever its super class object is required. This is commonly known as polymorphism. In simple terms polymorphism means that a variable of super type can refer to a sub type object.

Fig. 4(Polymorphism)

JAVA INTERFACE

Java Interface:

Interfaces are similar to abstract classes, but differ in their functionality. In interfaces, none of the methods are implemented means interfaces defines methods without body. Interfaces are syntactically similar to classes, but they lack instance variables, and their methods are declared without any body. But, it can contain final variables, which must be initialized with values. Once it is defined, any number of classes can implement an interface. One class can implement any number of interfaces. If we are implementing an interface in a class we must implement all the methods defined in the interface as well as a class can also implement its own methods. Interfaces add most of the functionality that is required for many applications which would normally resort to using multiple inheritances in C++.

Defining interfaces in java with syntax:

Syntax :

[Access-specifier] interface interface-name

{

Access-specifier return-type method-name(parameter-list);

final type var1=value;

}

Where, Access-specifier is either public or it is not given. When no access specifier is used, it results into default access specifier and if interface has default access specifier then it is only available to other members of the same package. When it is declared as public, the interface can be used by any other code of other package.

Interface-Name: name of an interface, it can be any valid identifier.

The methods which are declared having no bodies they end with a semicolon after the parameter list. Actually they are abstract methods; Any class that includes an interface must implement all of the methods. Variables can be declared inside interface declarations. They are implicitly final and static, means they cannot be changed by implementing it in a class. They must also be initialized with a constant value.

EX :

interface Item

{

static final int code = 100;

static final String name = "Fan";

void display ( );

}

interface Area

{

static final float pi = 3.14F;

float compute ( float x, float y );

void show ( );

}

Implementing interfaces

Once an interface has been defined, one or more classes can implement that interface. To implement an interface, include the implements clause in a class definition, and then create the methods declared by the interface.

The general form of a class that includes the implements clause looks like this:

Access-specifier class classname [extends superclass] [implements interface, [, interface..]]

{

// class body

}

If a class implements from more than one interface, names are separated by comma.

If a class implements two interfaces that declare the same method, then the same method will be used by clients of either interface. The methods that implement an interface must be declared as public.

The type-signature of implementing method must match exactly the type signature specified in the interface.

Prog. No.:- 55

interface religion

{

String city = new String("Shimla");

void greet();

void pray();

}

class gs implements religion

{

public void greet()

{

System.out.println("We greet – B.Tech 4^th yr");

}

public void pray()

{

System.out.println("We pray at " + city + "SummerHill ");

}

class IfaceTest

{

public static void main(String args[])

{

gs s = new gs();

s.greet();

s.pray();

}

Output :

C:\java> javac IfaceTest.java

C:\java> java IfaceTest

We greet – B.Tech 4^th yr.

We pray at Shimla SummerHill

Implementing interface having common function name

Prog. No.:- 56

interface i1

{

void disp();

}

interface i2

{

void disp();

}

class c implements i1, i2

{

public void disp()

{

System.out.println("This is display .. ");

}

class IfaceTest7

{

public static void main(String args[])

{

c cobj = new c();

cobj.disp();

}

Output :

C:\java> javac IfaceTest7.java

C:\java> java IfaceTest7

This is display ..

Note : When implementing an interface method, it must be declared as public. It is possible for classes that implement interfaces to define additional members of their own.

Partial Implementation of Interface :

If we want to implement an interface in a class we have to implement all the methods defined in the interface. But if a class implements an interface but does not fully implement the method defined by that interface, then that class must be declared as abstract.

Prog. No.:- 57

interface i1

{

void disp1();

void disp2();

}

abstract class c1 implements i1

{

public void disp1()

{

System.out.println("This is display of 1");

}

class c2 extends c1

{

public void disp2()

{

System.out.println("This is display of 2");

}

class IfaceTest9

{

public static void main(String args[])

{

c2 c2obj = new c2();

c2obj.disp1();

c2obj.disp2();

}

Output :

C:\java> javac IfaceTest9.java

C:\java> java IfaceTest9

This is display of 1

This is display of 2

Accessing interface variable:

Once can declare variable as object references that uses an interface rather than a class type. When you call a method through one of these references, the correct version will be called based on the actual instance of the interface being referred to.

Prog. No.:- 58

interface AreaCal

{

final double pi = 3.14;

double areacalculation(double r);

}

class Circle implements AreaCal

{

public double areacalculation(double r)

{

double ar;

ar = pi*r*r;

return ar;

}

class IfaceTest09

{

public static void main(String args[])

{

double area;

AreaCal ac = new Circle();

ar = ac.areacalculation(10.25);

System.out.println("Area of Circle is : " + ar);

}

Output :

C:\java> javac IfaceTest09.java

C:\java> java IfaceTest09

Area of Circle is : 329.89625

Here variable ac is declared to be of the interface type AreaCal, it was assigned an instance of circle. Although ac can be used to access the areacalculation() method, it cannot access any other members of the client class. An interface reference variable only has knowledge of the method declared by its interface declaration.

Extending interfaces:

One interface can inherit another by use of the keyword extends. The syntax is the same as for inheriting classes. When a class implements an interface that inherits another interface, It must provide implementation of all methods defined within the interface inheritance.

Note: Any class that implements an interface must implement all methods defined by that interface, including any that inherited from other interfaces.

Prog. No.:- 59

interface if1

{

void dispi1();

}

interface if2 extends if1

{

void dispi2();

}

class cls1 implements if2

{

public void dispi1()

{

System.out.println("This is display of i1");

}

public void dispi2()

{

System.out.println("This is display of i2");

}

public class Ext_ IfaceTest

{

public static void main(String args[])

{

cls1 c1obj = new cls1();

c1obj.dispi1();

c1obj.dispi2();

}

Output :

C:\java> javac Ext_ IfaceTest.java

C:\java> java Ext_ IfaceTest

This is display of i1

This is display of i2

Note : We have to define disp1() and disp2() in cls1.

Multiple inheritance using interface..

Prog. No.:- 60

class stu

{

int rollno;

String name = new String();

int marks;

stu(int r, String n, int m)

{

rollno = r;

name = n;

marks = m;

}

interface i

{

void display();

}

class studerived extends stu implements i

{

studerived(int r, String n, int m)

{

super(r,n,m);

}

public void display()

{

System.out.println("Displaying student details .. ");

System.out.println("Rollno = " + rollno);

System.out.println("Name = " + name);

System.out.println("Marks = " + marks);

}

public class Multi_inhe_Test

{

public static void main(String args[])

{

studerived obj = new studerived(1912, "Ram", 75);

obj.display();

}

Output :

C:\java> javac Multi_inhe_Test.java

C:\java> java Multi_inhe_Test

Displaying student details ..

Rollno = 1912

Name = Ram

Marks = 75

Fig. 5(INTERFACE IMPLEMENTATION)

PACKAGES IN JAVA

Java inbuilt packages:

Package:

Packages are java`s way of grouping a variety of classes and/or interfaces together.

Java API packages:

Java API provides a large number of classes grouped into different packages according to functionality.

Syntax for import packages:

import packagename.classname;

import packagename.*;

These are known as import statements and must appear at the top of the file, before any file declaration as you can see in our few examples. Here import is a keyword. The first statement allows the specified class in the specified package to be imported.

EX :

import java.awt.Color;

double y = java.lang.Math.sqrt(x);

//lang is a package, Math is a class and sqrt is a method.

For create new package you can write...

package firstPackage;

public class Firstclass

{

..................

body of class

.................

}

Vector class:

The Vector class is one of the most important in all of the Java class libraries. We cannot expand the size of a static array.
We may think of a vector as a dynamic array that automatically expands as more elements are added to it.
All vectors are created with some initial capacity.
When space is needed to accommodate more elements, the capacity is automatically increased.
That is why vectors are commonly used in java programming.

This class provides the following constructors:

Vector()

Vector(int n)

Vector(int n, int delta)

The first form creates a vector with an initial capacity of ten elements.
The second form creates a vector with an initial capacity of n elements.
The third form creates a vector with an initial capacity of n elements that increases by delta elements each time it needs to expand.

Prog. No.:- 61

import java.util.*;

public class Vector_Test

{

public static void main(String args[])

{

int i;

Vector_Test v = new Vector_Test();

v.addElement(new Integer(10));

v.addElement(new Float(5.5f));

v.addElement(new String("Hi"));

v.addElement(new Long(2500));

v.addElement(new Double(23.25));

System.out.println(v);

String s = new String("Internet");

v.insertElementAt(s,1);

System.out.println(v);

v.removeElementAt(2);

System.out.println(v);

for(i=0;i<5;i++)

{

System.out.println(v.elementAt(i));

}

Output :

C:\java> javac Vector_Test.java

C:\java> java Vector_Test

Internet

2500

23.25

Random class:

The Random class allows you to generate random double, float, int, or long numbers.
This can be very helpful if you are building a simulation of a real-world system.
This class provides the following constructors.

Random()

Random(long start)

Here, start is a value to initialize the random number generator.

Method	Description
Double nextDouble()	Returns a random double value.
Float nextFloat()	Returns a random float value.
Double nextGaussian()	Returns a random double value. Numbers obtained from repeated calls to this method have a Gaussian distribution with a mean of 0 and a standard deviation of 1.
Int nextInt()	Returns a random int value.
Long nextLong()	Returns a random long value.

Prog. No.:- 62

import java.util.*;

public class Random_Test

{

public static void main(String args[])

{

Random_Test ran = new Random_Test();

for(int i = 0; i<5;i++)

{

System.out.println(ran.nextInt());

}

Output:

C:\java> javac Random_Test.java

C:\java> java Random_Test

64256704

1265771787

-1962940029

1372052

Date class:

The Date classes encapsulate information about a specific date and time.

It provides the following constructors.

Date()

Date(long msec)

Here, the first form returns an object that represent the current date and time.
The second form returns an object that represents the date and time msec in milliseconds after the time.

The time is defined as midnight on January 1,1970 GMT (Greenwich Mean Time).

Method	Description
Boolean after(Date d)	Returns true if d is after the current date. Otherwise, returns false.
Boolean before(Date d)	Returns true if d is before the current date. Otherwise, returns false.
Boolean equals(Date d)	Returns true if d has the same value as the current date. Otherwise, returns false.
Long getTime()	Returns the number of milliseconds since the epoch.
Void setTime (long msec)	Sets the date and time of the current object to represent msec milliseconds since the epoch.
String toString()	Returns the string equivalent of the date.

Prog. No.:- 63

import java.util.*;

public class Date_Test

{

public static void main(String args[])

{

Date_Test dt = new Date_Test();

System.out.println(dt);

Date_Test epoch = new Date_Test(0);

System.out.println(epoch);

}

Output :

C:\java> javac Date_Test.java

C:\java> java Date_Test

Thu Sep 05 05:04:06 IST 2013

Thu Jan 01 05:30:00 IST 1970

Prog. No.:- 64

import java.util.Date;

public class date2_Test

{

public static void main(String[] args)

{

Date d1 = new Date();

try

{

Thread.sleep(1000);

}

catch(Exception e){}

Date d2 = new Date();

System.out.println("First Date : " + d1);

System.out.println("Second Date : " + d2);

System.out.println("Is second date after first ? : " + d2.after(d1));

}

Output :

C:\java> javac Date2_Test.java

C:\java> java Date_Test2

First Date : Thu Sep 05 05:06:46 IST 2013

Second Date : Thu Sep 05 05:06:47 IST 2013

Is second date after first ? : true

Calendar & Gregorian class:

The Calendar class allows you to interpret date and time information. This class defines several integer constants that are used when you get or set components of the calendar. These are listed here.

AM	AM_PM	APRIL
AUGUST	DATE	DAY_OF_MONTH
DAY_OF_WEEK	DAY_OF_WEEK_IN_MONTH	DAY_OF_YEAR
DECEMBER	DST_OFFSET	ERA
FEBRUARY	FIELD_COUNT	FRIDAY
HOUR	HOUR_OF_DAY	JANUARY
JULY	JUNE	MARCH
MAY	MILLISECOND	MINUTE
MONDAY	MONTH	NOVEMBER
OCTOBER	PM	SATURADAY
SECOND	SEPTEMBER	SUNDAY
THURSDAY	TUESDAY	UNDERIMBER
WEDNESDAY	WEEK_OF_MONTH	WEEK_OF_YEAR
YEAR	ZONE_OFFSET	The Calendar class does not have public constructors. Instead, you may use the static getInstance() method to obtain a calendar initialized to the current date and time.

Calendar getInstance()

Prog. No.:- 65

import java.util.Calendar;

public class Cal_Test

{

public static void main(String[] args)

{

Calendar cal = Calendar.getInstance();

System.out.println("DATE is : " + cal.get(cal.DATE));

System.out.println("YEAR is : " + cal.get(cal.YEAR));

System.out.println("MONTH is : " + cal.get(cal.MONTH));

System.out.println("DAY OF WEEK is : " + cal.get(cal.DAY_OF_WEEK));

System.out.println("WEEK OF MONTH is : " + cal.get(cal.WEEK_OF_MONTH));

System.out.println("DAY OF YEAR is : " + cal.get(cal.DAY_OF_YEAR));

System.out.println("DAY OF MONTH is : " + cal.get(cal.DAY_OF_MONTH));

System.out.println("WEEK OF YEAR is : " + cal.get(cal.WEEK_OF_YEAR));

System.out.println("HOUR is : " + cal.get(cal.HOUR));

System.out.println("MINUTE is : " + cal.get(cal.MINUTE));

System.out.println("SECOND is : " + cal.get(cal.SECOND));

System.out.println("DAY OF WEEK IN MONTH is : " + cal.get(cal.DAY_OF_WEEK_IN_MONTH));

System.out.println("Era is : " + cal.get(cal.ERA));

System.out.println("HOUR OF DAY is : " + cal.get(cal.HOUR_OF_DAY));

System.out.println("MILLISECOND : " + cal.get(cal.MILLISECOND));

System.out.println("AM_PM : " + cal.get(cal.AM_PM));// Returns 0 if AM and 1 if PM

}

Output :

C:\java> javac Cal_Test.java

C:\java> java Cal_Test

DATE is : 23

YEAR is : 2012

MONTH is : 9

DAY OF WEEK is : 3

WEEK OF MONTH is : 4

DAY OF YEAR is : 297

DAY OF MONTH is : 23

WEEK OF YEAR is : 43

HOUR is : 2

MINUTE is : 32

SECOND is : 32

DAY OF WEEK IN MONTH is : 4

Era is : 1

HOUR OF DAY is : 14

MILLISECOND : 595

AM_PM : 1

The GregorianCalendar class is a subclass of Calendar.
It provides the logic to manage date and time information according to the rules of the Gregorian calendar.
This class provides following constructors:

GregorianCalendar()

GregorianCalendar(int year, int month, int date)

GregorianCalendar(int year, int month, int date, int hour, int minute, int sec)

GregorianCalendar(int year, int month, int date, int hour, int minute)

The first form creates an object initialized with the current date and time.
The other forms allow you to specify how various date and time components are initialized.
The class provides all of the method defined by Calendar and also adds the isLeapYear() method shown here:

Boolean isLeapYear()

This method returns true if the current year is a leap year. Otherwise, it returns false.

Math Class:

For scientific and engineering calculations, a variety of mathematical functions are required.
Java provides these functions in the Math class available in java.lang package.
The methods defined in Math class are given following:

Method	Description
Double sin(double x)	Returns the sine value of angle x in radians.
Double cos(double x)	Returns the cosine value of the angle x in radians
Double tan(double x)	Returns the tangent value of the angle x in radians
Double asin(double x)	Returns angle value in radians for arcsin of x
Double acos(double x)	Returns angle value in radians for arcos of x
Double atan(double x)	Returns angle value in radians for arctangent of x
Double exp(double x)	Returns exponential value of x
Double log(double x)	Returns the natural logarithm of x
Double pow(double x, double y)	Returns x to the power of y
Double sqrt(double x)	Returns the square root of x
Int abs(double n)	Returns absolute value of n
Double ceil(double x)	Returns the smallest wholoe number greater than or equal to x
Double floor(double x)	Returns the largest whole number less than or equal to x
Int max(itn n, int m)	Returns the maximum of n and m
Int min(int n, int m)	Returns the minimum of n and m
Double rint(double x)	Returns the rounded whole number of x
Int round(float x)	Returns the rounded int value of x
Long round(double x)	Returns the rounded int value of x
Double random()	Returns a random value between 0 and 1.0
Double toRandians(double angle)	Converts the angle in degrees to radians
Double toDegrees(double angle)	Converts the angle in radians to degrees

Prog. No.:- 66

public class Angles

{

public static void main(String args[])

{

double theta = 120.0;

System.out.println(theta + " degrees is " + Math.toRadians(theta) + " radians.");

theta = 1.312;

System.out.println(theta + " radians is " + Math.toDegrees(theta) + " degrees.");

}

Output :

C:\java> javac Angles.java

C:\java> java Angles

120.0 degrees is 2.0943951023931953 radians.

1.312 radians is 75.17206272116401 degrees.

Hashtable :

Hashtable is a part of the java.util library and is a concrete implementation of a dictionary. (Dictionary is a class that represents a key/value storage repository. Given a key and value, you can store the value in a Dictionary object. Once the value is stored, you can retrieve it by using its key.) Hashtable stores key/value pairs in a hash table. When using a Hashtable, you specify an object that is used as a key, and the value that you want to link to that key. The key is then hashed, and the resulting hash code is used as the index at which the value is stored within the table.

The Hashtable constructors are shown here:

Hashtable()

Hashtable(int size)

The first constructor is the default constructor.

The second constructor creates a hash table that has an initial size specified by size.

The methods available with Hashtable are

Method	Description
Void clear()	Resets and empties the hash table.
Boolean containsKey(Object key)	Returns true if some key equals to key exists within the hash table. Returns false if the key isn’t found.
Boolean containsValue(Object value)	Returns true if some value equal to value exists within the hash table. Returns false if the value isn’t found.
Enumeration elements( )	Returns an enumeration of the values contained in the hash table.
Object get(Object key)	Returns the object that contains the value associated with key. If key is not in the hash table, a null object is returned.
Boolean isEmpty( )	Returns true if the hash table is empty; Returns false if it contains at least one key.
Enumeration keys( )	Returns an enumeration of the keys contained in the hash table.
Object put(Object key Object value)	Inserts a key and a value into the hash table.
Object remove(Object key)	Removes key and its value. Returns the value associated with key. If key is not in the hash table, a null object is returned.
Int size( )	Returns the number of entries in the hash table.
String toString( )	Returns the string equivalent of a hash table.

Prog. No.:- 67

import java.util.*;

public class hash1

{

public static void main(String args[])

{

Hashtable marks = new Hashtable();

Enumeration names;

Enumeration emarks;

String str;

int nm;

// Checks wheather the hashtable is empty

System.out.println("Is Hashtable empty " + marks.isEmpty());

marks.put("Ankit", 58);

marks.put("Amit", 88);

marks.put("Shewta", 69);

marks.put("Kriti", 99);

marks.put("Joyti", 54);

System.out.println("Is Hashtable empty " + marks.isEmpty());

// Creates enumeration of keys

names = marks.keys();

while(names.hasMoreElements())

{

str = (String) names.nextElement();

System.out.println(str + ": " + marks.get(str));

}

nm = (Integer) marks.get("Janki");

marks.put("Janki", nm+15);

System.out.println("Janki's new marks: " + marks.get("Janki"));

// Creates enumeration of values

emarks = marks.elements();

while(emarks.hasMoreElements())

{

nm = (Integer) emarks.nextElement();

System.out.println(nm);

}

// Number of entries in a hashtable

System.out.println("The number of entries in a table are " + marks.size());

// Checking wheather the element available

System.out.println("The element is their " + marks.containsValue(88));

// Removing an element from hashtable

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

marks.remove("Bharat");

names = marks.keys();

while(names.hasMoreElements())

{

str = (String) names.nextElement();

System.out.println(str + ": " + marks.get(str));

}

// Returning an String equivalent of the Hashtable

System.out.println("String " + marks.toString());

// Emptying hashtable

marks.clear();

System.out.println("Is Hashtable empty " + marks.isEmpty());

}

Output :

C:\java> javac Hash1.java

C:\java> java Hash1

Amit: 88

Jyoti: 54

Ankit: 58

String {Kriti=99, Amit=88, Jyoti=54, Ankit=58}

Is Hashtable empty true

WRAPPER CLASS IN JAVA

Wrapper Class:

Java uses primitive types, such as int, char, double to hold the basic data types supported by the language.
Sometimes it is required to create an object representation of these primitive types.
These are collection classes that deal only with such objects. One needs to wrap the primitive type in a class.
To satisfy this need, java provides classes that correspond to each of the primitive types. Basically, these classes encapsulate, or wrap, the primitive types within a class.
Thus, they are commonly referred to as type wrapper. Type wrappers are classes that encapsulate a primitive type within an object.
The wrapper types are Byte, Short, Integer, Long, Character, Boolean, Double, Float.

These classes offer a wide array of methods that allow to fully integrate the primitive types into Java’s object hierarchy.

Wrapper classes for converting simple types

Converting primitive numbers to Object numbers using constructor methods

NOTE : I, f, d and l are primitive data values denoting int, float, double and long data types. They may be constants or variables.

Converting Object numbers to Primitive numbers using typeValue() method

Converting Numbers to Strings using toString() method

Converting String Object in to Numeric Object using static method ValueOf()

Converting Numeric Strings to Primitive numbers using Parsing method

NOTE : parseInt() and parseLong() methods throw a NumberFormatException if the value of the str does not represent an integer.

Byte class example in java:

The Byte class encapsulates a byte value. It defines the constants MAX_VALUE and MIN_VALUE and provides these constructors:

Byte(byte b)

Byte(String str)

Here, b is a byte value and str is the string equivalent of a byte value.

Prog. No.:- 68

import java.util.*;

public class Byte_Test

{

public static void main(String args[])

{

Byte_Test b1 = new Byte_Test ((byte)120);

for(int i = 125; i<=135; i++)

{

Byte b2 = new Byte((byte)i);

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

}

System.out.println("b1 Object = " + b1);

System.out.println("Minimum Value of Byte = " + Byte.MIN_VALUE);

System.out.println("Maximum Value of Byte = " + Byte.MAX_VALUE);

System.out.println("b1* 2 = " + b1*2);

System.out.println("b1* 2 = " + b1.byteValue()*2);

Byte b3 = new Byte("120");

System.out.println("b3 Object = " + b3);

System.out.println("(b1==b3)? " + b1.equals(b3));

System.out.println("(b1.compareTo(b3)? " + b1.compareTo(b3));

/*Returns 0 if equal. Returns -1 if b1 is less than b3 and 1 if b1 is

greater than 1*/

}

Output :

C:\java> javac Byte_Test.java

C:\java> java Byte_Test

b2 = 125

b2 = 126

b2 = 127

b2 = -128

b2 = -127

b2 = -126

b2 = -125

b2 = -124

b2 = -123

b2 = -122

b2 = -121

b1 Object = 120

Minimum Value of Byte = -128

Maximum Value of Byte = 127

b1* 2 = 240

b3 Object = 120

(b1==b3)? true

(b1.compareTo(b3)? 0

Short :

The Short class encapsulates a short value. It defines the constants MAX_VALUE and MIN_VALUE and provides the following constructors:

Short(short s)

Short(String str)

Prog. No.:- 69

import java.util.*;

public class Short_Test

{

public static void main(String args[])

{

Short_Test s1 = new Short_Test ((short)2345);

for(int i = 32765; i<=32775; i++)

{

Short_Test s2 = new Short_Test ((short)i);

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

}

System.out.println("s1 Object = " + s1);

System.out.println("Minimum Value of Short = " + Short.MIN_VALUE);

System.out.println("Maximum Value of Short = " + Short.MAX_VALUE);

System.out.println("s1* 2 = " + s1.shortValue()*2);

Short s3 = new Short("2345");

System.out.println("s3 Object = " + s3);

System.out.println("(s1==s3)? " + s1.equals(s3));

Short s4 = Short.valueOf("10", 16);

System.out.println("s4 Object = " + s4);

}

Output :

C:\java> javac Short_Test.java

C:\java> java Short_Test

s2 = 32765

s2 = 32766

s2 = 32767

s2 = -32768

s2 = -32767

s2 = -32766

s2 = -32765

s2 = -32764

s2 = -32763

s2 = -32762

s2 = -32761

s1 Object = 2345

Minimum Value of Short = -32768

Maximum Value of Short = 32767

s1* 2 = 4690

s3 Object = 2345

(s1==s3)? true

s4 Object = 16

Integer class:

The Integer class encapsulates an integer value. This class provides following constructors:

Integer(int i)

Integer(String str)

Here, i is a simple int value and str is a String object.

Prog. No.:- 70

import java.util.*;

public class Integer_Test

{

public static void main(String args[])

{

Integer_Test i1 = new Integer_Test (12);

System.out.println("I1 = " + i1);

System.out.println("Binary Equivalent = " + Integer.toBinaryString(i1));

System.out.println("Hexadecimal Equivalent = " + Integer.toHexString(i1));

System.out.println("Minimum Value of Integer = " + Integer.MIN_VALUE);

System.out.println("Maximum Value of Integer = " + Integer.MAX_VALUE);

System.out.println("Byte Value of Integer = " + i1.byteValue());

System.out.println("Double Value of Integer = " + i1.doubleValue());

Integer_Test i2 = new Integer_Test (12);

System.out.println("i1==i2 " + i1.equals(i2));

System.out.println("i1.compareTo(i2) = " + i2.compareTo(i1));

// Compareto - if it is less than it returns -1 else 1, if equal it return 0.

Integer_Test i3 = Integer.valueOf("11", 16);

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

}

Output :

C:\java> javac Integer_Test.java

C:\java> java Integer_Test

I1 = 12

Binary Equivalent = 1100

Hexadecimal Equivalent = c

Minimum Value of Integer = -2147483648

Maximum Value of Integer = 2147483647

Byte Value of Integer = 12

Double Value of Integer = 12.0

i1==i2 true

i1.compareTo(i2) = 0

i3 = 17

Long :

The Long class encapsulates a long value. It defines the constants MAX_VALUE and MIN_VALUE and provides the following constructors:

Long(long l)

Long(String str)

Prog. No.:- 71

import java.util.*;

public class Long_Test

{

public static void main(String args[])

{

Long_Test L1 = new Long_Test (68764);

Long_Test L2 = new Long_Test ("686748");

System.out.println("Object L1 = " + L1);

System.out.println("Object L2 = " + L2);

System.out.println("Minimum Value of Long = " + Long.MIN_VALUE);

System.out.println("Maximum Value of Long = " + Long.MAX_VALUE);

System.out.println("L1 * 2 = " + L1 * 2);

System.out.println("L1.longValue() * 2 = " + L1.longValue() * 2);

System.out.println("L1.compareTo(l2) = " + L1.compareTo(L2));

System.out.println("L1==L2 ? = " + L1.equals(L2));

Long_Test L3 = Long.valueOf("10", 16);

System.out.println("Object L3 = " + L3);

System.out.println("Byte value of Long = " + L1.byteValue());

System.out.println("int value of Long = " + L1.intValue());

System.out.println("Double value of Long = " + L1.doubleValue());

int i = 12;

System.out.println("Binary equivalent of decimal " + i + "=" + Long.toBinaryString(i));

System.out.println("Hexadecimal equivalent of decimal " + i + "=" + Long.toHexString(i));

}

Output :

C:\java> javac Long_Test.java

C:\java> java Long_Test

Object L1 = 68764

Object L2 = 686748

Minimum Value of Long = -9223372036854775808

Maximum Value of Long = 9223372036854775807

L1 * 2 = 137528

L1.longValue() * 2 = 137528

L1.compareTo(l2) = -1

L1==L2 ? = false

Object L3 = 16

Byte value of Long = -100

int value of Long = 68764

Double value of Long = 68764.0

Binary equivalent of decimal 12=1100

Hexadecimal equivalent of decimal 12=c

Double class:

The Double class encapsulates a double value. It defines several constants. The largest and smallest values are saved in MAX_VALUE and MIN_VALUE. The constant NaN (Not a Number) indicates that a value is not a number. If you divide a double number by zero, the result is NaN.

This class defines these constructors:

Double(double d)

Double(String str)

Here, d is a double value to be encapsulated in a Double object. In the last form, str is the string representation of a double value.

Prog. No.:- 72

import java.util.*;

class Double_Test

{

public static void main(String args[])

{

Double_Test d1 = new Double_Test (687642365.4563);

Double_Test d2 = new Double_Test ("686748");

System.out.println("Object d1 = " + d1);

System.out.println("Object d2 = " + d2);

System.out.println("Minimum Value of Double = " + Double.MIN_VALUE);

System.out.println("Maximum Value of Double = " + Double.MAX_VALUE);

System.out.println("Byte value of Double = " + d1.byteValue());

System.out.println("int value of Double = " + d1.intValue());

System.out.println("Float value of Double = " + d1.floatValue());

Double_Test d3 = Double.parseDouble("765.89");

System.out.println("Double value from the string \"765.89\"="+d3);

}

Output :

C:\java> javac Double_Test.java

C:\java> java Double_Test

Object d1 = 6.876423654563E8

Object d2 = 686748.0

Minimum Value of Double = 4.9E-324

Maximum Value of Double = 1.7976931348623157E308

Byte value of Double = -3

int value of Double = 687642365

Float value of Double = 6.8764237E8

Double value from the string "765.89"=765.89

Float class:

The float class encapsulates a float value. It defines several constants the largest and smallest values are stored in MAX_VALUE and MIN_VALUE. The constant NaN indicates that a value is not a number. If you divide a floating – point number by zero, the result is NaN.

This class defines these constructors:

Float(float f)

Float(double d)

Float(String str)

Here, f and d are float and double types to be encapsulated in a Float object. str is the string representation of a float value.

Prog. No.:- 73

import java.util.*;

public class Float_Test

{

public static void main(String args[])

{

Float_Test f1 = new Float_Test (123.5626);

Float_Test f2 = new Float_Test (854.32f);

Float_Test i = new Float_Test (10);

System.out.println("Object f1 = " + f1);

System.out.println("Object f2 = " + f2);

System.out.println("Minimum Value of Float = " + Float.MIN_VALUE);

System.out.println("Maximum Value of Float = " + Float.MAX_VALUE);

System.out.println("Byte value of Float = " + f1.byteValue());

System.out.println("Short value of Float = " + f1.shortValue());

System.out.println("Integer value of Float = " + f1.intValue());

System.out.println("Double value of Float = " + f1.doubleValue());

System.out.println("(f1==f2) ?= " + f1.equals(f2));

System.out.println("f1.compareTo(f2) = " + f1.compareTo(f2));

System.out.println("f1 is not a number = " + i.isNaN());

}

Output :

C:\java> javac Float_Test.java

C:\java> java Float_Test

Object f1 = 123.5626

Object f2 = 854.32

Minimum Value of Float = 1.4E-45

Maximum Value of Float = 3.4028235E38

Byte value of Float = 123

Short value of Float = 123

Integer value of Float = 123

Double value of Float = 123.5625991821289

(f1==f2) ?= false

f1.compareTo(f2) = -1

f1 is not a number = false

Character class:

The Character class encapsulates a char value. This class provides the following constructor.

Character(char ch)

Here, c is a char value. charValue() method returns the char value that is encapsulated by a Character object and has the following form:

char charValue().

Prog. No.:- 74

import java.util.*;

public class Char_Test

{

public static void main(String args[])

{

Character_Test c1 = new Character_Test ('m');

char c2 = 'O';

System.out.println("Object C1 = " + c1);

System.out.println("char value of Character Object = " + c1.charValue());

System.out.println(c2 + " is defined character set ? " + Character.isDefined(c2));

System.out.println("c2 is digit = " + Character.isDigit(c2));

System.out.println("c2 is lowercase character = " + Character.isLowerCase(c2));

System.out.println("c2 is uppercase character = " + Character.isUpperCase(c2));

}

Output :

C:\java> javac Char_Test.java

C:\java> java Char_Test

Object C1 = m

char value of Character Object = m

O is defined character set ? true

c2 is digit = false

c2 is lowercase character = false

c2 is uppercase character = true

Boolean class:

The Boolean class encapsulates a Boolean value. It defines FALSE and TRUE constants.

This class provides following constructors:

Boolean(Boolean b)

Boolean(String str)

Here, b is a Boolean value and str is the string equivalent of a Boolean value.

The methods associated with Boolean Class are as follows:

1. Boolean booleanValue()

2. Boolean equals(Boolean b)

3. String toString(Boolean b)

Prog. No.:- 75

import java.util.*;

public class Boolean_Test

{

public static void main(String args[])

{

Boolean_Test b1 = new Boolean_Test (true);

Boolean_Test b2 = new Boolean_Test (false);

System.out.println("Object B1 = " + b1);

System.out.println("Object B2 = " + b2);

Boolean_Test b3 = new Boolean_Test ("true");

Boolean_Test b4 = new Boolean_Test ("false");

System.out.println("Object B3 = " + b3);

System.out.println("Object B4 = " + b4);

System.out.println("Boolean Value = " + b1.booleanValue());

System.out.println("(b1==b2)? " + b1.equals(b2));

String S1 = b1.toString();

System.out.println("String S1 " + S1);

}

Output :

C:\java> javac Boolean_Test.java

C:\java> java Boolean_Test

Object B1 = true

Object B2 = false

Object B3 = true

Object B4 = false

Boolean Value = true

(b1==b2)? false

String S1 true

STRING &STRING BUFFER IN JAVA

String Handling:-

In Java, a string is defined as a sequence of characters. But, unlike many other languages that implement strings as character arrays, java implements strings as objects of type String. Java handles String by two classes StringBuffer and String. The String and StringBuffer classes are defined in java.lang. Thus, they are available to all programs automatically.

String Concatenation (+)

Prog. No.:- 76

import java.util.*;

class STest

{

public static void main(String args[])

{

STest s1 = new STest ("Java");

STest s2 = "2all";

STest s3 = s1+s2;

System.out.println("S1 = " + s1);

System.out.println("S2 = " + s2);

System.out.println("Concatenation Operator = " + s1+s2);

System.out.println("S3 = " + s3);

byte num [] = {65,66,67,68};

STest s4 = new STest (num);

System.out.println("S4 = " + s4);

}

Output :

C:\java> javac STest.java

C:\java> java STest

S1 = Java

S2 = 2all

Concatenation Operator = Java2all

S3 = Java2all

S4 = ABCD

Character Extraction :

The String class provides ways in which characters can be extracted from a String object.

String Comparison :

The String class provides several methods that compare strings or substrings within strings.

equals( ) – used to compare two strings

General form:

Boolean equals(Object str)

Here, str is a String object.

It returns true if the strings contain the same character otherwise it returns false.

The comparison is case-sensitive.

equalsIgnoreCase( ) – Same as equals but this ignores case.

General form:

Boolean equalsIgnoreCase(String str)

Here, str is the String object.

It returns true if the strings contain the same character otherwise it returns false.

This is case in – sensitive.

regionMatches( )

This method compares a specific region inside a string with another specific region in another string.

There is an overloaded form that allows you to ignore case in such comparisons.

General form:

Boolean regionMatches(int startIndex, String str2, int str2StartIndes, int numChars)

Boolean regionMatches(Boolean ignoreCase, int startIndex, String str2, int str2StartIndex, int numChars)

startsWith( ) and endsWith()

The startsWith( ) method determines whether a given String begins with a specified string.

endsWith( ) determines whether the String ends with a specified string.

General Form

Boolean startsWith(String str)

Boolean endsWith(String str)

equals( ) Versus = =

Equals( ) method and the = = operator perform two different operations. The equals ( ) method compares the characters inside a String object. The = = operator compares two object references to see whether they refer to the same instance.

compareTo( )

It is not enough to know that two strings just for equal or not. For sorting applications, we need to know which is less than, equal to, or greater than the other string.

The String method compareTo( ) serves this purpose.

General Form:

int compareTo(String str)

Modifying a string :

If we want to modify a String, we must either copy it into a StringBufer or we can use following String methods:

valueOf() :

The valueOf() method converts data from internal format into a human-readable form. It has several forms:

String valueOf(double num)

String valueOf(long num)

String valueOf(Object ob)

String valueOf(char chars[ ] )

String valueOf(char chars[], int startIndex, int numChars)

String Buffer class:

StringBuffer is a peer class of String. String creates strings of fixed length, while StringBuffer creates strings of flexible length that can be modified in terms of both length and content. So Strings that need modification are handled by StringBuffer class. We can insert characters and substrings in the middle of a string, or append another string to the end.

StringBufer defines these Constructors:

StringBuffer()

StringBuffer(int size)

StringBuffer(String str)

Method Call	Task Performed
Sb.length()	Gives the current length of a StringBuffer.
Sb.capacity()	Gives the total allocated capacity (default 16)
setLength(int len)	Set the length of the buffer within a String Buffer object.
charAt(int where)	Gives the value of character
setCharAt(int where, char ch)	Set the value of a character within a StringBuffer.
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.reverse()	Reverse the string of s1
S1.deleteCharAt(nth)	Delete the nth character of string s1
S1.delete(StartIndex, endIndex)	Delete characters from start to end.

Prog. No.:- 77

import java.util.*;

class Strbuf_Test

{

public static void main(String args[])

{

Strbuf_Test s1 = new Strbuf_Test ();

Strbuf_Test s2 = new Strbuf_Test ("Anurag");

Strbuf_Test s3 = new Strbuf_Test (s2);

Strbuf_Test s4 = new Strbuf_Test (100);

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

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

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

System.out.println("s1.length = " + s1.length());

System.out.println("s2.length = " + s2.length());

System.out.println("s3.length = " + s3.length());

System.out.println("s4.length = " + s4.length());

System.out.println("s1.capacity = " + s1.capacity());

System.out.println("s2.capacity = " + s2.capacity());

System.out.println("s3.capacity = " + s3.capacity());

System.out.println("s4.capacity = " + s4.capacity());

}

Output :

C:\java> javac Strbuf_Test.java

C:\java> java Strbuf_Test

s1 =

s2 = Anurag

s3 = Anurag

s1.length = 0

s2.length = 9

s3.length = 9

s4.length = 0

s1.capacity = 16

s2.capacity = 25

s3.capacity = 25

s4.capacity = 100

Prog. No.:- 78

import java.util.*;

class Strbuf2_Test

{

public static void main(String args[])

{

Strbuf2_Test s1 = new Strbuf2_Test ("Anurag Rana");

Strbuf2_Test s2 = new Strbuf2_Test ("Hello");

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

//System.out.println("s1.charAt(6) = " + s1.charAt(6));

//s1.setCharAt(6,'z');

//System.out.println("s1 = " + s1);

//System.out.println("Inserting String = " + s1.insert(6,s2));

//System.out.println("s1 = " + s1);

//System.out.println("Appending String = " + s1.append(s2));

//System.out.println("s1 = " + s1);

//System.out.println("Reversing String = " + s1.reverse());

//System.out.println("Deleting 6th character = " + s1.deleteCharAt(6));

System.out.println("Deleting 6 to 11 character = " + s1.delete(6,11));

}

Output :

C:\java> javac Strbuf2_Test.java

C:\java> java Strbuf2_Test

s1 = Anurag Rana

Deleting 6 to 11 character = Anurag

Prog. No.:- 79

import java.util.*;

public class Strbuf3_Test

{

public static void main(String[] args)

{

Strbuf3_Test s = new Strbuf3_Test ("Hello world!");

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

System.out.println("s.length() = " + s.length());

System.out.println("s.length() = " + s.capacity());

// Change the length of buffer to 5 characters:

s.setLength(5);

System.out.println(s);

System.out.println("s.length() = " + s.length());

System.out.println("s.length() = " + s.capacity());

}

Output :

C:\java> javac Strbuf3_Test.java

C:\java> java Strbuf3_Test

s = Hello world!

s.length() = 12

s.length() = 28

Hello

s.length() = 5

s.length() = 28

EXCEPTION HANDLING IN JAVA

Exception handling:

Exception is a run-time error which arises during the execution of java program. The term exception in java stands for an “exceptional event”.

So Exceptions are nothing but some abnormal and typically an event or conditions that arise during the execution which may interrupt the normal flow of program.

An exception can occur for many different reasons, including the following:

· A user has entered invalid data.

· A file that needs to be opened cannot be found.

· A network connection has been lost in the middle of communications, or the JVM has run out of memory.

“If the exception object is not handled properly, the interpreter will display the error and will terminate the program.

Now if we want to continue the program with the remaining code, then we should write the part of the program which generate the error in the try{} block and catch the errors using catch() block..

Exception turns the direction of normal flow of the program control and send to the related catch() block and should display error message for taking proper action. This process is known as Exception handling.”

The purpose of exception handling is to detect and report an exception so that proper action can be taken and prevent the program which is automatically terminate or stop the execution because of that exception.

Java exception handling is managed by using five keywords: try, catch, throw, throws and finally.

Try:

Piece of code of your program that you want to monitor for exceptions are contained within a try block. If an exception occurs within the try block, it is thrown.

Catch:

Catch block can catch this exception and handle it in some logical manner.

Throw:

System-generated exceptions are automatically thrown by the Java run-time system. Now if we want to manually throw an exception, we have to use the throw keyword.

Throws:

If a method is capable of causing an exception that it does not handle, it must specify this behavior so that callers of the method can guard themselves against that exception.

You do this by including a throws clause in the method’s declaration. Basically it is used for IOException. A throws clause lists the types of exceptions that a method might throw.

This is necessary for all exceptions, except those of type Error or RuntimeException, or any of their subclasses.

All other exceptions that a method can throw must be declared in the throws clause. If they are not, a compile-time error will result.

Finally:

Any code that absolutely must be executed before a method returns, is put in a finally block.

General form:

try {

// block of code to monitor for errors

}

catch (ExceptionType1 e1) {

// exception handler for ExceptionType1

}

catch (ExceptionType2 e2) {

// exception handler for ExceptionType2

}

// ...

finally {

// block of code to be executed before try block ends

}

Exception Hierarchy:

All exception classes are subtypes of the java.lang.Exception class.

The exception class is a subclass of the Throwable class. Other than the exception class there is another subclass called Error which is derived from the Throwable class.

Errors :

These are not normally trapped form the Java programs.

Errors are typically ignored in your code because you can rarely do anything about an error.

These conditions normally happen in case of severe failures, which are not handled by the java programs. Errors are generated to indicate errors generated by the runtime environment.

For Example :

(1) JVM is out of Memory. Normally programs cannot recover from errors.

(2) If a stack overflow occurs then an error will arise. They are also ignored at the time of compilation.

The Exception class has two main subclasses:

(1) IOException or Checked Exceptions class and

(2) RuntimeException or Unchecked Exception class

(1) IOException or Checked Exceptions :

Exceptions that must be included in a method’s throws list if that method can generate one of these exceptions and does not handle it itself. These are called checked exceptions. For example, if a file is to be opened, but the file cannot be found, an exception occurs. These exceptions cannot simply be ignored at the time of compilation.

Java’s Checked Exceptions Defined in java.lang

(2) RuntimeException or Unchecked Exception :

Exceptions need not be included in any method’s throws list. These are called unchecked exceptions because the compiler does not check to see if a method handles or throws these exceptions. As opposed to checked exceptions, runtime exceptions are ignored at the time of compilation.

Java’s Unchecked RuntimeException Subclasses.

Try and catch in java:

Prog. No.:- 80

public class TC_Test

{

public static void main(String[] args)

{

int a=10;

int b=5,c=5;

int x,y;

try

{

x = a / (b-c);

}

catch(ArithmeticException e)

{

System.out.println("Divide by zero");

}

y = a / (b+c);

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

}

Output :

C:\java> javac TC_Test.java

C:\java> java TC_Test

Divide by zero

y = 1

Note that program did not stop at the point of exceptional condition.It catches the error condition, prints the error message, and continues the execution, as if nothing has happened. If we run same program without try catch block we will not gate the y value in output. It displays the following message and stops without executing further statements.

Exception in thread "main" java.lang.ArithmeticException: / by zero

at Thrw_Excp.TC_Demo.main(TC_Demo.java:10)

Here we write ArithmaticException in catch block because it caused by math errors such as divide by zero.

Now how to display description of an exception ?

The description of thrown object by using it in a println() statement by simply passing the exception as an argument. For example;

catch (ArithmeticException e)

{

system.out.pritnln(“Exception:” +e);

}

Multiple catch blocks :

?It is possible to have multiple catch blocks in our program.

Prog. No.:- 81

public class MultiCatch

{

public static void main(String[] args)

{

int a [] = {5,10};

int b=5;

try

{

int x = a[2] / b - a[1];

}

catch(ArithmeticException e)

{

System.out.println("Divide by zero");

}

catch(ArrayIndexOutOfBoundsException e)

{

System.out.println("Array index error");

}

catch(ArrayStoreException e)

{

System.out.println("Wrong data type");

}

int y = a[1]/a[0];

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

}

Output :

C:\java> javac MultiCatch.java

C:\java> java MultiCatch

Array index error

y = 2

Note that array element a[2] does not exist. Therefore the index 2 is outside the array boundary. When exception in try block is generated, the java treats the multiple catch statements like cases in switch statement. The first statement whose parameter matches with the exception object will be executed, and the remaining statements will be skipped. When you are using multiple catch blocks, it is important to remember that exception subclasses must come before any of their superclasses. This is because a catch statement that uses a superclass will catch exceptions of that type plus any of its subclasses. Thus, a subclass will never be reached if it comes after its superclass. And it will result into syntax error.

// Catching super exception before sub

Prog. No.:- 82

class etion3

{

public static void main(String args[])

{

int num1 = 100;

int num2 = 50;

int num3 = 50;

int result1;

try

{

result1 = num1/(num2-num3);

System.out.println("Result1 = " + result1);

}

catch (Exception e)

{

System.out.println("This is mistake. ");

}

catch(ArithmeticException g)

{

System.out.println("Division by zero");

}

Output :

If you try to compile this program, you will receive an error message because the exception has already been caught in first catch block. Since ArithmeticException is a subclass of Exception, the first catch block will handle all exception based errors, including ArithmeticException. This means that the second catch statement will never execute. To fix the problem, revere the order of the catch statement.

Nested try statements:

The try statement can be nested. That is, a try statement can be inside a block of another try. Each time a try statement is entered, its corresponding catch block has to enter. The catch statements are operated from corresponding statement blocks defined by try.

Prog. No.:- 83

public class NestedTry

{

public static void main(String args[])

{

int num1 = 100;

int num2 = 50;

int num3 = 50;

int result1;

try

{

result1 = num1/(num2-num3);

System.out.println("Result1 = " + result1);

try

{

result1 = num1/(num2-num3);

System.out.println("Result1 = " + result1);

}

catch(ArithmeticException e)

{

System.out.println("This is inner catch");

}

catch(ArithmeticException g)

{

System.out.println("This is outer catch");

}

Output :

C:\java> javac NestedTry.java

C:\java> java NestedTry

This is outer catch.

Finally:

Java supports another statement known as finally statement that can be used to handle an exception that is not caught by any of the previous catch statements. We can put finally block after the try block or after the last catch block. The finally block is executed in all circumstances. Even if a try block completes without problems, the finally block executes.

Prog. No.:- 84

public class Finally_Test

{

public static void main(String args[])

{

int num1 = 100;

int num2 = 50;

int num3 = 50;

int result1;

try

{

result1 = num1/(num2-num3);

System.out.println("Result1 = " + result1);

}

catch(ArithmeticException g)

{

System.out.println("Division by zero");

}

finally

{

System.out.println("This is final");

}

Output :

C:\java> javac Finally_Test.java

C:\java> java Finally_Test

Division by zero

This is final

Throw:

We saw that an exception was generated by the JVM when certain run-time problems occurred. It is also possible for our program to explicitly generate an exception. This can be done with a throw statement.

Throw object;

Inside a catch block, you can throw the same exception object that was provided as an argument.

Syntax:

catch(ExceptionType object)

{

throw object;

}

Alternatively, you may create and throw a new exception object as follows:

Throw new ExceptionType(args);

Here, exceptionType is the type of the exception object and args is the optional argument list for its constructor. When a throw statement is encountered, a search for a matching catch block begins and if found it is executed.

Prog. No.:- 85

class Throw_Test

{

public static void a()

{

try

{

System.out.println("Before b");

b();

}

catch(ArrayIndexOutOfBoundsException j) //manually thrown object catched here

{

System.out.println("J : " + j) ;

}

public static void b()

{

int a=5,b=0;

try

{

System.out.println("We r in b");

System.out.println("********");

int x = a/b;

}

catch(ArithmeticException e)

{

System.out.println("c : " + e);

throw new ArrayIndexOutOfBoundsException("demo"); //throw from here

}

public static void main(String args[])

{

try

{

System.out.println("Before a");

a();

System.out.println("********");

System.out.println("After a");

}

catch(ArithmeticException e)

{

System.out.println("Main Program : " + e);

}

Output :

C:\java> javac Throw_Test.java

C:\java> java Throw_Test

Before a

Before b

We r in b

********

c : java.lang.ArithmeticException: / by zero

J : java.lang.ArrayIndexOutOfBoundsException: demo

********

After a

Throwing our own object :

?If we want to throw our own exception, we can do this by using the keyword throw as follow.

throw new Throwable_subclass;

Example : throw new ArithmaticException( );

throw new NumberFormatException( );

Prog. No.:- 86

import java.lang.Exception;

class MyException extends Exception

{

MyException(String message)

{

super(message);

}

class TestMyException

{

public static void main(String[] args)

{

int x = 5, y = 1000;

try

{

float z = (float)x / (float)y;

if(z < 0.01)

{

throw new MyException("Number is too small");

}

catch(MyException e)

{

System.out.println("Caught MyException");

System.out.println(e.getMessage());

}

finally

{

System.out.println("uiit.hpu");

}

Output :

C:\java> javac TestMyException.java

C:\java> java TestMyException

Caught MyException

Number is too small

uiit.hpu

Here The object e which contains the error message "Number is too small" is caught by the catch block which then displays the message using getMessage( ) method.

NOTE:

Exception is a subclass of Throwable and therefore MyException is a subclass of Throwable class. An object of a class that extends Throwable can be thrown and caught.

Throws:

If a method is capable of causing an exception that it does not handle, it must specify this behavior so that callers of the method can guard themselves against that exception. We do this by including a throws clause in the method’s declaration. Basically it is used for IOException. A throws clause lists the types of exceptions that a method might throw. This is necessary for all exceptions, except those of type Error or RuntimeException,or any of their subclasses. All other exceptions that a method can throw must be declared in the throws clause. If they are not, a compile-time error will result.

General form of a method declaration that includes a throws clause:

type method-name(parameter-list) throws exception-list

{

// body of method

}

Here, exception-list is a comma-separated list of the exceptions that a method can throw. Throw is used to actually throw the exception, whereas throws is declarative statement for the method. They are not interchangeable.

Prog. No.:- 87

class NewException extends Exception

{

public String toS()

{

return "You are in NewException ";

}

class Customexception

{

public static void main(String args[])

{

try

{

doWork(3);

doWork(2);

doWork(1);

doWork(0);

}

catch (NewException e)

{

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

}

static void doWork(int value) throws NewException

{

if (value == 0)

{

throw new NewException();

}

else

{

System.out.println("****No Problem.****");

}

Output:

C:\java> javac Customexception.java

C:\java> java Customexception

****No Problem.****

Difference b/w exceptions and assertions. Define call stack mechanism. Is it possible to create user define exception. If yes then explain how? Write a program to print the sum of array using fine-grained exception handling.

Exceptions are the mechanism used by many programming languages to describe what to do when something unexpected happens. Typically something unexpected is an error of some sort, for example when a method is invoked with unacceptable arguments, or a network connection fails, or the user asks to open a non-existent file.

Assertions are a way to test certain assumptions about the logic of a program. Assertions are used to test assumptions about local program logic inside a method, and usually not to test that external exceptions are met. For example , if we believe that that at particular point the value of a variable will always be positive, then an assertion can test this.

Assertions can be removed entirely from the code when it runs. This make it possible for us to enable assertions during program development, but to not have the tests executed at runtime when the final product is delivered.

The java programming language provides two broad categories of exceptions, known as checked and unchecked exceptions.

Checked exceptions are those that the programming is expected to handle in the program, and that arise from external conditions that can readily occur in a working program. Example:-- file not found or a network failure.

Unchecked exceptions might arise from conditions that represent bugs, or situations that are considered generally too difficult for a program to handle reasonably. They are called unchecked because we are not required to check for them or do anything about them if they occur. Exceptions that arise from a category of situations that probably represent bugs are called runtime exceptions. Example of runtime exception is attempting to access beyond the end of an array.

Exceptions that arise as a result of environment issues that are rare enough or hard enough to recover from are called error. Example:--- running out of memory. Errors are also unchecked exception.

Call Stack Mechanism:-

If a statement throws an exception, and that exception is not handling in the immediately enclosing method, then that exception is thrown to the calling method. If the exception is not handled in the calling method, it is thrown to the caller of that method. This process continues if the exception is still not handled by the time it gets back to the main() method and main() does not handle it, the exception terminates the program abnormally.

User- defined Exceptions:

User-defined exceptions are created by extending the Exception class. Exception classes contain anything that a regular class contains.

Public class TestException extends Exception

{

Private int port;

Public TestException(String msg, int port)

{

super(msg);

this.port=port;

}

Public int getPort()

{

Return port;

}

//throwing a user defined exception

Public void connect(String serverName) throws TestException

{

boolean successful;

int portConnect=80;

successful = open(serverName, portConnect);

if(! successful)

{

Throw new TestException(“Could not connect”,portConnect);

}

Write a program to print the sum of array using fine-grained exception handling.

public class Sum

{

Public static void main(String [] args)

{

int add=0;

for(int i=0;i<args.length;i++)

{

try{

add+=Integer.parseInt(args[i]);

}

catch.err.println(“[”+args[i]”]is not an integer” +”and will not be included in the sum.”);

}

System.out.println(“Add=”+add);

}

/*this program capture the exception for each non-integer, command-line argument and generate an warning message. However, this program proceeds to add all of the valid integer. */

Javac Sum.java

Java sum 1 two 3.0 4

[two] is not an integer and will not be included in the add.

[3.0] is not an integer and will not be included in the add.

Add =5.

MULTITHREADING IN JAVA

Thread: A thread is a single flow of control like simple program.

A unique property of java is multithreading only because java supports multithreading. More than one thread (program) run simultaneously is known as multithreading (multiprogramming). In multithreading java interpreter handles the switching of control between the threads in such a way that it looks like they are running concurrently. Multithreading is useful in a number of ways. We can divide a long program into number of threads and executes them in parallel.

The Main Thread:

When our simple program starts one single thread begins running immediately. This is called our single main thread. The main thread create automatically when program is started.

It is very important thread because of two reasons:

1.) From the main thread other child thread will be created.

2.) Main thread is all most everytime stop running lastly because it has to remove or shutdown few resources as well as few action.

Now the question is how can we control our main thread?

Actually by calling the method currentThread() of Thread class we can control our main thread.

Prog. No.:- 88 (Main Thread.)

public class Main_Thread

{

public static void main(String args[])

{

Main_Thread t = Main_Thread.currentThread();

System.out.println("Current thread: " + t);

// change the name of the thread

t.setName("My Thread");

System.out.println("After name change: " + t);

try

{

for(int n = 5; n > 0; n--)

{

System.out.println(n); //print number with interval of 1 sec.

Thread.sleep(1000); //Thread is going to sleep for 1 sec.

}

catch (InterruptedException e)

{

System.out.println("Main thread interrupted");

}

Output:

C:\java> javac Main_Thread.java

C:\java> java Main_Thread

Current thread: Thread[main,5,main]

After name change: Thread[My Thread,5,main]

Here first of all we give reference of our current main single thread to t by thread object and currentThread() method. The number 5 to 1 will be print at interval of 1 second due to sleep method. Thread will go to sleep for 1000 ms. due to sleep method

Thread Life Cycle:

Thread has many different state through out its life.

1 Newborn State

2 Runnable State

3 Running State

4 Blocked State

5 Dead State

1 Newborn State:

When we create a thread it will be in Newborn State. The thread is just created still its not running. We can move it to running mode by invoking the start() method and it can be killed by using stop() method.

2 Runnable State:

It means that thread is now ready for running and its waiting to give control. We can move control to another thread by yield() method.

3 Running State:

It means thread is in its execution mode becaause the control of cpu is given to that particular thread. It can be move in three different situation from running mode.

4 Blocked State:

A thread is called in Blocked State when it is not allowed to entering in Runnable State or Running State. It happens when thread is in waiting mode, suspended or in sleeping mode.

5 Dead State:

When a thread is completed executing its run() method the life cycle of that particular thread is end. We can kill thread by invoking stop() method for that particular thread and send it to be in Dead State.

Create Thread:

We can create thread in java with two different ways.

1. Extending the Thread Class.

2. Implements runnable interface.

1. Extending the Thread class:

In this method one normal class extends the inbuilt class thread and override its run() method with the code required by that particular thread. Here we are going to extend class java.lang.Thread. so we can access all the methods of thread class. Create one class which extends the thread class. Override the run method and put lines of code inside thread method that will be perform by thread.

Create an object of class which we created with extending the thread class and call the start() method to execute the thread.

Class MyThread extends Thread

{

………………..

}

So now we have one thread named MyThread.

Implementing the run() method

Public void run()

{

………

// Thread code here

}

Starting new Thread

MyThread aTh = new MyThread(); // it instantiates a new object of class MyThread

aTh.start(); // invokes run() method

Prog. No.:- 89(Extending the Thread class.)

class A extends Thread

{

public void run()

{

System.out.println("Thread A");

for(int i=1;i<=5;i++)

{

System.out.println("From thread A i = " + i);

}

System.out.println("Exit from A");

}

class B extends Thread

{

public void run()

{

System.out.println("Thread B");

for(int i=1;i<=5;i++)

{

System.out.println("From thread B i = " + i);

}

System.out.println("Exit from B");

}

public class Thread_Class

{

public static void main(String[] args)

{

new A().start(); //creating A class thread object and calling run method

new B().start(); //creating B class thread object and calling run method

System.out.println("End of main thread");

}

Output :

C:\java> javac Thread_Class.java

C:\java> java Thread_Class

Thread A

From thread A i = 1

From thread A i = 2

From thread A i = 3

From thread A i = 4

From thread A i = 5

Exit from A

End of main thread

Thread B

From thread B i = 1

From thread B i = 2

From thread B i = 3

From thread B i = 4

From thread B i = 5

Exit from B

2. Implementing the Runnable interface:

In this method we have one interface named runnable and we implements this interface for implement a thread. Create one class which implements runnable interface. Override the run() method and put some line of code for that particular thread. Now create an object of inbuilt thread class and create an object of class that implements runnable interface. Give the reference of object to thread object by passing an argument (argument must be the object of class which implements the runnable interface) while creating a thread object. Call the start() method to run the thread.

Prog. No.:- 90 (Implementing the Runnable interface.)

public class Thread_Interface

{

public static void main(String[] args)

{

X x1 = new X(); //class object

Thread xthread = new Thread(x1); //creating thread object and giving reference of class object to thread object

xthread.start();

System.out.println("End of main Thread");

}

class X implements Runnable

{

public void run()

{

System.out.println("Inside X thread");

for(int i=1;i<=10;i++)

{

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

}

System.out.println("Exit from X");

}

Output :

C:\java> javac Thread_Interface.java

C:\java> java Thread_Interface

End of main Thread

Inside X thread

From xthread i = 1

From xthread i = 2

From xthread i = 3

From xthread i = 4

From xthread i = 5

From xthread i = 6

From xthread i = 7

From xthread i = 8

From xthread i = 9

From xthread i = 10

Exit from X

Anurag Rana Educator CSE/IT

Anurag RANA

Easy to Learn Java

Token:

Identifiers :

Keywords :

Separators :

Comments and Whitespaces :

Operators:

1. Integers:

1.1 byte

1.2 short

1.3 int

1.4 long

2. Floating-Point Types:

2.1 float

2.2 double

3. Characters:

4. Boolean:

VARIABLES IN JAVA

Declare Variable

Dynamic initialization: area is = 200

The Scope and Lifetime of Variables

if in java:

if else :

if-else-if Ladder :

Nested if :

switch :

Looping statements

1. for :

2. while :

3. do while :

Nested loops :

Jump Statements

The break statement

Continue statement

How to declare object of class in java?

CONSTRUCTOR IN JAVA

new:

this:

static :

super :

final :

ACCESS CONTROL IN JAVA

METHOD OVERLOADING IN JAVA

CONSTRUCTOR OVERLOADING IN JAVA

MORE ABOUT METHOD

INHERITANCE IN JAVA

JAVA INTERFACE

Java Interface:

Defining interfaces in java with syntax:

Implementing interfaces

Java inbuilt packages:

STRING &STRING BUFFER IN JAVA

Exception handling:

Throws:

The Main Thread:

Thread Life Cycle:

Comments

Post a Comment

Popular posts from this blog

JAVA Scrollbar, MenuItem and Menu, PopupMenu

Difference between net platform and dot net framework...

Standard and Formatted Input / Output in C++

`Dynamic initialization: area is = 200`