Transcript EEM336 – Microprocessors I

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);
Source
Filtered?
Milk?
Sugar?
13
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 lengths
40