Interfaces
The term interface is a general term, which is widely used in several different areas, not only in Computer Science. For example, a graphical user interface (GUI) is a series of screens with buttons, textboxes and other elements which you interact with when running an application such as Microsoft Word. We have seen the term interface used in a different context, during Week 2, where we talked about an interface of a class. Through the class interface you can specify the public attributes and behaviors of a class, which are presented to the user (client) of the class. This set of attributes and behaviors comprise the protocol by which objects communicate with each other. Now, I’m sure you will be content to hear that there is yet another definition of the word interface, as it applies to object-oriented development! There are several instances in object-oriented software development, where it is necessary to specify general behavior different classes should adhere to, without specifying any details of what the behavior is. Each of the classes is responsible for providing a particular definition of the behavior and it is mandatory that all specified general behaviors be explicitly defined by each involved class. For example, let’s imagine a company, where there are several guidelines, one of them being the dress code of the personnel. Each department should establish its own dress code policy. It doesn’t matter what the specific dress code policy is, as long as all departments have some dress code policy. One way this is enforced in object-oriented languages is through the use of interfaces. In C#, an interface resembles a class (it is not a class, we cannot instantiate objects of this type), which can only contain methods, properties, events, indexers, or any combination of these four member types. All members are automatically declared as public. Given our dress code example above, here is an example of the syntax. The keyword interface is used followed by the interface name. The body of the interface lies between opening and closing braces: interface ICompanyPolicies //the interface name usually begins with a capital ‘I’ { //method declarations (notice that no implementation is given) void DressCode(); } If a class chooses to conform to this interface, we say that a class implements the interface. To specify that a class implements an interface in C#, we use the following syntax. Note the colon after the class name followed by the interface name. The following code states that “the AccountingDept class implements interface ICompanyPolicies”: class AccountingDept : ICompanyPolicies { } All classes that implement an interface, must to provide implementation details for all interface components. So in our example, the AccountDept class needs to implement the interface method DressCode(). If the interface contained other methods as well, then the AccountDept class must provide an implementation for each and every one of them. class AccountingDept : ICompanyPolicies {

//Implementation of the Interface method DressCode() void DressCode() { Console.WriteLine(“Dark blue or gray suit with tie is required for men.“); Console.WriteLine(“Dark blue skirt with white shirt and red scarf is required for women.“); } } To access the method DressCode() of the AccountingDept class, you use an object of the class and the dot operator as you would to access any other method of the class, ex: AccountingDept myAccDept = new AccountingDept(); myAccDept.DressCode(); Similarly, if other classes in the above scenario, such as PublicRelationsDept, InformationTechnologyDept etc, choose to adhere to the specifications of this interface, they need to implement the ICompanyPolicies interface in a similar fashion. So as you might guess, an interface is a way to enforce structure in the classes that implement the interface. By knowing that a class implements the ICompanyPolicies interface, you are sure that it provides a method called DressCode(). Key points to note: • Interfaces are not classes. In particular, you can never use the new operator to instantiate the interface. ICompanyPolicies policy = new ICompanyPolicies(); //This is an ERROR • • However, you can declare a reference to an interface. ICompanyPolicies policy; //This is OK A reference to an interface, can refer to an object of a class which implements the interface. ICompanyPolicies policy; //This is OK since AccountingDept implements ICompanyPolicies policy = new AccountingDept();

Once we talk about inheritance next week and abstract classes during week 6, you will have a chance to compare what you learned about interfaces and detect similarities/differences as well as think about scenarios where one can be used over the other.