This is more than a ruby question, it's a basic OOP (Object Oriented
Programming) question.

Try thinking of it like this (insanely simplified, but it'll get you going)
A class is a collection of variables and methods.

If you haven't used objects, your variables so far have been global to
the program, or local to a method.  With a class your variables can be
local to the method, local to the class, global to the class, or
(ugly) just plain global.  I'm not going to go into how now, but if
you think about it, this makes life easier.

When someone has an object based off of your class, they can't see the
variables in the class (this isn't entirely true), they can only use
the classes methods.  More than that, you can specify that some
methods can not be used outside, only inside (again, not entirely
true).

So when you make a class, you end up with this collection of methods,
some you can use outside, some only inside, and variables, which are
only on the inside.  This is known as encapsulation.

It makes life easier in many many situations.  For instance if you
have a stapler program you don't want to have a get_staples() method
as a global method that can be called anywhere.  You want it bound to
a specific stapler.

class Stapler
#lots of cool code....
end

swingline = Stapler.new("red")
swingline.get_staples


Does that help at all?