Introduction to java programming language

INDEX
UNIT 1 PPT SLIDES
 History of Java,
 Java buzzwords, data types.
 variables, scope and life time of variables,
 arrays, operators, expressions
 control statements,
 type conversion and costing

L 1.1
Java History
• Computer language innovation and development
occurs for two fundamental reasons:
1) to adapt to changing environments and uses
2) to implement improvements in the art of
programming
• The development of Java was driven by both in equal
measures.
• Many Java features are inherited from the earlier
languages:
B  C  C++  Java

L 1.2
Before Java: C
• Designed by Dennis Ritchie in 1970s.
• Before C: BASIC, COBOL, FORTRAN, PASCAL
• C- structured, efficient, high-level language that could
replace assembly code when creating systems
programs.
• Designed, implemented and tested by programmers.

L 1.3
Before Java: C++
• Designed by Bjarne Stroustrup in 1979.
• Response to the increased complexity of programs and
respective improvements in the programming
paradigms and methods:
1) assembler languages
2) high-level languages
3) structured programming
4) object-oriented programming (OOP)
• OOP – methodology that helps organize complex
programs through the use of inheritance,
encapsulation and polymorphism.
• C++ extends C by adding object-oriented features.

L 1.4
Java: History
• In 1990, Sun Microsystems started a project called
Green.
• Objective: to develop software for consumer electronics.
• Project was assigned to James Gosling, a veteran of
classic network software design. Others included Patrick
Naughton, ChrisWarth, Ed Frank, and Mike Sheridan.
• The team started writing programs in C++ for embedding
into
– toasters
– washing machines
– VCR’s
• Aim was to make these appliances more “intelligent”.

L 1.5
Java: History (contd.)
• C++ is powerful, but also dangerous. The power and popularity of C
derived from the extensive use of pointers. However, any incorrect
use of pointers can cause memory leaks, leading the program to
crash.
• In a complex program, such memory leaks are often hard to detect.
• Robustness is essential. Users have come to expect that Windows
may crash or that a program running under Windows may crash.
(“This program has performed an illegal operation and will be shut
down”)
• However, users do not expect toasters to crash, or washing
machines to crash.
• A design for consumer electronics has to be robust.
• Replacing pointers by references, and automating memory
management was the proposed solution.

L 1.6
Java: History (contd.)
• Hence, the team built a new programming language called Oak,
which avoided potentially dangerous constructs in C++, such as
pointers, pointer arithmetic, operator overloading etc.
• Introduced automatic memory management, freeing the
programmer to concentrate on other things.
• Architecture neutrality (Platform independence)
• Many different CPU’s are used as controllers. Hardware chips
are evolving rapidly. As better chips become available, older
chips become obsolete and their production is stopped.
Manufacturers of toasters and washing machines would like to
use the chips available off the shelf, and would not like to
reinvest in compiler development every two-three years.
• So, the software and programming language had to be
architecture neutral.

L 1.7
Java: History (contd)
• It was soon realized that these design goals of consumer electronics
perfectly suited an ideal programming language for the Internet and WWW,
which should be:
 object-oriented (& support GUI)
– robust
– architecture neutral
• Internet programming presented a BIG business opportunity. Much bigger
than programming for consumer electronics.
• Java was “re-targeted” for the Internet
• The team was expanded to include Bill Joy (developer of Unix), Arthur van
Hoff, Jonathan Payne, Frank Yellin, Tim Lindholm etc.
• In 1994, an early web browser called WebRunner was written in Oak.
WebRunner was later renamed HotJava.
• In 1995, Oak was renamed Java.
• A common story is that the name Java relates to the place from where the
development team got its coffee. The name Java survived the trade mark
search.

L 1.8
Java History
• Designed by James Gosling, Patrick Naughton, Chris
Warth, Ed Frank and Mike Sheridan at Sun
Microsystems in 1991.
• The original motivation is not Internet: platform-
independent software embedded in consumer
electronics devices.
• With Internet, the urgent need appeared to break the
fortified positions of Intel, Macintosh and Unix
programmer communities.
• Java as an “Internet version of C++”? No.
• Java was not designed to replace C++, but to solve a
different set of problems.

