Forem: Daniel Moreto

Orientação a Objetos com Ruby (parte 3) - Mais sobre métodos

Daniel Moreto — Tue, 19 Sep 2023 11:08:41 +0000

Fala comiigo!!

Dando continuidade à nossa série de POO (Programação Orientada a Objetos) com Ruby, nessa parte vamos nos aprofundar mais nos métodos, passando por alguns métodos especiais e métodos estáticos na Orientação a Objetos e como o Ruby lida com cada um deles.

Pra você que está chegando neste post, o código que escreveremos aqui parte da branch parte_02 que foi construído no post anterior e está nesse link:

https://github.com/dfmoreto/dev_to-poo_ruby/tree/parte_02

Construção de Objetos

No post anterior, nós vimos como construir um objeto. Por exemplo a comanda:

minha_comanda = Comanda.new

Lembrando que o objeto tem um nome mais chique que é instância e que o ato de criar um objeto também pode ser chamado de instanciar.

Toda vez que este método new é chamado, ele cria o objeto e chama o método initialize da Classe para que o objeto possa ser configurado. Este método é um tipo de método especial que chamamos de construtor e mesmo que não tenhamos declarado esse método na nossa classe Comanda, o Comanda.new funcionou porque todas as classes possuem esse método de maneira implícita.

Vamos lá na classe Comanda e adicione o seguinte:

class Comanda
  def initialize
  end

  def numero=(numero)
  ...
end

Repare que o método está vazio, ele não está fazendo nada realmente útil. É exatamente desta forma que initialize existe de maneira implícita: vazio. Nos posts futuros nós vamos entender como ele recebe esse método de maneira implícita mas por hora podemos assumir que ele sempre esteve ai.

Pra que serve um método construtor?

Acima nós declaramos ele vazio, mas o método construtor tem uma função importante. É nele que nós podemos informar os valores com os quais queremos que nossos objetos sejam criados.

Vamos ao exemplo da Comanda: ela tem os atributos numero, atendente, mesa e itens. Enquanto não atribuímos valor nenhum para estes atributos, eles estão vazios, sem nenhum valor. Para ser mais exato estão com valores nulos (que no Ruby é representado pelo nil).

Aqui podemos fazer umas perguntas interessantes. Uma Comanda pode ser aberta, ou passar a existir, sem um número? E sem a mesa? E sem uma pessoa que atenda? E sem item nenhum?

Sem item nenhum até que vai, porque no começo realmente não haverá itens, mas ainda assim não é legal que deixemos o atributo item nulo. Porém sem um número, sem uma mesa e sem atendente, acredito que não faça muito sentido. No nosso caso, o propósito de existir de uma Comanda é ter um número, uma mesa que ela representa e quem é a pessoa atendente. Ela tem uma DEPENDÊNCIA desses dados existirem.

Alterando o Construtor da Comanda

Se uma Comanda não deveria existir sem um número, sem uma mesa e sem uma pessoa que atenda, podemos exigir que ela só seja instanciada com o número, com a mesa e com atendente.

Pra fazer isso, vamos alterar o método initialize que declaramos antes pra esse:

class Comanda
  def initialize(numero, mesa, atendente)
    @numero = numero
    @mesa = mesa
    @atendente = atendente
    @itens = []
  end

  def numero=(numero)
  ...
end

Repare que agora o método está esperando um argumento para o numero, outro para a mesa e um terceito para atendente.

Se a gente for tentar executar o código (no README do repositório tem como fazer isso), uma exceção como essa será levantada:

