BTCS0205

OBJECT ORIENTED PROGRAMMING USING JAVA

BASICS OF JAVA &

OBJECT ORIENTED PROGRAMMING

ANKIT JAIN
COURSE INTRODUCTION
FACULTY INTRODUCTION

Instructor:
• Ankit Jain
• ankit.jain@suas.ac.in
• +91-7709285065
COURSE INTRODUCTION

• Java as a second language course

• Teaches programming in Java for people who already
know how to program in C or similar language
• Pre-requisites
• Basic programming background (C/C++/Pascal)
• Problem solving techniques
• Debugging skills
• Basic object-oriented concepts and web technology
• Flavor
• A hands-on course for practitioners
• Requires considerable hands-on development time.
 SYLLABUS
Sr. Module/Units Detailed Topic wise Syllabus
No.
Basics of Java & Features of Java, Bytecode & JVM, JDK. Class, Object,
1 Object-Oriented Constructors, new, this, static keywords. String handling,
Programming
Wrapper Classes.
Packages, Interfaces
Package, access control, Create and implement interface.,
2 and Exception
Dynamic method dispatch, Exception handling.
handling
Thread class & Runnable Interface. Thread priority,
Multithreaded
synchronization, communication and deadlock. Introduction to
3 Programming & IO
Stream, Byte, Character Streams, Readers & Writers. File
Programming
handling.
Collection API & Introduction to Collection APIs (List, Queue, Set). Networking
4 Networking APIs, client-server Application using networking APIs and
java.net package.
5 Swing Programming GUI programming using Swing. Components. Event Handling
COURSE OUTCOME

1. Understand and implement the object-oriented concepts in Java

programming.
2. Create and use packages in java for specific tasks.
3. Implement parallel processing and process synchronization using
multi-threading.
4. Understand and use file handling methods using java programming.
5. Implement client-server applications using java APIs.
6. Implement Graphical User Interface (GUI) based Windows
applications.
TEXT BOOK

➢Text Book
• Java Fundamentals A Comprehensive Introduction (Herbert
Scheldt, Dale Skrien).

• Programming with Java - A Primer (E.Balagurusamy)

➢ Reference Book
• Java The Complete Reference (Herbert Schildt).

➢ Lecture PPTs & Notes

• Will be uploaded on teams after the completion of the
chapter.
EVALUATION SCHEME

Allotted
Description
marks
Internal Theory (MST) 50
Internal Practical 40
Term end Theory 50
Term end Practical 40
Skill Assessment 20
TOTAL 200
STUDENT INTRODUCTIONS

• Please say your:

• Name
• Where you are from
• How much do you grade yourself in
programming (10)
• Career Objective
• Any other accomplishment
LOOKING FOR CONSTANT
FEEDBACK!
Your feedback is most welcome to make sure that
the course is on track
• Please feel free to email/text or talk with me
about the course and let us know how you
think it is going often!
• You can also drop an anonymous written
feedback to my office whenever you feel like.
 INTRODUCTION
TO
JAVA PROGRAMMING
WHAT IS JAVA?

• Java is a general-purpose, high-level programming

language.
• Java is a software-only platform running on top of other,
hardware-based platforms.
• Java Virtual Machine (Java VM)
• The Java Application Programming Interface
(JAVA API)
WHAT IS JAVA?

A simple, object oriented, distributed, interpreted, robust, secure,

architecture neutral, portable, high performance, multithreaded,
dynamic language.

From: Java: An Overview

James Gosling, Sun Microsystems,
WHAT ELSE IS JAVA?

• Right Language, Right Time

• Kept all the good features of C/C++
• Dumped a lot of the ugliness
• Timing
• Internet boom
• Moore’s Law.

• Java is a phenomenon
• Took the world by storm in 1995 when introduced with the HotJava web
Browser
• Quickly integrated with Netscape browser
 SOME HISTORY

• 1993 Oak project at Sun

• small, robust, architecture independent, Object-Oriented, language to control interactive
TV.
• didn’t go anywhere
• 1995 Oak becomes Java
• Focus on the web
• 1996 Java 1.0 available
• 1997 (March) Java 1.1 - some language changes, much larger library, new event handling model
• 1997 (September) Java 1.2 beta – huge increase in libraries including Swing, new collection
classes, J2EE
• 1998 (October) Java 1.2 final (Java2!)
• 2000 (April) Java 1.3 final
• 2001 Java 1.4 final (assert)
• 2004 Java 1.5 (parameterized types, enum, …) (Java5!)
• 2005 J2EE 1.5
JAVA DEVELOPER'S KIT (I)

