More on Classes and Access Modifiers : Inheritance

In the previous post, we saw how to create our own class and how to work with it. In this post, we shall explore more on classes and access modifiers like private, protected and public.

One of the most powerful feature of object oriented programming is inheriting information from another class. This feature is commonly named as inheritance. Like real world example, if your parents or your grandparents leave behind something (wealth, land/property) after their death, then as a heir you own that wealth. You are eligible to consume that wealth because you have an inherited relation with the people leaving behind that wealth.

Apply the same on classes. A class can inherit part or all of the information that belongs to another class. Suppose you have a class called A. You write another class B which inherits A. Then we call B a subclass, while A is the base class. Lets learn these things modifying the previous example.

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            PublicExam pe1 = new PublicExam("Nabiha", 5, 12, 2002, 2013);

            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        int standard;
        int rollnum;
        int dob;    //newly added dob -> date of birth
        static int count = 0;
        public StudentInfo(string name, int stndrd, int roll,int dob)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
            this.dob = dob;
            count++;
        }
        public static int GetCount()
        {
            return count;
        }
    }
    class PublicExam : StudentInfo
    {
        const string PRIMARY = "Primary";
        const string JUNIOR = "Junior";
        const string SECONDARY = "Secondary";
        const string H_SECONDARY = "Higher Secondary";
        int currentyear;
        public PublicExam(string name, int stndrd, int roll,int dob,int year)
            : base(name, stndrd, roll, dob)
        {
            currentyear = year;
        }
    }
}

I have changed the code quite a lot. If you compare the code from the previous post, you will see that a new class called PublicExam now inherits StudentInfo class. Therefore StudentInfo is the base class while PublicExam is a subclass.

Notice line 34. This is the way you inherit a class. In this case, PublicExam class is inheriting StudentInfo class. Now have a good look inside the Main method. We are no longer creating objects of StudentInfo, rather we are interested in objects of PublicExam. In object oriented programming, you already know that when you create an object, you automatically call the constructor. In this case you are calling the PublicExam constructor which takes 5 arguments. This automatically makes a call to the base class constructor StudentInfo. Observe line 42, in this case you are actually specifying how to call the base class constructor. You can choose not to specify in this way; in that case you have to provide a base class constructor that takes no arguments. Go ahead and remove line 42. What do you see? An error that says "Error    1    'Spells.StudentInfo' does not contain a constructor that takes 0 arguments ". You can get rid of this error. For example -

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            PublicExam pe1 = new PublicExam("Nabiha", 5, 12, 2002, 2013);

            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        int standard;
        int rollnum;
        int dob;    //newly added dob -> date of birth
        static int count = 0;
        public StudentInfo()
        { 
            //necessary codes here
        }
        public StudentInfo(string name, int stndrd, int roll,int dob)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
            this.dob = dob;
            count++;
        }
        public static int GetCount()
        {
            return count;
        }
    }
    class PublicExam : StudentInfo
    {
        const string PRIMARY = "Primary";
        const string JUNIOR = "Junior";
        const string SECONDARY = "Secondary";
        const string H_SECONDARY = "Higher Secondary";
        int currentyear;
        public PublicExam(string name, int stndrd, int roll,int dob,int year)
        {
            currentyear = year;
        }
    }
}

To sum up, if you do not provide a statement like base(...), the compiler will automatically call the base class constructor that has no argument. The constructor from line 21 to 24 takes no arguments. You would probably think that how two methods with the same name can co-exist? They can. This is called constructor overloading. Overloaded methods can have the same name, but they should differ on the number of arguments.

Does this code serve to our purpose? Though the base class constructor is called, but it is actually of no use to us, at least in this case. So we better specify how to call. That was what the first code was doing for us. We revert back to that again. Now we make the classes useful. You possibly have the students date of birth and which standard he/she reads in. Suppose when someone is in standard 5 and at least 10 years old, he/she is eligible to enter Primary exam. How do we do that?

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            PublicExam pe1 = new PublicExam("Nabiha", 5, 12, 2000, 2013);

            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        int standard;
        int rollnum;
        int dob;    //newly added dob -> date of birth
        static int count = 0;
        public StudentInfo(string name, int stndrd, int roll,int dob)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
            this.dob = dob;
            count++;
        }
        public static int GetCount()
        {
            return count;
        }
    }
    class PublicExam : StudentInfo
    {
        const string PRIMARY = "Primary";
        const string JUNIOR = "Junior";
        const string SECONDARY = "Secondary";
        const string H_SECONDARY = "Higher Secondary";
        int currentyear;
        public PublicExam(string name, int stndrd, int roll,int dob,int year): base(name,stndrd,roll,dob)
        {
            currentyear = year;
        }

        public string WhichExam()
        {
            int age = currentyear - dob;   //the current age
            if (standard == 5 && age >= 10)
            {
                return PRIMARY;
            }
            else if (standard == 8 && age >= 13)
            {
                return JUNIOR;
            }
            else if (standard == 10 && age >= 16)
            {
                return SECONDARY;
            }
            else if (standard == 12 && age >= 18)
            {
                return H_SECONDARY;
            }
            else
            {
                return "No exams!";
            }
        }
    }
}