main.rb:2:in `initialize': wrong number of arguments (given 0, expected 3) (ArgumentError)

Talvez no seu código não esteja apontando pra linha 2 do arquivo main.rb (main.rb:2), mas o erro será o mesmo.

Este erro está nos informando que o método initialize está recebendo um número errado de argumentos, que 0 argumentos foram passados e ele espera que sejam enviados 3.

Lembra que eu falei que quando chamamos Comanda.new para construir o objeto, ele chama o método initialize? Como nosso initialize agora está definido com 3 parâmetros, o new também precisa ser chamado com 3.

Bora alterar a instanciação da Comanda para enviar agora o número, a mesa e a atendente. Onde estava:

minha_comanda = Comanda.new
minha_comanda.numero = 5421
minha_comanda.atendente = "Maria"
minha_comanda.mesa = 17

Agora podemos colocar:

minha_comanda = Comanda.new(5421, 17, 'Maria')

Se voltarmos a executar o código Ruby, teremos o resultado novamente sem erros:

Número: 5421 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo

Não vamos mexer nos itens por ora, só nos interessa por enquanto que na instanciação ele receba um array vazio.

Métodos de Escrita e Leitura

É importante que uma classe proteja o livre acesso aos seus atributos. Especificamente no Ruby isso já vem por padrão, tanto que criamos métodos que os manipulam.

Olhando por um ponto de vista de manter os seus atributos encapsulados (é um conceito que logo vamos ver) dentro dela, os métodos são uma estratégias interessante, já que com os métodos a classe é capaz de decidir como essa alteração vai ocorrer.

No caso da Comanda, nós já criamos métodos deste tipo mesmo sem perceber.

Os métodos de escrita são chamados de Setters, que utilizamos para atribuir algum valor num atributo. Repare que nosso código contém métodos que fazem isso, e eles tem um = no final e são eles: numero=, atendente=, mesa= e itens=. Este são métodos Setters.

Os relacionados a leitura são os Getters. Ou seja, são criados quando queremos disponibilizar a leitura de algum atributo. Ele simplesmente retorna o valor do atributo. No caso dos Getters eles não tem nenhum caractere especial no nome, mas olhando o corpo do método você é capaz de inferir. Temos: numero, mesa, atendente e itens. O método fechar não é um Getter porque ele não tem como objetivo único retornar o valor de um atributo.

Enxugando o código

Como no Ruby o único jeito de acessar os atributos de um objeto é por meio dos métodos, isso faz com que obrigatoriamente precisemos dos Getters e dos Setters. Mas pra não precisarmos ficar criando sempre esses métodos, o Ruby fornece pra gente meios de criá-los automaticamente.

Para Getters, os métodos criados especificamente para ler o valor de um atributo, podemos utilizar o attr_reader.

Atualmente, na nossa classe Comanda, temos quatro métodos cuja única finalidade é retornar o valor de um atributo e são eles:

class Comanda
  ...

  def numero
    @numero
  end

  ...

  def atendente
    @atendente
  end

  ...

  def mesa
    @mesa
  end

  ...

  def itens
    @itens
  end

  ...
end

...

Nós vamos REMOVER estes métodos e adicionar no topo da classe Comanda o attr_reader dessa forma:

class Comanda
  attr_reader :numero, :atendente, :mesa, :itens

  def initialize(numero, mesa, atendente)
  ...
end

...

Os quatro métodos numero, atendente, mesa e itens foram removidos e este attr_reader foi adicionado. O attr_reader é um método interno do Ruby que está pegando este Array de valores :numero, :atendente, :mesa e :itens e fazendo, por baixo dos panos, a criação daqueles quatro métodos que acabamos de remover.

Para os Setters, os métodos que fazem a escrita de valores dos atributos, nós temos o attr_writer. Na nossa classe Comanda, os métodos Setters são:

class Comanda
  ...

  def numero=(numero)
    @numero = numero
  end

  def atendente=(atendente)
    @atendente = atendente
  end

  def mesa=(mesa)
    @mesa = mesa
  end

  def itens=(itens)
    @itens= itens
  end

  ...
end

...

Da mesma forma que fizemos anteriormente, vamos REMOVER estes quatro métodos e adicionar o seguinte no topo da classe:

class Comanda
  attr_reader :numero, :atendente, :mesa, :itens
  attr_writer :numero, :atendente, :mesa, :itens

  ...
end

Logo abaixo do attr_reader, colocamos o attr_writer que faz a mesma coisa: é um método interno do Ruby que está pegando este Array de valores :numero, :mesa e :itens e fazendo, por baixo dos panos, a criação daqueles três métodos que acabamos de remover.

Uma informação importante é que não precisamos deixar os dois necessariamente nesta ordem. O attr_reader não precisa vir antes do attr_writer e eles também não precisam estar no topo da classe. Eles só precisam existir em algum momento. Como eles são um recurso que, como disse anteriormente, cria aqueles métodos por baixo dos panos, a ordem em que eles aparecem não faz muita diferença porque os métodos estarão lá para serem utilizados.

Com estes dois recursos adicionados, quando executamos o nosso arquivo no terminal temos exatamente o mesmo resultado que tínhamos antes:

Número: 5421 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo

Isso mostra que a substituição dos métodos pelos attr_reader e pelo attr_writer foi um sucesso

Mas ainda não acabou :)

O Ruby nos disponibiliza mais uma facilidade para os casos que queremos criar tanto um Getter quanto um Setter para um atributo nosso, e ele é o attr_accessor.

Com o attr_accessor, nós criados um "acesso completo" a um atributo do objeto e como temos isso sendo feito atualmente para numero, atendente, mesa e itens, nós podemos fazer uma substituição interessante. Onde temos o attr_reader e o attr_writer na classe Comanda:

class Comanda
  attr_reader :numero, :atendente, :mesa, :itens
  attr_writer :numero, :atendente, :mesa, :itens

  ...
end

Podemos SUBSTITUIR pelo attr_accessor:

class Comanda
  attr_accessor :numero, :atendente, :mesa, :itens

  ...
end

Desta forma estamos criando ambos Getters e Setters para numero, atendente, mesa e itens.

E se executamos nosso arquivo novamente, temos o mesmo resultado:

Número: 5421 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo

Ou seja, tudo certo.

Métodos Estáticos

Até o momento vimos que vários recursos que dizem respeito ao objeto, que é criado a partir de uma classe. Porém existem recursos que não podemos atrelar à instância de uma classe (um objeto), mas à classe em si.

Vamos a um exemplo: atualmente nós instanciamos a classe Comanda passando número, atendente e mesa. Porém nós vamos seguir por um outro caminho agora; vamos fazer com que a Comanda gere seu próprio número em ordem de criação. Seguindo o raciocínio, a primeira comanda receberá o número #1, a segunda o número #2 e assim por diante.

Se olharmos para o conceito do objeto, seria impossível conseguirmos fazer isso porque cada objeto é responsável apenas por si mesmo: por seu próprio número, sua própria mesa e seus próprios itens. Para que isso aconteça nós precisamos manter uma contagem da quantidade de objetos da comanda que foram criados.

Existem vários meios de fazer isso, mas neste momento nós vamos colocar um método que será responsável por gerenciar a quantidade de instâncias de uma Comanda na própria classe Comanda.

Primeiro, vamos criar uma variável na classe para conseguirmos manter a quantidade de Comandas instanciadas.

Adicione o seguinte na classe Comanda:

class Comanda
  @contador_de_comandas = 0

  attr_accessor :numero, :atendente, :mesa, :itens
  ...
end

Uai, adicionamos uma variável para o objeto do topo da Classe? Podemos dizer que não. Quando colocamos uma variável de instância fora dos métodos do objeto, ela pertence à própria Classe. Ou seja, este valor está atrelado à própria classe Comanda, ou seja, independente do objeto o valor será sempre o mesmo.

Com essa variável criada, que podemos chamar de atributo estático porque vai possuir o mesmo valor em todos os objetos, vamos criar também um método para gerar o número da comanda a partir dessa variável. Para isso, vamos adicionar no nossa classe comanda o seguinte:

class Comanda
  ...

  def fechar
  ...

  def self.gerar_numero
    @contador_de_comandas += 1
  end
end

...

Quando colocamos este self na frente de um método, ele é criado na própria classe, ou seja, é um método estático. E neste método estamos pegando o valor do @contador_de_comandas, somando o valor 1, reatribuindo o novo valor na própria própria variável e retornado. E pelo fato dele ser um método estático, nos conseguimos acessar o valor de um atributo estático do mesmo jeito que acessamos o valor de um atributo do objeto num método do objeto.

Vamos fazer um teste pra ver como funciona um método de classe. Primeiro, vamos tentar executar esse método a partir de um objeto da classe Comanda. Adicione o seguinte no seu código:

class Comanda
  ...
end

...

puts minha_comanda.gerar_numero

Quando tentamos executar o código, é retornado essa mensagem

Número: 5421 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo
main.rb:26:in `<main>': undefined method `gerar_numero' for #<Comanda:0x00007fb0a50a81d0 @numero=5421, @mesa=17, @atendente="Maria", @itens=["Café pingado", "Pão de queijo"]> (NoMethodError)

