Types Of Classes And Their Characteristics

<access modifier> class ClassName
{
    // Data members or member variables
    <access modifier> <data type> variable1;
    public string Name; // Field

    <access modifier> <data type> variable2;
    public int Age { get; set; } // Property

    // Member methods that may or may not perform actions on the data members
    <access modifier> <return type> Method1(parameter_list)
    {
        // Method body (implementation)
    }

    public string Greeting(string name)
    {
        return "Hello " + name;
    }
    // ...
}

public class Box
{
    // Data members or member variables
    public int Height { get; set; }
    public int Width { get; set; }
    public int Length { get; set; }
    // ...

    // Member methods that may or may not perform actions on the data members
    public int Volume(Box objBox)
    {
        int vol = objBox.Length * objBox.Width * objBox.Height;
        return vol;
    }

    public int SurfaceArea(Box objBox)
    {
        int area = 2 * (objBox.Height * objBox.Width) + 2 * (objBox.Height * objBox.Length) + 2 * (objBox.Width * objBox.Length);
        return area;
    }
    // ...
}

interface IInterfaceName
{
    // Declare Events
    // Declare Indexers
    // Declare Methods
    int InterfaceMethod();

    // Declare Properties
}

class ClassName : IInterfaceName
{
    // Class code

    // Implement methods of the interface
    public int InterfaceMethod()
    {
        return 0;
    }
}

abstract class AbstractClassName
{
    // Declare Events
    // Declare Indexers

    // Declare Methods
    public abstract int AbstractMethod();

    // Declare Properties
}

Syntax for Implementing Abstract Class

class ClassName : AbstractClassName
{
    public override int AbstractMethod()
    {
        return 0;
    }
}

Example. A computer cabinet provides slots for installing Motherboard, Hard disk, Power Supply, CD Driver, etc. This can be used to assemble a computer of any company and configuration provided its parts get fit into the cabinet (i.e. follows the contract of the Abstract cabinet). The Hard Disk size, motherboard shape, Power Supply shape, and size should match with the slots provided in the cabinet. Apart from providing slots, it also provides common functionality like inbuilt USB ports, LED light indicator, cooling fans, etc.

In scenes of completeness, after this will come a simple class. A class with implementation for all the methods.

Sealed Class

A developer may want the class he is defining to be absolutely complete. Its behaviors (implemented methods) are like a protocol that should never be changed. It should never be used along with other behaviors. Extending it would change the real meaning of the entity (base class). The class we are defining is complete and should never be used by other classes for inheriting its features. This class should be the end of the extending chain. We have a sealed class in C# which can never be derived by any other class. It is called sealed because it is like a perfectly packed (sealed) box which should not be tampered.

Such a class can absolutely be instantiated because it is a complete class. It is created using the “sealed” keyword. So, the scenario in which we want to make our class a uniform and complete, rule which should never be used or altered using derivation, we use Sealed class it blocks inheritance. In simple terms, it is a class with all implemented methods + Inheriting + Non-Inheritable + Member access through own object.

Syntax

sealed class SealedClassName
{
    // Declare members
    // Declare methods
    // ...
}

Example. You can make as many keys (objects) with the same features (shape, size, and thickness), the lock will open. But if you try to change its design by making a bigger, thicker or of different shape, the lock won’t open. The design of the key is complete in itself to open the lock. There is no need to change its features/design. Changing its features will cease it from its basic behavior of opening the lock.

Static Class

In development, there are situations where certain actions of an entity remain the same irrespective of the part of code we are working on. No matter how many (or where) objects we create of a class, the output/action of every method belonging to the class is going to be the same.

We may want a class that has behaviors that are the same (static) throughout the program. As the behavior is going to be the same, then it should not depend on any instance of the class.

A static class is a container that holds static data and static methods which exist for use without the instance of the class.

It has data members and methods which are declared as well as implemented. As the data member and methods are static which does not depends on any instance of the class, object creation is not at all necessary.

Data Members and Methods are directly accessed through the class name. This does not support inheritance, because inheritance is for derived object creation, and static class does not support object.

It is created using the “static” keyword, so the scenario in which we want data and rules/behavior to be independent of objects, we use static class.

In simple terms, it is a class with all implemented methods + Non Inheritable + Non Instantiable + Member access through class name.

Syntax

static class StaticClassName
{
    // Declare static members
    // Declare static methods
    // ...
}

Example. There are many planets and satellites, asteroids and other objects in the solar system, but there is only one star, which is the sun. It exists from the beginning of the solar system. If another sun is added (another object) to the solar system or if the sun changes its behavior (i.e. get derived), it will complete disrupt the working or our current solar system. Life on our planet will be disrupted. Also, all the planets will get disrupted due to imbalance in the gravitational field and solar energy of multiple suns. For every planet to exist properly, the same sun is required.

So these where the different behavioral class types provided by the language, structurally also there may be certain expectations from a class.

Partial Class

Many times, it is cumbersome to keep everything in a class in one place. If there are a lot of data members and member functions, the class becomes less readable. We may want to separate the class content across different files.

