0% found this document useful (0 votes)
31 views43 pages

Wa0008

OOP- UNIT NO. 2

Uploaded by

Vinay Bansode
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
0% found this document useful (0 votes)
31 views43 pages

Wa0008

OOP- UNIT NO. 2

Uploaded by

Vinay Bansode
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 43

Object Oriented Programming[214444]

Second Year Information Technology (2019 Course)


Unit 2 : Classes, Objects, & Methods
Syllabus:-
Class : Creating a Class, Visibility/Access Modifiers, Encapsulation, Methods: Adding a Method to Class,
Returning a Value, Adding a Method that takes Parameters, The “this” Keyword, Method Overloading,
Object Creation, Using Object as a Parameters, Returning Object, Array of Objects, Memory Allocation:
“new”, Memory Recovery: “delete”, Static Data Members, Static Methods, Forward Declaration, Class as
Abstract Data Types (ADTs), Classes as Objects.

Unit Objectives
On completion of the unit students will be able to:
1. To understand concepts of classes, methods and objects.
2.To understand different types of methods
3.To understand fundamentals of objects
4. To understand fundamentals of memory allocation

Unit Outcomes:
1. To learn need of classes, objects and methods .

Texts Books:
T1) An Introduction to Object Oriented Programming (3rd Ed), by Timothy A. Budd, published by Addison-
Wesley,2002
T2) E. Balaguruswamy, “Object Oriented Programming Using C++ and Java”, Tata McGrawHill

Outcome Satisfied: PEOs: 1 PSOs:2 POs: a,c,e COs:1


Outline
Sr. No. Topic Name Reference Book

1 Class : Creating a Class, Visibility/Access Modifiers, T2(Page No. 95, 339)


Encapsulation,

2 Methods: Adding a Method to Class, Returning a Value, T2(Page No.99,340)


Adding a Method That Takes Parameters,

3 The “this” Keyword, Method Overloading, Object Creation, T2(Page No.248,347)


Memory Allocation: “new”, Memory Recovery: “delete”,

4 Using Object as a Parameters, Returning Object, T2(Page No.117)

5 Array of Objects, Static Data Members, Static Methods, T2(Page No.109-114)

6 Forward Declaration, Class as Abstract Data Types (ADTs), T2(Page No.110-112,348)


Classes as Objects
Case study
Creating Class
• A class is a blueprint or prototype that defines the variables and
the methods (functions) common to all objects of a certain kind.

• Objects (data and functions) are members of user-defined types


called classes.

• To create a class, use the keyword class:

public class Student


{

}//End of Student Class


Visibility/Access Modifier
• An accessmodifier is used to set the access level for classes, attributes, methods and
constructors.
• For classes, we can use either public or default access modifier

• Public
– The class is accessible by any other class

public class Student{

}//End of Student Class


• Default
– The class is only accessible by classes in the same package. This is used when you don't
specify a modifier.

class Student{

}//End of Student Class