puts minha_comanda.gerar_numero
                  ^^^^^^^^^^^^^

Na primeira linha ele imprimiu o texto de antes, mas da segunda em diante ele está trazendo um erro que informa que o método gerar_numero não existe pro objeto que está na variável minha_comada

Este é um erro esperado, já que o método gerar_numero não existe para os objetos da classe Comanda, mas para a classe em si. Para conseguimos chamar este método direto na classe, vamos substituir este código que acabamos de colocar:

puts minha_comanda.gerar_numero

Por este

puts Comanda.gerar_numero

Estamos chamando o método gerar_numero a partir da própria classe Comanda. Repare que é o mesmo formato de quando chamamos o Comanda.new

E ao executar o arquivo não temos mais nenhum erro

Número: 5421 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo
1

Imprimimos o conteúdo das linhas anteriores e executamos o método gerar_numero a partir da classe Comanda, cujo valor impresso foi 1.

Agora que vimos como funciona, podemos APAGAR essa linha que adicionamos para teste:

puts Comanda.gerar_numero

Enriquecendo nossos exemplos

Com o entendimento de como podemos fazer a geração do número da Comanda, vamos colocar isso no nosso código e vamos aproveitar para enriquecer mais nosso exemplo para vermos que está tudo funcionado bem.

No nosso arquivo de código, onde temos:

