CHAPTER-1.1: Class and object
CHAPTER-1.1:Class and Object
Object:
In the real world, Objects are the entities of which the world is
comprised. Everything that happens in
the world is related to the interactions between the objects in the world. Just as atoms, which are objects, combine to
form larger objects, the interacting entities in the world can be thought of as
interactions between and among both singular ("atomic") as well as
compound ("composed") objects.
The real world consists of many, many objects interacting in many
ways. While each object may not be
overly complex, their interactions create the overall complexity of the natural
world. It is this complexity that we
wish to capture in our software systems. In an object-oriented software system,
objects are entities used to represent or model a particular piece of the
system. Objects are the primary units used to create abstract models.
An object that does not interact with anything else effectively does not
exist. Access to internally stored data
is necessarily through some sort of defined behavior of the object. It is impossible for an outside entity to
truly "know" whether or not a particular piece of data is being
stored inside of another object. The
real meaning of the object is in how the object behaves in relationship to its
data, should it contain any. The
existence of data in an object is an implementation technique used to generate
the required behavior of that object.
Objects are variables of type class.
Once a class has been defined, we can create any number of objects belonging to
that class. Objects contain data and code to manipulate that data. Object is
using to allocate memory space for class member variables and member functions.
Classes :
Many objects differ from each other only in the value of the data that
they hold. For example, both a red light
and a blue light are lights; they differ only in the value of the color
attribute, one has a red color and the other a blue color. Our object-oriented system needs a way to
capture the abstraction of a light, independent of the value of its color. That is, we want to express that a set of
objects are abstractly equivalent, differing only in the values of their
attributes.
Object-oriented systems use classes
to express the above concept of abstract equivalence. A class is a summary description of a set of
objects. A class thus contains the descriptions of all the behaviors of the
objects that it represents. In computer science parlance, we call the
individual behaviors of a class its methods.
In addition, a class contains descriptions of the internal data held by
the objects. Turning the description around, we can say that a class is a
pattern for the creation of a particular type of object.
That is, one can use a class to create objects of the type described by
the class. A class is an arrangement of
a set of objects, it is not the actual object. In technical terms, a class
defines a new type in the system. Types
are identifies used to differentiate different kinds of data. For instance, integers, characters, strings
and arrays are all types of data.
A class is a way to bind the data and
its associated functions together. It allows the data (and function) to be
hidden, if necessary from external use. A class is a collection of objects of
similar type. Classes are user defined data types and behave like the built in
data types of a programming language.
example:
class muna
{
memberfunction()
{
datatype:
}
};
main()
{
muna ob1;
ob1.memberfunction();
}
Example: if a is a class name and ob is a object of class a, then the
format of using class and object in C++ program is look like as follows:
class a
{
public:
int x;
void getdata()
{
}
void display()
{
}
};
void main()
{
a ob; //object declaration
ob.getdata();// accessing
class member function
ob.display(); //accessing
class member function
}
Specifying a class:
Generally, a class specification has two parts:
Class declaration
Class function definition
The class declaration describes the type and scope of its members. The
class function definitions describe how the class functions are implemented.
The general form of a class declaration is:
class class_name
{
private:
variable declarations;
function declarations;
public:
variable declarations;
function declarations;
};
The body of a class is enclosed within braces and terminated by a
semicolon. The class body contains the declaration of variables and functions.
These functions and variables are collectively called class members. Class
members are usually grouped into two sections, namely, private and public. The
keywords private and public are known as visibility labels. Note that these
keywords are followed by a colon.
The class members that have been declared as private can be accessed
only from within the class. On the other hand, public members can be accessed
from outside the class also. The data hiding (using private declaration) is the
key features of object oriented programming. The use of the keyword is
optional. By default the members of a class are private.
The variables inside the class are known as data members and functions
are known as member functions. Only the member functions can have access to the
private data members and private functions. However, the public members (both
function and data) can be accessed from outside the class.
Accessing class members:
We can access class members like the following way-
Syntax:
object_name.function_name(argument_list);
example:
ob.getdata();
ob.display();
Defining member function:
Member functions can be defined in two places:
Outside the class definition
Inside the class definition
Outside the class definition:
Member functions that are declared inside a class have to define
separately outside the class. return_type class_name :: function_name (argument
declaration)
{
Function body
}
Example:
void a::getdata(int a, float b)
{
number=a;
cost=b;
}
The symbol :: is called scope resolution operator.
The member functions have some special characteristics that are often
used in the program development. These characteristics are:
qSeveral different
classes can use the same function name.
qMember functions
can access the private data of the class. A non member function cannot do so.
(However, an exception to this rule is a friend function discussed later.)
qA member function
can call another member function directly, without using the dot operator.
Inside the class definition:
We can define member functions inside the class as well. Only small
functions are defined inside the class.
class ae
{
public:
int x;
void getdata()
{
Int x=10;
}
void display()
{
cout<<x;
}
};
void main()
{
a ob; //object declaration
ob.getdata();// accessing
class member function
ob.display(); //accessing
class member function
}
What are the advantages of OOP?
qIt presents a
simple, clear and easy to maintain structure.
qIt enhances
program modularity (partitioning) since each object exists independently.
qNew features can
be easily added without disturbing the existing one.
qObjects can be
reused in other program.
qData is fully
secured
qOperator
overloading is possible in OOP
Various elements of OOP are:
qObject
qClass
qMethod
qEncapsulation
qInformation Hiding
qInheritance
qPolymorphism
Class
A class is a collection of data and the various operations that can be
performed on that data.
Object
This is the basic unit that are associated with the data and methods of
a class. To access any element of a class, an object is used.
Method
A set of programming code used to
perform the operation of the program. For example, find_salary().
Encapsulation:
Encapsulation is the process of binding class elements (data and
functions) in a single unit. Encapsulation separates the conceptual interface.
Encapsulation is the process of hiding data of a class from objects. This is to
say, if a function or a method inside this class is private, only objects of
this class can access the method. The three access specifiers (private, public, protected) determine
whether the methods are accessible to all classes or only the defining class or
the friend class.
Information Hiding:
Information hiding is the primary criteria of system and should be
concerned with hiding the critical element in system. Information hiding
separates the end users from illegal access of the requirement. Encapsulation supports information hiding by making
use of the three access specifiers of a class.
Public:- If a class member is public, it can be used anywhere without the
access restrictions.
Private: if a class member is private, it can be used only by the members and
friends of class.
Protected : if a class member is protected, it can be used only by the members of
class, friends of class and derived class.
Inheritance:
Inheritance is a way by which a subclass inherits attributes and
behaviors of a parent or base class and can have its own as well. Inheritance
is the process of involving building classes upon existing classes. So that
additional functionality can be added. Using inheritance the hierarchical
relationships are established. Inheritance allows the reusability of an
existing functions and data of a class.
Polymorphism:
Polymorphism is the ability to calls the same named methods from
different classes. Each function contains its own specific behavior.
Polymorphism means the ability to take more than one form. An operation may
exhibit different behaviors in different instances.
No comments