Reader Level:
TUTORIAL

Abstraction and Interface in C#

Posted by Paresh Vaishnav Tutorials | Visual C# December 10, 2007
Here I will explain the abstraction and interface in c# by using simple example.
  • 0
  • 0
  • 131276
Download Files:
 

Abstraction

using System;
namespace OOPs
{
    
/// <summary>
    
/// Summary description for Abstract1.
    
/// </summary>
    
/// Abstract class
    
abstract class Abstract1
    
{
         
public Abstract1()
          {
              
// TODO: Add constructor logic here
         
}
          
//non-abstract method
          
public void nonabmethod()
     {
          System.
Console.WriteLine("Non Abstract Method!");
     }
         
//abstract method
         
public abstract void abmethod(); //they are implicitly virtual it is not contain the body of the method
         
public static void Main()
          {
              
myclass mycls = new myclass();
               mycls.nonabmethod();
               mycls.abmethod();
          }
     }
         
class myclass : Abstract1 //class derived from abstract class
         
{
              
public override void abmethod() //must implement the abstract method derived in class
         
{
               System.
Console.WriteLine("Abstract Method!");
          }
     }

}

using System;
namespace OOPs
{
    
/// <summary>
    
/// Summary description for Abstract2. Partial implementation of abstract class
    
/// </summary>
    
abstract class Abstract2
    
{
         
public static void Main()
          {
              
myclass2 mycl = new myclass2();
               mycl.method1();
               mycl.method2();
          }
         
public Abstract2()
          {
              
// TODO: Add constructor logic here
          
}
          
public abstract void method1();
          
public abstract void method2();
          }
          
abstract class myclass1 : Abstract2
         
{
              
public override void method1()
               {
                   
Console.WriteLine("Abstract Method #1");
               }
          }
           
class myclass2 : myclass1
         
{
          
public override void method2()
          {
              
Console.WriteLine("Abstract Method #2");
          }
     }
}

using System;
namespace OOPs
{
    
/// <summary>
    
/// Summary description for Abstract3.
    
/// </summary>
    
/// abstract class derived from non abstract class
    
public class Abstract3
    
{
         
public static void Main()
     {
         
mainclass mcl = new mainclass();
          mcl.noabsmethod();
          mcl.absmethod();
     }
     
public Abstract3()
     {
         
// TODO: Add constructor logic here
     
}
     
public void noabsmethod()
     {
         
Console.WriteLine("Non-Abs class method");
     }
}
abstract class absclass : Abstract3
{
    
public abstract void absmethod();
}
class mainclass : absclass
{
    
public override void absmethod()
{
    
Console.WriteLine("Abstract method call");
}
}
}

using System;
namespace OOPs
{
    
/// <summary>
    
/// Summary description for Abstract4.
    
/// </summary>
    
/// abstract class dervied from interface
    
public abstract class Abstract4 : myowninterface
    
{
         
public static void Main()
     {
         
myclasses mc = new myclasses();
          mc.IMethod();
     }
         
public Abstract4()
          {
              
// TODO: Add constructor logic here
          
}
          
public void IMethod()
          {
              
Console.WriteLine("Method implementation from interface");
          }
}
interface myowninterface
{
    
void IMethod();
}
class myclasses : Abstract4
{
}
}

using System;
namespace OOPs
{
    
/// <summary>
     
/// Summary description for Abstract5.
    
/// </summary>
    
public abstract class Abstract5
    
{
         
public static void Main()
          {
              
Abstract5 abs = new baseclass(); // Polymorphism
              
abs.method();
               abs.method1();
          }
      
public Abstract5()
     {
          
// TODO: Add constructor logic here
     
}
        
public abstract void method();
        
public abstract void method1();
}
class baseclass : Abstract5
{
     public override void method()
{
     Console.WriteLine("Abstract Method1 of baseclass");
}
    
public override void method1()
{
    
Console.WriteLine("Abstract Method2 of baseclass");
}
}
}

Interface:

using System;
namespace OOPs
{
    
/// <summary>
    
/// Summary description for Interface1.
    
/// </summary>
    
public class Interface1 : myinterface
     {
         
public static void Main()
     {
         
Interface1 inf1 = new Interface1();
          inf1.callmethod();
     }
     
public Interface1()
     {
         
// TODO: Add constructor logic here
     
}
      
public void callmethod()
     {
         
Console.WriteLine("callmethod implemented!");
     }

}
interface myinterface
{
void callmethod();
}
}

using System;
namespace OOPs
{
/// <summary>
/// Combining Interfaces
/// </summary>
public class Interface2 : combineinterface
{
    
public static void Main()
{
    
Interface2 inf2 = new Interface2();
     inf2.show();
     inf2.display();
}
public Interface2()
{
    
// TODO: Add constructor logic here
}
public void show()
{
    
Console.WriteLine("Show Method Call!");
}
    
public void display()
{
    
Console.WriteLine("Dislay Method Call!");
}
}
interface myinterface1
{
void show();
}
interface myinterface2
{
void display();
}
interface combineinterface : myinterface1, myinterface2
{
}
}

using
System;
namespace OOPs
{
    
public class Interface3 : interdemo
     {
         
public static void Main()
          {
              
Interface3 inf3 = new Interface3();
               inf3.show();
              
if (inf3 is interdemol)
               {
                   
interdemol id = (interdemol)inf3;
                   
bool ok = id.display();
                   
Console.WriteLine("Method implmented");
               }
              
else
              
{
                   
Console.WriteLine("Method not implmented");
               }
          }
          
public Interface3()
          {
              
// TODO: Add constructor logic here
          
}
          
public bool show()
          {
              
Console.WriteLine("Show method call");
              
return true;
          }
     }
interface interdemo
{
    
bool show();
}
interface interdemol
{
    
bool display();
}
}

using
System;
namespace OOPs
{
    
public class Interface4 : inf1, inf2
{
    
public static void Main()
{
    
Interface4 infobj = new Interface4();
}
    
public Interface4()
{
    
// TODO: Add constructor logic here
}
void inf1.show12()
{
    
Console.WriteLine("call show method1!");
}
void inf2.show12()
{
    
Console.WriteLine("call show method2!");
}
}
interface inf1
{
    
void show12();
}
interface inf2
{
    
void show12();
}
interface inf : inf1, inf2
{
}
}

COMMENT USING

Trending up