There are two types inheritance: Class inheritance which has been allready described and Interface inheritance (subtyping).


An interface looks like a concrete class with one important difference: properties and methods are only declared but not defined. An object can not be created from type of an interface!

  1. interface IAccount                      // Definition of an interface
  2. {
  3.     int initialBalance { get; }        // no definitions of methods and properties - only deklarations
  4.     int transaction(double amount);     // all methods are public by default
  5.     double getBalance();                
  6. }

Example of an interface in C#


Subsequently interfaces specify only what the class is doing, not how it is doing it. The implementing class of that interface has to define every method wich is declared by the interface and specifiy how to do it:

  1. class Account : IAccount                // Interface is implemented by class
  2. {       
  3.     protected double balance;
  4.  
  5.     public Account()
  6.     {
  7.         balance = INITIAL_BALANCE;
  8.     }
  9.  
  10.     int INITIAL_BALANCE
  11.     {                                   // Methods declared by implemented interfaces
  12.         get                             // now have to be defined
  13.         {
  14.             return 50;           
  15.         }
  16.     }
  17.     public int transaction(double amount)
  18.     {     
  19.         balance += amount;                      
  20.         return 0;
  21.     }
  22.     public double getBalance()
  23.     {
  24.         return balance;
  25.     }
  26. }


Example of an class which implements this interface in C#


An interface defines what the behavior a an object will have, but it will not actually specify the behavior. It is a contract, that will guarantee, that a certain class can do something.

Implementing of Inteface IAccount

UML class diagram: Implementation of an interface



Summary

  • An object of an interface cannot be created,

    1. IAccount iAccount = new IAccount();

  • but an interface describes what the implementing class should can do, without specifying how to do it.
  • Subsequently a class that implements interface must implements all the methods and properties in interface.
  • A class can implement more than one interface. That means it can be used used to achieve multiple inheritance.
  • An interface can extends one or more another interfaces.
  • C# do not allow fields in interfaces.



Last modified: Tuesday, 13 August 2019, 3:07 PM