Object Oriented Concept In Ruby 
Tags: ruby, programming
Published: 2018-04-10 12:26:24

---
title: Object Oriented Concept In Ruby 
published: true
description: 
tags: #ruby #programming
cover_image: https://thepracticaldev.s3.amazonaws.com/i/nhixkxy8xrybt9l9ppu7.jpg
---

Object oriented concept is one of the popular concept in programming. I am learning how Object Oriented Concept Implemented in Ruby, So In this post I will write about it.

## 1. Almost Everything is Object

```
  # a is an object 
  # a.object_id gives the identifier
  a = 10
    
  # similarly b is also object
  b = "Hello World !"
```
Arrays are object, Class are Object, Modules are object, Range is also object, Blocks of code can be Object, nil is also object which represents nothingness and almost everything is object in ruby. 

## 2. Classes

Syntax for writing class in ruby is straight forward, just you write keyword class and class name. Method inside class is in small latter and snake case syntax is more preferred. Instance variable of class in ruby can be started with @ symbol.

And initilize is the special function of class which is automatically called when object created. To create the Object of the class we can use the ClassName.new syntax. One of the simple example is as follows. 

```
require 'date'

class User
  def initialize(date_of_birth)
    days_since_birth = Date.today - Date.parse(date_of_birth)
    @age = days_since_birth / 365
  end
  def is_kid?
    @age <= 18
  end
end

john = User.new("2006-02-12")
puts john.is_kid? # Returns False
```
Initilize method is automatically called when object is created, and Above code snippet is all about creation of object of User class. age is the class variable.

## 3. Methods
Methods are pretty fundamental to ruby, method just start by the def symbol, method name with no or more parameters. 
```
    def another_method(first_arg, last_arg)
        "You passed in #{first_arg} and #{second_arg}"
    end
```
It is possible to create method name by capital letter, But please do not do this. So always write method lower case latter connected by the underscore.
```
    def ThisIsPossible
        # Please do not do this
    end
```
Methods which return true or false (Boolean Value) always ends with question mark.
           
```
    def is_not_boy?
      @gender != 'boy'
    end
```

Exclamation mark ! at the end of the method in ruby mean lookout, that means original reference value of the property is also changed so be aware of it. for example
```
    message = "Hello World"
    message.downcase! # This change message value to 'hello world'
```  
We can define the optional argument in ruby is also possible, optional argument should be always last argument in the method.  
```
    def greet(name, informal = false)
      if informal
        "hi #{name}"
      end
      else
        "Hello #{name}"
      end      
    end
```
Let's say there is three argument and two of the argument are optional. we do not need to send the default value but if third argument is different than default value of argument then we should pass all the three argument during method call right? lets clear from the example
```
    def greet(name, informal = false, shout = false)
      greeting = if informal then "hi" else "hello" end
      message = "#{greeting} #{name}"
      if shout
        message.upcase
      else
        message
      end
    end

    greet("John", false, true)
```
To fix this we can do like this way ! This is much clearer way to pass the arguments in ruby methods.
```
    def greet(name, informal: false, shout: false)
      greeting = if informal then "hi" else "hello" end
      message = "#{greeting} #{name}"
      if shout
        message.upcase
      else
        message
      end
    end

    greet("John", shout: true)
```
Normally we do not need to return the value in methods, last value of method is automatically return by the method. But sometime we should return if any conditions then we can return value by using return keyword like this.
```
    class MyClass
      def odd_or_even(num)
        return unless num.respond_to?(:odd?)
        if num.odd? then  "odd" else "even" end
      end
    end

    MyClass.new.odd_or_even(3)
```
## 4. Inheritance
Ruby only support single inheritance that means every class in ruby has exactly one super class. We can specify superclass by writing the '<' sign followed by the name of superclass. Class inherit methods from superclass.
```
    class User
      attr_reder :name
      def initilize(name)
        @name = name
      end    
    end

    # child class of User class
    class Admin < User
      def is_admin
        true
      end
    end

    user = Admin.new("Madhu Sudhan")
    user.name # will results 'Madhu Sudhan'
    user.is_admin? # will return true
```
Here is the example how one class contains exactly one superclass see the follwing example
```
    Admin.superclass
    => User
    User.superclass
    => Object
    Object.superclass
    => BasicObject
    BasicObject.superclass
    => nil
```

## 5. Modules
Modules in ruby is really just a collection of methods and class is also a special type of module. We can define modules same ways a class.
```
require 'date'

module Employee
  attr_accessor :start_date

  def employment_length
    days = Date.today - start_date.to_date
    "#{days.to_i} days"
  end
end

class User
  include Employee
end

u = User.new
u.start_date = Date.today - 365
puts u.employment_length
```
Extend is another way to use module and is much more interesting, before we are using include keyword that the module define in the class, but we can also use the extend keyword tell the method to single instance of class,
```
require 'date'

module Employee
  attr_accessor :start_date

  def employment_length
    days = Date.today - start_date.to_date
    "#{days.to_i} days"
  end
end

class User
end

u = User.new
u.extend(Employee)
u.start_date = Date.today - 365
puts u.employment_length
```  

### 6. Constants
Constants in ruby a pretty much like constant in any other language, it violets the mutation of the value. Look like variable but start with capital letter. It is a convention that all the letter of constant should be uppercase. 
```
    PI = 3.14 # is good

    Pi = 3.14 # is possible but not do it
```    
Using the constants in class and Modules can be access like this way
```
    module Geometry
      PI = 3.14
    end

    class Circle
      PI = 3.142
    end

    puts Geometry::PI == Circle::PI # false

```


### Conclusion
It's really interesting to learn ruby programming language and it's easy too.