Unit I Introduction

Introduction History of java: Java was invented by James Goslings, Patrick Naughton, Chris Warth, Ed Frank, and Mike Sheridan at Sun Microsystems, Inc in 1991. This language is earlier called as “OAk” has renamed to java in 1995.

The java Buzzwords or the features of java: The features of java can be listed as follows. 1) Simple 2) Object oriented 3) Robust 4) Architecture Neutral 5) Interpreted and High performance 6) Multithreaded 7) Distributed 8) Dynamic Simple: Java inherits the c/c++ langue syntax to some extent. This makes the programmer easier in learning this language. So java is defined as simple. Object oriented: Every entity can be treated as an object and build functionalities around it. It also makes easy to extend the functionalities around these object. And since java follows these principles of the object oriented, it is called as an object oriented programming language. Robust: Robust means able to with stand in all critical conditions. These below things make java a robust language. 1) Exception handling: some of the errors that occur during the program execution are hard to handle. Java provides an exception handling api(Application Programming Interface) for handling the divide by zero kind of exceptions which abruptly stop the program execution 2) Compile time errors- Java is a Strictly typed language. It does a compile time check to find the code syntax errors. 3) Memory management- java provides automatic allocation and deallocation of memory, which is know as garbage collection, whereas in case of c++ language the deallocation of the memory has to be done by programmers by writing destructors in their programs. All these features make java a robust language. Architecture Neutral: Java uses a runtime interpreter called JVM(Java Virtual Machine) which makes the java compiled programs executable. So java has a slogan as “write once run anywhere”(WORA). Ex: Java program compiled on windows can be executed on Unix platform. So java is also called as portable language.

Interpreted and High performance: Java is compiled into an intermediate bytecode program by the jvm. This byte code is interpreted line by line easily into the native machine code. So java is called a high performance language. Multithreaded: Using java we can create interactive programs, which needs multiple processes to be done in parallel. Java provides the api for multithreading to achieve the smoothly running interactive systems. Distributed: Java can work in the distributed environment(systems distributed over the network), which made it popular as an internet programming language. Also handles the TCP/IP protocols and supports RMI(Remote method invocation). Dynamic: Java can verify and resolve objects at runtime and updates the bytecode dynamically. This is one feature of called applet programming.

Importance of java to internet: Java supports two kinds of programming 1) Application programming & 2) Applet Programming. An applet is a small piece of executable code that can be transmitted over the internet and executed automatically in the java enabled web browser. It is not simply a sound or image file i.e. downloaded onto your system, but is an interactive program. This java enabled web browser will not allow the applet to open or interact with any other file on your hard disk. An applet will only interact with the server from which it is downloaded. Because of this kind of security provided by java, we can download an applet on to any kind of platform. Thus java became popular to internet.

Object oriented programming principles: The essential elements of object oriented programming are listed below:1) Class 2) Object 3) Encapsulation 4) Abstraction 5) Inheritance 6) Polymorphism Class & object : An Object is anything that is of some interest to an application under development. An object may represent an real time entity or an event. For Example in a banking application, an account holder is an object. Account holder name, account number, account balance etc are attributes and cash withdrawal, cash deposit are the operations. A class can be considered as the general description of an object. A class doesn’t exists in memory, but the objects created will exists in memory.

Ex: A class is like a blue print of a building and the object is its physical representation (the building itself). A class holds the data and the methods which operate on that data. In object oriented terminology data is referred as attributes and methods as operations. Encapsulation: The binding of data and the methods together, so that the external entities cannot modify the data is called encapsulation. In java a class encapsulates the data and methods by defining the data as private in the class. This is also defined as data hiding. Abstraction: This is one of the essential principle of OOP. Considering only the essential elements by eliminating the unnecessary things is called abstraction. For ex: When we use a car, we are not bothered about its inner alignment of the machine parts, but try to know about the gear, accelerator or break. Therefore the complexity involved in making a car reduced by knowing only the essential elements. Inheritance: The process of acquiring properties of one object for the purpose of the another object is called inheritance. The existing code is reused without rewriting it hence avoiding code redundancy. Polymorphism: Polymorphism means many forms. Ex: Car is a generic name for maruthi 800 or a wagoanR or Accent Hyundai. But each car has different specifications of speed, milage etc.

