Csharp/C Sharp/Class Interface/Abstract Class

Abstract Classes and Methods

 

using System;
abstract public class MotorVehicle {
    public string make;
    public string model;
    public MotorVehicle(string make, string model) {
        this.make = make;
        this.model = model;
    }
    abstract public void Accelerate();
}
public class Product : MotorVehicle {
    public Product(string make, string model) :
        base(make, model) {
        // do nothing
    }
    public override void Accelerate() {
        Console.WriteLine("In Product Accelerate() method");
        Console.WriteLine(model + " accelerating");
    }
}

class MainClass {
    public static void Main() {
        Product myProduct = new Product("Toyota", "MR2");
        myProduct.Accelerate();
    }
}

Bank Account class is abstract since there is no single implementation for Withdrawal

 
using System;
public class MainClass {
    public static void Main(string[] strings) {
        SavingsAccount sa = new SavingsAccount();
        sa.Withdrawal(100);
        CheckingAccount ca = new CheckingAccount();
        ca.Withdrawal(100);
    }
}
abstract public class BankAccount {
    abstract public void Withdrawal(double dWithdrawal);
}
public class SavingsAccount : BankAccount {
    override public void Withdrawal(double dWithdrawal) {
        Console.WriteLine("Call to SavingsAccount.Withdrawal()");
    }
}
public class CheckingAccount : BankAccount {
    override public void Withdrawal(double dWithdrawal) {
        Console.WriteLine("Call to CheckingAccount.Withdrawal()");
    }
}

Create an abstract class

/*
C#: The Complete Reference 
by Herbert Schildt 
Publisher: Osborne/McGraw-Hill (March 8, 2002)
ISBN: 0072134852
*/

// Create an abstract class. 
 
using System; 
 
abstract class TwoDShape {  
  double pri_width;  // private 
  double pri_height; // private 
  string pri_name;   // private 
  
  // A default constructor.  
  public TwoDShape() {  
    width = height = 0.0;  
    name = "null";  
  }  
  
  // Parameterized constructor.  
  public TwoDShape(double w, double h, string n) {  
    width = w;  
    height = h;  
    name = n;  
  }  
  
  // Construct object with equal width and height.  
  public TwoDShape(double x, string n) {  
    width = height = x;  
    name = n;  
  }  
  
  // Construct an object from an object.  
  public TwoDShape(TwoDShape ob) {  
    width = ob.width;  
    height = ob.height;  
    name = ob.name;  
  }  
  
  // Properties for width, height, and name 
  public double width { 
    get { return pri_width; } 
    set { pri_width = value; } 
  } 
 
  public double height { 
    get { return pri_height; } 
    set { pri_height = value; } 
  } 
 
  public string name { 
    get { return pri_name; } 
    set { pri_name = value; } 
  } 
  
  public void showDim() {  
    Console.WriteLine("Width and height are " +  
                       width + " and " + height);  
  }  
  
  // Now, area() is abstract. 
  public abstract double area(); 
}  
  
// A derived class of TwoDShape for triangles. 
class Triangle : TwoDShape {  
  string style; // private 
    
  // A default constructor.  
  public Triangle() {  
    style = "null";  
  }  
  
  // Constructor for Triangle.  
  public Triangle(string s, double w, double h) : 
    base(w, h, "triangle") {  
      style = s;   
  }  
  
  // Construct an isosceles triangle.  
  public Triangle(double x) : base(x, "triangle") {  
    style = "isosceles";   
  }  
  
  // Construct an object from an object.  
  public Triangle(Triangle ob) : base(ob) {  
    style = ob.style;  
  }  
  
  // Override area() for Triangle. 
  public override double area() {  
    return width * height / 2;  
  }  
  
  // Display a triangle"s style. 
  public void showStyle() {  
    Console.WriteLine("Triangle is " + style);  
  }  
}  
  
// A derived class of TwoDShape for rectangles.   
class Rectangle : TwoDShape {   
  // Constructor for Rectangle.  
  public Rectangle(double w, double h) :  
    base(w, h, "rectangle"){ }  
  
  // Construct a square.  
  public Rectangle(double x) :  
    base(x, "rectangle") { }  
  
  // Construct an object from an object.  
  public Rectangle(Rectangle ob) : base(ob) { }  
  
  // Return true if the rectangle is square. 
  public bool isSquare() {   
    if(width == height) return true;   
    return false;   
  }   
     
  // Override area() for Rectangle. 
  public override double area() {   
    return width * height;   
  }   
}  
  
public class AbsShape {  
  public static void Main() {  
    TwoDShape[] shapes = new TwoDShape[4];  
  
    shapes[0] = new Triangle("right", 8.0, 12.0);  
    shapes[1] = new Rectangle(10);  
    shapes[2] = new Rectangle(10, 4);  
    shapes[3] = new Triangle(7.0);  
  
    for(int i=0; i < shapes.Length; i++) {  
      Console.WriteLine("object is " + shapes[i].name);  
      Console.WriteLine("Area is " + shapes[i].area());  
  
      Console.WriteLine();    
    }  
  }  
}

Demostrates the use of an abstract class, including an abstract method and abstract properties

/*
C# Programming Tips & Techniques
by Charles Wright, Kris Jamsa
Publisher: Osborne/McGraw-Hill (December 28, 2001)
ISBN: 0072193794
*/
//
// Abstract.cs -- Demostrates the use of an abstract class, including
//                an abstract method and abstract properties.
//
//                Compile this program with the following command line:
//                    C:>csc Abstract.cs
//
namespace nsAbstract
{
    using System;
    
