Object-oriented Programming With Java

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.

2.

Instance variables can be

primitive and reference Multiple copies of Memory will be allocated for multiple objects

-Static variables also cab be primitive or reference -Single copy of memory will be allocated for multiple 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 A { private int a =10; private int b =20; protected int c=30; public int d =40; void show(){ System.out.println(“a class”); System.out.println(“a ”); System.out.println(“b”); System.out.println(“c”); System.out.println(“d”); } } class B extends A { void show() { System.out.println(“bclass”); System.out.println(“c”); System.out.println(“d”); } }

class C { void show() { A obj =new A(); System.out.println(“cclass”); System.out.println(“obj.c”); System.out.println(“obj.d”); } } class Ex1 { Public static void main(String as[]) { A obj1 =new A(); B obj2 =new B(); C obj3 =new C(); Obj1.show(); 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

Example: class A {

int a =10; static int b =20; { System.out.println(“a ”); System.out.println(“ A nsatance”); } Static { System.out.println(b); Sysytem.out.println(“a-static”); } void show A() { System.out.println(a); System.out.println(b); } }

class b extends A { …………… …………… …………… …………… } class ex1 { public static void main(String as[]) { B obj=new B(); obj.show(A); obj.show(B); } }

13

Types of Inheritance

1. 2. 3. 4. 5.

Simple Inheritance Multilevel Inheritance Hierarchical Inheritance Multiple Inheritance Hybrid Inheritance

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

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
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. 2.

Classes that are physical encapsulation and fallowes the same notation as c++ 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