This document discusses key concepts of object-oriented design and programming. It defines object-oriented design as planning a system of interacting objects to solve software problems. It describes object-oriented programming as representing concepts as objects that have data fields and methods. The document outlines some key pillars of object-oriented programming including inheritance, which allows code reuse; encapsulation, which protects data; and access modifiers like public, private, and protected, which control object accessibility.

1. Advance Concepts of
Object Oriented Design

3. Objectives
• Design principles of Object Oriented Programming
• Pillars of Object Oriented Programming
Concept of Object Oriented Design
The process of planning a system of interacting objects for the purpose
of solving a software problem .it is one of the approaches for software
design

4. Object Oriented programming
Object Oriented programming (OOP) is a programming
paradigm that represents concepts as “objects "that have data
fields (attributes that describe the object) and associates
procedures known as methods. Objects ,which are instances of
classes ,are used to interact with one another to design
applications and computer programs
Examples of Object Oriented languages include Smalltalk C++
and objective-c Eiffel .Python ,Ruby java C# Visual Basic .NET

5. Pillars of Object Oriented
Programming
Inheritance
one of the primary concepts of object-oriented programming.it
allows you to reuse existing code, through effective employment
of reuse you can save time in your programming

6. Using System;
public class Parent Class
{
public Parent Class()
{
Console.WriteLine(“Parent Constructor”);
}
public void print()
{
Console.WriteLine(“I am parent class ”);
}
}
Public Child Class :Parent Class
public Child Class()
{
Console.WriteLine(“Child Constructor ”);
}
}
Public static void main ()
{
Child Class child = new Child Class();
child.print();
}
}
The top class is named as parent
class and the main class is called
child class, what we want to do
is create a child class as the base
class of child class . This is
accomplished through the child
class declaration as public class.
the base class is specified by
adding a colon “:”; after the
derived class identifier and then
specifying the base class name .

7. Sealed Class
Sealed Classes are used to restrict the inheritance feature of object
oriented programming once a class is defined as sealed class this
class cannot be inherited
Encapsulation
Encapsulation is the process of putting data and the operations
(functions) that can be performed on data into a single container
called class
Now any programmer can use this class without knowing how is
implemented .Due to encapsulation data is insulated thus not directly
accessible from the outside world ,this is known as data hiding
Encapsulation is not data hiding but Encapsulation leads to data
hiding
Access Modifier
Access modifier are keywords used to specify the declared
accessibility of a member or a type .This section introduces the four
access modifiers

8. Public
The public keyword is an access modifier for types and type
members. Public access is the most permissive access level
there are no restriction accessing public members
Using system
class bank account Public
{
public decimal Get Amount()
{
return 1000.00m;
}
}

9. Using system
class MyClass
{
protected int x;
protected int y;
}
class My DerivedC:MyClass
{
public static void main()
{
MyDerived mC=new My DerivedC();
// Direct access to protected members:
mC.x = 10;
mC.y = 15;
Console.WriteLine(“ x = {0}, y = {1} ”. mC.x. mC,y);
}
}

10. Private
Private keyword is a member access modifier .A Private member is least
permissive access level .Private member are accessible within the body
of the class
Using System
class Bank Account Private
{
private string m_name ;
public string Customer Name
{
get
{
get { return m_name;}
set{ m_name = value;}
}
}

11. Internal
The Internal keyword is a member access modifier for types and type members
A Internal member are accessible from with in the files in the same assembly