minha_comanda = Comanda.new(5421, 17)

Vamos substituir por:

minha_comanda = Comanda.new(Comanda.gerar_numero, 17, 'Maria')

Repare que antes nós passamos um número aleatório, agora estamos passando o retorno do método estático gerar_numero da classe Comanda.

Além disso, vamos aproveitar para criar mais 2 comandas. Adicione no seu código:

puts "Número: #{minha_comanda.numero} | Atendente: #{minha_comanda.atendente} | Mesa: #{minha_comanda.mesa} | Itens: #{minha_comanda.itens.join(',')}"

segunda_comanda = Comanda.new(Comanda.gerar_numero, 13, 'João')
segunda_comanda.itens = ['Capuccino com Chatilly', 'Coxinha Assada']
puts "Número: #{segunda_comanda.numero} | Atendente: #{segunda_comanda.atendente} | Mesa: #{segunda_comanda.mesa} | Itens: #{segunda_comanda.itens.join(',')}"

terceira_comanda = Comanda.new(Comanda.gerar_numero, 9, 'Maria')
terceira_comanda.itens = ['Café coado', 'Pastel de Frango']
puts "Número: #{terceira_comanda.numero} | Atendente: #{terceira_comanda.atendente} | Mesa: #{terceira_comanda.mesa} | Itens: #{terceira_comanda.itens.join(',')}"

E pra finalizar, se executarmos este código, teremos o resultado:

Número: 1 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo
Número: 2 | Atendente: Maria | Mesa: 13 | Itens: Capuccino com Chatilly,Coxinha Assada
Número: 3 | Atendente: Maria | Mesa: 9 | Itens: Café coado,Pastel de Frango

Repare que o número da Comanda está em ordem crescente de criação. Isso significa que nosso método estático está funcionado perfeitamente independente os objetos da classe Comanda que são criados.

