In this series, I will go over the principles and foundations of object-oriented programming and some principles on databases. I will be using Ruby because I feel comfortable in the language; however, these concepts with some minor changes in syntax can be translated to other object-oriented programming languages, like Java, Node.js, etc.
Hello again, if you read my first blog post in this series. And welcome, if this your first time.
In my last post, if you haven't read it and/or need to brush up on the basic concept of object-oriented programming and classes, you can find the article here.
What is a Class?
In my last article, I used this definition:
But, what are these attributes, characteristics, and behaviors that is based on what happens in the real-world and how we can emulate it in code?
Let's take a look at our Person
class:

We determined that a person (or an instance of Person
) has a name, an age, and a height. In that case, a person should know their name, age, and height. And we can use methods in our class to invoke a certain behavior, like saying their name, age, or height.
First, we need to create a few methods to that our instance can call on to access the information we gave it.

After creating the methods that access our instance variables, we can create these behavior methods. Let's give it a try:

Using the say_name
, say_age
, and say_height
methods, we now give instances of the Person
class the ability to say (or print out) their name, age, and height. Using one of our examples from the last article:
alex = Person.new("alex", 26, 68)
The instance assigned to the variable alex
can now call on these instance methods. (We'll go over the differences between instance and class methods.)Here's what it would look like in the terminal:

(You ignore the nil
, it's the return value of using puts
. It's similar to console.log()
in JavaScript that returns in undefined.)
As you can see our instance can now speak and say the attributes that know about themselves.
Now that our instance knows things about itself, let's do some abstraction/we're getting a little philiosophical.
Class Methods vs. Instance Methods
To Thine Own Self Be True
You may have noticed above that we used the keyword self
in our behavioral methods. When used within a method, it refers to the instance of the class that calls on the instance method.

For example, I placed a binding.pry
within the initialize method. When calling on the variable alex
, we can see that self
refers to the instance of the Person
class:

Let's see what happens when we add a binding.pry
outside of a method but still within the class.


Just as expected, self
in this case refers to the Person
class.
The Differences of Methods
An easy way to remember the difference between both types of methods is the use of self
in the method name.
As we saw, the say_name
method is an instance method and can only be called on by an instance of a class because it access the attributes of that instance.
A Brief Note on Class and Instance Variables
We have already used instance variables in our construction of instances and accessing their information/attributes (e.g. @name
).
A class variable is contains an extra @
symbol and is defined outside of a method (i.e. @@all
). A class variable name can also be defined using capital letters (i.e. ALL
).

In the example above, we have defined the class variable @@all
and assigned to equal an empty array. We also instruct our initialize method to "shovel" or add each instance of the Person
class to the array.
Here's the philosophical part: As a person we should know certain things about ourselves. Although not all people know each other, we are still connected as a species. Therefore, in a way, our species should technically know every person derived from it. In this case, we can create a method that can only be accessed by the class (i.e. a class method).

Using the keyword self
in a method name allows the class to call on it. When we call Person.all
, the method should return an array of the instances created.

And here we go, both instances of the Person
class that we created are now returns. Through other class methods, we can loop or iterate through this for other purposes as well.
Conclusion
Thanks for reading! I hope this article helped you and I hope that you keep reading articles in this series.