First Java Program: Save as “HelloWorld.java” class Helloworld { public static void main(String args[]){ System.out.println(“Hello World”); } } main is the method where from the execution starts. void- since main method doesn’t return anything it return type is void. static - a method can be called without an object if it is declared as static. public- main method should be public to be accessed outside the class. Execution: Save the given file as HelloWorld.java and open the command prompt.Type the below command Compiling command d:\javac HelloWorld.java

The compilation process will convert the program to the intermediate byte code file which has the extension .class. This file has to be interpreted by jvm to get the out. If any compile time errors will be displayed in the console. If no errors, the command prompt is ready for the next command . The run the program using the below command. Running command d:\java HelloWorld Output : Hello World

Data Types: Java defines both primitive and non-primitive datatypes. Java defines 8 primitive data types that are listed below. S.No 1. 2. 3. 4.

Data type byte - 8-bit signed integer short - 16-bit signed integer int - 32-bit signed integer long - 64-bit signed integer

5. 6. 7. 8.

char - 16-bit Unicode float - 32-bit floating point double - 64-bit floating point boolean- either ture/false 1) 2) 3) 4) 5) 6) 7) 8)

byte short int long char float double Boolean

-

Value Range -128 to 127 -32,768 to 62,767 -2,147,483,648 to 2,147,483,647 -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807 0 to 65536 1.4e-045 to 3.4e+038 4.9e-324 to 1.8e+308

8-bit signed integer 16-bit signed integer 32-bit signed integer 64-bit signed integer 16-bit unicode 32-bit floating point 64-bit floating point either true/false

The non-primitive data types are class, array, Strings etc.

Variables: The unit of storage which can modify its data anytime during the execution of the program are called variables. Syntax of declaring a variable: Type identifier [=value][, identifier[=value]…]; Ex: int total = 449;

int value1,value2 = 100; Here the type can java primitive data type or name of a class or an interface. Dynamic Initialization: Initializing a variable with the value that is computed during the runtime. Ex: double percentage = (sum/total) * 100 ; Here the value of the variable percentage is assigned only after computing the right hand side equation at runtime. The Scope and lifetime of variables: The scope of a variable is defined as the accessibility of a variable . The variables have the block scope i.e. they are accessible from the line of their declaration to the end the its block. The block is defined as the statements between the two curly braces { }. Ex: VariableScope.java Line 1 : class VariableScope{ 2 public static void main(String args[]){ 3 double height = 20; 4 if( height != 0){ 5 double base = height / 2; 6 } 7 } 8 } The scope of the variable height is from line no. 3 to 7. The scope of the variable base is from line no. 5 to 6. Lifetime of a variable: The lifetime of a variable is the interval of time for which the variable exists; i.e. the time from when it is created to when it is destroyed It is common to find confusion between scope and lifetime - though they are in cases related, they are entirely different notions: lifetime is to do with a period of time during the execution of a program, scope is to do with which parts of a program text. In Java, lifetime is dynamic - you must execute the program (or do so in a thought experiment) in order to determine it. Scope is static - determinable at compile time, or by reading the program text. Ex: VariableLifeTime.java Line 1 : class VariableLifeTime{ 2 public static void main(String args[]){ 3 VariableLifeTime ob = new VariableLifeTime(); 4 ob.calc(); 5 }

6 public void calc(){ 7 double height = 20; 8 if( height != 0){ 9 double base = height / 2; 10 } 11 } 12 } The lifetime of the variables height and base are only during the calc() method execution.

