Introduction to Classes and Constructors in OOP
Tags: beginners, oop, csharp
Published: 2021-09-28 09:55:17

Let's learn about classes and constructors in Object Oriented Programming using the C# programming language. We are going to create a simple program where we will learn how to declare a class and a constructor. I am also going to discuss parameterless and parameterized constructors and how we can use them to initialize an object.

### What is a Class
A class is a model for creating objects. It defines the attributes, properties, and methods shared by all objects created from it. If two objects are instantiated from the same class, each object will share the same properties of the class, though they may have different property values. 

### Declaring a Class
Let’s start by creating a `Student` class:

```c#
public class Student
{
}
```

A class declaration consists of:
* Access Modifier: This sets the class access level. The public keyword means we can access and instantiate this class from other classes. If we do not specify any access modifier in our declaration, it defaults to `internal`.
* Class keyword: This is a reserved keyword in C#. We are using it here to declare the class.
* Identifier: This can be any name we give to the class. It must start with a letter or an underscore character (_). A naming convention in C# is using pascal casing for class names (e.g StudentLoan)

### What is a Constructor
A constructor is a special method of a class that we can automatically call anytime we instantiate a class. Constructors set the initial values for object fields and can contain any code that executes at the time of object creation. If we do not provide a constructor in our class, the C# compiler creates a default constructor for us and it sets the fields to their default values.

 
### Declaring a Constructor
Let’s create a constructor for the `Student` class we declared earlier:

```c#
public class Student
{
    public Student()
    {
    }
}
```

A constructor declaration consists of:
* Access modifier: Just like in our class declaration, the constructor also has an access modifier. If we do not specify any access modifier in our declaration, it defaults to `private`. This makes this class inaccessible from classes outside of it.
* Identifier: The constructor identifier must have the same name as the class name. Unlike classes that we can give any valid name, specifying an identifier different from the class name will result in a compile-time error. This is because C# will treat the constructor like a class method that requires a return value in its declaration.
* Constructor parameters: Constructors can accept parameters or have no parameter. 
The `Student` constructor we declared above accepts no parameter and is known as a `parameterless` constructor.


```c#
public class Student
{
    private readonly int _age;
    private readonly string _name;     

    public Student()
    {
    }

    public Student (string studentName, int studentAge)
    {
        _name = studentName;
        _age = studentAge;
    }
}
```
Here, we declare another `Student` constructor that accepts parameters which we then use to set the fields’ initial values. This type of constructor is known as a `parameterized` constructor. It allows us to pass in values for the fields during object creation.

### Instantiating a class
Now we are going to instantiate the `Student` class using its constructors:

```c#
public class Student
{
    private readonly int _age;
    private readonly string _name;     

    public Student()
    {
    }

    public Student (string studentName, int studentAge)
    {
        _name = studentName;
        _age = studentAge;
    }

    static void Main()
    {
        var student = new Student();
        var johnson = new Student("Johnson", 12);    
    }
}
```

Classes are instantiated in C# using the `new` operator. It is what invokes the class constructor. 

We are passing no argument to the `student` object and as a result, it calls our first constructor (parameterless) because it matches its argument list. 
The constructor initializes the two fields to their default values. Here, `_age` is set to zero, and `_name` is set to null. To learn more about the default values of C# data types, this Microsoft [guide](https://docs.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/default-values) can be useful.

To initialize the `johnson` object, we are passing the same arguments as stated in the declaration of our parameterized constructor. The constructor accepts these values and assigns them to the fields. Here, `_age` is set to 12, and `_name` is set to *Johnson*

We can see here that we have declared two constructors in a single class each with a different number of parameters. This is allowed in C# and is known as Constructor overloading.


### Conclusion
In this article, we have learned about classes and constructors in OOP using C# and how they can be declared. We studied two different types of constructors: parameterless and parameterized and how they can be used to initialize an object. Lastly, we saw how constructor overloading allows us to declare multiple constructors in a single class.