Re: Newbie Question: What is a class for?

Matthias Borgeson wrote:
> I am now trying to grasp what a class isand what is is for. I understand
> that there a bunch of different classes, but how does that help me?

In your code you use a lot of objects, right? Like 1 is an Integer object,
"hello" is a String object, /\d+/ is a Regexp object, [] is an Array object, 
2..3 is a Range object (made out of two Integer objects) and so on.
You will have noticed that those objects all have a different set of methods:
You can do (2..3).each or [1,3,5].each, but you can't do 4.each or /la/.each.
You can do "I'm a string".length, but you can't do 3.length.
You can do 5.times, but you can't do "hello".times.
And it makes sense that it works that way, right? Cause what would the length 
of an Integer be? Or what would it mean to execute a block of code "hello" 
times?
As you can see, certain methods only make sense when used with a certain kind 
of object. But how does Ruby know which objects are supposed to have which 
methods? It know because of classes:
Every object is an instance of a class. "hello" is an instance of class 
String, 5 is an instance of class Integer (Fixnum actually, but let's not 
care about the difference at this point), 3..4 is an instance of class Range 
and so on. Those classes describe what properties and methods their instances 
have. "hello" has the methods length, gsub, tr and so on because they are 
defined as methods of String. 2..5 and ["a","b","c"] have the method each 
because in the class Range as well as in the class Array there is a method 
called each. And so on.

But what can you do with classes? Well, you can use those classes by using 
their instances. But you're already doing that. Even when you do 3 + 5 you're 
using two instances of a class (3 and 5 of class Integer) and one method of 
that class (the method +).
So what else can you do with classes? For starters you can extend the existing 
classes. Let's say you have a method that "censors" a string:

def censor(string)
  string.gsub(/./, "x")
end

You can use it like this: censor("hello world"), but now you're thinking that 
it would be much more fun if you could use it like this: "hello world".censor 
cause after all: all the other methods working with strings are used that way 
too. So here's how you'd do that:

class String
  def censor()
    self.gsub(/./, "x")
  end
end

Now you can type "hello".censor and get back "xxxxx" (how very useful, isn't 
it). You will have noticed that where we previously said string.gsub we now 
said self.gsub. Why's that? That's because the parameter string doesn't exist 
anymore. We want to call the method like mystring.censor() without any 
paramether. The method should work with the string that's in front of the dot 
(also called the receiver of the method) and not with any parameter. So how 
do we access the receiver? By using self. Inside a method definition self 
will point to the object that the method has been called on. So when you 
do "hello".censor, self is "hello" and if you do "bla".censor, self is bla. 
Actually we wouldn't have even needed to use self in there: If you call a 
method and you don't specify a receiver (i.e. you write foo() instead of 
self.foo() ), the receiver is assumed to be self. So gsub(...) would be the 
same as self.gsub(...).

So that's how you can extend existing classes. But sometimes that's not 
enough. I mean think about what kind of objects does ruby have? Strings, 
numbers, ranges of numbers, ranges of strings,... BORING! You're a people 
person, you can't be expected to sit in the basement all day and only work 
with numbers and strings. So ruby clearly needs a way to use people in your 
program. So what we do is we create a class called Person that describes what 
properties a person has and what he/she can do (what methods he/she has). So 
that we can then use Person objects (I know you usually shouldn't think of a 
person as an object, but here it's okay) in our code. Here's how to:
First you decide what properties a person should have. For now let's keep it 
small and only let him/her have a name.

class Person
  def initialize(firstname, surname)
    @fname = firstname
    @sname = surname
  end

  def name()
    "#{@fname} #{surname}"
  end

  def firstname()
    @fname
  end

  def surname()
    @sname
  end
end

So how do you use this class? Like this:

my_person = Person.new("John", "Smith")

new is a method that can be used on classes. It creates an instance of this 
class and then calls a method called initialize on it (that's why we defined 
such a method in our class). So now our initialize method gets called with 
the parameters firstname and surname. All it does with those two is store 
them: the value of firstname gets stored in @fname and the value of surname 
in @sname. Variables starting with an @-sign are so called instance 
variables. They're properties of an object. If a method sets an instance 
variable to some value, all methods that get called on the same object can 
now see this value when they access that variable.
Other than initialize there are three other methods: firstname, surname and 
name. firstname and surname are boring. All they do is return the value of 
the instance variable @fname or @sname respectively. name is a bit different. 
It uses @fname and @sname to create the full name and then returns that. Of 
course you can do things far more advanced than this with classes, but this 
should give you something to start with.

HTH,
Sebastian
-- 
Jabber: [e-mail]
ICQ: 205544826