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.