Com a geração automática dos números ~~e vendo trabalhadora mulher atender sozinha três mesas graças à precarização do trabalho no capitalismo~~, finalizamos este post.

O código que produzimos aqui está no mesmo repositório na branch parte_03.
https://github.com/dfmoreto/dev_to-poo_ruby

Já já nos vemos nos próximos posts. Ainda tem conteúdo pra chegar =)

Orientação a Objetos com Ruby (Parte 2) - Objetos e Classes

Daniel Moreto — Tue, 22 Aug 2023 22:27:03 +0000

Fala comiigo!

Dando continuidade à série de Orientação a Objetos com Ruby, nesse post começaremos a falar da parte mais técnica e tentar entender o que é de fato um objeto e como ele se comporta na Programação Orientada a Objetos.

Vamos lá, Objetos...

O que é Objeto?

Nós podemos podemos pensar em Objetos como a representação de algo do mundo real. Eu sei que pode parecer um pouco aleatório isso, mas a ideia da orientação a objetos é que nós possamos literalmente representar qualquer coisa que esteja presente no nosso mundo, seja tangível ou intangível.

Exemplos disso seriam: um computador, um celular, seu animal de estimação, a casa onde você mora, a cadeira que você senta, tudo.

Poderia inclusive ser você, que enquanto trabalhador exerce a sua profissão todos os dias, ou aquela cafeteria que você vai tomar um cafezinho às vezes. Ou seja, você, seu registro de ponto, a cafeteria, o seu café, a comanda que você recebe, tudo isso pode ser um objeto na Programação Orientada a Objetos (POO).

Pois bem, fica com isso na cuca que a gente precisa adicionar uns detalhes...

Interação dos Objetos com o Mundo

Vamos fazer uma observação do mundo real. Pensa naquela cafeteria, numa pessoa atendente que está lá todo santo dia trabalhando. Imagine que ela, que aqui vamos chamar de Maria, trabalha 10h por dia contando sábados e domingos, entra às 4:00h e sai apenas às 14:00h.

Que tipo de informações conseguimos extrair fazendo essa observação?

~~Provavelmente é uma pessoa trabalhadora super explorada~~
O nome dessa pessoa é Maria
A carga horária de trabalho é de 60h semanais
Horário que ela entra é 4:00h
Horário que ela sai é às 14:00h

E como essa trabalhadora interage com o mundo real enquanto atendente desta cafeteria?

Abre comanda
Anota pedido
Registra o ponto

Vamos pensar se você foi até esta cafeteria e a Maria, ao te atender, abriu uma comanda de número 5142 para a sua mesa de número 17. Você pediu à Maria um cafezinho pingado e um pão de queijo. Que características conseguimos extrair dessa situação?

O número da comanda é 5142
A mesa que ela atende é 17
Os itens são um café pingado e um pão de queijo
A pessoa atendente é Maria

E como essa comanda pode "interagir" com o mundo?

Ela pode receber um novo item
Um item pode ser removido dela
Pode ser fechada

Então, pega a visão: todo objeto tem características e comportamentos.

Se tiver animado, faça esse exercício: olhe à sua volta e anote as carecterísticas e comportamentos você consegue extrair dos objetos que identifica.

Tá, Objeto foi.. E Classe?

Vamos voltar à comanda, onde seu pedido é anotado.

Quando paramos pra pensar, aquele pedaço de papel dividido como uma tabela que tem um número, os itens que você consumiu e o número da sua mesa é apenas uma das possíveis que a Maria vai abrir. Milhares de outras vão existir antes e depois da sua.

Porém, todos estes pedaços de papel tem uma classificação, ou uma Classe, algo que a define, algo que diz todas as caraterísticas e os comportamentos que esse papel conhecido como Comanda precisa ter. Ou seja, a Classe é o esqueleto do Objeto.

Para que a sua comanda exista com o número 5142, com o seu café pingado e seu pão de queijo, com o número da sua mesa 17 e associada à pessoa atendente Maria, ela precisa de um molde, esse molde é a Classe.

