Aprendendo Ruby

Classes e métodos

Agora vamos criar nossa própria classe Address. É simples. Vamos começar com um endereço que contenha apenas o campo "street" (rua).

Aqui está como definir a classe :

class Address
    def initialize(street)  
        @street = street 
    end
end
                       

Veja isso:

- a palavra-chave class define a classe.

- Por definir um método dentro desta classe, estamos associando-o com esta classe.

- O método initialize é o que realmente constrói a estrutura de dados. Cada turma deve conter um método initialize.

- @street é uma variável. Similar às keys (chaves)da hash. O sinal @ distingue @street como uma variável. Cada vez que você criar um objeto da classe Address, este objeto irá conter uma variável @street.

Vamos usar esta classe para criar um objeto endereço.

address = Addres.new("23 St George St.")  
                       

É isso. address agora é um objeto da classe Address

Lendo os dados de um objeto

Suponha que você queira ler os dados do objeto address. Para fazer isso, nós precisamos escrever um método que retorne esta informação:

class Address
    def initialize(street)   
        @street = street 
    end

    # Just return @street
    def street
        @street
    end
end
                       

Agora o método Address#street possibilita ler a rua do endereço. No irb:

>> address.street 
=> "23 St George St."
                       

A propriedade de um objeto, o que é visível exteriormente, é chamada de atributo. Neste caso, streeté um atributo. Em particular, é um atributo legível. Por esse tipo de atributo ser muito comum, Ruby lhe oferece um atalho através do termo attr_reader:

class Address
    attr_reader :self
    def initialize(street)   
        @street = street 
    end
end
                       

Mudando o dado num objeto

Nós vamos definir um método que mude os dados num objeto.

class Address
    attr_reader :street
    def initialize(street)  
        @street = street 
    end
    def street=(street)
        @street = street
    end
end
                       

Ruby é inteligente o suficiente para que possamos usar "street=":

address.street = "45 Main St."
                       

Observe que você pode colocar espaços entre street e "=". Agora que nós podemos mudar o endereço, podemos simplificar o método initialize, e tê-lo simplesmente para padronizar street como sendo uma string vazia "".

class Address
    attr_reader :street
    def initialize
        @street = ""
    end
    def street=(street)
        @street = street  
    end
end

address = Address.new
address.street = "23 St George St."  
                       

Isso pode não parecer muito com uma simplificação, mas quando se adiciona os campos city (cidade), state (estado) e zip (CEP), e mais métodos, isto fará a classe definição seja um pouco mais simples.

Agora, street também é um atributo gravável. Como antes, você pode declará - la como tal, com attr_writerr:

class Address
    attr_reader :street
    attr_writer :street  
    def initialize
        @street = ""
    end
end
                       

Acessando dados

Muitas vezes, você tem atributos que são, simultaneamente, para gravação e leitura. Ruby permite fixá-los juntos com attr_accessor. É, acho que estes seriam chamados "atributos acessíveis", mas nunca vi serem chamados assim.

class Address
    attr_accessor :street  
    def initialize
        @street = ""
    end
end
                       

Com este conhecimento, fica fácil definir toda a estrutura do livro de endereços. Para terminar, attr_accessor e todos seus amigos aceitam argumentos múltiplos.

class Address
    attr_accessor :street, :city, :state, :zip  
    def initialize
        @street = @city = @state = @zip = ""
    end
end