Lecture 1: Overview of Java

Object Oriented Languages??

Object Oriented Languages are based upon
Classes and Objects.
Helps us to create Real World Applications
very easily

Javas History
Developed by Sun Microsystems (James Gosling)

A general-purpose object-oriented language

Oak - In 1991
Java - In 1995
Hot Java First Java Enabled Browser
Netscape Navigator In 1995 to incorporate Java
Technology

Based on C/C++
Designed for easy Web/Internet applications
3

Javas Magic : Byte Code

The key that allows java to solve both the
security and the portability problems
Compiler
(Javac)

JVM

Source Code

Byte Code

(Java Run
Time
Environmen
t)

Output

Java Program

Java Compiler

Source code

Byte code

Virtual machine
Byte Code

Java Interpreter

Virtual Machine

Machine code

Real Machine

Byte Code
Translating a java program into bytecode helps
makes it much easier to run a program in a
wide variety of environments.
Byte Code is interpreted (which helps to make
it secure)
Interpretation is slower but the use of
bytecode enables the java run-time system to
execute programs much faster than you might
expect.
6

Java Class Lifecycle

Java Virtual Machine (JVM)

Source File
(.java)

ClassLoader

Compiler
(javac)

Bytecode Verifier

Interpreter

Class File
(.class)
Network
or
File System

= security gateway

Security Manager

Operating System

Java Features
Complied and interpreted
java compiler generate byte-codes, not native machine code
the compiled byte-codes are platform-independent
java byte codes are translated on the fly to machine readable
instructions in runtime (Java Virtual Machine)

Platform independent and Portable

the sizes of the primitive data types are machine independent
Java compiler generates byte code instructions that can be
implemented on any machine

 Object oriented
focus on the data (objects) and methods manipulating the data
all functions are associated with objects
potentially better code organization and reuse

Simple
fixes some clumsy features of C++
no pointers
automatic garbage collection

Multithreaded and Interactive

Handles multiple tasks simultaneously

Distributed
9

 Reliable
extensive compile-time and runtime error checking
no pointers. Memory corruptions or unauthorized memory accesses
are impossible
automatic garbage collection tracks objects usage over time

Secure
No Pointers
Byte Code Verifier

10

Java and C
Java does not include the C unique statement
keywords sizeof and typedef
Does not contain data type struct and union
Does not define the type modifier keywords Auto,
extern, register
Does not support an explicit pointer type
Does not have a pre-processor and therefore we
can not use #define, #include statement
Java requires that the function with no arguments
must be declared with empty parentheses and not
with void keyword as done in C
11

Java and C++

Java does not support operator overloading
Does not have template classes as in C++
Does not support multiple inheritance. This is
accomplished using a new feature called interface
Does not support global variables. Every variable and
method is declared within a class and forms part of
that class
Does not use pointers
Java has replaced the destructor function with the
finalize() function
There are no header files in java
12

C++

Java

Overlapping of C, C++, and JAVA

13

Two ways of
using Java

Java Source
code

Java Compiler
Applet type

Application type

Java enabled
Web
browser

Java
Interpreter

Output

Output

14

Language basics (1)

Data types
8 primitive types:
boolean, byte, short, int, long, float, double, char

Class types, either provided by Java, or made by programmers

String, Integer, Array, Frame, Object, Person, Animal,

Array types

Variables
dataType identifier [ = Expression]:
Example variable declarations and initializations:
int x; x=5;
boolean b = true;
String x = how are you?;

Data types in java

Primitive
(intrinsic))

Numeric

Non-Primitive
(Derived)

Classes)

Non
Numeric

Boolean

Integer

Arrays)

Interface)

Character
16

Comments
English text scattered through the code are
comments
JAVA supports 3 types of comments
/* */ - Usually used from multi-line
comments
// - Used for single line comments
/** */ - Documentation comments

Language basics (2)

Flow of control

if, if-else, if-else if

switch
for, while, do-while
break
continue

 while loop
while (squared <= MAX) {
squared = lo * lo; // Calculate square
System.out.println(squared);
lo = lo + 1; /* Compute the new lo value */
}

 for loop
for (int i = 1; i < MAX; i++) {
System.out.println(i); // prints 1 2 3 4 5
}

 do-while loop
do {
squared = lo * lo; // Calculate square
System.out.println(squared);
lo = lo + 1; /* Compute the new lo value */
} while (squared <= MAX);

 if-else loop
if ( i < 10) {
System.out.println(i is less than 10 );
}
else {
System.out.println(i is greater than or equal to 10);
}

 switch statement
switch (c) {
case a:
System.out.println ( The character is a );
break;
case b:
System.out.println ( The character is b );
break;
default:
System.out.println ( The character is not a or
b );
break;
}

Getting Started: (1)

(1) Create the source file:
open a text editor, type in the code which defines a class
(HelloWorldApp) and then save it in a file (HelloWorldApp.java)
file and class name are case sensitive and must be matched exactly
(except the .java part)
Example Code: HelloWorldApp.java
public class HelloWorldApp
{
public static void main(String[] args)
{
// Display "Hello World!"
System.out.println("Hello World!");
}
}

