Object-Oriented Programming

with Java
 Introduction
• Java is a platform independent because of JVM and Byte code
• When you compile java source code it generates the byte code
which can be understood by JVM only
• When you running the byte code first it will be converted into native
code and then it will be executed (interpreter convert byte code to
native code)
• Java program goes through foll. Phases:
Edit Hello
Compiler Compiler(javac.exe)
Loading Hello.class(byte code)
Verifier Interpreter(java.exe)
Execute native code

• Jvm is an interpreter for byte code

2
 Java program Structure:
class Hello{
public static void main(String as[])
{ System.out.println(“java”);
}
}
• The keyword class to declare that a new class is being defined Hello is an
identifier that is the name of the class
• All java applications begin execution by calling main()
• Static allows main() to be called without having to instantiate a particular
instance of the class
• String as[] declares a parameter named arguments present when the
program is executed
• System is predefined class (access to the system)
• out is the output stream that is converted in to the console
• println displays the string which is passed to it (displays other types of infor.
too)

3
 Class
• A class is a blueprint or prototype that defines the variables and methods
common to all objects of a certain kind
• A class is declared by use of the class keyword
Syntax:
class class name
{
type instance-variable1;
type instance-variable1;
….
type instance-variable N;
type method name1(parameter list)
{ //body of method
}
………..
type method nameN(parameter list)
{ //body of method
}

4
Example:
class Hello
{ double width;
double height;
double depth;
}
• The data or variables defined with in a class are called instance variable
• The code is contained with in methods
• The methods and variables defined with in a class are called members of the
class
1. Instance variables can be -Static variables also cab be
primitive and reference primitive or reference
2. Multiple copies of Memory -Single copy of memory
will be allocated for multiple will be allocated for multiple
objects objects

5
 Objects
• Objects is constructed either on a memory heap or on a stack
Memory heap:
• The objects are created using the new keyword(operator)
• Some heap memory is allocated to this newly created objects
Stack:
• During method calls, objects are created for method arguments
and method variables.These objects are created on stack
Class and object:
• The class is not shaded because it represents a blueprint of an
object rather than an object itself.
• An object is shaded, indicating that the object actually exists and
you can use it.
• Classes provide the benefit of reusability
• Objects provide the benefit of modularity and information hiding

6
Example:
Class Box
{ double width;
double height;
double depth;
}
Class BoxDemo
{
Public static void main(String as[])
{ //reference to an object of type Box
Box mybox = new Box();
Double vol;
mybox. width=10;
mybox. heighrt=20;
mybox. depth=30;
vol=mybox. width*mybox. height*mybox. depth;
System.out.println(“volume is”, +vol);
}
}
7
Statement Effect
null

Box mybox; mybox

null

mybox=new Box(); Width

Height
Depth

Box

8
 Assigning object reference variables
• Its acts differently than you might expect when an assignment
takes place
Box b1=new Box();
Box b2=b1;
• You may think that b2 is assigned a reference to a copy of the
object referred to a by b1.b1 and b2 refers to separate and distinct
objects but b1 and b2 both will refer to the same object
• The assignment of b1&b2 did not allocate any memory or copy any
part of the original objects
• B2 refers to the same objects as does b1.
• Change made to the object through b2 will effect to b1
Box b1=new Box();
Box b2=b1;
b1=null;
• B1=null but b2 is still points original object b1.

9
 Access Modifiers
• Access Modifiers also called as Access specifiers or visibility Modifiers
• Access Modifiers will be used to specify the scope for the variables,
methods and classes
• They are four Access modifiers
Private
Default
Protected
Public
Private: members of a class can be accessed with in the class only and can’t be
occurred within the subclass and non subclass of same package.
Default, Protected, Public: member of a class can be accessed directly in the
subclass be access with object in non-subclass.

10
Example: class C
class A {
void show()
{ private int a =10; {
private int b =20; A obj =new A();
protected int c=30; System.out.println(“c-
public int d =40; class”);
void show(){
System.out.println(“a class”); System.out.println(“obj.c”);
System.out.println(“a ”);
System.out.println(“obj.d”);
System.out.println(“b”);
}
System.out.println(“c”);
}
System.out.println(“d”);
class Ex1
}
{
}
Public static void main(String as[])
class B extends A
{
{
A obj1 =new A();
void show()
B obj2 =new B();
{ System.out.println(“b- C obj3 =new C();
class”); System.out.println(“c”); Obj1.show();
System.out.println(“d”); Obj2.show();
} Obj3.show();
} }
}

11
 Inheritance
• Is a process of writing a new class from the existing class.New class is
called as subclass or derived class and existing class as a super class
• To implement an inheritance we have to use “extends “ keyword
class A
{ …..
}
class B extends A
{ ……….
}
• B is extending A because of this all the A (functionality)
members become members of B class
• Super class will considered first and then subclass.All the members of super
class is members of sub class

12
 class b extends A
Example: {
……………
class A ……………
{ int a =10; ……………
static int b =20; ……………
{ }
System.out.println(“a ”); class ex1
System.out.println(“ A nsatance”); {
} public static void
Static main(String as[])
{ {
System.out.println(b); B obj=new B();
Sysytem.out.println(“a-static”);
obj.show(A);
}
void show A() obj.show(B);
{ }
System.out.println(a); }
System.out.println(b);
}
}

13
 Types of Inheritance

1. Simple Inheritance
2. Multilevel Inheritance
3. Hierarchical Inheritance
4. Multiple Inheritance
5. Hybrid Inheritance

Simple Inheritance: will have only one subclass and one super class

14
Multilevel :
• Super class can have many subclass. in this one is directs subclass and all
remaining are indirect subclasses
• One subclass can have many super class
• In this one is direct super class and remaining are indirect super class
Hierarchical :
one super class have many direct sub classes and one
Sub class can have only one super class
Multiple :
• one sub class can have many super class and one super class can have
only one sub class
• Multiple inheritance is not allowed in Java using java class and is allowed
using java interfaces
Hybrid :
• Is combination of simple and multiple, hierarchical , multilevel inheritance
• We are unable to implement hybrid because it include multiple.

15
 Why multiple inheritance is not allowed with java?

• In classes we can declare instance variables when multiple

inheritance is allowed multiple copies of instance variables will be
inherited to subclass because of this lot of memory will be wasted
• In the case of interfaces only static variables are allowed so only
one copy of the memory will be allowed for many objects because
of this no publication of data and no memory wastage
• Because of this reason multiple inheritance allowed with
interfaces

• Combinations:
class extends class
class implements interfaces
interface extends interface
interface not allowed class

16
 Methods
• Method is a set of statements with some name
• Syntax:
[modifier] return-type methodname(datatype var1,var2….)
{ ……..
……. Method body
}
Ex:
1. void m1() 2. int m2()
{ { s.o.p(“m2”);
s.o.p(“m1”); return 10;
} }
• Method may or may not return a value when method is not
returning any value we should specify the method type as void
and no need to write returns statement inside the method

17
• When the method is returning the value we should specify the data
type of that value as the return type and we must specify the return
statement
• We can define two types of methods
Instance methods
Static methods
Ex:
class A
{
int a=10;
static int b=20;
void m1()
{
s.o.p(a); }
static void m2(){
s.o.p(b);}
}

18
 Encapsulation
• Wrapping of data and function into a single unit called encapsulation
Ex: all java programs
• Nothing but data hiding ,like the variables declared under private of a
particular class are accessed only in that class and cannot access in
any other the class .or hiding the information from others is called as
Encapsulation.
• Encapsulation is the mechanism that binds together code and data it
manipulates and keeps both safe from outside interference and misuse
• Encapsulation helps clarify the distinction between an objects operation
and implementation
• The implementation of an object can change without implications for
the clients
• Encapsulation also reduces complexity, as the internal operations of
an object are hidden from the clients, who can not influence its
implementation
• Because of encapsulation, the code you write tends to be modular.

19
• Example:
public class LineOfText
{ //return the length of the line
public int getLength()
{
return length;
}
//return the current index
public int getCurrentIndex()
{
return index;
}
//advance the index by 1 if it is not already at the end
public void forwordCharacter()
{
if(index<length-1)
{
index++;
}
}
private int length;
private int index;
private String buffer;

20
• LineOfText object has length,index,buffer that are not exposed to
any piece of code outside of this particular class.
• These fields are private and are so specified by use of the private
keyword
• Only the getLength(),getCurrentIndex() and forwardCharacter()
methods in the object are visible to other parts of the program
that use this class
Java provides two kinds of encapsulation constructs:
1. Classes that are physical encapsulation and fallowes the same
notation as c++
2. Packages that are logical encapsulation and fallow the notation of
packages. In this case ,any class definition can specify that it
belongs to a particular package
A class that does not specify a package name would be placed in
an unnamed package.

21