My undstanding of Duck Typing
The definition of Duck Typing in wiki is ""When I see a bird that walks like a duck and swims like a duck and quacks like a duck, I call that bird a duck." My understanding is behavior over type, now. That is eazy to undstandin for the programmer who is using dynamic type programming such as ruby, python etc. But, maybe is not so eazy to understanding to someone like me who is never use dynamic type programming lanuage before. When I started to learn ruby, i confused there is no interface syntax in ruby. As you know, ruby is a OO programming language. How do i do interface orintend programming in ruby.
At first, we should know what is interface? Interface is a contract. If a class implments a specfic interface, we think the class statisfied the contract. Then we should know why do we need interface. Interface efficient decoupling a behavior, which dependence a specific implementation. After I knew the 2 points, i completely undstand. I unstand why there is no interface in ruby. Please take a look the below code.
ruby code:
class Person
def walk
puts 'Person is walking'
end
def swim
puts 'Person is swimming'
end
def quack
puts "Person can't quack"
end
end
class Duck
def walk
puts 'Duck is walking'
end
def swim
puts 'Duck is swimming'
end
def quack
puts "Duck is quacking"
end
end
def detect_duck_behavior(duck)
duck.walk()
duck.swim()
duck.quack()
end
detect_duck_behavior(Person.new)
detect_duck_behaviro(Duck.new)
C# code
interface IDuckBehavior
{
void Walk();
void Swim();
void Quack();
}
class Person: IDuckBehavior
{
public void Walk()
{
Console.WriteLine("Person is walking");
}
public void Swim()
{
Console.WriteLine("Person is swimming");
}
public void Quack()
{
Console.WriteLine("Person can't quack");
}
}
class Duck : IDuckBehavior
{
public void Walk()
{
Console.WriteLine("Duck is walking");
}
public void Swim()
{
Console.WriteLine("Duck is swimming");
}
public void Quack()
{
Console.WriteLine("Duck is quacking");
}
}
class Program
{
static void Main(string[] args)
{
DetectDuckBehavior(new Person());
DetectDuckBehavior(new Duck());
}
static void DetectDuckBehavior(IDuckBehavior duckBehavior)
{
duckBehavior.Walk();
duckBehavior.Swim();
duckBehavior.Quack();
}
}
Comparing the 2 code snippet, you will find ruby can do as same as c#, althought there is no interface in ruby. So, i think the dynamic type OO programming language is behavior over type. We care what behavior it have, not its type.