Chapter 8. Objects and Classes
Ruby is an object-oriented programming language; this chapter will show you what that really means. Like all modern languages, Ruby supports object-oriented notions like classes, inheiritance, and polymorphism. But Ruby goes further than other languages you may have used. Some languages are strict and some are permissive; Ruby is one of the most permissive languages around.
Strict languages enforce strong typing, usually at compile type: a variable defined as an array can’t be used as another data type. If a method takes an array as an argument, you can’t pass in an array-like object unless that object happens to be a subclass of the array class or can be converted into an array.
Ruby enforces dynamic typing, or duck typing (“if it quacks like a duck, it is a duck”). A strongly typed language enforces its typing everywhere, even when it’s not needed. Ruby enforces its duck typing relative to a particular task. If a variable quacks like a duck, it is one—assuming you wanted to hear it quack. When you want “swims like a duck” instead, duck typing will enforce the swimming, and not the quacking.
Here’s an example. Consider the following three classes,
Duck, Goose, and
class Duck def quack 'Quack!' end def swim 'Paddle paddle paddle…' end end class Goose def honk 'Honk!' end def swim 'Splash splash splash…' end end class DuckRecording def quack play end def play 'Quack!' end end
If Ruby was a strongly typed language, a method that told a ...