Arrays: An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed. Each item in an array is called an element, and each element is accessed by its numerical index. Note: Array indexes start with 0. One dimensional array:Syntax: type[] arrayName; ( type arrayName[]; is also valid ) arrayName = new type[size]; (or) type[] arrayName = new type[size]; Ex: Save as ArrayDemo.java class ArrayDemo { public static void main(String[] args) { int[] anArray; // declares an array of integers anArray = new int[5];

// allocates memory for 10 integers

anArray[0] = 100; // initialize first element anArray[1] = 200; // initialize second element anArray[2] = 300; // etc. anArray[3] = 400; anArray[4] = 500; System.out.println("Element at index 0: " + anArray[0]); System.out.println("Element at index 1: " + anArray[1]); System.out.println("Element at index 2: " + anArray[2]); System.out.println("Element at index 3: " + anArray[3]); System.out.println("Element at index 4: " + anArray[4]); } }

Multidimensional arrays:-A multidimensional array is an array whose components are themselves arrays. If we have the marks table of some students for three subjects.

Student1 Student2 Student3

sub1

sub2

sub3

10 30 50

20 40 60

30 50 70

And we need to calculate the sum of all three subjects of each student. To do this we add row[0]col[0] +row[0]col[1]+row[0]col[2] . similarly for the remaining row the addition should be done. Syntax:type[][] arrayName; ( type arrayName[][]; is also valid ) arrayName = new type[rows][cols]; (or) type[][] arrayName = new type[rows][cols]; 1) int marksArray[][] = new int[3][3]; 2) int array[][] = new int[3][]; array[0] = new int[3]; array[1]=new int[2]; array[2]=new int[4]; Ex: MultidimentionalArray.java class MultidimentionalArray{ public static void main(String args[]){ int marksArray[][] = { {10,20,30 }, {30,40,50 }, {50,60,70} }; int sumArray[][] = new int[3][1]; for( int =0 ; i < 3; i++){ for (int j= 0;j<3;j++)

} } }

Operators in java: Operators in java are classified as follows. 1) Arithmetic operators. 2) Relational operators. 3) Logical operators. 4) Assignment operators & Assignment arithmetic operators. 5) Increment & decrement operators. 6) Bitwise & shift operators Arithmetic operators: + addition subtraction * multiplication / division % remainder or mod operator. Relational Operators: < less than <= lesser than equal to > greater than >= greater than equal to == equal to != not equal to Logical Operators: && logical and !! logical or ! not operator Assignment Operators: = assignment operator Assigns the value on the right of = to the variable on the left Assignment arithmetic operators: += (Ex: a+=2 is same as a= a+2) -= (Ex: a-=2 is same as a= a-2) *= (Ex: a*=2 is same as a= a*2) /= (Ex: a/=2 is same as a= a/2) %= (Ex: a%=2 is same as a= a%2) Increment & Decrement operators: ++ pre/post increment operators -- pre/post decrement operators Ex: int a = 2 ; System.out.println( a++ ); // prints 3

a = 2; System.out.println( ++a ); // prints 2 System.out.println( a ); // prints 3 Similarly decrement operators works by decreasing the value by 1. Bitwise & shift Operators: & bitwise AND ^ bitwise exclusive OR | bitwise inclusive OR ~ Unary bitwise complement << Signed left shift >> Signed right shift >>> Unsigned right shift Ex: Save as BitwiseANDDemo.java class BitwiseANDDemo { public static void main(String[] args) { int bitmask = 0x000F; int val = 0x2222; System.out.println(val & bitmask); // prints "2" } } Operator Precedence: The operators in java have precedence over one other. The equations in java should be calculated using the operator precedence. The below is the precedence table listed. Operators

Precedence

postfix

expr++ expr--

unary

++expr --expr +expr -expr ~ !

multiplicative

* / %

additive

+ -

shift

<< >> >>>

relational

< > <= >= instanceof

equality

== !=

bitwise AND

&

bitwise exclusive ^

OR bitwise inclusive | OR logical AND

&&

logical OR

||

ternary

? :

assignment

= += -= *= /= %= &= ^= |= <<= >>= >>>=