L 1.9
The Java Buzzwords
• The key considerations were summed up by the Java
team in the following list of buzzwords:
 Simple
 Secure
 Portable
 Object-oriented
 Robust
 Multithreaded
 Architecture-neutral
 Interpreted
 High performance
 Distributed
 Dynamic

L 1.10
• simple – Java is designed to be easy for the professional
programmer to learn and use.
• object-oriented: a clean, usable, pragmatic approach to
objects, not restricted by the need for compatibility with
other languages.
• Robust: restricts the programmer to find the mistakes
early, performs compile-time (strong typing) and run-time
(exception-handling) checks, manages memory
automatically.
• Multithreaded: supports multi-threaded programming for
writing program that perform concurrent computations

L 1.11
• Architecture-neutral: Java Virtual Machine
provides a platform independent environment for the
execution of Java byte code
• Interpreted and high-performance: Java
programs are compiled into an intermediate
representation – byte code:
a) can be later interpreted by any JVM
b) can be also translated into the native machine
code for efficiency.

L 1.12
• Distributed: Java handles TCP/IP protocols,
accessing a resource through its URL much like
accessing a local file.
• Dynamic: substantial amounts of run-time type
information to verify and resolve access to
objects at run-time.
• Secure: programs are confined to the Java
execution environment and cannot access other
parts of the computer.

L 1.13
• Portability: Many types of computers and
operating systems are in use throughout the
world—and many are connected to the Internet.
• For programs to be dynamically downloaded to
all the various types of platforms connected to
the Internet, some means of generating portable
executable code is needed. The same
mechanism that helps ensure security also helps
create portability.
• Indeed, Java's solution to these two problems is
both elegant and efficient.

L 1.14
Data Types
• Java defines eight simple types:
1)byte – 8-bit integer type
2)short – 16-bit integer type
3)int – 32-bit integer type
4)long – 64-bit integer type
5)float – 32-bit floating-point type
6)double – 64-bit floating-point type
7)char – symbols in a character set
8)boolean – logical values true and false

L 1.15
• byte: 8-bit integer type.
Range: -128 to 127.
Example: byte b = -15;
Usage: particularly when working with data
streams.
• short: 16-bit integer type.
Range: -32768 to 32767.
Example: short c = 1000;
Usage: probably the least used simple type.

L 1.16
• int: 32-bit integer type.
Range: -2147483648 to 2147483647.
Example: int b = -50000;
Usage:
1) Most common integer type.
2) Typically used to control loops and to index
arrays.
3) Expressions involving the byte, short and int
values are promoted to int before calculation.

L 1.17
• long: 64-bit integer type.
Range: -9223372036854775808 to
9223372036854775807.
Example: long l = 10000000000000000;
Usage: 1) useful when int type is not large enough to hold the
desired value
• float: 32-bit floating-point number.
Range: 1.4e-045 to 3.4e+038.
Example: float f = 1.5;
Usage:
1) fractional part is needed
2) large degree of precision is not required

L 1.18
• double: 64-bit floating-point number.
Range: 4.9e-324 to 1.8e+308.
Example: double pi = 3.1416;
Usage:
1) accuracy over many iterative calculations
2) manipulation of large-valued numbers

L 1.19
char: 16-bit data type used to store characters.
Range: 0 to 65536.
Example: char c = ‘a’;
Usage:
1) Represents both ASCII and Unicode character
sets; Unicode defines a
character set with characters found in (almost) all
human languages.
2) Not the same as in C/C++ where char is 8-bit and
represents ASCII only.

L 1.20
• boolean: Two-valued type of logical values.
Range: values true and false.
Example: boolean b = (1<2);
Usage:
1) returned by relational operators, such as
1<2
2) required by branching expressions such
as if or for

L 2.1
Variables
• declaration – how to assign a type to a variable
• initialization – how to give an initial value to a variable
• scope – how the variable is visible to other parts of the
program
• lifetime – how the variable is created, used and destroyed
• type conversion – how Java handles automatic type
conversion
• type casting – how the type of a variable can be narrowed
down
• type promotion – how the type of a variable can be
expanded

