Methods and instance variables

    Right now, we can’t do much with a person aside from create it with a name. Its age will always be zero. So lets add a method that makes a person become older:

    2.   def initialize(@name : String)
    3.     @age = 0
    4.   end
    6.   def age
    7.     @age
    8.   end
    10.   def become_older
    11.     @age += 1
    12.   end
    13. end
    15. peter = Person.new "Peter"
    17. john.age # => 0
    20. john.age # => 1
    22. peter.age # => 0

    Method names begin with a lowercase letter and, as a convention, only use lowercase letters, underscores and numbers.

    For more information on getter and setter macros, see the standard library documentation for Object#getter, , and Object#property.

    As a side note, we can define become_older inside the original Person definition, or in a separate definition: Crystal combines all definitions into a single class. The following works just fine:

    1. class Person
    2.   def initialize(@name : String)
    3.     @age = 0
    4.   end
    5. end
    7. class Person
    8.   def become_older
    9.     @age += 1
    10. end

    You can invoke the previously redefined method with previous_def:

    1. class Person
    3.     @age += 1
    4.   end
    5. end
    7. class Person
    8.   def become_older
    9.     previous_def
    10.     @age += 2
    11.   end
    12. end
    14. person = Person.new "John"
    15. person.become_older
    16. person.age # => 3

    Without arguments or parentheses, previous_def receives all of the method’s parameters as arguments. Otherwise, it receives the arguments you pass to it.

    This will initialize @age to zero in every constructor. This is useful to avoid duplication, but also to avoid the Nil type when reopening a class and adding instance variables to it.