    public class AbstractclsMain
    {
        static public void Main ()
        {
            // Create an instance of the derived class.
            clsDerived derived = new clsDerived (3.14159);
            // Calling GetAbstract() actually calls the public method in the
            // base class. There is no GetAbstract() in the derived class.
            derived.GetAbstract();
        }
    }
    // Declare an abstract class
    abstract class clsBase
    {
        // Declare an abstract method. Note the semicolon to end the declaration
        abstract public void Describe();
        // Declare an abstract property that has only a get accessor. 
        // Note that you
        // do not prove the braces for the accessor
        abstract public double DoubleProp
        {
            get;
        }
        // Declare an abstract property that has only a set accessor.
        abstract public int IntProp
        {
            set;
        }
        // Declare an abstract propety that has both get and set accessors. Note
        // that neither the get or set accessor may have a body.
        abstract public string StringProp
        {
            get;
            set;
        }
        // Declare a method that will access the abstract members.
        public void GetAbstract ()
        {
            // Get the DoubleProp, which will be in the derived class.
            Console.WriteLine ("DoubleProp = " + DoubleProp);
            // You can only set the IntProp value. The storage is in the
            // derived class.
            IntProp = 42;
            // Set the StringProp value
            StringProp = "StringProperty actually is stored in " +
                         "the derived class.";
            // Now show StringProp
            Console.WriteLine (StringProp);
            
            // Finally, call the abstract method
            Describe ();
        }
    }
    // Derive a class from clsBase. You must implement the abstract members
    class clsDerived : clsBase
    {
        // Declare a constructor to set the DoubleProp member
         public clsDerived (double val)
         {
             m_Double = val;
         }
        // When you implement an abstract member in a derived class, you may not
        // change the type or access level.
        override public void Describe()
        {
            Console.WriteLine ("You called Describe() from the base " +
                               "class but the code body is in the \r\n" +
                               "derived class");
            Console.WriteLine ("m_Int = " + m_Int);
        }
        // Implement the DoubleProp property. This is where you provide a body
        // for the accessors.
        override public double DoubleProp
        {
            get {return (m_Double);}
        }
        // Implement the set accessor for IntProp.
        override public int IntProp
        {
            set {m_Int = value;}
        }
        
        // Implement StringProp, providing a body for both the get
        // and set accessors.
        override public string StringProp
        {
            get {return (m_String);}
            set {m_String = value;}
        }
        
        // Declare fields to support the properties.
        private double m_Double;
        private int m_Int;
        private string m_String;
    }
}

Illustrates abstract classes and methods

/*
Mastering Visual C# .NET
by Jason Price, Mike Gunderloy
Publisher: Sybex;
ISBN: 0782129110
*/
/*
  Example7_9.cs illustrates abstract classes and methods
*/
using System;

// declare the abstract MotorVehicle class
abstract class MotorVehicle
{
  // declare the fields
  public string make;
  public string model;
  // define a constructor
  public MotorVehicle(string make, string model)
  {
    this.make = make;
    this.model = model;
  }
  // declare the abstract Accelerate() method (no code)
  abstract public void Accelerate();
}

// declare the Car class (derived from MotorVehicle)
class Car : MotorVehicle
{
  // define a constructor
  public Car(string make, string model) :
  base(make, model)
  {
    // do nothing
  }
  // override the Accelerate() method (contains code)
  public override void Accelerate()
  {
    Console.WriteLine("In Car Accelerate() method");
    Console.WriteLine(model + " accelerating");
  }
}

public class Example7_9
{
  public static void Main()
  {
    // create a Car object
    Console.WriteLine("Creating a Car object");
    Car myCar = new Car("Toyota", "MR2");
    // call the Car object"s Accelerate() method
    Console.WriteLine("Calling myCar.Accelerate()");
    myCar.Accelerate();
  }
}

Test abstract class

/*
Learning C# 
by Jesse Liberty
Publisher: O"Reilly 
ISBN: 0596003765
*/
 using System;
 abstract class Window
 {
     // constructor takes two integers to
     // fix location on the console
     public Window(int top, int left)
     {
         this.top = top;
         this.left = left;
     }
     // simulates drawing the window
     // notice: no implementation
     abstract public void DrawWindow();
     protected int top;
     protected int left;
 }
 // ListBox derives from Window
 class ListBox : Window
 {
     // constructor adds a parameter
     public ListBox(
         int top,
         int left,
         string contents):
         base(top, left)  // call base constructor
     {
         listBoxContents = contents;
     }
     // an overridden version implementing the
     // abstract method
     public override void DrawWindow()
     {
         Console.WriteLine ("Writing string to the listbox: {0}",
             listBoxContents);
     }
     private string listBoxContents;  // new member variable
 }
 class Button : Window
 {
     public Button(
         int top,
         int left):
         base(top, left)
     {
     }
     // implement the abstract method
     public override void DrawWindow()
     {
         Console.WriteLine("Drawing a button at {0}, {1}\n",
             top, left);
     }
 }
 public class TesterAbstractClass
 {
     static void Main()
     {
         Window[] winArray = new Window[3];
         winArray[0] = new ListBox(1,2,"First List Box");
         winArray[1] = new ListBox(3,4,"Second List Box");
         winArray[2] = new Button(5,6);
         for (int i = 0;i < 3; i++)
         {
             winArray[i].DrawWindow();
         }
     }
 }