Visibility/Access Modifier
• For attributes, methods and constructors, you can use the one of the following
Public
•The code is accessible for all classes
public class Person {
public String fname = "John";
public String lname = "Doe";
public String email = "[email protected]";
public int age = 24;
}
class MyClass {
public static void main(String[] args) {
Person myObj = new Person();
System.out.println("Name: " + myObj.fname + " " + myObj.lname);
System.out.println("Email: " + myObj.email);
System.out.println("Age: " +myObj.age); Output:
} Name: John Doe
} Email: [email protected]
Age: 24
Visibility/Access Modifier
Private
•The code is only accessible within the declared class
public class Person
{
private String fname = "John";
private String lname = "Doe";
private String email = "[email protected]";
private int age = 24;
public static void main(String[] args)
{
Person myObj = new Person();
System.out.println("Name: " + myObj.fname + " " + myObj.lname);
System.out.println("Email: " + myObj.email);
System.out.println("Age: " +myObj.age); Output:

} Name: John Doe


Email: [email protected]
} Age: 24
Visibility/Access Modifier
Default
• The code is only accessible in the same package. This is used when you don't
specify a modifier.
class Person {
String fname = "John";
String lname = "Doe";
String email = "[email protected]";
int age = 24;
public static void main(String[] args) {
Person myObj = new Person();
System.out.println("Name: " + myObj.fname + " " + myObj.lname);
System.out.println("Email: " + myObj.email);
System.out.println("Age: " +myObj.age);
}
Output:
} Name: John Doe
Email: [email protected]
Age: 24
Visibility/Access Modifier
Protected
•The code is accessible in the same package and subclasses.
class Person {
protected String fname = "John";
protected String lname = "Doe";
protected String email = "[email protected]";
protected int age = 24;
}
class Student extends Person {
private int graduationYear = 2018;
public static void main(String[] args) {
Student myObj = new Student();
System.out.println("Name: " + myObj.fname + " " + myObj.lname);
System.out.println("Email: " + myObj.email);

System.out.println("Age: " +myObj.age); Output:


System.out.println("Graduation Year: " + myObj.graduationYear); Name: JohnDoe
Email: [email protected]
} Age: 24
Graduation Year : 2018
}
Encapsulation

• The meaning of Encapsulation, is to make sure that "sensitive" data is hidden from
users.
• We can achieve encapsulation in Java by:
– Declaring the variables of a class as private.
– Providing public setter and getter methods to modify and view the variables
values.
•Let us look at the code below to get a better understanding of encapsulation:
public class Person { //class 1
private String name; / / private = restricted access
/ / Getter
public String getName() {
return name;
}
/ / Setter
public void setName(String newName)
{ this.name = newName;
}
}
Encapsulation

• However, as the name variable is declared as private, we cannot access it from


outside the class

public class MyClass { //class 2


public static void main(String[] args)
{
Person myObj = new Person();
myObj.name = "John"; / / error
System.out.println(myObj.name); / / error
}
}

However, as we try to access a private variable, we get an error.


Encapsulation

• Instead, we use the getName() and setName() methods to acccess and update
the variable:

public class MyClass


{
public static void main(String[] args)
{
Person myObj = new Person();
myObj.setName("John"); // Set the value of the name variable to "John“
System.out.println(myObj.getName());
}
}

• Output: "John"
Encapsulation
Why Encapsulation?

• Better control of class attributes and methods

• Class attributes can be made read-only (if you only use the get method),
or write-only (if you only use the set method)

• Flexible: the programmer can change one part of the code without affecting
other parts

• Increased security of data


Adding a Method to Class
• A method is a block of code which only runs when it is called.
• You can pass data, known as parameters, into a method.
• Methods are used to perform certain actions, and they are also known as
functions.
• Why use methods? Toreuse code: define the code once, and use it many
times.
• Create a method inside MyClass:
public class MyClass {
static void myMethod() {
/ / code to be executed
}
}
• myMethod() is the name of the method
• static means that the method belongs to the MyClass class and not an
object of the MyClassclass.
• void means that this method does not have a return value.
Calling a Method
public class MyClass {
static void myMethod() {
System.out.println("I just got executed!");
}
public static void main(String[] args) {
myMethod();
}
}

• Output: "I just got executed!"


Returning a Value

• If you want the method to return a value, you can use a primitive data type
(such as int, char, etc.) instead of void, and use the return keyword inside
the method.
• The void keyword indicates that the method should not return a value

public class MyClass {


static int myMethod(int x) {
return 5 + x;
}
public static void main(String[] args) {
System.out.println(myMethod(3));
}
}

• Output: 8
Adding a Method that Takes Parameters

• Information can be passed to methods as parameter. Parameters act as


