An Interface type is an abstraction. We use an Interface to create a contract.

Each type that

implements the Interface must have certain Functions. And this makes it possible to call those
Functions through an Interface reference.
So: The exact type of an Obect is no longer needed. !ore code is shared. A program becomes
simpler.
Example
This program declares the I"alue Interface# $hich re%uires one method &ender. The 'ontent and
Image classes both implement I"alue. These t$o classes implement I"alue.&ender in different
$ays.
Next: (otice ho$ in this program the Implements key$ord is used for both classes and
functions.
Program that uses Interface [VB.NET]
Interface IValue
Sub Render()
End Interface
Class Content : Implements IValue
Public Sub Render() Implements IValue.Render
Console.WriteLine("Content.Render")
End Sub
End Class
Class Imae : Implements IValue
Public Sub Render() Implements IValue.Render
Console.WriteLine("Imae.Render")
End Sub
End Class
!odule !odule"
Sub !ain()
' Create dictionary of Interface type instances.
#im dict $s #ictionar%(&f Strin' IValue) ( )e* #ictionar%(&f Strin'
IValue)
dict.$dd("cat".pn"' )e* Imae())
dict.$dd("imae".pn"' )e* Imae())
dict.$dd("+ome.+tml"' )e* Content())
' Get value from Dictionary and call their Render methods.
#im ,alue $s IValue ( )ot+in
If dict.-r%.etValue("cat".pn"' ,alue) -+en
,alue.Render()
End If
' Again.
If dict.-r%.etValue("+ome.+tml"' ,alue) -+en
,alue.Render()
End If
End Sub
End !odule
Output
Imae.Render
Content.Render
Sub Main description. What happens in the !ain entry point) A ne$ *ictionary is created and
three +tring keys are added. They point to t$o Image class instances and one 'ontent class
image.
Then, the Try,et"alue function is invoked t$ice. When the I"alue is retrieved from the
*ictionary# the &ender sub is called. This results in the speciali-ed implementation being called
from the general Interface type.
Summary
Interfaces in "..(ET introduce a level of abstraction. .y declaring an Interface in many
'lasses# you can then refer to instances of those 'lasses through the Interface type. This
streamlines program logic.
Tip: /ou can call the Interface functions# $hich $ill invoke the speciali-ed functions from the
'lasses.