OOPCG

1. Sandip Foundation’s
Sandip Institute of Engineering & Management,
Mahiravani, Trimbak Road, Nashik-422213
Second Year of Computer Engineering
(2024 Course)
PCC-202-COM :
Object Oriented Programming and Computer
Graphics90
 Examination Scheme :
 CCE : 30 Marks
 End-Semester : 70 Marks
 Credits : 03
Asst.Prof. B.A.Gaikwad

2. Programming Paradigms
• Introduction to programming paradigms
• Programming paradigms are fundamental styles
or approaches to structuring and developing
computer programs.
• They provide different ways of thinking about
problems and organizing code, offering unique
perspectives on how to solve them.

3. Introduction to four main Programming
• Procedural
• Object Oriented
• Functional
• Logic & Rule based.

4. 1. Procedural Programming:
• This is a step-by-step approach where a program
is organized into procedures (also known as
functions or subroutines).
• The program executes these procedures in
a specific order to achieve a desired outcome.
• Examples of procedural languages include
C, Pascal, and Fortran.
• A key characteristic is the use of variables to store
and modify data as the program progresses.

5. 2. Object-Oriented Programming (OOP):
• OOP organizes code around objects, which
encapsulate data (attributes) and methods
(functions that operate on the data).
• It promotes concepts like encapsulation,
inheritance, and polymorphism to create
modular and reusable code.
• OOP languages include Java, C++, and Python.

6. 3. Functional Programming:
• This paradigm treats
computation
as the
evaluation of mathematical functions,
emphasizing the application and composition of
functions.
• It avoids changing the state of data (immutability)
and side effects, leading to more predictable and
easier-to-reason-about code.
• Functional languages include Haskell, Lisp, and
Erlang.

7. 4. Logic and Rule-based Programming:
• This paradigm expresses programs as a set of
logical rules and facts, rather than a sequence
of instructions.
• It focuses on describing the problem and
letting the system infer the solution based on
the rules.
• Prolog is a prominent example of a logic
programming language.

8. Need of object oriented programming
• 1. Managing Complexity:
• Modern software systems are often very large
and intricate. OOP helps break down these complex
systems into smaller, manageable objects.
• Each object has its own data (attributes) and
functions (methods) that operate on that data, making it
easier to understand, develop, and debug individual
components.
• 2. Code Reusability:
• OOP promotes code reuse through concepts
like inheritance and polymorphism.
• Inheritance allows new objects to inherit properties
and methods from existing ones, reducing redundancy
and development time.
• Polymorphism enables objects to be used
interchangeably in different contexts, further enhancing

9. • 3. Maintainability and Flexibility:
• OOP's modular structure makes it easier to maintain
and update code.
• Changes to one object are less likely to affect other
parts of the system, minimizing the risk of introducing
bugs.
• The flexibility of OOP allows for easier adaptation to
changing requirements and future enhancements.
• 4. Real-World Modeling:
• OOP allows developers to model real-world entities
and their interactions in a natural way using objects.
• This makes the code more intuitive and easier to
understand for both developers and users.

10. • 5. Enhanced Collaboration:
• OOP's modularity and clear structure facilitate
teamwork and collaboration.
• Developers can work on different objects
concurrently, leading to faster development
cycles.

11. Fundamentals of object-oriented programming
• Namespaces:-
• namespace is used to define a scope that could hold global
identifiers.
• ex:-namespace scope for c++ standard library. A
classes
,functions and templates are declared within the
namespace named std using namespace std;-->directive
can be used.
• user defined name space: syntax for defining name
space is namespace namespace_name
{
//declarations of variables.functions,classes etc...
}

12. • Example:
#include using namespace std;
namespace sample
{
int m;
void display(int n)
{
cout<<"in namespace
N="<<n<<endl;
}
}
using namespace sample;
int main()
{
int a=5;
m=100;
display(
200); c
out<<"M in sample name space:"<<sample::m;

13. Objects
• Objects are the basic run-time entities in an
object-oriented system. They may represent a
person, a place, a bank account, a table of
data or any item that the program must
handle.
• The fundamental idea behind object oriented
approach is to combine both data and
function into a single unit and these units are
called objects.

14. • For example: consider an example named Amit; Amit
is 25 years old and his Marks is 80. The Amit may
be represented in a computer program as an
object. The data part of the object would be
(name: Amit, age: 25, Marks: 80)

15. Classes
• C++ is an object-oriented programming language.
• Everything in C++ is associated with classes and
objects, along with its attributes and methods. For
example: in real life, a car is an object. The car
has attributes, such as weight and color, and methods,
such as drive and brake.
• Attributes and methods are
basically variables and functions that belongs to the
class. These are often referred to as "class members".
• A class is a user-defined data type that we can use in
our program, and it works as an object constructor, or
a "blueprint" for creating objects.

16. • Create a Class
• To create a class, use the class keyword:
• Example
• Create a class called "MyClass":
e.g
class MyClass
{ // The
class
public:
// Access specifier
int myNum; // Attribute (int
variable)
string myString; // Attribute (string variable)
};