This code will let you down. You will see that dob and standard variables aren't recognized inside the function WhichExam. Your Visual Studio should say that these variables aren't accessible because of protection level. But hey! Didn't we just inherit everything from StudentInfo? True. Then what's wrong? In C#, everything by default is private. So all the variables inside StudentInfo are private and are only accessible inside StudentInfo class. So how do we access these variables? There are two possible ways -

• Make the variables public.
• Make the variables protected.

I will go with solution no. 2. Making the variables public isn't an intelligent solution. Because in that way, you expose your variables to the outer world that aren't quite necessary to them. You also make them vulnerable because you can accidentally modify their values anywhere else! See the working code using protected modifier on line 19 and 21.

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            PublicExam pe1 = new PublicExam("Nabiha", 5, 12, 2000, 2013);
            PublicExam pe2 = new PublicExam("Abrar", 2, 22, 2003, 2013);
            Console.WriteLine("{0} will sit for {1}",pe1.GetStudentName(),pe1.WhichExam());
            Console.WriteLine("{0} will sit for {1}", pe2.GetStudentName(), pe2.WhichExam());
            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        protected int standard;
        int rollnum;
        protected int dob;    //newly added dob -> date of birth
        static int count = 0;
        public StudentInfo(string name, int stndrd, int roll,int dob)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
            this.dob = dob;
            count++;
        }
        public static int GetCount()
        {
            return count;
        }
        public string GetStudentName()
        {
            return name;
        }
    }
    class PublicExam : StudentInfo
    {
        const string PRIMARY = "Primary Exam";
        const string JUNIOR = "Junior Exam";
        const string SECONDARY = "Secondary Exam";
        const string H_SECONDARY = "Higher Secondary Exam";
        int currentyear;
        public PublicExam(string name, int stndrd, int roll,int dob,int year) : base(name,stndrd,roll,dob)
        {
            currentyear = year;
        }

        public string WhichExam()
        {
            int age = currentyear - dob;   //the current age
            if (standard == 5 && age >= 10)
            {
                return PRIMARY;
            }
            else if (standard == 8 && age >= 13)
            {
                return JUNIOR;
            }
            else if (standard == 10 && age >= 16)
            {
                return SECONDARY;
            }
            else if (standard == 12 && age >= 18)
            {
                return H_SECONDARY;
            }
            else
            {
                return "No exams!";
            }
        }
    }
}

Aha! Your code is ready to run. Hit F5 and see the output. Finally, you will notice that you can access methods from the base class by an object of the subclass. Subclass objects can have access to public methods inside the base class.

I hope the concepts of inheritance, access modifiers and how to control access to members and methods are quite clear. Just play with them, edit/modify these codes and see what you are allowed to do and what not.

Classes and Objects

We already know that C# is an Object Oriented Programming language. We have seen that every variable that we declare in our program are objects. A C# program at the heart is an object; you probably have noticed that your code is inside a class named Program. Inside that class, you declare some other variables or objects or methods and you do your stuff.

So what we understand from this is that C# is inherently an object oriented programming language. We shall discuss about classes and objects in this post. We shall also go through some important aspects that are related to classes and objects.

Classes group together some data and logic with those data. If you have some data and logic which are closely related, the idea is to keep them together and bundle up. While you bundle things up, you will want to control how you want to modify these data. So classes actually provide you a neat and cleaner experience of doing these things.

Interaction between classes

Classes can interact with each other. By all means you will want to modify/update your data from other end. This is how you make your program dynamic.

A class is actually a blueprint or model of what an object looks like, what this object is capable of. It tells you what kinds of data this object is interested in, what kinds of task this object can perform. Suppose someone makes the design of how a laptop looks like, the blueprint of a laptop is a class. When you make an actual product from that blueprint, its an object from that design. A red covered laptop is an object, so is a silver covered laptop. Your blueprint lets you know what each of them has in basics.

.NET framework provides you a whole bunch of useful classes. You can use them for many different purposes. You can declare your own class. Classes essentially have two major types of members.

1. Fields and Properties
2. Methods (or functions)

The fields and properties are what the class (read object) holds and works with. Methods provide a way of doing stuffs with these fields and properties. You can manipulate or use the fields and properties via these methods.

Let us consider a system where we hold on some data of a student in a school. If we keep it simple, lets say we deal only with his/her name, the standard he/she reads in and his/her roll number. You might have noticed that we have already prepared our fields.

