Object-Oriented Programming

Learning Goals

• Explain the core concepts of Object-Oriented Programming
• Gain exposure and familiarity with the Ruby syntax for classes and object instances

Vocabulary

• attribute
• class
• instance method
• object instance
• Object-Oriented Programming (OOP)

What is OOP?

Back End Engineering is concerned with the management of data for an application. There are different ways we can structure the data itself as well as the systems that manage it. Object-Oriented Programming (OOP) is one way to design a program to manage the data in a Back End.

OOP is not exclusive to Ruby! In fact, many of the most widely used programming languages follow the patterns of OOP, including Java, C#, and Python.

Connecting OOP to Real-World Scenarios

In the introduction, we shared that Object-Oriented Programming (OOP) is a paradigm for how we can organize code. Without seeing examples, that definition just feels… unhelpful. In this section, we won’t dig into code quite yet, but we’ll do some thinking and list-making to set ourselves up to write code in the next section!

Car Factory

Let’s think about some components of a Ford car factory. We may make some stuff up, but this analogy should help us build context for what OOP is.

• The factory has a machine that is designed to make a Ford Escape
• All Ford Escapes have four wheels and four doors
• The color, interior fabric and engine size can vary from one Ford Escape to another

With the information above, in theory, the manager at the factory should be able to say “please make a blue Escape with a leather interior and 2.5 cylinder engine”, and that should be possible.

That example about the car factory ties directly to concepts of OOP. We will use three main technical terms today. They are below, with the connection to the car factory example:

• class - A class is like a blueprint or template. The factory machines are designed to make a car - that is the template for ALL Ford Escapes. We could probably name it the EscapeCar class.
• object instance - An instance is an object that is made from the class template. The blue Escape that the manager requested (and was able to physically sit in and drive) is referred to as an object or instance of the EscapeCar class.
• attribute - An attribute is a specific characteristic about an instance that has the potential of varying from other instances. With our Escapes, color, interior and engine would be attributes, because they weren’t programmed into the template, but were extra information the manager was able to give for each specific instance of that class. The fact that the Escape has four wheels may also be an attribute; but it’s not a dynamic attribute since all Escapes have four wheels.

Explore Class Syntax

While this may feel uncomfortable at first, research shows that one of the most effective ways to learn is to explore. Instead of your instructor typing code and explaining every character, you are going to read some Ruby code that’s already been written. You will likely have some questions about what X or Y is doing, and you’ll also likely be able to make some deductions about what other pieces are doing. We will talk through it all after you’ve had a chance to use your brain and make some connections on your own.

Look at the code in this replit and think through the guiding questions:

• What is the name of the class?
• How many instances are being made?
• What are the attributes? Which is a default attribute and which is dynamic?
• How might you make another instance?

Answers to the questions above are available on line 50 of the replit, if you’d like to check yourself!

Write a New Class

In the previous section, you identified an object in your physical space and wrote a list of instances and attributes. The Navigator in this activity will direct their Driver to write a Ruby program that represents this object.

Access Attributes

With the class you wrote in the previous activity try to print out just one attribute. Does it work?

Flexible Attributes

At times, we want an attribute to have a default value, but also be flexible if a different value is passed in. For example, maybe the default value for a drive attribute is “front-wheel”, but we want to have the option to upgrade to “all-wheel” drive. To do this, we assign the attribute a value in the parameters for the initialize method.

class EscapeCar
  attr_reader :color, :drive, :wheels

  def initialize(color, drive = "front-wheel")
    @color = color
    @drive = drive
    @wheels = 4
  end
end

car1 = EscapeCar.new("blue")
p car1.drive
car2 = EscapeCar.new("red", "all-wheel")
p car2.drive

In the example above, car1 will have “front-wheel” drive by default, but car2 will have “all-wheel” drive, because we specified that value when we initialized the car2 instance object. It’s important to note that any flexible attributes must be last in the list of parameters.

Instance Methods

Information, even when we include dynamic information, about an object is not always enough. In software engineering, we also want the ability to change information about an object. We will use instance methods to accomplish this.

Instance methods are methods defined by the developer that can be called on any existing instance object of that class. What follows is an example to illustrate the syntax:

class EscapeCar
  def initialize(color)
    @color = color
    @wheels = 4
    @gear = "park"
  end

  def change_gear(new_gear)
    @gear = new_gear
  end
end

car1 = EscapeCar.new("blue")
p car1
car1.change_gear("drive")
p car1

Read the code carefully. Consider copy-and-pasting it into a replit and running it. Work to build an understanding of what is happening, then, read the explanations below:

• def change_gear(new_gear): this line of code is declaring a method on the EscapeCar class. Note that it lives inside of the class. It has declared a parameter, new_gear.
• @gear = new_gear: the code inside of the method will reassign the value of the gear attribute, to the value of the argument that will be passed in when this method is called.
• car1.change_gear("drive"): this is the method call. t must be called with dot notation, after the variable name of the variable that holds the object instance. This is demonstrated by the change in that attribuet value that prints out in the p statement.

Connection to Apps we Use

Now that you’ve seen how this “factory” concept can be used in code, you may be wondering about how this code concept is used within apps we use every day.

We won’t get all the way there in illustrating it today, but, we can look at Instagram for a moment to talk through where we see some use of classes and instances.

Build A Class with Specifications

Many times, you’ll build a class based on specifications (commonly referred to as specs). They will usually be written in the form of tests, which we will learn about later. For now, use the specifications below to write a class and object instances from it. You should struggle a bit while completing this, but do your best and try something!

Check For Understanding

Each partner should complete this independently. It is ok to consult one another if needed!

Follow the directions in the README of this repository, and submit your fork in the submission form!

Remember that it’s ok to not know everything, or solve everything perfectly. Give it your best effort, but if you get stuck on something, it’s ok to document in the file: what you tried, where you were stuck, and submit it like that.