17. Data Members & Methods
• The variables declared inside the class are
known as data members and the functions are
known as members of the functions.
• Only the member functions can have access to
the private data members and private
functions. However, the public members can
be accessed from the outside the class.

18. • Syntax:-
class item
{
int member;
float cost;
public: void getldata (int a ,float b);
void putdata (void);
}
The class item contains two data members and two
function members, the data members are private by
default while both the functions are public by declaration.
The function getdata() can be used to assign values to the
member variables member and cost, and putdata() for
displaying their values . These functions provide the only
access to the data members from outside the class.

19. Message Passing
• An object oriented program consists of set of
object that communicate with each other.
Objects communicates with each other by
sending and receiving information .
• A message for an object is a request
for execution of a procedure and there
fore invoke the function that is called for an
object and generates result

20. Data Encapsulation
• The wrapping up of data and function into a
single unit (called class) is known as
encapsulation.
• The data is not accessible to the outside world
and only those functions which are wrapped
in the class can access it. These functions
provide the interface between the objects
data and the program.

21. Data Abstraction & Information Hiding
• Abstraction refers to the act of representing
essential features without including the back
ground details or explanations.
• Classes use the concept of abstraction and are
defined as size, width and cost and functions
to operate on the attributes.

22. Inheritance
• Inheritance is the process by which objects of
one class acquire the properties of another
class. In the concept of inheritance provides
the idea of reusablity.
• This mean that we can add additional features
to an existing class with out modifying it.
• This is possible by designing a new class
will have the combined features of both
the classes.

23. Polymorphism
• Polymorphism means the ability to take more
than one form. An operation may exhibit
different instance. The behaviour depends
upon the type of data used in the operation.
• A language feature that allows a function or
operator to be given more than one definition.
The types of the arguments with which the
function or operator is called determines
which definition will be used.

24. • Overloading may be operator overloading or
function overloading.
• It is able to express the operation of addition
by a single operater say ‘+’. When this is
possible you use the expression x + y to
denote the sum of x and y, for many different
types of x and y; integers , float and complex
no.
• You can even define the + operation for
two strings to mean the concatenation of
the strings.

25. Benefits of object oriented programming
(OOPs)
• Reusability : In OOP‟ s programs functions and modules that are
written by a user can be reused by other users without
any modification.
• Inheritance: Through this we can eliminate redundant code and
extend the use of existing classes.
• Data Hiding: The programmer can hide the data and functions in
a class from other classes. It helps the programmer to build
the secure programs.
• Reduced complexity of a problem: The given problem can be
viewed as a collection of different objects. Each object
is responsible for a specific task. The problem is solved
by interfacing the objects. This technique reduces the
complexity of the program design.

26. • Easy to Maintain and Upgrade: OOP makes it easy
to maintain and modify existing code as
new objects can be created with small
differences to existing ones. Software
complexity can be easily managed.
• Message Passing: The technique of message
communication between objects makes
the interface with external systems easier.
• Modifiability: it is easy to make minor changes in
the data representation or the procedures in
an OO program. Changes inside a class do not
affect any other part of a program, since the
only public interface that the external world has
to a class is through the use of methods.

27. Java as Object Oriented Programming Language
• Java is considered an object-oriented
programming (OOP) language because it
revolves around the concept of objects, which
encapsulate data and methods.
• This approach allows for modular, reusable,
and maintainable code, making it well-
suited for building complex systems.

28. Java's Approach
• Java strictly adheres to the principles of OOP, with
features like classes, objects, inheritance,
polymorphism, and encapsulation.
• While Java also supports primitive data types and
static methods, which are not strictly part of OOP,
it is widely recognized and used as an object-
oriented language.
• This combination of features makes Java a
powerful and versatile language for a wide range
of applications.

