Ruby is an object-oriented language. In this lesson, we'll cover objects, classes, and how they're used to organize information and behavior in our programs.

Object-Oriented Programming I

Any given Ruby class can have only one superclass. Some languages allow a class to have more than one parent, which is a model called **multiple inheritance**. This can get really ugly really fast, which is why Ruby disallows it.

However, there are instances where you want to incorporate data or behavior from several classes into a single class, and Ruby allows this through the use of *mixins*. We'll learn about mixins in a later lesson! For now, we'll demonstrate what happens if you try to do multiple inheritance in Ruby.

The demo code we're about to show you includes a fancy trick: if you want to end a Ruby statement without going to a new line, you can just type a semicolon. This means you can write something like
```rb
class Monkey
end
```
on just one line: `class Monkey; end`. This is a time saver when you're writing something very short, like an empty class or method definition.

There Can Be Only One!

We'd like our classes to do more than... well, nothing, so we'll have to add some code between our `class Person` and `end`.

You may have noticed in our example back in the first exercise that we started our class definition off with a method called `initialize`. You can think of `initialize` as the function that "boots up" each object the class creates.

Classing It Up

On the flip side, sometimes you'll be working with a derived class (or *subclass*) and realize that you've overwritten a method or attribute defined in that class' base class (also called a *parent* or *superclass*) that you actually need. Have no fear! You can directly access the attributes or methods of a superclass with Ruby's built-in `super` keyword.

The syntax looks like this:
```rb
class DerivedClass < Base
  def some_method
    super(optional, args)
    # Some other stuff
  end
end
```
When you call `super` from inside a method, that tells Ruby to look in the superclass of the current class and find a method with the same name as the one from which `super` is called. If it finds it, Ruby will use the superclass' version of the method.

When Good isn't Good Enough

Classes like `Language` and `Person` are great when you are starting to learn the concepts of classes and instances.

However, classes and objects are often used to model real-world objects. The code in the editor is a more realistic demonstration of the kind of classes and objects you might find in commercial software. Here we have a snippet of the <a href="https://github.com/rails/rails" target="_blank">Rails source code</a>. See how they've created an instance of the `RecordInvalid` class?

Classes Are Serious Business

Perfect! Now let's class things up a bit with a class variable.

Getting Classier

We can create class variables by starting a variable name with two `@` symbols. Class variables are attached to entire classes, not just instances of classes, like so:
```rb
class MyClass
  @@class_variable
end
```
Because there's only one copy of a class variable shared by all instances of a class, we can use them to pull off some cool Ruby tricks. For example, we can use a class variable to keep track of the number of instances of that class we've created. Let's do that now!

Twice the @, Twice as Classy

Ruby is an object-oriented programming language, which means it manipulates programming constructs called _objects_. (Almost) everything in Ruby is an object! You've been using them all along, so they should be very familiar. Objects have methods, which you've seen before, and _attributes_, which are just data. For instance, in
```rb
"Matz".length
# ==> 4
```
the `"Matz"` object is a string with a `.length` method and a length attribute of `4`. We'll learn how to build our own objects with their own methods and internal variables in the next few exercises.

But what exactly makes `"Matz"` a string? The fact that it's an instance of the `String` *class*. A class is just a way of organizing and producing objects with similar attributes and methods.

Why Classes?

Class Basics

Another important aspect of Ruby classes is *scope*. The scope of a variable is the context in which it's visible to the program.

It may surprise you to learn that not all variables are accessible to all parts of a Ruby program at all times. When dealing with classes, you can have variables that are available everywhere (*global variables*), ones that are only available inside certain methods (*local variables*), others that are members of a certain class (*class variables*), and variables that are only available to particular instances of a class (*instance variables*).

The same goes for methods: some are available everywhere, some are only available to members of a certain class, and some are only available to particular instance objects.

Scope it Out

*Inheritance* is a tricky concept, so let's go through it step by step.

Inheritance is the process by which one class takes on the attributes and methods of another, and it's used to express an *is-a* relationship. For example, a cartoon fox *is a* cartoon mammal, so a CartoonFox class could inherit from a CartoonMammal class. 

However, a Wizard is not an Elf, so it shouldn't inherit from the Elf class (even if they have a lot of magical attributes and methods in common). Instead, both Wizard and Elf could ultimately inherit from the same MagicalBeing class.

Watch Your Step

Perfect! Let's go ahead and create an instance of our `Message` class.

Forge an Object in the Fires of Mount Ruby

Perfect! Now let's get in a little practice with inheritance.

Inheriting a Fortune

Sometimes you'll want one class that inherits from another to not only take on the methods and attributes of its parent, but to override one or more of them.

For instance, you might have an `Email` class that inherits from `Message`. Both classes might have a `send` method that sends them, but the e-mail version may have to identify valid e-mail addresses and use a bunch of e-mail protocols that `Message` knows nothing about. Rather than add a `send_email` method to your derived class and inherit a `send` method you'll never use, you can instead just explicitly create a `send` method in the `Email` class and have it do all the email-sending work.

This new version of `send` will *override* (that is, replace) the inherited version for any object that is an instance of `Email`.

Override!

Perfect! Now we're ready to start creating objects.

We can create an instance of a class just by calling `.new` on the class name, like so:
```rb
me = Person.new("Eric")
```


Instantiating Your First Object

All right! Just one more step before we can create a person from our `Person` class: we have to make sure each person has a `@name`.

In Ruby, we use `@` before a variable to signify that it's an *instance variable*. This means that the variable is attached to the *instance* of the class. 
```rb
class Car
  def initialize(make, model) 
    @make = make
    @model = model
  end
end

kitt = Car.new("Pontiac", "Trans Am")
```
The code in the example above creates an instance, `kitt`, of the class `Car`. `kitt` has his own `@make` ("Pontiac") and `@model` ("Trans Am"). Those variables belong to the `kitt` instance, which is why they're called instance variables.

We'll cover other kinds of variables (like those attached to entire classes!) in the next few exercises.

What's in a @name?

Good! A caveat, though: global variables can be changed from anywhere in your program, and they are generally not a very good idea. It's much better to create variables with limited scope that can only be changed from a few places!

For example, instance variables belong to a particular object (or "instance"). Let's get in some practice with instance variables! We've added our `Person` class from before to the editor.

For Instance...

Recall that instance variables begin with an `@`. This isn't just a Ruby convention—it's part of the syntax! Always start your instance variables with `@`.

*Class variables* are like instance variables, but instead of belonging to an instance of a class, they belong to the class itself. Class variables always start with two `@`s, like so: `@@files`.

*Global variables* can be declared in two ways. The first is one that's already familiar to you: you just define the variable outside of any method or class, and voilà! It's global. If you want to make a variable global from inside a method or class, just start it with a `$`, like so: `$matz`.

We'll go through instance and class variables in more detail in a moment. First, let's do a quick review of local and global scope.

Naming Your Variables

A basic class consists only of the `class` keyword and the name of the class. Check it out:
```rb
    class NewClass
      # Class magic here
    end
```
Our `NewClass` has the ability to create new Ruby objects of class `NewClass` (just like `"Hello!"` is a `String` and `4` is a `Fixnum`). By convention, class names start with a capital letter and use CamelCase instead of relying_on_underscores.

Class Syntax

You're a champion! Our last topic: Ruby's `super` keyword. (We've decided we liked `Message`'s `initialize` method after all.)

Up, Up, and Away!

In Ruby, inheritance works like this:
```rb
class DerivedClass < BaseClass
  # Some stuff!
end
```
The derived class is the new class you're making and the base class is the class from which that new class inherits. You can read "`<`" as "inherits from."