• Java's programming environment

• Core Java API
• compiler
• interpreter
• debugger
• dis-assembler
• profiler
• more...
 THE JAVA PLATFORM

App1 App2 App3 App4 App5

Java Virtual Machine

Windows Linux OS X Solaris Linux

Intel PowerPC SPARC

THE JAVA VIRTUAL MACHINE

• The Java Language runs on a “Java Virtual Machine”

• Java Virtual machine abstracts away the details of the
underlying platform and provides a uniform environment
for executing Java “byte-code”
• The Java compiler (javac) compiles Java code into
byte-code
• Bytecode is an intermediate form which can run on the
JVM
• JVM does the translation from byte-code to machine-code
in a platform dependent way.
 JAVA DEVELOPER'S KIT (II)

Java Java
Compiler Interpreter

Java Source Java Bytecode

<file>.java <file>.class
Java
Dis-assembler
 PREPARE AND EXECUTE JAVA

Source Computer

Java Program Compilation Java ByteCode

Internet

Verification
Your computer

Java ByteCode Execution Restricted Env.

WRITE ONCE, RUN ANYWHERE
 BYTECODE: FOOD FOR THE VM

• For most languages, compilation produces machine code

• Java compilation produces “bytecode”
• Intermediate code readable by the VM
• Transferable across the Internet as applets
• VM interprets BC into instructions
• Partly responsible for performance lag
• ByteCode produced on any platform may be executed on
any other platform which supports a VM
 EXECUTION MODEL OF JAVA

source bytecode
(text) compiler (aka. class file)
JVML
dynamic
loading

verifier
virtual machine

JIT compiled
bytecode code
compiler
interpreter

CPU
 THE JIT

• Just-In-Time compiler
• Translates bytecode into machine code at runtime
• 1-time overhead when run initiated
• Performance increase 10-30 times

• Now the default for most JVM’s

• Can be turned off if desired
• JIT can apply statistical optimizations based on runtime usage profile
 CHARACTERISTICS OF JAVA

• Java Is Simple
• Java Is Object-Oriented
• Java Is Distributed
• Java Is Interpreted
• Java Is Robust
• Java Is Secure
• Java Is Architecture-Neutral
• Java Is Portable
• Java's Performance
• Java Is Multithreaded
• Java Is Dynamic
 SIMPLE

• Java is partially modeled on C++, but greatly simplified and

improved. Some people refer to Java as "C++--" because it is like
C++ but with more functionality and fewer negative aspects.
• Eliminates several complexities of
• No operator overloading
• No direct pointer manipulation or pointer arithmetic
• No multiple inheritance
• No malloc() and free() – handles memory automatically
• Garbage Collector
• Lots more things which make Java more attractive.
OBJECT-ORIENTED

• Java is inherently object-oriented. Although many object-oriented

languages began strictly as procedural languages, Java was designed
from the start to be object-oriented.
• One of the central issues in software development is how to reuse
code. Object-oriented programming provides great flexibility,
modularity, clarity, and reusability through encapsulation, inheritance,
and polymorphism.
• Fundamentally based on OOP
• Classes and Objects
• Uses a formal OOP type system
• Efficient re-use of packages such that the programmer only cares about the
interface and not the implementation
DISTRIBUTED / NETWORK
ORIENTED
• Distributed computing involves several computers working together
on a network.
• Java is designed to make distributed computing easy. Since networking
capability is inherently integrated into Java, writing network programs
is like sending and receiving data to and from a file.
• Java grew up in the days of the Internet
• Inherently network friendly
• Original release of Java came with Networking libraries
• Newer releases contain even more for handling distributed applications
• RMI, Transactions
ROBUST

• Java has eliminated certain types of error-prone programming

constructs found in other languages. [i.e., No pointer arithmetic or
memory management!]
• Java compilers can detect many problems that would first show up at
execution time in other languages.
• Java has a runtime exception-handling feature to provide programming
support for robustness. [Exception Handling]
• Dynamic runtime checking for pointer and array access
• No buffer overflow bugs!
SECURE / SAFE