1. Name
2. Standard he reads in
3. Roll number

This is a simple model of our class.

class StudentInfo
{
    string name;
    int standard;
    int rollnum;
}

How do we manipulate these data? How do we put data in the first place? Lets take a look into the following code.

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            StudentInfo student1 = new StudentInfo("Mahmud", 8, 21);
            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        int standard;
        int rollnum;
        public StudentInfo(string name, int stndrd, int roll)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
        }
    }
} 

Line 9 creates an object of the class StudentInfo. If you are familiar with other object oriented languages, you are familiar with this line. This is the way we create an object. And you can see, while creating the object, we are passing three values that we would like to define in our object of type StudentInfo. In a nutshell, the object student1 belongs to a student whose name is Mahmud.

This class functionally does nothing. It can't communicate with others. So how do we make it to speak? Lets try out this.

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            StudentInfo student1 = new StudentInfo("Mahmud", 8, 21);
            StudentInfo student2 = new StudentInfo("Nabiha", 2, 5);
            Console.WriteLine("{0}'s roll number is {1}",student1.getName(),student1.getRollNum());
            Console.WriteLine("{0}'s roll number is {1}", student2.getName(), student2.getRollNum());
            
            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        int standard;
        int rollnum;
        public StudentInfo(string name, int stndrd, int roll)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
        }
        public int getRollNum()
        {
            return rollnum;
        }
        public string getName()
        {
            return name;
        }
    }
}

You will notice that we create yet another object, but notice that when we ask for the same piece of information from both of the objects, they give us their own individual information.For example, consider line 11 and 12, the output that we are showing, we don't know who actually is student1 or student2 object. So we provided some functions inside the StudentInfo class. Notice that we call the same function from two different objects, so we are getting two different values. Congratulations! You have seen the power of using objects. So you see, you don't have to define different functions for individual records, all you do is code once and use it again and again, perhaps using different objects.

You can create as many objects as you like, as many useful methods as you need. Notice that, while writing the code, when you type the object name and hit a period(dot .) the Visual Studio editor will provide you some options. Aha! You don't see the fields name, do you? What do you understand from this? In C#, the default access modifier is private. What are access modifiers? In C# there are different modes which you can specify how your fields or methods are visible to the outside world. In our case, the string variable name, integer variable  standard and rollnum are private to the class. It means that you can only access them when you are inside the class. For example, from line 25 to 35, you accessed them, returned their values to outside world. You can manipulate here. You cannot manipulate these variables from outside.

Hit the dot [.] again after the object name, now notice that you are able to see the methods getName() and getRollNum(). You can access them because their access modifier is public! Had they been private, they would have been inaccessible from where we accessed earlier.

Constructor: Finally, the one and only constructor. The name of the constructor should be that of the class name. It should be declared public. A constructor should not return anything. A constructor can take any number of arguments. If you do not provide a constructor, your compiler automatically puts (I mean not visible to you!) a default constructor that takes no argument and does nothing. 

Finally let's look into another method in the slightly modified code.

using System;

namespace Spells
{
    class Program
    {
        static void Main(string[] args)
        {
            StudentInfo student1 = new StudentInfo("Mahmud", 8, 21);
            StudentInfo student2 = new StudentInfo("Nabiha", 2, 5);
            
            Console.WriteLine("{0}'s roll number is {1}",student1.GetName(),student1.GetRollNum());
            Console.WriteLine("{0}'s roll number is {1}", student2.GetName(), student2.GetRollNum());
            Console.WriteLine("{0} students are available", StudentInfo.GetCount());
            
            Console.Read(); //keeps the console alive
        }
    }
    class StudentInfo
    {
        string name;
        int standard;
        int rollnum;
        static int count = 0;
        public StudentInfo(string name, int stndrd, int roll)
        {
            this.name = name;
            standard = stndrd;
            rollnum = roll;
            count++;
        }
        public int GetRollNum()
        {
            return rollnum;
        }
        public string GetName()
        {
            return name;
        }
        public static int GetCount()
        {
            return count;
        }
    }
}

Static fields and methods: Suppose you want to get a count of how many students are available in your StudentInfo class. This count should be kept in a variable which should not get changed (re-initialized) when new objects are created. Fortunately the static variables are really good in this purpose. Notice the static integer variable on line 24. It is initialized with default value 0. Each time a new object is created, the constructor is called and a count++ occurs, which increments the value. 

Now notice the method GetCount(). Its access modifier is public static. What does that mean? public allows you to call this method from outside. A static method is something special. Go ahead and try to access it using one of the objects (student1 or student2). This method is inaccessible, right? A static method is accessible from the class definition, it means that in order to access a static method, you don't need to create an object, you can access it using the name of the class itself.

I hope these things make sense to you after reading this post. Happy coding!