Object Oriented Programming

OOP In Java

Lecture #01
Prof- Maqsood Ahemd Razi
 Different Programming Paradigms

• Functional/procedural programming:
– program is a list of instructions to the computer

• Object-oriented programming
– program is composed of a collection objects
that communicate with each other
 Main Concepts
• Object
• Class
• Inheritance
• Encapsulation
 Objects
• identity – unique identification of an object
• attributes – data/state
• services – methods/operations
– supported by the object
– within objects responsibility to provide these
services to other clients
 Class
• “type”
• object is an instance of class
• class groups similar objects
– same (structure of) attributes
– same services
• object holds values of its class’s attributes
 Inheritance
• Class hierarchy
• Generalization and Specialization
– subclass inherits attributes and services from its
superclass
– subclass may add new attributes and services
– subclass may reuse the code in the superclass
– subclasses provide specialized behaviors (overriding
and dynamic binding)
– partially define and implement common behaviors
(abstract)
 Encapsulation
• Separation between internal state of the object
and its external aspects

• How ?
– control access to members of the class
– interface “type”
 What does it buy us ?
• Modularity
– source code for an object can be written and maintained
independently of the source code for other objects
– easier maintainance and reuse
• Information hiding
– other objects can ignore implementation details
– security (object has control over its internal state)
• but
– shared data need special design patterns (e.g., DB)
– performance overhead
 Why Java ?
• Portable
• Easy to learn

• [ Designed to be used on the Internet ]

 JVM

• JVM stands for

Java Virtual Machine

• Unlike other languages, Java “executables”

are executed on a CPU that does not exist.
 Platform Dependent

myprog.c myprog.exe
gcc machine code
C source code

OS/Hardware

Platform Independent

myprog.java myprog.class
javac bytecode
Java source code

JVM

OS/Hardware
 Primitive types

• int 4 bytes
• short 2 bytes
• long 8 bytes
Behaviors is
exactly as in
• byte 1 byte
C++
• float 4 bytes
• double 8 bytes
• char Unicode encoding (2 bytes) Note:
Primitive type
• boolean {true,false} always begin
with lower-case
 Primitive types - cont.

• Constants
37 integer
37.2 float
42F float
0754 integer (octal)
0xfe integer (hexadecimal)
 Wrappers

Java provides Objects which wrap

primitive types and supply methods.
Example:

Integer n = new Integer(“4”);

int m = n.intValue();

Read more about Integer in JDK Documentation

 Hello World
Hello.java
class Hello {
public static void main(String[] args) {
System.out.println(“Hello World !!!”);
}
}

C:\javac Hello.java ( compilation creates Hello.class )

C:\java Hello (Execution on the local JVM)

 More sophisticated
class Kyle {
private boolean kennyIsAlive_;
Default public Kyle() { kennyIsAlive_ = true; }
C’tor public Kyle(Kyle aKyle) {
kennyIsAlive_ = aKyle.kennyIsAlive_;
}
public String theyKilledKenny() {
if (kennyIsAlive_) {
Copy
kennyIsAlive_ = false;
C’tor return “You bastards !!!”;
} else {
return “?”;
}
}
public static void main(String[] args) {
Kyle k = new Kyle();
String s = k.theyKilledKenny();
System.out.println(“Kyle: “ + s);
}
}
 Results

javac Kyle.java ( to compile )

java Kyle ( to execute )

Kyle: You bastards !!!

 Arrays
• Array is an object

• Array size is fixed

Animal[] arr; // nothing yet …

arr = new Animal[4]; // only array of pointers

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

arr[i] = new Animal();

// now we have a complete array

 Arrays - Multidimensional
• In C++
Animal arr[2][2]

Is:

• In Java
Animal[][] arr=
new Animal[2][2]

What is the type of

the object here ?
 Static - [1/4]
• Member data - Same data is used for all the
instances (objects) of some Class.
Assignment performed
Class A {
on the first access to the
public int y = 0;
Class.
public static int x_ = 1;
Only one instance of ‘x’
};
exists in memory
A a = new A();
A b = new A(); a b
System.out.println(b.x_); Output: 0 0
a.x_ = 5; y y
System.out.println(b.x_);
A.x_ = 10;
1
System.out.println(b.x_); 5 1
10 A.x_
 Static - [2/4]
• Member function
– Static member function can access only static members
– Static member function can be called without an
instance. Class TeaPot {
private static int numOfTP = 0;
private Color myColor_;
public TeaPot(Color c) {
myColor_ = c;
numOfTP++;
}
public static int howManyTeaPots()
{ return numOfTP; }

// error :
public static Color getColor()
{ return myColor_; }
}
 Static - [2/4] cont.

Usage:

TeaPot tp1 = new TeaPot(Color.RED);

TeaPot tp2 = new TeaPot(Color.GREEN);

System.out.println(“We have “ +
TeaPot.howManyTeaPots()+ “Tea Pots”);
 Static - [3/4]
• Block
– Code that is executed in the first reference to the class.
– Several static blocks can exist in the same class
( Execution order is by the appearance order in the class
definition ).
– Only static members can be accessed.
class RandomGenerator {
private static int seed_;

static {
int t = System.getTime() % 100;
seed_ = System.getTime();
while(t-- > 0)
seed_ = getNextNumber(seed_);
}
}
}
 String is an Object
• Constant strings as in C, does not exist

• The function call foo(“Hello”) creates a String object,

containing “Hello”, and passes reference to it to foo.

• There is no point in writing :

String s = new String(“Hello”);

• The String object is a constant. It can’t be changed using

a reference to it.
 Flow control
Basically, it is exactly like c/c++.
do/while
int i=5; switch
if/else do { char
If(x==4) { // act1 c=IN.getChar();
// act1 i--; switch(c) {
} else { } while(i!=0); case ‘a’:
// act2 case ‘b’:
} for // act1
break;
int j;
default:
for(int i=0;i<=9;i++)
// act2
{
}
j+=i;
}
 Packages

• Java code has hierarchical structure.

• The environment variable CLASSPATH contains
the directory names of the roots.
• Every Object belongs to a package ( ‘package’
keyword)
• Object full name contains the name full name of the
package containing it.
 Access Control
• public member (function/data)
– Can be called/modified from outside.
• protected
– Can be called/modified from derived classes
• private
– Can be called/modified only from the current class
• default ( if no access modifier stated )
– Usually referred to as “Friendly”.
– Can be called/modified/instantiated from the same package.
 class Base {
Inheritance Base(){}
Base(int i) {}
protected void foo() {…}
}
Base
class Derived extends Base {
Derived() {}
protected void foo() {…}
Derived(int i) {
super(i);
Derived …
super.foo();
}
}

As opposed to C++, it is possible to inherit only from ONE class.

Pros avoids many potential problems and bugs.
Cons might cause code replication
 Polymorphism
• Inheritance creates an “is a” relation:
For example, if B inherits from A, than we say that
“B is also an A”.
Implications are:
– access rights (Java forbids reducing access rights) -
derived class can receive all the messages that the base
class can.
– behavior
– precondition and postcondition