Classes e Módulos.

25/10/2011 by urieljuliatti

Fala rapazeada, tudo na ‘sussabilidade’?!

Pois é, vamos aqui seguindo mais um post para contribuir para essa longa e maravilhosa jornada que estou percorrendo com o ruby.

Resolvi ir direto para um tema que estou tendo bastante curiosidade no momento, que é sobre Classes e Módulos com ruby, especialmente os módulos.

Começarei com as Classes, cuja abordagem é vasta, podendo ser dividida em várias etapas. É bem capaz que eu resuma muita coisa, dando ênfase apenas as partes relevantes, mas sempre deixando algumas referências para acrescentar e talvez divida esse post em séries de posts, para facilitar a divisão dos tópicos.

Antes de tudo.

Como muitos de nós sabemos, Ruby é uma linguagem puramente Orientada a Objetos, cada valor é (ou ao menos se comporta) como um objeto. Todo objeto é uma instância de uma classe. E uma classe define uma série de métodos que respondem a um objeto. Por convenção de arquitetura de software, uma classe pode extender ou ser uma subclasse de outras classes e herdar ou sobrescrever métodos de suas superclasses. Em Ruby, as classes também podem ter métodos herdados de módulos.

Os objetos são estritamente encapsulados: Os estados só podem ser acessados por seus métodos já definidos. As variáveis de instância manipuladas por esses métodos não podem ser acessadas diretamente por fora do objeto. É possível gerar getters e setters, acessando diretamente o estado do objeto. Esses acessores são conhecidos como atributos são diferentes das variáveis de instância. A visibilidade dos métodos de uma classe podem ser definidas como “public”, “private” ou “protected” que afetam drásticamente na forma que eles são chamados.

Ao contrário do que se pensa sobre as restrições geradas pelo encapsulamento de um estado do objeto, as classes em Ruby são bastante abertas. Qualquer programa em ruby pode adicionar métodos para classes já existentes e até mesmo métodos singleton para objetos específicos. É um conceito bem interessante, pois ao fazer:

class Test
 
   def user(nome)
 
       nome ||= "João Padrão"
 
   end
 
end
 
# abrindo a mesma classe e editando-a novamente
 
def Test
 
    def user(nome, cpf)
 
        nome ||= "Pedro Padrão"
 
        cpf ||= "106.778.900-90"
 
    end
 
end

class Test

   def user(nome)

       nome ||= "João Padrão"

   end

end

# abrindo a mesma classe e editando-a novamente

def Test

    def user(nome, cpf)

        nome ||= "Pedro Padrão"

        cpf ||= "106.778.900-90"

    end

end

O que vamos fazer inicialmente é definir uma classe e seus métodos. Muita coisa aqui vai ser retomada posteriormente, com uma abordagem mais avançada

Definindo uma classe.

Baby Steps, é um conceito que meu amigo @m3nd3s sempre aconselha. Seguindo esse conselho, vamos dar início a esse tópico definindo uma classe bem boba, mas que aborda um aprendizado conciso.

O que precisamos para criar uma classe? Definí-la. É tudo muito simples:

1
2
3

class Ponto
 
end

class Ponto

end

Com a palavra chave “class” definimos uma classe, seguindo pelo end, que fecha seu escopo. Não sei vocês observaram, a classe foi nomeada com a inicial maiúscula, é uma regra do Ruby, obrigatória por sinal. O nome da constante e o nome da classe são os mesmos, você verá isso posteriormente com mais detalhes.

Instanciando.

Mesmo se não colocarmos nada na classe Ponto, podemos instanciá-la:

1 2	ruby-1.9.2-p290 :005 > p = Ponto.new => #<Ponto:0x00000106b99c70>

ruby-1.9.2-p290 :005 > p = Ponto.new
=> #<Ponto:0x00000106b99c70>

A constante Ponto mantêm em um objeto o que representa a nossa classe. Todos os objetos possuem um método chamado new que é responsável por criar uma nova instância. Não há muita coisa interessante a fazer com esse objeto que criamos, apenas verificar algo do tipo:

ruby-1.9.2-p290 :006 > p.class
=> Ponto
 
ruby-1.9.2-p290 :008 > p.is_a?Ponto
=> true