variables inside the method.
• Parameters are specified after the method name, inside the parentheses.
• You can add as many parameters as you want, just separate them with a
comma.
public class MyClass {
static void myMethod(String fname) {
System.out.println(fname + “ Institutes");
}
public static void main(String[] args) {
myMethod(“Sinhgad");
}
}

• Output: Sinhgad Institutes


‘this’ Keyword
• The this keyword refers to the current object in a method or constructor.
• The most common use of the this keyword is to eliminate the confusion
between class attributes and parameters with the samename
public class MyClass {
int x;
/ / Constructor with a parameter
public MyClass(int x) {
this.x = x;
}
/ / Call the constructor
public static void main(String[] args) {
MyClass myObj = new MyClass(5);
System.out.println("Value of x = " +myObj.x);
}
}
If you omit the keyword in the example above, the output would be "0" instead
of "5".
‘this’ Keyword
‘this’ keyword can also be used to:
• Invoke current class constructor
• Invoke current class method
• Return the current class object
• Pass an argument in the method call
• Pass an argument in the constructor call

‘this’KeywordVideo
Method Overloading

• In Method Overloading, multiple methods can have the same name with
different parameters
• Example:
– int myMethod(int x)
– float myMethod(float x)
– double myMethod(double x, double y)
• we have to perform only one operation, having same name of the methods
increases the readability of the program.
• Method overloading increases the readability of the program.
• There are two ways to overload the method in java
• By changing number of arguments
• By changing the data type
Method Overloading
• Method Overloading by changing no. of arguments

class Adder{
static int add(int a,int b){
return a+b;
}
static int add(int a,int b,int c){
return a+b+c;
}
}
class TestOverloading{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11,11,11));
}}
Method Overloading
• Method Overloading by changing data type of arguments

class Adder{
static int add(int a,int b){
return a+b;
}
static double add(double a, double b){
return a+b;
}
}
class TestOverloading{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
System.out.println(Adder.add(11.2,11.3));
}}
Method Overloading
• Why Method Overloading is not possible by changing the return type of
method only?
class Adder{
static int add(int a,int b){
return a+b;
}
static double add(int a, int b){
return a+b;
}}
class TestOverloading{
public static void main(String[] args){
System.out.println(Adder.add(11,11));
}}
In java, method overloading is not possible by changing the return type of the
method only because of ambiguity
Object Creation
• In Java, an object is created from a class
• Tocreate an object of Class, specify the class name, followed by the object
name, and use the keyword new
public class MyClass {
int x = 5;
public static void main(String[] args) { MyClass
myObj = new MyClass();
System.out.println(myObj.x);
}
}

• You can create multiple objects of one class


• MyClass myObj1 = new MyClass(); / / Object 1
• MyClass myObj2 = new MyClass(); / / Object 2
Memory Allocation : ’new’
• The new keyword creates new objects.
• C++allows us to allocate the memory of a variable or an array in run time.
This is known as dynamic memory allocation.
• In Java, all objects are dynamically allocated on Heap.
• This is different from C++where objects can be allocated memory either
on Stack or on Heap.
• In C++, when we allocate the object using ‘new’ keyword, the object is
allocated on Heap, otherwise on Stack if not global or static.
• In Java, when we only declare a variable of a class type, only a reference is
created (memory is not allocated for the object).
• Toallocate memory to an object, we must use ‘new’. So the object is
always allocated memory on heap
• syntax for using the new operator is
pointerVariable = new dataType;
Memory Allocation : ’new’
public class MyClass {
int x = 5;
public static void main(String[] args) {
MyClass myObj ;
myObj = new MyClass();
System.out.println(myObj.x);
}
}
Memory Recovery : ’delete’

• In other programming languages such as Java and Python, the compiler


automatically manages the memories allocated to variables. But this is not
the case in C++.
• In C++, we need to deallocate the dynamically allocated memory manually
after we have no use for the variable.
• We can allocate and then deallocate memory dynamically using the new
and delete operators respectively.
• Once we no longer need to use a variable that we have declared
dynamically, we can deallocate the memory occupied by the variable.
• For this, the delete operator is used. It returns the memory to the
operating system. This is known as memory deallocation.
• The syntax for ‘delete’ operator is
delete pointerVariable;
Memory Recovery : ’delete’

