In the previous chapter, you learned some of the basics of the object-oriented paradigm, including classes and objects, also known as instances. Now, when you dive deep into the programming languages, the class is always going to be the type and the blueprint. The object is the working instance of the class, and one or more variables can hold a reference to an instance.

Let's move to the world of our best friends, the dogs. If we want to model an object-oriented application that has to work with dogs and about a dozen dog breeds, we will definitely have a Dog abstract class. Each dog breed required in our application will be a subclass of the Dog superclass. For example, let's assume that we have the following subclasses of Dog:

So, each dog breed will become a subclass of...

When you ask the programming language to create an instance of a specific class, something happens under the hood. The programming language runtime creates a new instance of the specified type, allocates the necessary memory, and then executes the code specified in the constructor. When the runtime executes the code within the constructor, there is already a live instance of the class. Thus, you have access to the attributes and methods defined in the class. However, as you might have guessed, you must be careful with the code you put within the constructor, because you might end up generating large delays when you create instances of the class.

So, for example, before you can call the CalculateArea method, you want the Width and Height attributes for each new Rectangle instance to have a value initialized to 0. Constructors are extremely useful when...

Throughout this book, we will work with Python 3.4.3. However, all the explanations and code samples are compatible with Python 3.x.x. Therefore, you can work with previous Python versions as long as the major version number is 3. We will use JetBrains PyCharm Community Edition 4 as the main Python IDE and the supplier of an interactive Python console. However, you can use your favorite Python IDE or just the Python console.

For example, when we enter the following lines in a Python...

We want to initialize instances of the Rectangle class with the values of both width and height. After we create an instance of a class, Python automatically calls the __init__ method. Thus, we can use this method to receive both the width and height arguments. We can then use these arguments to initialize attributes with the same names. We can think of the __init__ method as the equivalent of a constructor in other object-oriented programming languages.

The following lines create a Rectangle class and declare an __init__ method within the body of the class:

class Rectangle:
    def __init__(self, width, height):
        print("I'm initializing a new Rectangle instance.")
        self.width = width
        self.height = height

This method receives three arguments: self, width, and height. The first argument is a reference to the instance that called the method. We used the name self for this argument. It is important to notice that self is not a Python keyword...

We want to know when the instances of the Rectangle class are removed from memory, that is, when the objects become inaccessible and get deleted by the garbage-collection mechanism. However, it is very important to notice that the ways in which garbage collection works depends on the implementation of Python. Remember that, Python runs on a wide variety of platforms.

Before Python removes an instance from memory, it calls the __del__ method. Thus, we can use this method to add any code we want to run before the instance is destroyed. We can think of the __del__ method as the equivalent of a destructor in other object-oriented programming languages.

The following lines declare a __del__ method within the body of the Rectangle class. Remember that Python always receives self as the first argument for any instance method:

def __del__(self):
        print('A Rectangle instance is being destroyed.')

The following lines create two instances of the Rectangle class...

We already created instances of the simple Rectangle class. We just needed to use the class name, specify the required arguments enclosed in parentheses, and assign the result to a variable.

The following lines declare a calculate_area method within the body of the Rectangle class:

def calculate_area(self):
    return self.width * self.height

The method doesn't require arguments to be called from an instance because it just declares the previously explained self parameter. The following lines create an instance of the Rectangle class named rectangle4 and then print the results of the call to the calculate_area method for this object:

rectangle4 = Rectangle(143, 187)
print(rectangle4.calculate_area())

Now, imagine that we want to have a function that receives the width and height values of a rectangle and returns the calculated area. We can take advantage of the Rectangle class to code this new function. We just need to create an instance of the Rectangle...

Throughout this book, we will work with C# 6.0 (introduced in Microsoft Visual Studio 2015). However, most of the explanations and code samples are also compatible with C# 5.0 (introduced in Visual Studio 2013). If a specific example uses C# 6.0 syntax and isn't compatible with C# 5.0, the code will be properly labeled with the compatibility warning. We will use Visual Studio Community 2015 as the main IDE. However, you can also run the examples using Mono or Xamarin.

The following lines declare a new minimal Circle class in C#:

class Circle
{
}

The class keyword followed by the class name (Circle) composes the header of the class definition. In this case, the class doesn't have a parent class or a superclass. Therefore, there aren't any superclasses listed after the class name and a colon (:). A pair of curly braces ({}) encloses the class body after the class header. In this case, the class body is empty. The Circle class is the simplest possible class we can declare...

We want to initialize instances of the Circle class with the radius value. In order to do so, we can take advantage of the constructors in C#. Constructors are special class methods that are automatically executed when we create an instance of a given type. The runtime executes the code within the constructor before any other code within a class.

We can define a constructor that receives the radius value as an argument and use it to initialize an attribute with the same name. We can define as many constructors as we want. Therefore, we can provide many different ways of initializing a class. In this case, we just need one constructor.

The following lines create a Circle class and define a constructor within the class body.

class Circle
{
  private double radius;

  public Circle(double radius)
  {
    Console.WriteLine(String.Format("I'm initializing a new Circle instance with a radius value of {0}.", radius));
    this.radius = radius;
  }
}

The constructor is...

We want to know when the instances of the Circle class are removed from memory, that is, when the objects go out of scope and the garbage-collection mechanism removes them from memory. Destructors are the special class methods that are automatically executed when the run time destroys an instance of a given type. Thus, we can use them to add any code we want to run before the instance is destroyed.

The destructor is a special class method that uses the same name as the class, but prefixed with a tilde (~): ~Circle. The destructor must be parameterless, and it cannot return a value.

The following lines declare a destructor (a ~Circle method) within the body of the Circle class:

~Circle()
{
  Console.WriteLine(String.Format("I'm destroying the Circle instance with a radius value of {0}.", radius));
}

The code within the destructor prints a message on the console indicating that the runtime is destroying a Circle instance with a specific radius value. This way, we...