What is Object Orientated Programming (OOP)? (Part one)
Tags: oop, beginners, ruby
Published: 2019-11-25 19:22:39

Objected Oriented Programming (OOP) is a term that will come up often as you start your journey of learning on how to become a software developer.

It is an important concept to understand if you want to continue to improve as a developer. 

Here is the definition of OOP from PC Magazine

<i>"A programming language structure wherein the data and their associated processing ("methods") are defined as self-contained entities called "objects." The norm today, object-oriented programming (OOP) languages, such as C++ and Java, provide a formal set of rules for creating and managing objects. The data are stored in a traditional relational database or in an object database if the data have a complex structure. See O-R mapping and object database."</i>
<a href="https://www.pcmag.com/encyclopedia/term/48238/object-oriented-programming">Link to PC MAG Encyclopedia</a>

In order to getting a better understanding of OOP, we will need to know what these important concepts are: 
<ul>
<li>Class</li>
<li>Object</li>
<li>Inheritance</li>
<li>Encapsulation</li>
<li>Abstraction</li>
<li>Polymorphism</li>
</ul>

I will be using Ruby to demonstrate the concepts of OOP. 

<h2>What is a Class?</h2>

A class can be thought of as a blueprint to create objects. Classes can contain methods, variables or even constants. 

Let's see how this works with an example. 

```ruby
Class Mammal

end
```
For the remainder of this series on what is OOP, we will continue to use the Mammal class for our examples. 

We have created a class but it doesn't do anything. To make this class more useful we'll need to create an <em>initialize</em> method. 

The <em>initialize</em> method is a Ruby class method and is used to initialize variables at the class level. This is helpful when you create an object of the class.


```ruby
class Mammal
  def initialize(species)
    @species = species
    @endothermic = true
    @live_birth = true
  end
end 
```

Before we continue, we'll need to look at what we have done above. The first thing that you may have noticed is the <em>@symbol</em> preceding the variable name. 

In Ruby, this is called an instance variable and it has a scope limited to the current object. So two different instances of the Mammal class can have different values for their instance variables. 

Instance variables are not public. Let's see what happens when we create a cat object from the Mammal class without making it available outside of the object.

```ruby
cat = Mammal.new("Felis Catus")
cat.species
# output
NoMethodError: undefined method `species' for #
```

To make the instance variable available outside the object, we will need to create a getter method and we would also need to create a setter method to be able to change the values of the other two instances variables (@endothermic and @live_birth).

Ruby has a clean and elegant way of doing this. Instead of creating methods for setting and getting the value of the instance variables, Ruby has three attribute accessors. 

<ul>
   <li>attr_writer allows you to set the value</li>
   <li>attr_reader allows you to get the value</li>
   <li>attr_accessor allows you to get and set the value</li>
</ul>

Let's add this to our Mammal class and see what happens when we try to access the value of the instance variables outside the newly created cat object. 

```ruby
class Mammal
attr_accessor :species, :endothermic, :live_birth
  def initialize(species)
    @species = species
    @endothermic = true
    @live_birth = true
  end
end 

cat = Mammal.new("Felis Catus")
puts cat.species # output Felius Catus
puts cat.endothermic # output true
puts cat.live_birth # output true
```

We used the attr_accessor method, which will allow us to get the value of the instance variable to set it to something different. If we would want to only allow the value to be read, we would have used the attr_reader accessor. 

However, in this example, we want to allow both the reading and writing of the variable because this will come in handy when we reach the polymorphism section.

This should give you a better understanding of Classes and Objects. The next blog will cover Inheritance in our OOP blog series.