ruby-1.9.2-p290 :006 > p.class
=> Ponto

ruby-1.9.2-p290 :008 > p.is_a?Ponto
=> true

Inicializando.

Se você veio de outras linguagens orientadas a objeto, certamente deve conhecer o termo “construtor”, é exatamente isso que
o initialize faz.

class Ponto
 
   def initialize(x,y)
       @x, @y = x,y
   end
 
end

class Ponto

   def initialize(x,y)
       @x, @y = x,y
   end

end

Com esse método definido, podemos criar outros ponteiros e ver o seu retorno.

ruby-1.9.2-p290 :008 > p = Ponto.new(1,10)
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>
 
ruby-1.9.2-p290 :009 > p
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>

ruby-1.9.2-p290 :008 > p = Ponto.new(1,10)
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>

ruby-1.9.2-p290 :009 > p
 => #<Ponto:0x00000105dd6fc0 @x=1, @y=10>

Repare bem nas variáveis de instância x e y, que ja foram inicializadas para o objeto corrente com o valor de 1 e 10 para x e y, respectivamente.
Acessores e Atributos

Como falei anteriormente, a classe Ponto utiliza duas variáveis de instância, contudo, o valor dessas variáveis estão acessiveis apenas para outros métodos de instância. Isto significa se quisermos que outros objetos da classe queiram utilizar métodos para acessar o valor de X e Y, teremos que fornecer métodos acessores que retornariam os valores dessas variáveis.

Ao pé da letra, para quem vem de outras linguagens Orientadas a Objeto, faríamos assim:

class Ponto
 
   def initialize(x,y)
       @x, @y = x,y
   end
 
   def x
      @x
   end
 
   def y
      @y
   end
 
end

class Ponto

   def initialize(x,y)
       @x, @y = x,y
   end

   def x
      @x
   end

   def y
      @y
   end

end

Uma vez definindo esses métodos, poderíamos fazer isso:

ruby-1.9.2-p290 :023 > p = Ponto.new(1,2)
 => #<Ponto:0x00000105db3700 @x=1, @y=2>
 
ruby-1.9.2-p290 :024 > q = Ponto.new(p.x*2, p.y*3)
 => #<Ponto:0x00000105dab870 @x=2, @y=6>

ruby-1.9.2-p290 :023 > p = Ponto.new(1,2)
 => #<Ponto:0x00000105db3700 @x=1, @y=2>

ruby-1.9.2-p290 :024 > q = Ponto.new(p.x*2, p.y*3)
 => #<Ponto:0x00000105dab870 @x=2, @y=6>

Agora, para fazermos um setter, faríamos algo do tipo:

class Ponto
 
   def initialize(x,y)
       @x, @y = x,y
   end
 
   def x
      @x
   end
 
   def y
      @y
   end
 
   def x=(value)
       @x = value
   end
 
   def y=(value)
       @y = value
   end
 
end

class Ponto

   def initialize(x,y)
       @x, @y = x,y
   end

   def x
      @x
   end

   def y
      @y
   end

   def x=(value)
       @x = value
   end

   def y=(value)
       @y = value
   end

end

Dessa forma, modificaríamos o valor da variável de instância do objeto corrente da seguinte jeito:

ruby-1.9.2-p290 :045 > p = Ponto.new(1,1)
 => #<Ponto:0x00000105d790f0 @x=1, @y=1>
 
ruby-1.9.2-p290 :046 > p.x = 0
 => 0
 
ruby-1.9.2-p290 :047 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=1>
 
ruby-1.9.2-p290 :048 > p.y = 50
 => 50
 
ruby-1.9.2-p290 :049 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=50>

ruby-1.9.2-p290 :045 > p = Ponto.new(1,1)
 => #<Ponto:0x00000105d790f0 @x=1, @y=1>

ruby-1.9.2-p290 :046 > p.x = 0
 => 0

ruby-1.9.2-p290 :047 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=1>

ruby-1.9.2-p290 :048 > p.y = 50
 => 50

ruby-1.9.2-p290 :049 > p
 => #<Ponto:0x00000105d790f0 @x=0, @y=50>

Porém, com ruby podemos simplificar a nossa vida, muitas vezes com apenas uma linha. Nesse exemplo, seguiremos o legado rubyway e faremos os getters e setters em apenas duas linhas:

class Ponto
 
   attr_accessor : x, :y
 
end

class Ponto

   attr_accessor : x, :y

end

Faça a mesma coisa agora no terminal para você ver o retorno:

ruby-1.9.2-p290 :065 > p = Ponto.new(10,10)
 => #<Ponto:0x00000105d1a528 @x=10, @y=10>
 
ruby-1.9.2-p290 :066 > p.x = 20
 => 20
 
ruby-1.9.2-p290 :067 > p
 => #<Ponto:0x00000105d1a528 @x=20, @y=10>

ruby-1.9.2-p290 :065 > p = Ponto.new(10,10)
 => #<Ponto:0x00000105d1a528 @x=10, @y=10>

ruby-1.9.2-p290 :066 > p.x = 20
 => 20

ruby-1.9.2-p290 :067 > p
 => #<Ponto:0x00000105d1a528 @x=20, @y=10>

Existem os métodos attr_writer (setter), attr_reader (getter) e o que utilizamos, o attr_accessor (getter e setter), eles são responsáveis por criarem métodos de instância para nós

Esse é um exemplo clássico de metaprogramação, e a habilidade de fazer isso é um dos maiores recursos que o ruby oferece.

Métodos de Classe.

Para quem já conhece a Orientação a Objetos, sabe que um método de classe pode ser acessado apenas pela própria classe seja lá onde ele for chamado. Isto é, no exemplo que estamos seguindo, o método de classe que vamos criar agora não é um método de instância que seria chamado em um objeto Ponto.

A chamada para o método de classe seria algo como:

1	total = Ponto.soma(p1, p2,p3)

total = Ponto.soma(p1, p2,p3)

class Ponto
 
   attr_reader : x, :y
 
   def self.soma(*pontos)
       x = y = 0
       pontos.each {|p| x += p.x; y += p.y}
       Ponto.new(x,y)
   end
 
end

class Ponto

   attr_reader : x, :y

   def self.soma(*pontos)
       x = y = 0
       pontos.each {|p| x += p.x; y += p.y}
       Ponto.new(x,y)
   end

end

Dessa forma, estaremos acessando a soma de todos os x e y de cada ponto através de um método de classe

Constantes.

Várias classes podem ser beneficiadas por uma associação e definição de algumas constantes, eis um exemplo:

class Ponto
 
def initialize(x,y)
 
    @x, @y = x,y
 
end
 
ORIGEM = Ponto.new(0,0)
 
COORD_X = Ponto.new(1,0)
 
COORD_Y = Ponto.new(0,1)
 
[...]
 
end

class Ponto

def initialize(x,y)

    @x, @y = x,y

end

ORIGEM = Ponto.new(0,0)

COORD_X = Ponto.new(1,0)

COORD_Y = Ponto.new(0,1)

[...]

end

Uma vez dentro da classe, as constantes podem ser acessadas pelos nomes, diretamente. Caso estejam fora, para serem acessadas, devem estar acompanhada no nome da classe, como no exemplo:

1	Ponto::COORD_X + PONTO::CORD_Y

Ponto::COORD_X + PONTO::CORD_Y

Você pode inicializar até mesmo fora da classe:

1 2	ruby-1.9.2-p136 :206 > Ponto::COORD_X = Ponto.new(2,0) => #<Ponto:0x00000103bb2728 @x=2, @y=0>

ruby-1.9.2-p136 :206 > Ponto::COORD_X = Ponto.new(2,0)
 => #<Ponto:0x00000103bb2728 @x=2, @y=0>

O tópico é enorme, portanto, vou extendê-lo em outros posts. Para o próximo post trarei tópicos que abordam Variáveis de Classe, Variáveis de Instância e Visibilidade.

Referências:

http://www.ruby-doc.org/docs/ProgrammingRuby/html/classes.html

http://www.devarticles.com/c/a/Ruby-on-Rails/Ruby-Classes-and-Objects/

http://blog.bluesoft.com.br/ruby-classes-e-objetos/

Fork me on GitHub

Category rails, Ruby, Ruby on Rails | Tags: , classes, modules, oop, ruby, ruby1.9.2

Uriel Juliatti

Classes e Módulos.

No Comments »

Leave a Reply Cancel reply