/ / declare an int pointer


int* pointVar;
/ / dynamically allocate memory for an int variable
pointVar = new int;
/ / assign value to the variable memory
*pointVar = 45;
/ / print the value stored in memory
cout << *pointVar; / / Output: 45
/ / deallocate the memory
delete pointVar;

Here, we have dynamically allocated memory for an int variable using the
pointer pointVar.
After printing the contents of pointVar, we deallocated the memory
using delete
Using Object as Parameters
• Object references can be parameters.
• Call by value is used, but now the value is an object reference.
• This reference can be used to access the object and possibly change it.
• When we pass a primitive type to a method, it is passed by value. But when
we pass an object to a method, the situation changes dramatically, because
objects are passed by what is effectively call-by-reference.
• Java does this interesting thing that’s sort of a hybrid between pass-by-
value and pass-by-reference.
• Basically, a parameter cannot be changed by the function, but the function
can ask the parameter to change itself via calling some method within it.
– While creating a variable of a class type, we only create a reference to an object. Thus,
when we pass this reference to a method, the parameter that receives it will refer to the
same object as that referred to by the argument.
– This effectively means that objects act as if they are passed to methods by use of call-by-
reference.
– Changes to the object inside the method do reflect in the object used as an argument.
Using Object as Parameters
public class Rectangle { public void set(double l, double w) {
private double length; length = l;
private double width; width = w;
public Rectangle() { }
length = 0.0; public double getLength() {
width = 0.0; return length;
} }
public Rectangle(double l, double cpublic double getWidth() {
w) { return width;
length = l; }
width = w; public double getArea() {
} return length * width;
public void setLength(double l) { }
length = l; public double getPerimeter() {
} return 2 * (length + width);
public void setWidth(double w) { }
width = w;
}
}
Using Object as Parameters
public class PassObjectDemo {
public static void main(String[] args) {
/ / Create an Rectangle object.
Rectangle rect = new Rectangle(10, 20);
/ / Display the object's contents.
System.out.println("Length : " +rect.getLength());
System.out.println("Width: " + rect.getWidth());
System.out.println("Area: " +rect.getArea());
/ / Passthe object to the ChangeRectangle method.
changeRectangle(rect);
/ / Display the object's contents again.
System.out.println();
System.out.println("Length : " +rect.getLength());
System.out.println("Width: " + rect.getWidth());
System.out.println("Area: " +rect.getArea()); Output :
} Length : 10.0
Width: 20.0
public static void changeRectangle(Rectangle r) { Area: 200.0
r.set(30, 5);
} Length : 30.0
} Width: 5.0
Area: 150.0
Returning Object
• Like any other data datatype, a method can returns object.
• In java, a method can return any type of data, including objects
class ObjectReturnDemo {
int a;
ObjectReturnDemo(int i) {
a = i;
}
/ / This method returns an object
ObjectReturnDemo incrByTen() {
ObjectReturnDemo temp = new ObjectReturnDemo(a+10);
return temp;
}
}
/ / Driver class
public class Test {
public static void main(String args[]) {
ObjectReturnDemo ob1 = new ObjectReturnDemo(2);
ObjectReturnDemo ob2;
ob2 = ob1.incrByTen(); Output:
System.out.println("ob1.a: " +ob1.a);
System.out.println("ob2.a: " +ob2.a); ob1.a: 2
} ob2.a: 12
}
Array of Objects

• The array of objects, as defined by its name, stores an array of