A partir da Classe nós definimos quais características e comportamentos os Objetos existirão.

E o código, heim?! E o Ruby?!

Nos exemplos de código, nós utilizaremos a Comanda.

Bem, todo Objeto surge a partir de uma Classe definida, então se quisermos representar a Comanda, nós precisamos criar uma Classe pra ela, e no Ruby seria desta forma:

class Comanda
end

A palavra-chave class é utilizada para definir uma classe.

Com esta classe criada, se quisermos criar um Objeto a partir dela, faremos

class Comanda
end

minha_comanda = Comanda.new

Com o Comanda.new criamos um objeto Comanda e armazenamos na variável minha_comanda. Nós estamos criando somente um objeto, mas não existe um limite que nos impeça de criar mais 2 ou mais 1000 com a mesma classe.

Adicionando Comportamento na Classe

Como vimos, a Comanda possui comportamentos que define as ações que um objeto pode exercer. No Ruby, toda e qualquer comunicação do Objeto com o mundo real ocorre por meio da definição de Métodos. E se você veio de outro paradigma de programação, o método é uma função dentro de uma Classe.

Vamos pegar como o exemplo o comportamento "ser fechada". Para que a Comanda tenha o comportamento de ser fechada, nós vamos criar um método chamado fechar dentro dela desta forma:

class Comanda
  def fechar
    puts "Comanda fechada!"
  end
end

...

Uma vez que definimos o método fechar na classe, nós podemos chamá-lo no objeto desta forma:

class Comanda
  ...
end

minha_comanda = Comanda.new
minha_comanda.fechar

Lembrando que quando definimos o fechar ali em cima, nós estamos declarando como o objeto vai se comportar quando este método for chamado. Com isso, você verá que o seguinte texto será impresso na sua tela:

Comanda fechada!

Este foi apenas um exemplo de um método, a ideia é que futuramente ele faça coisas significativas em vez de só imprimir coisas na tela =)

Adicionamos um primeiro comportamento, agora precisamos também adicionar as características.

Definindo as Características

Na POO, as características de um objeto são conhecidas como Atributos.

Uma particularidade do Ruby é que TODO e qualquer atributo de um objeto é privado ao próprio objeto. Um atributo NUNCA será manipulado ou acessado diretamente do mundo exterior ao objeto.

Você deve estar se perguntando, então pra que raios eu vou precisar de um atributo?!?!...

Pois bem, repetindo, ele realmente NUNCA será manipulado ou acessado diretamente do mundo exterior ao objeto, MAS o objeto pode fornecer meios desses atributos serem manipulados se forma indireta. Lembra que eu te falei que "toda e qualquer comunicação do Objeto com o mundo real ocorre por meio da definição de Métodos"? Nós também utilizaremos os métodos para manipular os atributos de um objeto.

Retomando a nossa Comanda, nós vimos que ela tem as características como número da comanda, número da mesa, lista de itens e quem é a atendente. E assumiremos que a partir destas características nós vamos definir os atributos numero para o numero da comanda, mesa para o número da mesa, itens para a lista de itens e atendente para o nome da pessoa que te atendeu.

Para que uma Comanda possa receber um número, criaremos um método que vai atribuir este valor num atributo numero. Para isso, vamos definir este método na classe Comanda:

class Comanda
  def numero=(numero)
    @numero = numero
  end

  def fechar
  ...
end

No corpo deste método, a variável @numero é conhecida como Variável de Instância e ela faz parte APENAS do escopo do objeto. É exatamente por este motivo que anteriormente eu disse que um atributo de um objeto nunca será manipulado diretamente fora dele, porque não existe outro recurso seguro para que isso seja feito além de um Método.

Estamos criando um método numero= (você não leu errado, ele tem um "=" no final do nome) e neste método estamos definindo que ele precisa receber um atributo numero. Dentro deste método, estamos pegando o valor que será enviado como parâmetro para numero e atribuindo em @numero.