Java implements several security mechanisms to protect your system

against harm caused by stray programs.
• Designed with the intention of being secure
• The JVM “verifier”
• Checks integrity of byte-codes
• SecurityManager to check which operations a piece of code is
allowed to do
• “Sandbox” operation for applets and other untrusted code
• Limited set of operations or resources made available
• Contrast to ActiveX
ARCHITECTURE-NEUTRAL/
PORTABLE
• “Write once, run anywhere”
• With a Java Virtual Machine (JVM), you can write one program that
will run on any platform.
• Because Java is architecture neutral, Java programs are portable.
They can be run on any platform without being recompiled.
• The Java Virtual Machine becomes the common denominator
• Bytecodes are common across all platforms
• JVM hides the complexity of working on a particular platform
• Difficult to implement a JVM
• But simpler for the application developer

• Java does this well

HIGH-PERFORMANCE

• Java’s performance Because Java is architecture neutral, Java

programs are portable. They can be run on any platform without
being recompiled.
• Java performance IS slower than C
• Tradeoff between development time vs. run time
• Additional checks in Java which make is secure and robust and network aware etc, all
have a small cost.

• BUT
• JIT compilation and HotSpot
• Dynamic compilation of bytecode to native code at runtime to improve performance
• HotSpot optimizes code on the fly based on dynamic execution patterns
• Can sometimes be even faster than compiled C code!
MULTI-THREADED

• Multithread programming is smoothly integrated in Java,

whereas in other languages you have to call procedures specific
to the operating system to enable multithreading.
• Basic concept
• The ability to have multiple flows of control/programs which
appear to run at the same time
• Processes - application level
• Threads – within the application
• JVM uses native threads on operating system but provides a
consistent abstraction for the developer.
DYNAMIC

• Java was designed to adapt to an evolving environment.

New code can be loaded on the fly without
recompilation.
• There is no need for developers to create, and for users to
install, major new software versions. New features can be
incorporated transparently as needed.
• Java is “self-aware”
• Java code can look at itself and tell what interfaces it exports
(Introspection)
• Can dynamically load new classes/code at runtime
JAVA PROGRAMMER EFFICIENCY

• Faster Development
• More programmer friendly
• Less error prone
• OOP
• Easier to manage large development projects
• Robust memory system
• No pointer arithmetic and manual memory management. Garbage
collector!
• Libraries
• Re-use of code
 FEATURES OF JAVA
• Simple • Portable
• Architecture-neutral
• High-Performance
• Object-Oriented
• Distributed • Robust
• Compiled • Secure
• Interpreted
• Extensible
• Statically Typed
• Multi-Threaded
• Well-Understood
• Garbage Collected
JAVA PLATFORM & VM & DEVICES
 APPLICATIONS OF JAVA

• Java can be used to develop Web applications.

• Java Applets
• Java Web Applications
• Java can also be used to develop applications for hand-
held devices such as Palm and cell phones
EXAMPLES OF JAVA’S VERSATILITY
(APPLETS)
 POPULAR JAVA IDES

• NetBeans Open Source by Sun

• Eclipse Open Source by IBM
 A SIMPLE JAVA PROGRAM

Listing 1.1
//This program prints Welcome to Java!
public class Welcome {
public static void main(String[] args) {
System.out.println("Welcome to Java!");
}
}

Welcome

Run
 CREATING AND EDITING USING NOTEPAD

To use NotePad, type

notepad Welcome.java
from the DOS prompt.
 CREATING, COMPILING, AND
RUNNING PROGRAMS
Create/Modify Source Code

Source code (developed by the programmer)

Saved on the disk
public class Welcome {
public static void main(String[] args) {
System.out.println("Welcome to Java!"); Source Code
}
}

Compile Source Code

Byte code (generated by the compiler for JVM i.e., javac Welcome.java
to read and interpret, not for you to understand)
…
Method Welcome() If compilation errors
0 aload_0 stored on the disk
…
Bytecode
Method void main(java.lang.String[])
0 getstatic #2 …
3 ldc #3 <String "Welcome to
Java!">
5 invokevirtual #4 …
8 return Run Byteode
i.e., java Welcome

Result

If runtime errors or incorrect result

animation

TRACE A PROGRAM EXECUTION

Enter main method