29. Simple Java Program Structure
Documentation Section
Package Statements Import Statements
Interface Statements
Class Definitions
main method class
{
//Definitions
}

30. Simple Java programs
/* This is a simple Java program. Call this file
"Example.java". */
class Example
{
// Your program begins with a call to main().
public static void main(String args[])
{
System.out.println("This is a simple Java
program.");
}
}

31. Java Virtual Machine(JVM)
‘Simulated computer within the computer’
• JVM is the virtual machine that run the Java byte
code. It's also the entity that allows Java to be a
"portable language" (write once, run anywhere).
• Indeed there are specific implementations of the
JVM for different systems (Windows, Linux,
MacOS,..), the aim is that with the same byte code
they all give the same results (i.e. JVM is platform
dependent).

32. Data types
• The Java is a strongly typed language, part of Java’s safety
and robustness.
• First, every variable has a type, every expression has a type,
and every type is strictly defined.
• Second, all assignments, whether explicit or via
parameter passing in method calls, are checked for type
compatibility.
• There are no automatic coercions or conversions
of conflicting types as in some languages.
• The Java compiler checks all expressions and parameters to
ensure that the types are compatible. Any type
mismatches are errors that must be corrected before the
compiler will finish compiling the class.
• The domains which determine what type of contents
can be stored in a variable. In Java, there are two types of
data types:
• Primitive /Simple data types: Defines eight types of
data: byte, short, int, long, char, float, double, and boolean.
• Reference data types: or Abstract datatypes

34. Data Type Default Value Default size Range
byte 0 1 byte or 8 bits -128 to 127
short 0 2 bytes or 16 bits -32,768 to 32,767
int 0 4 bytes or 32 bits
2,147,483,648 to
2,147,483,647
long 0 8 bytes or 64 bits
9,223,372,036,85
4,775,808 to
9,223,372,036,85
4,775,807
float 0.0f 4 bytes or 32 bits
1.4e-045 to
3.4e+038
double 0.0d 8 bytes or 64 bits
4.9e-324 to
1.8e+308
char ‘u0000’ 2 bytes or 16 bits 0 to 65536
boolean FALSE 1 byte or 2 bytes 0 or 1
Primitive Data Types Table – Default Value, Size, and Range

35. Primitive Types vs. Reference type
• Storage: Primitives store values directly; references store
addresses of objects.
• Memory Allocation: Primitives are typically on the
stack; objects referenced by reference types are on the
heap.
• Methods: Primitives have no methods; reference types can
have methods.
• Nullability: Primitives cannot be null; reference types can
be null.
• Assignment Behavior: Assigning a primitive copies the
value; assigning a reference copies the address, potentially
leading to multiple references pointing to the same object

36. Floating Point Numbers
• The floating-point number are those number which
needs fractional precision that is the number that can
be in the fraction. There many more mathematical
calculations in which floating type is involved. For e.g.
finding the square root of a number up to certain
decimal values finding the cube root of the number,
finding roots of quadratic equation, and calculation
involving trigonometric functions like sin cos tan.
• There are two types of floating-point data type
• Float
• Double

37. • Float: It is a single-precision value that has 32 bits
in storage. and this single precision is faster and
does take less size compared to double precision.
• For java variables, we can use float while
declaring or initializing for expected value to be
fractional. The default value in java is 0.0f and its
size is 4 bytes. Float in java can have negative
values.
• The correct ways and incorrect ways of defining
java floating-point.
• float a1=10.57f which is equal to 10.57
• float a2 =10f it is equal to 10.0
• float a3=9.58 it will give an error.

38. // Java Program to Illustrate the Usage of Floating
import java.io.*;
public class GFG {
public static void main(String[] args)
{
// initialized two float variables with
// the least and max value of float
float a1 = 1.40129846432481707e-45f;
float a2 =
3.40282346638528860e+38f;
// printed the value of a1 and a2
System.out.println("Start range: " + a1);
System.out.println("End range: " + a2);
}

39. Operators and Expressions
• Java provides a rich operator environment. Most
of its operators can be divided into the following
four groups: arithmetic, bitwise, relational, and
logical. Classification of Operators
(1) Arithmetic Operators
(2) Relational Operators
(3) Logical Operators
(4) Assignment Operators
(5) Increments and Decrement Operators
(6) Conditional Operators
(7) Bitwise Operators
(8) Special Operators