Java

is CASE SENSITIVE!

24

 public: The keyword public is an access

specifier that declares the main method as
unprotected.
static: It says this method belongs to the entire
class and NOT a part of any objects of class. The
main must always be declared static since the
interpreter uses this before any objects are
created.
void: The type modifier that states that main
does not return any value.

Hello World: Java and C

S1: // HelloWorld.java: Hello World program
S2: import java.lang.*;
S3: class HelloWorld

public static void main(String args[])

{
System.out.println(Hello World);
}

S4:
S5:

/* helloworld.c: Hello World program*/

#define <stdio.h>
void main()
{
printf(Hello World\n);
}

Getting Started: (2)

(2) Compile the program:
compile HelloWorldApp.java by using the following command:
javac HelloWorldApp.java

it generates a file named HelloWorldApp.class

27

Getting Started: (3)

(3) Run the program:

run the code through:
java HelloWorldApp

Note that the command is java, not javac, and you refer to
HelloWorldApp, not HelloWorldApp.java or
HelloWorldApp. Class

28

Manav Rachna College of Engg.

Reading Data into the program

Data can be taken into the program using
two methods
Interactive Mode
Command Line or Non-interactive Mode

Interactive mode can be used using two

kind of classes
Scanner class of java.util package

BufferedReader class of java.io package

29

Manav Rachna College of Engg.

Giving input to java source code

Scanner
First create an object of Scanner class and provide the place from where to read the
data
Scanner sc=new Scanner(System.in);
Methods of Scanner class

int nextInt()

String next()

double nextDouble()

Using BufferedReader class

Data is passed by the keyboard (system.in) to another class
InputStreamReader to convert the data into character form
The characters are passed for buffering to BufferedReader class
Use readLine() method of BufferedReader class to read data from
temporary buffer area
InputStreamReader isr=new InputStreamReader(System.in);
BufferedReader br=new BufferedReader(isr);
System.out.print(Enter Name : );
String name=br.readLine();

31

Manav Rachna College of Engg.

Arrays in java

 An array is a list of similar things

An array has a fixed:
name
type
length

These must be declared when the array is

created.
Arrays sizes cannot be changed during the
execution of the code

myArray =

myArray has room for 8 elements

the elements are accessed by their index
in Java, array indices start at 0

Declaring Arrays
int myArray[];
declares myArray to be an array of integers
myArray = new int[8];
sets up 8 integer-sized spaces in memory,
labelled myArray[0] to myArray[7]
int myArray[] = new int[8];
combines the two statements in one line

Assigning Values
refer to the array elements by index to
store values in them.
myArray[0] = 3;
myArray[1] = 6;
myArray[2] = 3; ...

can create and initialise in one step:

int myArray[] = {3, 6, 3, 1, 6, 3, 4, 1};

int[] foo = {1,2,3,4,5};

String[] names = {Joe, Sam};

Arrays of Objects
So far we have looked at an array of
primitive types.
integers
could also use doubles, floats, characters

Often want to have an array of objects

Students, Books, Loans

Need to follow 3 steps.

Declaring the Array

1. Declare the array
Student s[];

this declares s as an object

2 .Create the array

s[] = new Student[10];
this sets up 10 spaces in memory that can hold
references to Student objects

3. Create Student objects and add them to

the array: s[0] = new Student();

2-Dimensional Arrays
Declaration
int myArray[] [];
myArray=new int[3][4];
or
int myarray[][]=new int[3][4];

Arrays Length
Arrays are fixed length
Length is specified at create time
In java, all arrays store the allocated size
in a variable named length.
We can access the length of arrays as
arrayName.length:
e.g. int x = students.length();

// x = 7

Strings in java

Strings represent a sequence of characters. The

easiest way to represent a sequence of characters
in java is by using a character array.

Example:
Char charArray[]=new char[4];
charArray*0+=j;
charArray*1+=a;
charArray*2+=v;
charArray*3+=a;

Strings may be declared and created as follows :

String stringName;
stringName=new String(string);
Eg:
String firstname;
firstname=new String(Anil);
or
String firstname=new String(anil);

Like arrays, it is possible to get the length of

string using the length method of String class
int m=firstname.length();

Java strings can be concatenated using the +

Operator. Eg,
String fullName=name1+name2;
String city1=new +delhi;

String arrays
We can create and use arrays that contain strings.
The statement:

String itemArray[]=new String[3];

Will create an itemArray of size 3 to hold three string
constants

String methods
String class defines a number of methods that allow
us to
accomplish a variety of string manipulation tasks

S2=s1.toLowerCase;
// converts string s1 to lowercase
S2=s1.toUpperCase;
// converts string s1 to uppercase
S2=s1.replace(x, y); // replace all appearance of x with y
S1.equals(s2);
// returns true if s1 is equal to s2
S1.equalsIgnoreCase(s2); // returns true if s1=s2 ignoring case
S1.length();
// gives length of s1
S1.charAt(n);
// gives nth character of s1
S1.compareTo(s2) // returns ve if s1<s2, +ve if s1>s2 and 0 if
s1=s2
S1.concat(s2)
// concatenates s1 and s2