L 2.2
Variables
• Java uses variables to store data.
• To allocate memory space for a variable JVM
requires:
1) to specify the data type of the variable
2) to associate an identifier with the variable
3) optionally, the variable may be assigned an
initial value
• All done as part of variable declaration.

L 2.3
Basic Variable Declaration
• datatype identifier [=value];
• datatype must be
– A simple datatype
– User defined datatype (class type)
• Identifier is a recognizable name confirm
to identifier rules
• Value is an optional initial value.

L 2.4
Variable Declaration
• We can declare several variables at the same time:
type identifier [=value][, identifier [=value] …];
Examples:
int a, b, c;
int d = 3, e, f = 5;
byte g = 22;
double pi = 3.14159;
char ch = 'x';

L 2.5
Variable Scope
• Scope determines the visibility of program elements with respect
to other program elements.
• In Java, scope is defined separately for classes and methods:
1) variables defined by a class have a global scope
2) variables defined by a method have a local scope
A scope is defined by a block:
{
…
}
A variable declared inside the scope is not visible outside:
{
int n;
}
n = 1;// this is illegal

L 2.6
Variable Lifetime
• Variables are created when their scope is
entered by control flow and destroyed when their
scope is left:
• A variable declared in a method will not hold its
value between different invocations of this
method.
• A variable declared in a block looses its value
when the block is left.
• Initialized in a block, a variable will be re-
initialized with every re-entry. Variables lifetime is
confined to its scope!

L 2.7
Arrays
• An array is a group of liked-typed variables referred to
by a common
• name, with individual variables accessed by their
index.
• Arrays are:
1) declared
2) created
3) initialized
4) used
• Also, arrays can have one or several dimensions.

L 2.8
Array Declaration
• Array declaration involves:
1) declaring an array identifier
2) declaring the number of dimensions
3) declaring the data type of the array elements
• Two styles of array declaration:
type array-variable[];
or
type [] array-variable;

L 2.9
Array Creation
• After declaration, no array actually exists.
• In order to create an array, we use the new
operator:
type array-variable[];
array-variable = new type[size];
• This creates a new array to hold size elements
of type type, which reference will be kept in the
variable array-variable.

L 2.10
Array Indexing
• Later we can refer to the elements of this
array through their indexes:
• array-variable[index]
• The array index always starts with zero!
• The Java run-time system makes sure that
all array indexes are in the correct range,
otherwise raises a run-time error.

L 2.11
Array Initialization
• Arrays can be initialized when they are declared:
• int monthDays[] =
{31,28,31,30,31,30,31,31,30,31,30,31};
• Note:
1) there is no need to use the new operator
2) the array is created large enough to hold all
specified elements

L 2.12
Multidimensional Arrays
• Multidimensional arrays are arrays of arrays:
1) declaration: int array[][];
2) creation: int array = new int[2][3];
3) initialization
int array[][] = { {1, 2, 3}, {4, 5, 6} };

L 2.13
Operators Types
• Java operators are used to build value
expressions.
• Java provides a rich set of operators:
1) assignment
2) arithmetic
3) relational
4) logical
5) bitwise

L 2.14
Arithmetic assignments
+= v += expr; v = v + expr ;
-= v -=expr; v = v - expr ;
*= v *= expr; v = v * expr ;
/= v /= expr; v = v / expr ;
%= v %= expr; v = v % expr ;

L 2.15
Basic Arithmetic Operators
+ op1 + op2 ADD
- op1 - op2 SUBSTRACT
* op1 * op2 MULTIPLY
/ op1 / op2 DIVISION
% op1 % op2 REMAINDER

L 2.16
Relational operator
== Equals to Apply to any type
!= Not equals to Apply to any type
> Greater than Apply to numerical type
< Less than Apply to numerical type
>= Greater than or equal Apply to numerical type
<= Less than or equal Apply to numerical type

L 2.17
Logical operators
& op1 & op2 Logical AND
| op1 | op2 Logical OR
&& op1 && op2 Short-circuit
AND
|| op1 || op2 Short-circuit OR
! ! op Logical NOT
^ op1 ^ op2 Logical XOR