objects.
• An object represents a single record in memory, and thus for
multiple records, an array of objects must be created.
• It must be noted, that the arrays can hold only references to the
objects, and not the objects themselves.
• Declaring An Array Of Objects In Java
• We use the class name Object, followed by square brackets to
declare an Array of Objects.
Object[] JavaObjectArray;
• Another declaration can be as
follows: Object JavaObjectArray[];
Array of Objects
class JavaObjectArray
{ public static void main(String args[])
{ Account obj[] = new Account[1] ;
obj[0] = new Account();
obj[0].setData(1,2);
System.out.println("For Array Element 0");
obj[0].showData();
}
}
class Account
{ int a;
int b;
public void setData(int c,int d) {
a=c;
b=d;
}
public void showData() Output:
{ System.out.println("Value of a ="+a); For Array Element 0
System.out.println("Value of b ="+b); Value of a: 1
Value of b: 2
}
}
Static Data Members
• The static keyword is a non-access modifier used for methods and
attributes.
• Static methods/attributes can be accessed without creating an object of a
class.
• You can create a static field/data members by using the keyword static.
• The static fields have the same value in all the instances of the class.
• These are created and initialized when the class is loaded for the first time.
• you can access static fields using the class name (without instantiation).

• Example
public class MyClass {
public static int data = 20;
public static void main(String args[]){
System.out.println(MyClass.data);
}
}
Static Methods
• You can create a static method by using the keyword static.
• Static methods can access only static fields, methods.
• In Java, static members are those which belongs to the class and you can access
these members without instantiating the class.
• Toaccess static methods there is no need to instantiate the class, you can do it just
using the class name.
• Example
public class MyClass {
public static void sample(){
System.out.println("Hello");
}
public static void main(String args[])
{ MyClass.sample();
}
}
Forward Declaration
• In computer programming, a forward declaration is a declaration of an
identifier (denoting an entity such as a type, a variable, a constant, or a
function) for which the programmer has not yet given a complete
definition.
Forward Declaration
Example
/ / Forward Declaration of the sum()
void sum(int, int);
/ / Usage of the sum
void sum(int a, int b) {
/ / Body
}
• In C++, Forward declarations are usually used for Classes.
• In this, the class is pre-defined before its use so that it can be called and
used by other classes that are defined before this.
/ / Forward Declaration class A
class A;
/ / Definition of class A
class A {
/ / Body
};
Forward Declaration
#include <iostream> int sum(A m, Bn) {
using namespace std; int result;
result = m.y + n.x;
/ / Forward declaration return result;
class A;
}
class B;
int main() {
class B { B b;
int x; A a;
public: a.getdata(5);
void getdata(int n) {
b.getdata(4);
x = n; cout << "The sum is : " << sum(a,b);
} return 0;
friend int sum(A, B); }
};

class A {
int y;
• Output:The sum is : 9
public:
void getdata(int m) {
y = m;
}
friend int sum(A, B);
};
Forward Declaration
class Test2 {
public static void main(String[] args) {
Test1 t1 = new Test1();
t1.fun(5);
}
}
class Test1 {
void fun(int x) {
System.out.println("fun() called: x = " +x);
}
}
Output: fun() called: x = 5
• The Java program compiles and runs fine.
• Note that Test1 and fun() are not declared before their use.
• Unlike C++, we don’t need forward declarations in Java. Identifiers (class
and method names) are recognized automatically from source files
Class as Abstract DataTypes(ADT’s)

• Abstract Data type (ADT) is a type (or class) for objects


whose behaviour is defined by a set of value and a set of
operations.
• The definition of ADT only mentions what operations are to
be performed but not how these operations will be
implemented.
• It does not specify how data will be organized in
memory and what algorithms will be used for
implementing the operations.
• It is called “abstract” because it gives an implementation-
independent view.
• The process of providing only the essentials and hiding the
details is known
as abstraction.
Classes as Objects
• Java 7 has come up with a new class Objects that have 9 static utility
methods for operating on objects.
• These utilities include null-safe methods for computing the hash code of
an object, returning a string for an object, and comparing two objects
• Using Objects class methods, one can smartly
handle NullPointerException and can also show customized
NullPointerException message
• public final class Objects extends Object
• The java.lang.Object class is the root of the classhierarchy.
• Every class has Object as a superclass.
• Methods from object class are clone(), equals(), finalize(), getClass(),
hashCode(), notify(), notifyAll(), toString(), wait() wait(long
timeout),wait(long timeout, int nanos)

You might also like