//This program prints Welcome to Java!

public class Welcome {
public static void main(String[] args) {
System.out.println("Welcome to Java!");
}
}
animation

TRACE A PROGRAM EXECUTION

//This program prints Welcome to Java!

public class Welcome {
public static void main(String[] args) {
System.out.println("Welcome to Java!");
}
}

print a message to the

console
 TERMINOLOGY

• class keyword is used to declare a class in Java.

• public keyword is an access modifier.
• static If we declare any method as static, it is known as the static method. The core
advantage is that there is no need to create an object to invoke the static method.
• void is the return type of the method.
• main represents the starting point of the program.
• String[] args or String args[] is used for command line argument.
• System.out.println() is used to print statement. Here, System is a class, out is an
object, println() is a method.
BASIC JAVA SYNTAX
 PRIMITIVE TYPES AND VARIABLES
• boolean, char, byte, short, int, long, float, double etc.
• These basic (or primitive) types are the only types that are not
objects (due to performance issues).
• This means that you don’t use the new operator to create a primitive
variable.
• Declaring primitive variables:
float initVal;
int retVal, index = 2;
double gamma = 1.2, brightness
boolean valueOk = false;
INITIALISATION

• If no value is assigned prior to use, then the compiler

will give an error
• Java sets primitive variables to zero or false in the case
of a boolean variable
• All object references are initially set to null
• An array of anything is an object
• Set to null on declaration
• Elements to zero false or null on creation
DECLARATIONS

int index = 1.2; // compiler error

boolean retOk = 1; // compiler error
double fiveFourths = 5 / 4; // no error!
float ratio = 5.8f; // correct
double fiveFourths = 5.0 / 4.0; // correct

• 1.2f is a float value accurate to 7 decimal places.

• 1.2 is a double value accurate to 15 decimal
places.
 ASSIGNMENT

• All Java assignments are right associative

int a = 1, b = 2, c = 5
a=b=c
System.out.print(“a= “ + a + “b= “ + b + “c= “ + c)
• What is the value of a, b & c
• Done right to left: a = (b = c);
 TAKING INPUTS

The Scanner class is used to get user input, and it is found in the java.util package.

import java.util.Scanner; // Import the Scanner class

public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in); // Create a Scanner object
System.out.println("Enter username");
String userName = sc.nextLine(); // Read user input
System.out.println("Username is: " + userName); // Display output
}
}
 BASIC MATHEMATICAL
OPERATORS
• * / % + - are the mathematical operators
• * / % have a higher precedence than + or -
double myVal = a + b % d – c * d / b;

• Is the same as:

double myVal = (a + (b % d)) – ((c * d) / b);
 STATEMENTS & BLOCKS

• A simple statement is a command terminated by a semi-

colon:
name = “Fred”;

• A block is a compound statement enclosed in curly

brackets:
{
name1 = “Fred”; name2 = “Bill”;
}

• Blocks may contain other blocks

FLOW OF CONTROL

• Java executes one statement after the

other in the order they are written
• Many Java statements are flow control
statements:
Alternation: if, if else, switch
Looping: for, while, do while
Escapes: break, continue, return
IF – THE CONDITIONAL
STATEMENT
• The if statement evaluates an expression and if that evaluation is
true then the specified action is taken
if ( x < 10 ) x = 10;

• If the value of x is less than 10, make x equal to 10

• It could have been written:
if ( x < 10 )
x = 10;

• Or, alternatively:
if ( x < 10 ) { x = 10; }
 RELATIONAL OPERATORS

== Equal (careful)
!= Not equal
>= Greater than or equal
<= Less than or equal
> Greater than
< Less than
IF… ELSE

• The if … else statement evaluates an expression

and performs one action if that evaluation is true
or a different action if it is false.
if (x != oldx) {
System.out.print(“x was changed”);
}
else {
System.out.print(“x is unchanged”);
}
NESTED IF … ELSE

if ( myVal > 100 ) {

if ( remainderOn == true) {
myVal = mVal % 100;
}
else {
myVal = myVal / 100.0 }
}
else
{
System.out.print(“myVal is in
range”);
}
 ELSE IF

if ( n == 1 ) {
// execute code block #1
}
else if ( j == 2 ) {
// execute code block #2
}
else {
// if all previous tests have failed, execute
code block #3
}
THE SWITCH STATEMENT