L 2.18
Bit wise operators
~ ~op Inverts all bits
& op1 & op2 Produces 1 bit if both operands are 1
| op1 |op2 Produces 1 bit if either operand is 1
^ op1 ^ op2 Produces 1 bit if exactly one operand is 1
>> op1 >> op2 Shifts all bits in op1 right by the value of
op2
<< op1 << op2 Shifts all bits in op1 left by the value of
op2

L 2.19
• An expression is a construct made up of variables,
operators, and method invocations, which are
constructed according to the syntax of the language, that
evaluates to a single value.
• Examples of expressions are in bold below:
int number = 0;
anArray[0] = 100;
System.out.println ("Element 1 at index 0: " +
anArray[0]);
int result = 1 + 2; // result is now 3 if(value1 ==
value2)
System.out.println("value1 == value2");
Expressions

L 2.20
Expressions
• The data type of the value returned by an expression depends on the
elements used in the expression.
• The expression number = 0 returns an int because the assignment
operator returns a value of the same data type as its left-hand operand;
in this case, number is an int.
• As you can see from the other expressions, an expression can return
other types of values as well, such as boolean or String.
• The Java programming language allows you to construct compound
expressions from various smaller expressions as long as the data type
required by one part of the expression matches the data type of the
other.
• Here's an example of a compound expression: 1 * 2 * 3

L 3.1
Control Statements
• Java control statements cause the flow of execution
to advance and branch based on the changes to the
state of the program.
• Control statements are divided into three groups:
• 1) selection statements allow the program to choose
different parts of the execution based on the
outcome of an expression
• 2) iteration statements enable program execution to
repeat one or more statements
• 3) jump statements enable your program to execute
in a non-linear fashion

L 3.2
Selection Statements
• Java selection statements allow to control the
flow of program’s execution based upon
conditions known only during run-time.
• Java provides four selection statements:
1) if
2) if-else
3) if-else-if
4) switch

L 3.3
Iteration Statements
• Java iteration statements enable repeated
execution of part of a program until a certain
termination condition becomes true.
• Java provides three iteration statements:
1) while
2) do-while
3) for

L 3.4
Jump Statements
• Java jump statements enable transfer of
control to other parts of program.
• Java provides three jump statements:
1) break
2) continue
3) return
• In addition, Java supports exception
handling that can also alter the control flow
of a program.

L 3.5
Type Conversion
• Size Direction of Data Type
– Widening Type Conversion (Casting down)
• Smaller Data Type  Larger Data Type
– Narrowing Type Conversion (Casting up)
• Larger Data Type  Smaller Data Type
• Conversion done in two ways
– Implicit type conversion
• Carried out by compiler automatically
– Explicit type conversion
• Carried out by programmer using casting

L 3.6
Type Conversion
• Widening Type Converstion
– Implicit conversion by compiler automatically
byte -> short, int, long, float, double
short -> int, long, float, double
char -> int, long, float, double
int -> long, float, double
long -> float, double
float -> double

L 3.7
Type Conversion
• Narrowing Type Conversion
– Programmer should describe the conversion
explicitly
byte -> char
short -> byte, char
char -> byte, short
int -> byte, short, char
long -> byte, short, char, int
float -> byte, short, char, int, long
double -> byte, short, char, int, long, float

L 3.8
Type Conversion
• byte and short are always promoted to int
• if one operand is long, the whole
expression is promoted to long
• if one operand is float, the entire
expression is promoted to float
• if any operand is double, the result is
double

L 3.9
Type Casting
• General form: (targetType) value
• Examples:
• 1) integer value will be reduced module
bytes range:
int i;
byte b = (byte) i;
• 2) floating-point value will be truncated to
integer value:
float f;
int i = (int) f;

4.1
Simple Java Program
• A class to display a simple message:
class MyProgram
{
public static void main(String[] args)
{
System.out.println(“First Java program.");
}
}

L 6.8
finalize() Method
• A constructor helps to initialize an object just
after it has been created.
• In contrast, the finalize method is invoked just
before the object is destroyed:
• 1) implemented inside a class as:
protected void finalize() { … }
• 2) implemented when the usual way of removing
objects from memory is insufficient, and some
special actions has to be carried out

