interface implementation

In this chapter you will learn:

  1. How to implement an interface
  2. Code to show how to create and implement interface
  3. Multiple Implementation: implement two interfaces
  4. extend class and implement interface at the same time

Implement an interface

The general form of a class that implements an interface is shown here:

class class-name : interface-name {
  // class-body
}

To implement more than one interface, the interfaces are separated with a comma. A class can inherit a base class and also implement one or more interfaces.

The name of the base class must come first in the comma-separated list. The methods that implement an interface must be declared public.

Define and implement interface

The following code defines an interface.

using System;//  ja  v  a 2 s. c  o  m

interface Printable{
    void Print();
   
}

class Rectangle : Printable{
    int Width;
    
    public void Print(){
       Console.WriteLine("Width:"+Width);
    }

}


class Test
{
    static void Main()
    {

        Printable r = new Rectangle();

        r.Print();

    }
}

The output:

Implement two interfaces

interface IFoo//from j  av  a  2 s  .c  om
{
    void ExecuteFoo();
}

interface IBar
{
    void ExecuteBar();
}

class Tester: IFoo, IBar
{
    public void ExecuteFoo() {}
    public void ExecuteBar() {}
}

Base class and interface

public class Component
{/*from  java  2  s .  co m*/
    public Component() {}
}

interface Printable
{
    void printHeader(float factor);
    void printFooter(float factor);
}

public class TextField: Component, Printable
{
    public TextField(string text)
    {
        this.text = text;
    }
    // implementing Printable.printHeader()
    public void printHeader(float factor)
    {
        
    }
    
    // implementing Printable.printFooter()
    public void printFooter(float factor)
    {
        
    }
    
    private string text;
}

class MainClass
{
    public static void Main()
    {
        TextField text = new TextField("Hello");
        
        Printable scalable = (Printable) text;
        scalable.printHeader(0.5F);
        scalable.printFooter(0.5F);
    }
}

Next chapter...

What you will learn in the next chapter:

  1. When do we need explicit interface implementation
Home » C# Tutorial » Class
Classes and Structs
Encapsulation
Class and Struct Accessibility
Members
Static Members
Class
Class instance variables
Class instance Methods
Class Inheritance
Class constructor
Default constructors
Parameters of constructors
Constructor overloading
Static Constructor
Destructor
Override destructor
new operator
Class field
Static Fields
Read only field
Field default value
const value
Abstract class
Static Class
Partial type
Methods
Method local variable
Method Overloading
Method overloading with ref and out
Type conversion and method overloading
Error in Method overloading
virtual methods
Override methods
Method Parameter
Pass parameters
ref parameters
out parameters
Variable parameter length
Optional parameters
Named parameters
static method
function Return
Recursive methods
Virtual methods and polymorphism
Cast
Shadow inherited members
Seal a member
this keyword
base keyword
base and name hiding
Access Specifiers
private
public
protected
internal
Indexer
String type indexer
Multidimensional indexer
Indexer overloading
Indexer to append
Indexer logic
Properties
Properties getter and setter
Accessibilities of properties
Automatic properties
Read only and write only property
Virtual properties
Abstract Properties
Static Properties
interface
interface implementation
Explicit interface implementation
Interface inheritance
Indexer in an interface
Interface Properties
struct and interface
virtual interface implementation
as operator
is operator
null reference
Nested classes
object class
ToString method
GetHashCode
Object initialization
Extension method
Struct Instances vs. Class Instances