Partial class is a class whose content can be kept in different classes with the same name. These classes can be in the same file or across different files, So separate partial classes with the same name constitute a single complete class. We can declare data members in one partial class and use it in other partial class.

We can declare a member function in one partial class and implement the same in other partial class, at runtime all these partial classes are compiled into one single class. If we miss implementing a method, at runtime such a method is discarded. It is created by using the “partial” keyword

For any of the class types we have seen, we can use partial keyword to split it across different partial classes. Not on interface.

So the scenario in which we want to split the content of the class across different classes/files we use partial class.

In ASP.NET, for every webpage we create, a partial class file is created with extension .aspx.cs. The other partial part of this class is kept separately.

Syntax

public partial class ClassName
{
    // Declare or implement members
    // Declare or implement methods
    // ...
}

// 2nd part of the class
public partial class ClassName
{
    // Declare or implement members
    // Declare or implement methods
    // ...
}

Example. A bank has various types of businesses diversified across different sectors. Like SME Banking, Corporate Banking, Wealth Management, Lending, etc. Let the business be across different departments or locations, at the end all business together forms a bank. Even if one business ceases to exist, the bank still exists with other businesses.

Nested Class (Inner Class)

Sometimes there are certain objects/entities whose scope outside a class is of no use or not acceptable. That is, we may need an object of a (small) class which is to be, used just inside a specific class. Additionally, a class may be unique and small, and useful only to a specific class. So if we have such an entity, we can write such a class inside the required class. A class inside of a class, that’s why is has the name nested class.

The scope of a nested class is within the containing class. Nested class can have any of all the access modifiers, it can access even private members of the outer class while having the full power of a class itself.

The outer class cannot access the members of the inner class directly. It has to be through object creation. The outer class cannot access private members of the inner class.

Also they can be private which allows for some pretty powerful encapsulation in certain circumstances. Making it usable only within the containing class.

If the Outer class is inherited by some class, then the inner class is also inherited through the outer class. No special keyword is required to define such a class.

Syntax

class OuterClass
{
    // Declare members
    // Declare methods

    class InnerClass
    {
        // Declare members
        // Declare methods
        // ...
    }
}

Example. The boxes are nested one inside the other. Any outer box cannot touch the inner side of the box inside it. The inner box can move around inside the outer box.

Consider the inner sides of boxes as private properties and the outer sides as public properties. A smaller box placed inside any bigger box can touch the inner (private properties) side of the bigger (outer) box, but the bigger box can touch only the outer (public properties) sides of the smaller (inner) box.

The outer box can never go inside the inner box to access its private properties.

There are other types of classes that you may come across, but are not used in C#.

Virtual Class

With multiple inheritance allowed in OOP, there are chances that a class can be derived from multiple base classes which are actually derived from the same super base class.

So a virtual class is a super base class where a derived class has multiple copies of super base class through multiple inheritance (using multiple base classes). Supported in C++ and Java.

In such a scenario, there will be multiple copies of such a super base class with the derived class. This is called the DIAMOND problem.

By marking such a base class as virtual during inheritance, only one copy of the super base class will be maintained while creating the object of the derived class.

In C#, if there is conflicting method in child class and parent class (Not virtual class) we create a virtual method in the parent class and override this method in child class.

Virtual classes are functional classes that can be instantiated or extended without the need for overriding methods.

Example. Wedding Reception invitation from two of your best friends getting married.

When you get a wedding invitation from both the bride and groom, as both are your best friends, you can’t appear twice at the wedding. There will be only one copy for you at the reception.

A double invitation doesn’t mean that you can eat twice at the reception.

Local Class

There are scenarios where a class/entity will be used within a block of code only and nowhere else. Usually within a particular function.

So, there is no need to create a separate class at namespace or class level as it is not going to be used anywhere.

Local classes are classes that are defined in a block, which is a group of zero or more statements between balanced braces. Typically defined in the body of a method.

This limits the reference of the class where it is defined i.e. within the code block enclosed { }. No special keyword is required to define such a class. Supported in C++ and Java.

Example. BEST can run only within the boundary of the city. It cannot have scope outside the city.

If we consider State as a Class and City as function (OR Local boundaries created using braces {..}). Then the BEST bus has the functionality of moving locally within the city only. Whereas an ST bus which is State level transport can move throughout the state. We can consider ST bus as a nested class and the BEST bus as a local class.

Now, what if we have an expectation from a class which any of the above type of keywords do not satisfy.

Example: We want the only one object of a class to be created.

Answer is Design Patterns. Example Singleton Design Pattern

Conclusion

So in C++, the various ways to create different class’s characteristics can be considered as Design Patterns then.

In C# these Design Patterns are easily available with keywords given by the language, rest everything is handled by the compiler and CLR.

This is how our programming languages evolve with different needs arising. Maybe in new programming languages or in advanced versions of C#, we might have keywords on classes that will satisfy today's design pattern needs.

We might have a keyword "singleton" on class ;).