L 7.1
Method Overloading
• It is legal for a class to have two or more
methods with the same name.
• However, Java has to be able to uniquely
associate the invocation of a method with its
definition relying on the number and types of
arguments.
• Therefore the same-named methods must be
distinguished:
• 1) by the number of arguments, or
• 2) by the types of arguments
• Overloading and inheritance are two ways to
implement polymorphism.

L 7.2
Example: Overloading
class OverloadDemo {
void test() {
System.out.println("No parameters");
}
void test(int a) {
System.out.println("a: " + a);
}
void test(int a, int b) {
System.out.println("a and b: " + a + " " + b);
}
double test(double a) {
System.out.println("double a: " + a); return a*a;
}
}

L 7.3
Constructor Overloading
class Box {
double width, height, depth;
Box(double w, double h, double d) {
width = w; height = h; depth = d;
}
Box() {
width = -1; height = -1; depth = -1;
}
Box(double len) {
width = height = depth = len;
}
double volume() { return width * height * depth; }
}

L 7.4
Parameter Passing
• Two types of variables:
1) simple types
2) class types
• Two corresponding ways of how the arguments
are passed to methods:
• 1) by value a method receives a cope of the
original value; parameters of simple types
• 2) by reference a method receives the memory
address of the original value, not the value itself;
parameters of class types

L 7.5
Call by value
class CallByValue {
public static void main(String args[]) {
Test ob = new Test();
int a = 15, b = 20;
System.out.print("a and b before call: “);
System.out.println(a + " " + b);
ob.meth(a, b);
System.out.print("a and b after call: ");
System.out.println(a + " " + b);
}
}

L 7.6
Call by refference
• As the parameter hold the same address as the argument,
changes to the object inside the method do affect the object
used by the argument:
class CallByRef {
Test ob = new Test(15, 20);
System.out.print("ob.a and ob.b before call: “);
System.out.println(ob.a + " " + ob.b);
ob.meth(ob);
System.out.print("ob.a and ob.b after call: ");
System.out.println(ob.a + " " + ob.b);
}
}

L 8.1
Recursion
• A recursive method is a method that calls itself:
1) all method parameters and local variables are
allocated on the stack
2) arguments are prepared in the corresponding
parameter positions
3) the method code is executed for the new
arguments
4) upon return, all parameters and variables are
removed from the stack
5) the execution continues immediately after the
invocation point

L 8.2
Example: Recursion
class Factorial {
int fact(int n) {
if (n==1) return 1;
return fact(n-1) * n;
}
}
class Recursion {
Factorial f = new Factorial();
System.out.print("Factorial of 5 is ");
System.out.println(f.fact(5));
} }

L 8.3
String Handling
• String is probably the most commonly used class in
Java's class library. The obvious reason for this is
that strings are a very important part of programming.
• The first thing to understand about strings is that
every string you create is actually an object of type
String. Even string constants are actually String
objects.
• For example, in the statement
System.out.println("This is a String, too");
the string "This is a String, too" is a String constant

L 8.4
• Java defines one operator for String objects:
+.
• It is used to concatenate two strings. For
example, this statement
• String myString = "I" + " like " + "Java.";
results in myString containing
"I like Java."

L 8.5
• The String class contains several methods that you can
use. Here are a few. You can
• test two strings for equality by using
equals( ). You can obtain the length of a string by calling
the length( ) method. You can obtain the character at a
specified index within a string by calling charAt( ). The
general forms of these three methods are shown here:
• // Demonstrating some String methods.
class StringDemo2 {
String strOb1 = "First String";
String strOb2 = "Second String";
String strOb3 = strOb1;
System.out.println("Length of strOb1: " +
strOb1.length());

L 8.6
System.out.println ("Char at index 3 in strOb1: " +
strOb1.charAt(3));
if(strOb1.equals(strOb2))
System.out.println("strOb1 == strOb2");
else
System.out.println("strOb1 != strOb2");
if(strOb1.equals(strOb3))
System.out.println("strOb1 == strOb3");
else
System.out.println("strOb1 != strOb3");
} }
This program generates the following output:
Length of strOb1: 12
Char at index 3 in strOb1: s
strOb1 != strOb2
strOb1 == strOb3

Introduction to java programming language

More Related Content

Similar to Introduction to java programming language

More from RahulBhole12

Recently uploaded

Introduction to java programming language