introduction to oop
TRANSCRIPT
INTRODUCTION TO OOP
Session 4
A bit about me
Timisoara .Net Meetup organizer.
Web and mobile freelancer.
Xamarin enthusiast.
In love with software architecture.
@flaviusdemian
/pub/flavius-demian/32/191/178
/demian.flaviusradu
Agenda
What is OOP
OOP and .NET
Classes, objects, constructors
Encapsulation
Access Modifiers
The static keyword
Static vs Non-Static
Class inheritance
Agenda
Polymorphism
Method overloading
Method overriding
Abstract class
Sealed class
Interfaces
Interfaces vs abstract classes
Boxing and unboxing
The const keyword
Agenda
The readonly keyword
Properties
Indexers
The is and as keywords
Lists
Dictionaries
Queues
Stacks
What is OOP
Object-oriented programming (OOP) is a programming paradigm based on the concept of "objects", which are data structures that contain data, in the form of fields, often known as attributes; and code, in the form of procedures, often known as methods.
In object-oriented programming, computer programs are designed by making them out of objects that interact with one another.
OOP is a methodology to write the program where we specify the code in form of classes and objects.
What is OOP
OOP and .NET
In .NET Framework the object-oriented approach has roots in the deepest architectural level.
All .NET applications are object-oriented.
All .NET languages are object-oriented.
There is no multiple inheritance in .NET.
Classes can implement several interfaces at the same time.
Every object inherits System.Object – the root of the hierarchy.
Classes, objects, constructors
Classes model real-world objected and define:
Attributes (state, properties, fields)
Behavior (methods, operations)
A class is a blueprint or a template while objects are usable instances of a class.
// class declaration
Class SampleClass {};
// object instantiation
SampleClass mySampleClass = new SampleClass();
Classes, objects, constructors
Constructors are used to create and initialize an object of a class.
A constructor resembles an instance method, but it differs from a method in that it has no explicit return type. Constructors have the same name as the declaring class.
They have the task of initializing the object's data members and fields.
class MyClass
{
public MyClass() { //code init here}
}
Encapsulation
It basically means hiding the internals of a class.
Encapsulation, in OOP, prevents access to implementation details.
It enables the programmer to implement the desired level of abstraction.
Encapsulation is implemented by using access modifiers, which define the scope and visibility of a class member.
Encapsulation
Access Modifiers
Class members can have access modifiers which:
are used to restrict the classes able to access them
support the OOP principle of encapsulation
provide a certain level of access
Access modifiers are:
public – accessible from any class
protected– accessible from the class itself and all its descendent classes
private – accessible from the class itself only
internal – accessible from the current assembly (used by default)
Access Modifiers
Demo
The static keyword
A static member of the class is a property, procedure, or a field that is shared by all instances of a class.
A static member is associated rather with a class than with a instance.
Static members cannot access non-static properties, fields or methods.
The static keyword
static class SampleClass
{
static string myString = “My static string”;
}
private static void Main(string[] args)
{
Console.Write(SampleClass.myString);
}
Static vs Non-Static
Static:
Associated with a type, not with an instance
Non-Static:
The opposite, associated with an instance
Static:
Initialized just before the type is used for the first time
Non-Static:
Initialized when the constructor is called
The static keyword
Demo
Class inheritance
Inheritance allows child classes to inherit the characteristics of existing parent class:
Attributes (fields and properties)
Operations (methods)
Child (derived) class can extend the parent class:
Add new fields and methods
Redefine methods (modify existing behavior)
Every class that extends the base class can replace the base class.
A derived class extends a base (parent) class.
A class can inherit only one class.
Class inheritance
In .NET you extend a class by using :
class DerivedClass : BaseClass
{
//code here
}
Inheritance has a lot of benefits:
Extensibility Provides abstraction
Reusability Eliminates redundancy
Class inheritance
Use inheritance for building IS A relationship.
A dog is an animal
Don’t use it to build HAS A relationship.
A dog has a name (dog is not kind of name)
Class inheritance
Inheritance is a transitive relation: Honda Shine also inherits Automobiles !
Class inheritance
Demo 3,4
Polymorphism
Polymorphism => poly = many, morph = shape => multiple shapes.
Objects can behave differently depending on their types => an operation may exhibit different behavior in different situations.
Base classes may define and implement virtual methods and derived
classes can override them.
Polymorphism
The signature of a method is its name and parameter list, not the return type.
It happens in 2 ways:
overriding methods in derived classes - dynamic polymorphism
overloading methods by changing the signature - static polymorphism
Overloading
Overloading is the ability to create multiple methods of the same name with different implementations.
Calls to an overloaded function will run a specific implementation of that function appropriate to the context of the call.
This allows one function call to perform different tasks depending on context.
For example, doTask() and doTask(string s) are overloaded methods.
Overloading
Demo
Overriding
By default, a derived class inherits all members from its base class.
Overriding is all about specialization and refinement.
A method is said to be a virtual one when it is declared as virtual.
public virtual void Calculate() { //code here };
Overriding
Methods that are declared as virtual in a base class can be overridden using the keyword override in the derived class.
You cannot override a non-virtual or static method.
The overridden base method must be virtual, abstract or override.
Overriding
Overriding
Demo
Polymorphism
Polymorphism
Abstract class
An abstract method is a method without implementation => it is left empty to be implemented by descendant classes.
When a class contains at least one abstract method, it is called an abstract class.
The derived classes are obliged to implement their abstract methods.
Abstract classes cannot be directly instantiated.
Abstract class
public abstract class MyAbstractClass
{
public abstract void DoWork();
}
public class RealClass : MyAbstractClass
{
public override void DoWork()
{
// code here
}
}
Abstract class
Demo
Sealed class
When applied to a class, the sealed modifier prevents other classes from extending it.
When you define new methods or properties in a class, you can prevent deriving classes from overriding them by not declaring them as virtual.
Sealed class
public abstract class MyAbstractClass
{
public abstract void DoWork();
}
public sealed class RealClass : MyAbstractClass
{
//it seals the implementation
public override sealed void DoWork()
{
// code here
}
}
Sealed class
public sealed class MySealedClass
{
//methods here
}
//This is not valid…You receive an error at compile-time.
public sealed class RealClass : MySealedClass
{
}
Sealed class
Demo
Interface
Interfaces, like classes, define a set of properties, methods and events.
But unlike classes, interfaces do not provide implementation.
They are implemented by classes and defined as separate entities from classes.
Interface
An interface represents a contract, meaning that a class that implements an interface must respect every aspect of that interface exactly as defined.
Cannot be instantiated. Members do not have scope modifier and by default the scope is public.
Interface
To define an interface:
Interface ISampleInterface
{
void doSomething();
}
To implement and interface in a class:
class SampleClass : ISampleInterface
{
void doSomething()
{ // code here }
}
Interface
Demo
Interfaces vs abstract classes
Interfaces and abstract classes allow you to create definitions for component interaction.
Through interfaces, you can specify methods that a component must implement without actually specifying how the method is implemented.
Abstract classes allow you to create definitions for behavior while providing some common implementation for inheriting classes.
Both are valuable tools for implementing polymorphic behavior in your components.
Boxing and unboxing
Boxing:
Cast a value-type instance to a reference-type instance:
int valueInteger = 9;
Object obj = valueInteger;
Unboxing:
Reverse – cast a reference-type instance to a value-type instance
int newValueInteger = (int)obj;
It is computationally expensive – best if avoided
The const keyword
Constant fields are defined like fields.
They are defined with the keyword const.
Constants must be initialized at their definition.
Their value cannot be changed at runtime.
public class MathConstants
{
public const double PI = 3.14159;
}
The readonly keyword
Read-only fields are initialized at the definition or in the constructor and cannot be modified further.
They are defined with the keyword readonly and represent runtime constants.
public class ReadOnlyDemo
{
private readonly int size;
public ReadOnlyDemo(int size)
{
this.size = size;
}
}
Properties
Properties object’s are data to the outside world.
They control how the data is manipulated.
They can be
read-only
write-only
read and write
Properties give good level of abstraction.
Makes writing code easier .
Properties
Properties should have:
access modifier (public, protected, internal, private)
return type
unique name
Get and/or Set part
The getter and/or setter can contain code processing data in specific way.
Properties
public class Point
{
private int xCoord;
private int yCoord;
public int XCoord
{
get { return xCoord; }
set { xCoord = value; }
}
public int Ycoord
{
get { return yCoord; }
set { yCoord = value; }
}
}
Properties
Properties are not obligatory bound to a class field – they can be calculated dynamically => dynamic properties.
public class Rectangle
{
private float width;
private float height;
public float Area
{
get
{
return width * height;
}}
}
Properties
Demo
Indexers
Indexers provide access to inner list/dictionary of values.
public class Zoo{
public Animal[] animals;
public Zoo(Animal[] animals){
this.animals = animals;}public Animal this [int animalIndex]{
get { return animals[animalIndex]; }set { animals[animalIndex] = value; }
}}
Indexers
In the main method we would have something like this:
Zoo zoo = new Zoo( new Animal[]
{
new Animal(“Pete”),
new Animal(“Frank”),
new Animal(“Stephan”)
}
);
Console.WriteLine(zoo[2]);
Indexers
Demo
The is and as keywords
The is operator returns true if an object is an instance of a type.
The as operator attempts to cast to a specified type.
If it fails it returns null and it does not raise an exception.
var d = new Dog(“Rex”);
bool dogIsAnimal = d is Animal;
if( dogIsAnimal == true)
{
Animal dogAsAnimal = d as Animal;
}
The is and as keywords
Demo
List
The List class is a collection and defined in the System.Collections.Generic namespace.
It provides the methods and properties like other Collection classes such as add, insert, remove, search etc.
List<int> list = new List<int>();
list.Add(2);
list.Add(3);
foreach (int number in list) // Loop through List with foreach
{
Console.WriteLine(number );
}
List
Demo
Dictionary
A dictionary class is a data structure that represents a collection of keys and values pair of data.
The key is identical in a key-value pair and it can have at most one value in the dictionary, but a value can be associated with many different keys.
This class is defined in the System.Collections.Generic namespace.
Dictionary<string, int> dict = new Dictionary<string, int>();
dict.Add("one", 1);
dict.Add("two", 2);
Dictionary
foreach (KeyValuePair<string, int> pair in dict) // iterate over values
{
Console.WriteLine(pair.Key.ToString ()+ " - " + pair.Value.ToString () );
}
if (dict.ContainsKey("four") == true) //search for a key
{
Console.WriteLine(dict["four"].ToString ());
}
Dictionary
Demo
Queue
Queue is a FIFO (first in first out) collection. It processes elements in a first-in, first-out order.
To restate, it handles the elements that it received longest ago first.
// New Queue of integers
Queue<int> q = new Queue<int>();
q.Enqueue(5); // Add 5 to the end of the Queue.
q.Enqueue(10); // Then add 10. 5 is at the start.
Methods: Clear, Contains, Dequeue, Enqueue ,Peek, Count, ToArray,
Queue
Demo
Stack
Stack is a LIFO collection. It provides a powerful and simple last-in-first-out data structure.
This can help you develop parsers quickly and also replace complex recursive algorithms. Stack is a generic type.
Stack<int> stack = new Stack<int>();
stack.Push(100); - adds a value
stack.Push(1000); - adds a value
stack.Pop(); - removes 1000 and returns it
Methods: Push, Pop, Clear, Count, Copy, Search
Stack
Demo
References
Documentation:
http://msdn.microsoft.com/en-us
http://www.dotnetperls.com/
csharp.net-informations.com/
Presentations:
http://www.slideshare.net/SoftwareStartUpAcademyOsijek/c-igor-rali
http://www.slideshare.net/DonchoMinkov/objectoriented-programmingwith-c
http://www.slideshare.net/TelerikAcademy/25-object-oriented-programming-principles-c-fundamentals