Da mesma forma, podemos criar um método para acessar o valor do atributo @numero. Com isso, criamos mais um método na Comanda:

class Comanda
  def numero=(numero)
  ...

  def numero
    @numero
  end

  ...
end

...

No Ruby, apesar da palavra-chave return existir, nós a omitimos em diversos casos porque o Ruby sempre retorna a última expressão de um método

Neste método numero (que é diferente do método numero=), nós estamos retornando o valor do atributo @numero.

Para utilizarmos estes dois métodos, não será muito diferente do método fechar que usamos na sessão anterior. Podemos chamá-los desta forma:

class Comanda
  ...
end

minha_comanda = Comanda.new
minha_comanda.numero = 5421
puts minha_comanda.numero
puts minha_comanda.fechar

Neste caso, estamos chamando o método numero= passando como valor 5142 e em seguida chamamos o método numero imprimindo o que ele retornou. Por incrível que pareça, o Ruby nos deixa criar um método com um "=" no final do seu nome e chamar desta forma. Esta chamada é a mesma coisa que fazer minha_comanda.numero=(5421)

Olhando o resultado deste puts da ultima linha, teremos impresso:

5142
Comanda fechada!

Isso nos certifica que realmente o valor está sendo atribuído em @numero.

Para finalizar o papo desse post, vamos criar os mesmos métodos para o atributo atendente, mesa, itens. Os métodos para manipular e ler o número da mesa e os itens ficarão assim:

class Comanda
  def numero
  ...

  def atendente=(atendente)
    @atendente = atendente
  end

  def atendente
    @atendente
  end

  def mesa=(mesa)
    @mesa = mesa
  end

  def mesa
    @mesa
  end

  def itens=(itens)
    @itens= itens
  end

  def itens
    @itens
  end

  ...
end

...

Temos um novo método atendente= (com "=") para atribuir o nome da pessoa atendente e atendente (sem "=") para retornar o valor, que no caso está atribuído na variável de instância @atendente. O mesmo está ocorrendo com a mesa e os itens.

Vamos utilizar estes métodos para atribuir valores e imprimi-los. Ficaremos com o código do desta forma:

class Comanda
  ...
end

minha_comanda = Comanda.new
minha_comanda.numero = 5421
minha_comanda.atendente = 'Maria'
minha_comanda.mesa = 17
minha_comanda.itens = ['Café pingado', 'Pão de queijo']
puts "Número: #{minha_comanda.numero} | Atendente: #{minha_comanda.atendente} | Mesa: #{minha_comanda.mesa} | Itens: #{minha_comanda.itens.join(',')}"

Com isso, estamos atribuindo 5142 no atributo @numero, "Maria" no atributo @atendente, 17 para @mesa e ['Café pingado', 'Pão de queijo'] para @itens

Executando este script, será impresso na tela:

Número: 5142 | Atendente: Maria | Mesa: 17 | Itens: Café pingado,Pão de queijo

Com isso a gente termina essa segunda parte dessa série. Ainda tem mais, estamos no começo.

O código que foi feito aqui está neste repositório na branch parte_02:
https://github.com/dfmoreto/dev_to-poo_ruby/tree/parte_02

Curtiu? Sinta-se à vontade para fazer correções, comentários ou acréscimos ali em baixo nos comentários =)

Orientação a Objetos com Ruby (Parte 1) - Introdução e História

Daniel Moreto — Sun, 30 Jul 2023 21:26:41 +0000

Fala comigo!

Recentemente eu me peguei explicando Orientação a Objetos com Ruby e embora eu tenha conseguido expressar o que queria, me frustrou não conseguir de uma forma melhor.

Estou revisitando algumas bibliografias e aproveitando pra escrever essa série e solidificar o conteúdo novamente.

Antes de começar qualquer coisa, embora eu vá deixar todas as referências que estou utilizando no final dessa série, eu PRECISO dar um destaque nesse primeiro post a uma playlist do Guanabara do Curso em Vídeo sobre Programação Orientada à Objetos que é uma coisa linda de assistir:

https://www.youtube.com/playlist?list=PLHz_AreHm4dmGuLII3tsvryMMD7VgcT7x

Espero conseguir abordar alguns conceitos importantes da base da Orientação a Objetos. Então vamos começar pelo começo: de onde que surgiu isso? Pra que serve?

Uma Breve História da Orientação a Objetos

Os primeiros conceitos da orientação a objetos surgiram na Noruega na década de 70, quando Ole Johan Dahl e Kristen Nygaard criaram o Simula I em 1962, uma extensão da linguagem de programação Algol, e posteriormente o Simula 67 (em 1967), para simular comportamento de partículas de gases.

Posteriormente, aproveitando desses conceitos, o matemático estaduniense Alan Kay, uma figura importantíssima na área de Tecnologia da Informação, criou a linguagem Smalltalk dentro de uma área de pesquisa da Xerox PARC, onde os conceitos de Orientação a Objetos foram solidificados. Alan Kay também escreveu sua tese de PHD abordando a Orientação a Objetos.

Quando estava na Xerox, Alan Kay criou a linguagem Smalltalk devido a um projeto chamado Dynabook, que tinha o intuito de montar um ambiente de computação para pessoas de qualquer idade.

Aqui eu deixo uma recomendação: Alan Kay foi uma figura ímpar na área de TI e criar a Smalltalk e cunhar o termo Orientação a Objetos foi uma de suas várias realizações. Fica a dica pra pesquisar mais sobre ele.

O Paradigma Orientado a Objetos

Se você der uma googlada pela definição de "Paradigma", provavelmente você encontrará algo parecido que eu encontrei no Dicio (dicio.com.br): "Exemplo ou padrão a ser seguido".

Pensando na Orientação a Objetos como um modelo de programação, é importante dizer que ele não é o único e nem foi o primeiro a existir. Outros existem, como a programação estruturada, a imperativa e a funcional.

Acho importante fazer um adendo que eu já vi alguns lugares colocando a programação orientada a objetos como uma "evolução da programação estruturada", onde existe um bloco único de código que executa sequencialmente. Eu particularmente não gosto dessas definições, já que o paradigma estruturado existe até hoje e ainda é utilizado na resolução de problemas. Então, é bom ficar atento com lugares que colocam a Orientação a Objetos como uma bala de prata, porque ela não é.

O modelo (ou paradigma) da Orientação a Objetos, evoluído pelo querido Alan Kay, tinha como base o que foi chamado de Análise Biológica: "Como seria se um software funcionasse como um ser vivo?". Através disso, a ideia era que cada parte do código fossem como células que interagem entre si enviando mensagens para alcançar um objetivo comum.

Com isso, podemos ver que a Orientação a Objetos nada mais é que um paradigma que tem por objetivo trazer pra dentro do software uma representação do mundo real, e a essa representação nós chamamos de "Objetos".

E o que faz um Objeto?

Por ser uma representação de algo do mundo real, um Objeto sempre terá propriedades e comportamentos e com isso a gente pode literalmente pegar qualquer coisa tangível e intangível que está no nosso mundo, como: Pessoa, Animal, Livro, Temperatura, etc.

E esses objetos podem interagir uns com os outros para termos uma determinada ação dentro do sistema. Por exemplo, se um Veterinário atende um Animal, nós literalmente podemos ter dentro de um sistema
um objeto do tipo Veterinário que interagiria com um outro objeto do tipo Animal. Mas isso são cenas dos próximos capítulos =)

Tá, mas e o Ruby com isso tudo?

O Ruby é uma linguagem japonesa criada por Yukihiro Matsumoto (mais conhecido como "Matz") em 1995. Ela tem como seu paradigma principal a Orientação a Objetos. Inclusive, umas das inspirações do Ruby foi o próprio Smalltalk.

Nesta série eu não vou abordar mais da história do Ruby, o intuito daqui pra frente é falar dos conceitos da Orientação a Objetos em si e como o Ruby lida com isso.