Control Statements: Control flow statements, however, break up the flow of execution by employing decision making, looping, and branching, enabling your program to conditionally execute particular blocks of code. The control statements can be classified into the following: 1) Selection statements 2) Iterative statements 3) Break or jump statements. Selection statements: The selection statements will control the flow of execution based on the condition evaluated to the Boolean value. a) if b) if else c) else if ladder d) switch simple if: Simple if is a single selection statement. This statement executes the statements in its block one time only if the given condition is true. Ex: if(age<0){ System.out.println(“Age less than zero is invalid age”); } If the age = -1 then the statement “Age less than zero is invalid age” will be printed. If else statement: This is a double selection statement. Ex: if(age<0){ System.out.println(“Age less than zero is invalid age”); }else{ System.out.println(“Valid age , accept application”); } If age = -1 then “Age less than zero is invalid age” will be printed else “Valid age , accept application” will be printed. Else if ladder: This is a multiple selection statement. Ex: if( day ==1){

System.out.println(“Monday”); }else if( day == 2){ System.out.println(“Tuesday”); }else if( day ==3){ System.out.println(“Wednesday”); }else if( day ==4){ System.out.println(“Thursday”); }else if( day ==5){ System.out.println(“Friday”); }else if( day ==6){ System.out.println(“Saturday”); }else{ System.out.println(“Sunday”); } If any one of the If condition is true executes the statements in that block and control comes out without checking the other if statements. Switch statement : This is also a multiple selection statement and works similar to the else if ladder. switch(day){ case 1: System.out.println(“Monday”); break; case 2: System.out.println(“Tuesday”); break; case 3: . . . default: System.out.println(“Sunday”); } Every case statement should be ended by a break statement else the remaining statements also will be executed. Ex: if day = 2 , statements in case 2 will be executed and will also execute case 3, 4… if break statement is missing after case 2. Iterative statements: The iterative statements will control the flow of execution by looping through the statements until the terminate condition is met. a) for loop b) while loop c) do-while The for statement : The statements within this loop will be iterated until the termination condition is met Syntax: for (initialization; termination; increment) { statement(s)

} When using this version of the for statement, • The initialization expression initializes the loop; it's executed once, as the loop begins. • When the termination expression evaluates to false, the loop terminates. • The increment expression is invoked after each iteration through the loop; it is perfectly acceptable for this expression to increment or decrement a value.

Ex: class ForDemo{ public static void main(String[] args){ int marks[] = { 20, 27, 24, 22, 21}; for(int i=0; i< marks.length ; i++){ System.out.println(“Marks “+ (i+1) + “ “ +marks[i]); } } } while loop: The while statement continually executes a block of statements while a particular condition is true. Syntax: while (expression) { statement(s) } The while statement evaluates expression, which must return a boolean value. If the expression evaluates to true, the while statement executes the statement(s) in the while block. The while statement continues testing the expression and executing its block until the expression evaluates to false Ex: class WhileDemo{ public static void main(String[] args){ int marks[] = { 20, 27, 24, 22, 21}; int length = marks.length; while(length>0){ System.out.println(“Marks “+ (i+1) + “ “ +marks[i]); length-=1; } } } do- while statement: The Java programming language also provides a do-while statement, which can be expressed as follows:

Syntax: do { statement(s) } while (expression); The difference between do-while and while is that do-while evaluates its expression at the bottom of the loop instead of the top. Therefore, the statements within the do block are always executed at least once Ex: class DoWhileDemo{ public static void main(String[] args){ int marks[] = { 20, 27, 24, 22, 21}; int length = marks.length; do{ System.out.println(“Marks “+ (i+1) + “ “ +marks[i]); length-=1; } while(length>0); } } Jump or breaking statements: The jump statements will control the flow of execution by transferring the control from the current line to some other part of the program a) break statement b) continue statement c) return statement Ex: Save as BreakDemo.java class BreakDemo { public static void main(String[] args) { double temperature = 10; for (int i = 0; ; i++) { if (temperature > 100) break; temperature+=6; } System.out.println("temperature " + temperature); } } Ex: Save as ContinueDemo.java class ContinueDemo { public static void main(String[] args) { double temperature = 10; for (int i = 0; ; i++) { temperature+=6;

if (temperature < 100) continue; } System.out.println("temperature " + temperature); } } Ex: Save as ReturnDemo.java class ReturnDemo { public static void main(String[] args) { double temperature = 10; double temp = checkTemperature(temperature); System.out.println("temperature " + temp); } void checkTemperature(){ for (int i = 0; ; i++) { if (temperature > 100) return temperature; temperature+=6; } return –1; } }

Type Conversion and casting: Java automatically converts one data type to another type when both the types are compatible and destination type is larger than the source type. This is called automatic type conversion. Ex: int a=5; long l = a; (long and int are compatible data types) This is also called widening conersion. The floating point and the integer types are compatible data types, where Boolean and char are not. The process of converting a one data type to another where the destination type is smaller than the source type. This type of conversion is called narrowing conversion and cannot be done automatically. Ex: int a = 2; short s = a;

Casting: Using explicit casting we can type convert the incompatible data types. This explicit type conversion is called type casting. Ex: float fVal = 3.5; int a = (int)fVal; System.out.println(a); // prints 3 When trying to type cast floating point numbers to integers, the decimal value gets truncated and there will a loss of precision.