switch ( n ) {
case 1:
// execute code block #1
break;
case 2:
// execute code block #2
break;
default:
// if all previous tests fail then
//execute code block #4
break;
}
THE FOR LOOP

• Loop n times
for ( i = 0; i < n; n++ ) {
// this code body will execute n times
// from 0 to n-1
}
• Nested for:
for ( j = 0; j < 10; j++ ) {
for ( i = 0; i < 20; i++ ){
// this code body will execute 200
times
} }
 WHILE LOOPS

while(response == 1) {
System.out.print( “ID =” + userID[n]);
n++;
response = readInt( “Enter “);
}

What is the minimum number of times the loop is executed?

What is the maximum number of times?
 DO {… } WHILE LOOPS

do {
System.out.print( “ID =” + userID[n] );
n++;
response = readInt( “Enter ” );
}while (response == 1);

What is the minimum number of times the loop is executed?

What is the maximum number of times?
 BREAK

• A break statement causes an exit from the innermost

containing while, do, for or switch statement.
for ( int i = 0; i < maxID, i++ ) {
if ( userID[i] == targetID ) {
index = i;
break;
}
} // program jumps here after break
 CONTINUE

• Can only be used with while, do or for.

• The continue statement causes the innermost loop to start the
next iteration immediately
for ( int i = 0; i < maxID; i++ ) {
if ( userID[i] != -1 ) continue;
System.out.print( “UserID ” + i + “ :” + userID);
}
ARRAYS & STRINGS
ARRAYS

• 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 = 3 6 3 1 6 3 4 1
0 1 2 3 4 5 6 7

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};
ITERATING THROUGH ARRAYS

• for loops are useful when dealing with arrays:

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

myArray[i] = getsomevalue();
}
ARRAYS OF OBJECTS (DISCUSS LATER)

• 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

private Student studentList[];
• this declares studentList
2 .Create the array
studentList = 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:
studentList[0] = new Student("Cathy", "Computing");
STRING

Generally, String is a sequence of characters.

But in Java, string is an object that represents a
sequence of characters.
The java.lang.String class is used to create a string
object.
STRING

• Strings in java are immutable

• Once created they cannot be altered and hence any
alterations will lead to creation of new string object
STRING CREATION

There are two ways to create String object:

• By string literal
String s=“ankit";

• By new keyword
String s = new(“ankit”)
 EXAMPLE

❖ String s1 = “welcome”
❖ String s2 = new String(“welcome”)
❖ String s3 = “welcome”
• The difference between the three statements is that, s1 and s3 are
pointing to the same memory location i.e. the string pool.
• s3 is pointing to a memory location on the heap.
• Using a new operator creates a memory location on the heap.
STRING STORAGE
 STRING METHODS
No. Method Description
1 int length() It returns string length
2 char charAt(int index) It returns char value for the particular
index
3 String substring(int beginIndex) It returns substring for given begin
index.
4 String substring(int beginIndex, It returns substring for given begin
int endIndex) index and end index.
5 int indexOf(int ch) It returns the specified char value
index.
6 int indexOf(String substring) It returns the specified substring
index.
 STRING METHODS
No. Method Description
8 boolean equals(Object another) It checks the equality of string with
the given object.
9 static String It compares another string. It doesn't
equalsIgnoreCase(String check case.
another)
10 String concat(String str) It concatenates the specified string.
11 boolean isEmpty() It checks if string is empty.
13 String replace(char old, char It replaces all occurrences of the
new) specified char value.
 STRING METHODS
No. Method Description
14 String toLowerCase() It returns a string in lowercase.
15 String toUpperCase() It returns a string in uppercase.
16 String trim() It removes beginning and ending spaces of
the string.
17 static String valueOf(int It converts given type into string. It is an
value) overloaded method.
STRING BUFFER

• StringBuffer is a synchronized and allows us to mutate the

string.
• StringBuffer has many utility methods to manipulate the
string.
• This is more useful when using in a multithreaded
environment.
• Always has a locking overhead.
EXAMPLE

public class mybuffers{

public static void main(String args[]){
StringBuffer buffer = new StringBuffer(“Hi”);
buffer.append(“Bye”);
System.out.println(buffer);
}}
• This program appends the string Bye to Hi and prints it to the
screen.