BIM313 – Advanced Programming Techniques
Object-Oriented Programming
1
Contents
• Object-Oriented Programming– Objects– Constructors, Destructors– OOP Techniques (Interfaces, Inheritance,
Polymorphism, Operator Overloading, Events)
2
Object-Oriented Programming (OOP)
3
Contents
• What is OOP?• OOP Techniques• Using OOP in Console Application
4
What is OOP?
• The type of programming we have covered so far is known as functional (or procedural) programming
• OOP is an approach to creating computer applications which uses objects
• Code reuse is easier in OOP• We have already used some objects in our
programs (e.g. Console, Exception, etc.)
5
Objects
• An object has both member variables and methods– structs in C contain only member variables
• Objects are instantiated from classes• Objects are also called instances• The terms class and object are often
confused, and it is important to understand the distinction
6
Class vs. Object
Class• Class is only a definition
• Classes are coded in source files
• You write a class once
• Classes are abstract
Object• Object is the
implementation• Objects are created at
runtime• You can create many objects
from a class• Objects are concrete
7
Class vs. Object
8
Everything is an object
• Everything in C# and .NET Framework is an object!
• even the int variables are objects too!
9
Object Members
• Properties– Data contained in an object– Determine the state of the object– They may be read-only, write-only, or both readable
and writable– Example: Columbian filter coffee with milk and two
sugars• Methods– Functions of objects are called methods– Example: AddSugar(), Mix(), etc.
10
Visibility
• public– Public variables or methods are accessible by
other objects• private– Private variables or methods are accessible only
by the methods of the object itself
11
The Life Cycle of an Object
• Construction– Initialization of the object– Implemented by constructors– There may be several constructors– The code snippet ctor can be used to create a
constructor in Visual Studio• Destruction– Resources used by the object are freed– Implemented by a destructor function– Each class may have only one destructor function
12
Construction
• CupOfCoffee myCup = new CupOfCoffee();• CupOfCoffee myCup = new
CupOfCoffee(“Columbian”);• CupOfCoffee myCup = new
CupOfCoffee(“Columbian”, true, true, 2);
13
Source Filtered? Milk? Sugar?
Constructor Syntax
class MyClass{ public MyClass() { // Default constructor code } public MyClass(int myInt) { // Non-default constructor code }}
14
Destruction
• You can make some extra operations when an object is about to be destroyed– e.g. Saving the object data into a file
• Generally the default destructor does all the work for you and you don’t need to write a destructor
15
Destructor Syntax
class MyClass{ ~MyClass() { // Destructor body }}• Use the Finalize() method to call the destructor
16
Static and Instance Class Members
• Static Members– Shared between all instances of a class– You don’t need to instantiate an object to use a static member– You can access static member with the class name– Examples: Math.Sin(), Main(), Console.WriteLine(), int.Parse(),
Convert.ToDouble(), etc.– static methods can access only the static members of a class
• Instance Members– All objects have separate instance members– Instance members require an instance to be used– You can access instance members with the name of the objects– Examples: Length() (of strings and arrays), ToString(), etc.
17
OOP Techniques
• Interfaces• Inheritance• Polymorphism• Operator Overloading• Events
18
Interfaces
• An interface is a collection of methods and properties that are grouped together to encapsulate specific functionality
• Interfaces are only some definitions, and they should be implemented in classes– i.e. the class supports all functionality defined in the interface
• You can’t instantiate an interface• Interfaces cannot contain any code• Interface names generally start with ‘I’• A class may implement more than one interfaces
19
Interface Syntax
public interface IMyInterface{ …}public class MyClass : IMyInterface{ …}
20
Exercise: Sorting Cars
• Create an enumeration of ‘CarBrands’• Create a class ‘Car’• Add two members, ‘Brand’ and ‘Price’ to ‘Car’ class definition• Create a constructor (use ‘ctor’ code snippet)• Create a ‘Display()’ method in ‘Car’ class• Create an array of cars in Main• Change ‘Car’ definition so that it implements IComparable
interface– IComparable objects can be sorted
• Implement the CompareTo() method• Sort the cars in Main
21
Implementing an Interface in VS
22
Solution (Page 1) enum CarBrand { Mercedes, BMW, Honda, Toyota, Volkswagen, Mazda } class Car : IComparable<Car> { // Properties: CarBrand Brand; decimal Price;
// Constructor: public Car(CarBrand brand, decimal price) { this.Brand = brand; this.Price = price; }
// Methods public void Display() { Console.WriteLine(this.Brand + " - " + this.Price + " TL."); }
public int CompareTo(Car other) { return (int)this.Price - (int)other.Price; } }
23
Solution (Page 2)class Program { static void Main(string[] args) { Car[] cars = new Car[] { new Car(CarBrand.Volkswagen, 70000), new Car(CarBrand.Mercedes, 100000), new Car(CarBrand.Honda, 65000) };
Array.Sort(cars);
Console.WriteLine("Cars sorted in price:\n"); foreach (Car car in cars) { car.Display(); } } }
24
Inheritance
• Any class may inherit from another• Inherited class will have all members of base
class• Classes in C# may derive only from a single
base class directly (No multiple-inheritance)• Interfaces may inherit from other interfaces
(maybe multiple)• Syntax: class InheritedClass : BaseClass { … }
25
Inheritance Syntax
public class MyClass : BaseClass{ …}class MyClass : BaseClass, Interface1, Interface2{ …}
26
Visibility in Inheritance
• Public members of the base class are accessible from the derived class
• Private members of the base class are not accessible from the derived class
• Protected members of the base class are accessible from the derived class but not accessible from other classes
27
Virtual Members
• Virtual members of the base class can be overridden by the derived class
28
Abstract Classes
• Abstract classes can’t be instantiated directly• You have to derive another class from the
abstract class and then the derived class can be instantiated
• Abstract classes may have abstract members, which have no implementation in the base class, so an implementation must be supplied in the derived class
29
Sealed Classes
• A sealed class may not be used as a base class, so no derived classes are possible
30
Polymorphism
• Using the same method with different implementations in base and derived classes is called polymorphism
• Example: ToString() method of the Object class
31
Operator Overloading
if (carA.Price > carB.Price) {…}• You can use the following code if you overload
the < and > operators:if (carA > carB) {…}
32
Events
• When you click a button or move the mouse in a Windows program, events are raised
• When an event is raised, an event handler method is executed
• You can add custom events into your own classes
33
Reference Types vs. Simple Types
• Simple Types– int, float, double, etc.– string– object– struct
• Reference Types: Contents are stored in a separate memory location (heap)– Classes (Objects created with the new keyword)– Arrays
34
Shallow Copying vs. Deep Copying
• Shallow Copying– When you make a copy of an object, value types are
copied correctly but reference types point to the previous copies
– Accomplished by MemberwiseClone method of the object class• MemberwiseClone() is a protected member of the object
class
• Deep Copying– Reference types are copied too– Implement the ICloneable interface
35
Properties
• You can’t make range-check on public members– Age of a person can only be positive– If negative values are assigned, program may crash
• By using properties, you can check values before they are assigned
• You can create read-only or write-only properties
36
Properties Syntax
public int MyIntProp{ get { // Property get code. } set { // Property set code. }}
37
Properties Example
private int m_Age;public int Age{ get { return m_Age; } set { if (value < 0) m_Age = 0; else m_Age = value; }}
38
Read-Only Property Example
private string FirstName;private string LastName;public string FullName{ get { return FirstName + “ ” + LastName; }}
39
.:. Application .:.
• Create a Curve class which stores a list of points• Create a Point class to be used in the Curve class• Add PrintPoints() and AddPoint() methods into the Curve
class• Make the Curve class cloneable
– try shallow and deep copies• Create a property named CurveLength• Overload the ‘–’ operator so that Point1 – Point2 gives the
distance between them• Overload the ‘<’ and ‘>’ operators for the Curve class which
compares the curve lengths40