Aula 14 Introdução à Programação Orientada a Objetos

Prévia do material em texto

Aula 14 
 
Introdução à Programação Orientada a 
Objetos 
 
 
Prof. Jalerson Lima 
 
2 
Apresentação 
Nessa aula iremos dar início aos estudos da Programação Orientada a Objetos, iniciando 
compreendendo os conceitos de objetos, classes, métodos e atributos. Aprenderemos também 
como criar cada e utilizar cada uma dessas estruturas. 
Objetivos 
1. Compreender o que é e como funciona a Programação Orientada a Objetos; 
2. Compreender os conceitos de objetos, classes, métodos e atributos; 
3. Aprender como criar e utilizar objetos, classes métodos e atributos; 
4. Exercitar os conhecimentos através de exercícios práticos. 
 
3 
1. Introdução 
A Programação Orientada a Objetos (POO) é um paradigma de programação baseado no 
conceito de objetos. A ideia geral desse paradigma é tentar tornar a programação mais próxima 
do mundo real, e é por isso que o conceito de objetos é tão importante. Um objeto pode ser 
qualquer coisa do mundo real, que possui comportamento (métodos) e características 
(atributos). Se você parar para pensar, tudo no mundo tem comportamento e características. 
Através da Programação Orientada a Objetos nós conseguimos criar elementos do mundo 
real na programação, definido as suas características e comportamento. Portanto, podemos 
criar, no mundo da programação, qualquer coisa existente no mundo real. A ideia da 
Programação Orientada a Objetos é que os sistemas de software sejam compostos por um 
conjunto de objetos que trabalhem juntos para atingir um objetivo em comum. 
Você consegue imaginar algo do mundo real que possa ser representado por um objeto 
com características e comportamento? Vamos a alguns exemplos: uma pessoa poderia ser 
representada por um objeto, em que sua altura, peso, nome, cor e sexo poderiam ser alguns 
exemplos de características dessa pessoa. Andar, correr, falar, pular, comer poderiam ser 
alguns exemplos de comportamento dessa pessoa. 
Uma conta bancária também poderia ser um objeto, em que seu número, seu saldo e o 
tipo de conta poderiam ser características. Transferir, encerrar, debitar e creditar poderiam 
ser comportamentos dessa conta. Lembre-se: qualquer coisa do mundo real pode ser 
representada em objetos, sejam elas fisicamente tangíveis ou abstratas. 
Alan Kay, considerado um dos pais da Programação Orientada a Objetos, formulou a 
analogia “algébrico-biológica”, que diz que um software deve funcionar como um organismo 
vivo, em que cada célula deve trabalhar com outras a fim de alcançar um objetivo, mas 
funcionando de forma autônoma. A cooperação entre as células se daria através de mensagens 
trocadas entre as células. Na analogia de Alan Kay, é fácil perceber que as células seriam os 
objetos que trabalham juntos, trocando mensagens entre si, para desempenhar uma tarefa. 
A partir da aula de hoje começaremos a estudar a Programação Orientada a Objetos em 
Ruby. Aprenderemos como criar objetos, como definir seu comportamento e suas 
características, como fazê-los trabalhar juntos para resolver um problema, além de aprender 
conceitos e técnicas do paradigma. 
2. Classes 
O segundo importante conceito sobre o paradigma Orientado a Objetos é o conceito de 
classes. Você pode imaginar a classe como sendo o molde para criar objetos, pois é na classe 
que definimos o comportamento e as características dos objetos. Todo objeto está sempre 
associado a uma classe, portanto todo objeto pertence a uma classe. É muito comum nos 
referirmos a objetos como instâncias de uma classe. Os conceitos de objeto e classe estão tão 
ligados que é muito comum, ao nos referimos a objetos, mencionarmos também a classe: “um 
objeto da classe Pessoa”, “objetos da classe Conta”, etc. 
 
4 
O Exemplo de código 1 ilustra a sintaxe básica para criação de uma classe em Ruby. 
1 
2 
3 
class <NomeDaClasse> 
 // Atributos e métodos 
end 
Exemplo de código 1 – Sintaxe básica de uma classe 
Para criar uma classe, inicialmente use a palavra-chave class seguido do nome da classe. 
Por convenção, os nomes das classes em Ruby seguem o estilo CamelCase. Isso significa que os 
nomes das classes devem ser escritos com a primeira letra de cada palavra em maiúsculo. Por 
exemplo: Pessoa, ContaBancaria, ProdutoImportado, UnidadeBasicaDeSaude, etc. No corpo da 
classe, entre o class (linha 1) e o end (linha 3), é o local onde definimos os atributos 
(características) e métodos (comportamento). Costuma-se dizer que atributos e os métodos 
compõem os membros da classe. 
Para melhor ilustrar os conceitos e técnicas da Programação Orientada a Objetos, iremos 
utilizar classes e objetos que representem elementos de um sistema bancário. Observe o 
Exemplo de código 2, que ilustra a definição da classe ContaBancaria. 
1 
2 
class ContaBancaria 
end 
Exemplo de código 2 – Definição da classe ContaBancaria 
A classe ContaBancaria, definida no Exemplo de código 2, é uma construção básica de 
uma classe na qual ainda não criamos nenhum atributo ou método, mas vamos fazê-lo em breve. 
Agora que criamos a classe ContaBancaria, já podemos criar objetos dela. Para isso, basta 
usar o método new conforme ilustrado no Exemplo de código 3. 
1 
2 
3 
4 
class ContaBancaria 
end 
 
conta = ContaBancaria.new 
Exemplo de código 3 – Definição e criação de um objeto da classe ContaBancaria 
No Exemplo de código 3, definimos a classe ContaBancaria nas linhas 1 e 2, e na linha 
4 usamos ContaBancaria.new para criar um novo objeto dessa classe, que foi armazenado na 
variável conta. Você pode estar se perguntando de onde veio o método new, já que nós não o 
definimos na classe ContaBancaria. Ao definirmos uma classe qualquer em Ruby, a própria 
linguagem se encarrega de incluir automaticamente vários métodos e atributos nela, e um 
desses métodos é o new. 
5 
Atividade 14.1 
Crie a classe Pessoa e em seguida crie um objeto dessa classe. 
 
3. Métodos 
Os métodos são funções definidas dentro das classes, que juntos irão compor o 
comportamento dos objetos dessa classe. Portanto, os métodos definem as ações que poderão 
ser executadas pelos objetos, e tudo aquilo que estudamos sobre as funções (como cria-las, 
como receber parâmetros, como retornar valores, etc.) são aplicáveis para os métodos. 
Observe o Exemplo de código 4, que ilustra a classe Carro com os métodos ligar, 
desligar e acelerar. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
class Carro 
 
 def ligar 
 puts "Ligando o carro..." 
 end 
 
 def desligar 
 puts "Desligando o carro..." 
 end 
 
 def acelerar(velocidade) 
 puts "Acelerando para #{velocidade} Km/h" 
 end 
 
end 
Exemplo de código 4 – Métodos da classe Carro 
Observe que a definição dos métodos na classe é idêntica à definição de funções que 
estudamos anteriormente, exceto pelo fato de que os métodos são sempre definidos dentro da 
classe. O Exemplo de código 5 ilustra como criar um objeto da classe Carro (linha 3) e como 
chamar (ou invocar) os métodos ligar, acelerar e desligar (linhas 4 a 6). O Exemplo de 
código 5 omite a definição da classe Carro para poupar espaço. 
1 
2 
3 
4 
5 
6 
# Omitindo a definição da classe Carro 
 
carro = Carro.new 
carro.ligar 
carro.acelerar(60) 
carro.desligar 
Exemplo de código 5 – Chamando métodos da classe carro 
6 
Diferentemente das funções, em que bastava usar o nome da função para chama-la, e 
ocasionalmente passar alguns parâmetros, os métodos precisam ser chamados sobre objetos. É 
por isso que, entre as linhas 4 e 6, os métodos ligar, acelerar e desligar são executados 
sobre a variável carro (carro.ligar, carro.acelerar e carro.desligar), que guarda o 
objeto da classe Carro. 
Ao executar o Exemplo de código5, o resultado observado deve ser esse apresentado 
abaixo. 
Ligando o carro... 
Acelerando para 60 Km/h 
Desligando o carro... 
 
Quais poderiam ser os métodos da classe ContaBancaria? Vamos começar definido três: 
sacar, depositar e transferir. Observe a definição desses métodos no Exemplo de código 
6. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
class ContaBancaria 
 
 def sacar(valor) 
 end 
 
 def depositar(valor) 
 end 
 
 def transferir(valor, conta_destino) 
 end 
 
end 
Exemplo de código 6 – Definição dos métodos da classe ContaBancaria 
O método sacar recebe um parâmetro (valor) que será o valor a ser sacado da conta. 
O método depositar também recebe um parâmetro (valor) que será o valor a ser depositado 
na conta. O método transferir recebe dois parâmetros: valor, que é o valor a ser transferido 
e conta_destino, que é um objeto da classe ContaBancaria que irá receber o valor. 
Concluiremos a implementação desses métodos em breve. 
Atividade 14.2 
Na classe Pessoa, crie um método chamado falar que recebe um valor como 
parâmetro e mostre esse valor na tela. 
 
 
 
7 
3.1 O método initialize 
O método initialize é um método especial que será executado quando o método new for 
executado. Ou seja, initialize é executado quando um novo objeto da classe for criado, e ele 
normalmente é usado para definir os valores iniciais dos atributos do objeto que está sendo 
criado. 
Observe o Exemplo de código 7, que ilustra o método initialize da classe Carro. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
class Carro 
 
 def initialize(modelo, ano, marca, cor) 
 # Criando o objeto 
 end 
 
end 
 
gol = Carro.new("Nova Geração", 2015, "Volkswagen", "Branco") 
uno = Carro.new("Novo Uno", 2016, "Fiat", "Vermelho") 
Exemplo de código 7 – Método initialize da classe Carro 
O método initialize recebe quatro parâmetros: modelo, ano, marca e cor. Os 
parâmetros recebidos serão atribuídos aos atributos do objeto que está sendo criado. Como 
ainda não estudamos como trabalhar com atributos, iremos implementar o método initialize 
em breve. Observe, nas linhas 9 e 10 do Exemplo de código 7, que executamos o método new 
para criar dois objetos, e passamos os parâmetros definidos no método initialize. 
Dando continuidade ao exemplo da nossa classe ContaBancaria, observe o Exemplo de 
código 8, que ilustra a definição do método initialize, e que irá receber dois parâmetros: 
numero, que será o número da conta, e saldo_inicial, que será o saldo inicial disponível na 
conta quando ela for criada. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
class ContaBancaria 
 
 def initialize(numero, saldo_inicial) 
 end 
 
 def sacar(valor) 
 end 
 
 def depositar(valor) 
 end 
 
 def transferir(valor, conta_destino) 
 end 
 
end 
Exemplo de código 8 – Definição do método initialize da classe ContaBancaria 
8 
Atividade 14.3 
Na classe Pessoa, crie o método initialize, que recebe os parâmetros nome, idade, 
altura e peso. 
 
4. Atributos 
Atributos são propriedades definidas na classe que irão compor as características dos 
objetos dessa classe. Por exemplo: cor, marca, modelo, ano e quantidade de portas poderiam 
ser atributos da classe Carro; preço, peso, altura e largura poderiam ser atributos de objeto da 
classe Produto. 
Para definir um atributo na classe, use o @ seguido do nome do atributo. Os nomes dos 
atributos seguem as regras de nomenclatura de variáveis. Observe as linhas 4, 5, 6 do Exemplo 
de código 9, nas quais foram definidos os atributos @modelo, @ano, @marca e @cor. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
class Carro 
 
 def initialize(modelo, ano, marca, cor) 
 @modelo = modelo 
 @ano = ano 
 @marca = marca 
 @cor = cor 
 end 
 
end 
 
gol = Carro.new("Nova Geração", 2015, "Volkswagen", "Branco") 
uno = Carro.new("Novo Uno", 2016, "Fiat", "Vermelho") 
Exemplo de código 9 – Definido os atributos modelo, ano, marca e cor da classe Carro 
Você pode estar se perguntando qual é a diferença entre @modelo e modelo, @ano e ano, 
@marca e marca, @cor e cor. O @modelo, @ano, @marca e @cor são atributos da classe Carro 
e serão características dos objetos dessa classe. Os atributos estão disponíveis em toda a classe, 
enquanto modelo, ano, marca e cor são parâmetros recebidos pelo método initialize, e, 
portanto, só estão disponíveis dentro desse método. 
 
9 
Observe, no Exemplo de código 10, a implementação do método initialize da classe 
ContaBancaria. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
class ContaBancaria 
 
 def initialize(numero, saldo_inicial) 
 @numero = numero 
 @saldo = saldo_inicial 
 end 
 
 def sacar(valor) 
 end 
 
 def depositar(valor) 
 end 
 
 def transferir(valor, conta_destino) 
 end 
 
end 
 
conta1 = ContaBancaria.new(1, 500) 
conta2 = ContaBancaria.new(2, 1000) 
Exemplo de código 10 – Implementação do método initialize da classe ContaBancaria 
O método initialize da classe ContaBancaria recebe dois parâmetros: numero e 
saldo_inicial. O parâmetro numero foi associado ao atributo @numero, enquanto o parâmetro 
saldo_inicial foi atribuído a @saldo. 
Atividade 14.4 
No método initialize da classe Pessoa, atribua os valores recebidos por parâmetro aos 
atributos @nome, @idade, @altura e @peso. 
 
 
Agora já podemos implementar os métodos da classe ContaBancaria. Vamos começar 
pelo método depositar, que é o mais simples. Como funciona o depósito em uma conta 
bancária? O usuário fornece um valor a ser depositado, que será somado ao saldo da conta. O 
valor a ser depositado pelo usuário é fornecido pelo parâmetro valor, e o saldo da conta é 
guardado no atributo @saldo, portanto o método depositar só precisa somar valor e @saldo, 
guardar o resultado em @saldo e retornar verdadeiro para indicar que a operação foi realizada 
com sucesso. 
 
10 
Observe o Exemplo de código 11, que ilustra a implementação do método depositar. 
Observe também que omitimos os outros métodos da classe ContaBancaria para poupar espaço. 
1 
2 
3 
4 
5 
6 
7 
8 
class ContaBancaria 
 ... 
 def depositar(valor) 
 @saldo = @saldo + valor 
 return true 
 end 
 ... 
end 
Exemplo de código 11 – Implementação do método depositar 
Implementado o método depositar, vamos testá-lo usando o código ilustrado no 
Exemplo de código 12. 
1 
2 
3 
4 
5 
# Omitindo a definição da classe ContaBancaria 
 
conta = ContaBancaria.new(1, 500) 
conta.depositar(200) 
puts "Saldo = R$ #{conta.saldo}" 
Exemplo de código 12 – Testando o método depositar 
O resultado apresentado pela execução do Exemplo de código 12 deve ser esse 
apresentado abaixo, pois a conta foi criada inicialmente com R$ 500 reais, e com o depósito de 
R$ 200 reais, o saldo deve ficar em R$ 700 reais. 
Saldo = R$ 700 
 
O segundo método da classe ContaBancaria que iremos implementar é o sacar. Como 
funciona o saque numa conta bancária? O usuário fornece um valor a ser sacado, que será 
debitado do seu saldo apenas se o saldo for suficiente para o valor solicitado. O valor a ser 
sacado é fornecido através do parâmetro valor, e o saldo da conta está guardado no atributo 
@saldo. Portanto o método sacar precisa, primeiramente, verificar se o valor é menor ou 
igual ao @saldo. Caso seja, é preciso debitar o valor do @saldo e retornar verdadeiro para 
indicar que o saque foi realizado. Caso contrário, o método apenas retorna falso para indicar 
que não há saldo. 
 
11 
Observe o Exemplo de código 13, que ilustra a implementação do método sacar. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
class ContaBancaria... 
 def sacar(valor) 
 if valor <= @saldo 
 @saldo = @saldo – valor 
 return true 
 else 
 return false 
 end 
 end 
 ... 
end 
Exemplo de código 13 – Implementação do método sacar 
Agora vamos testar o método sacar usando o código ilustrado no Exemplo de código 14. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
conta = ContaBancaria.new(1, 500) 
 
if conta.sacar(200) 
 puts "Saque realizado com sucesso!" 
else 
 puts "Saldo insuficiente!" 
end 
 
puts "Saldo = R$ #{conta.saldo}" 
 
if conta.sacar(500) 
 puts "Saque realizado com sucesso!" 
else 
 puts "Saldo insuficiente!" 
end 
Exemplo de código 14 - Testando o método sacar 
A conta foi criada inicialmente com saldo de R$ 500 reais (linha 1). Como o método 
sacar retorna verdadeiro ou falso, usamos esse método na condição do if para poder indicar 
se o saque foi realizado ou não. A primeira operação de saque (linha 3), no valor de R$ 200 
reais, deve ser bem-sucedida, e, portanto, o valor mostrado na linha 9 deve ser de R$ 300 reais. 
A segunda operação de saque (linha 11) deve falhar pois não haverá saldo suficiente. Observe 
abaixo o resultado da execução do Exemplo de código 14. 
Saque realizado com sucesso! 
Saldo = R$ 300 
Saldo insuficiente! 
 
 
12 
O último método a ser implementado é o transferir. Como funciona a transferência 
de valores entre contas? Primeiramente é preciso verificar se a conta de origem tem saldo 
suficiente para transferir o valor solicitado. Caso haja, o saldo é debitado na conta de origem 
e creditado na conta de destino, e caso não haja, uma mensagem é emitida informando que 
não há saldo suficiente. O método transferir recebe dois parâmetros: o primeiro, valor, é o 
valor a ser transferido da conta de origem para a conta de destino, e o segundo parâmetro, 
conta_destino, é o objeto da classe ContaBancaria que irá receber o valor transferido. 
Confira a implementação do método transferir no Exemplo de código 15. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
class ContaBancaria 
 ... 
 def transferir(valor, conta_destino) 
 if valor <= @saldo 
 @saldo = @saldo - valor 
 conta_destino.saldo = conta_destino.saldo + valor 
 return true 
 else 
 return false 
 end 
 end 
 ... 
end 
Exemplo de código 15 – Implementação do método transferir 
Com a implementação do método transferir, a nossa classe ContaBancaria está 
quase pronta! Está faltando apenas um detalhe, e para descobrir o que falta, vamos tentar usar 
o método transferir, conforme ilustra o Exemplo de código 16. 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
# Omitindo a definição da classe ContaBancaria 
 
conta1 = ContaBancaria.new(1, 500) 
conta2 = ContaBancaria.new(2, 1000) 
 
if conta1.transferir(100, conta2) 
 puts "Transferência realizada com sucesso!" 
else 
 puts "Saldo insuficiente!" 
end 
 
puts "Saldo da conta1 = R$ #{conta1.saldo}" 
puts "Saldo da conta2 = R$ #{conta2.saldo}" 
Exemplo de código 16 – Chamando o método transferir 
Observe, no Exemplo de código 16, que criamos dois objetos (conta1 e conta2), 
executamos o método transferir sobre o objeto conta1 e passamos como parâmetros o valor 
100, que é o valor a ser transferido, e o objeto conta2, que é a conta de destino. Como o 
método transferir também retorna verdadeiro ou falso, usamos ele na condição do if para 
13 
indicar se a transferência foi realizada ou não. Ao executarmos esse código, receberemos a 
seguinte mensagem de erro. 
exemplo15.14.rb:23:in `transferir': undefined method `saldo' for 
#<ContaBancaria:0x00000002edc2c0 @numero=2, @saldo=1000> (NoMethodError) 
 from exemplo1.rb:34:in `<main>' 
 
O erro indica que houve um problema na linha 23, dentro da implementação do método 
transferir. A mensagem é a seguinte: undefined method ‘saldo’ for #<ContaBancaria:. 
Essa mensagem significa que o método saldo foi chamado, mas esse método não existe. A linha 
23, mencionada na mensagem de erro, é essa apresentada abaixo. 
conta_destino.saldo = conta_destino.saldo + valor 
 
Nesse momento você pode estar se perguntando: “Como assim método ‘saldo’? O saldo 
não era um atributo?”, e a resposta para essa pergunta é “sim”. O saldo é um atributo da classe 
ContaBancaria, e, portanto, também é um atributo de todos os objetos dessa classe. Então 
qual foi o problema? 
O problema é que não podemos simplesmente acessar um atributo de um objeto dessa 
forma: conta_destino.saldo. Para ter acesso ao saldo da conta de destino (conta_destino), 
precisamos definir métodos que nos permitam visualizar e modificar o atributo @saldo da conta 
de destino. 
Atividade 14.5 
Na classe Pessoa, crie um método chamado maioridade? (com interrogação no final), 
que retorna verdadeiro caso a @idade seja maior ou igual a 18 anos, e falso caso contrário. 
 
 
4.1 Acessando e manipulando atributos externamente 
Quando um objeto da classe A (uma classe qualquer) tenta acessar ou manipular 
atributos de outro objeto da classe B, a classe B precisa fornecer métodos que permitam isso. 
É por isso que nós não conseguimos fazer o método transferir funcionar corretamente: o 
objeto conta1 tentou acessar e modificar o atributo @saldo do objeto conta2. 
Portanto, precisamos criar dois métodos na classe ContaBancaria: um que permita 
acessar o atributo @saldo e outro que permita modifica-lo. Por convenção, esses métodos 
seguem um padrão de nomenclatura: o método que permite acessar o valor do atributo tem o 
mesmo nome do atributo; o método que permite alterar o valor do atributo também tem o 
mesmo nome do atributo, mas seguido do sinal de igual (=). Confira a implementação desses 
métodos para o atributo @saldo no Exemplo de código 17. 
14 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
class ContaBancaria 
 ... 
 def saldo # mesmo nome do atributo 
 return @saldo 
 end 
 
 def saldo=(saldo) # mesmo nome do atributo seguido de = 
 @saldo = saldo 
 end 
 ... 
end 
Exemplo de código 17 – Implementação dos métodos para acessar e manipular o atributo saldo 
Seguindo o padrão de nomenclatura, criamos o método saldo (linhas 3 a 5) que permite 
acessar o valor do atributo @saldo. O segundo método, saldo= (linhas 7 a 9), permite modificar 
o valor do atributo @saldo pelo valor passado como parâmetro (saldo). Se você tentar executar 
o Exemplo de código 16, verá que agora ele irá funcionar e o resultado deverá ser esse 
apresentado abaixo. 
Transferência realizada com sucesso! 
Saldo da conta1 = R$ 400 
Saldo da conta2 = R$ 1100 
 
Observe que a conta1, criada inicialmente com saldo de R$ 500 reais, ficou com saldo 
de R$ 400 reais após a transferência, e a conta2, criada inicialmente com R$ 1000 reais, ficou 
com R$ 1100 reais após a transferência, portanto o valor foi de fato transferido entre as contas. 
Pronto! Nossa classe ContaBancaria está funcionando perfeitamente! Mas talvez você 
tenha se incomodado com um detalhe: imagine se a nossa classe tivesse 10 atributos e você 
tivesse que implementar os métodos de acesso e manipulação de cada um desses atributos. 
Você teria que implementar 20 métodos, o que seria um trabalho bastante entediante. 
Para a nossa sorte a linguagem Ruby nos dá alguns atalhos. Ao invés de implementar o 
método saldo na classe ContaBancaria, podemos simplesmente fazer conforme ilustrado no 
Exemplo de código 18. 
1 
2 
3 
4 
class ContaBancaria 
 attr_reader :saldo 
 ... 
end 
Exemplo de código 18 – Substituindo o método saldo pelo attr_reader 
O attr_saldo :saldo substitui a implementação do método que permite acessar o 
atributo @saldo. Portanto, ao fazer isso, podemos simplesmente apagar o método saldo.15 
Será que existe algo semelhante para o método que modifica o valor do atributo? É claro 
que sim! Confira no Exemplo de código 19. 
1 
2 
3 
4 
5 
class ContaBancaria 
 attr_reader :saldo 
 attr_writer :saldo 
 ... 
end 
Exemplo de código 19 – Substituindo o método saldo pelo attr_writer 
O attr_writer :saldo substitui a implementação do método saldo=, que permite 
modificar o valor do atributo @saldo. Portanto, ao fazer isso, também podemos apagar o 
método saldo=. Ainda não ficou satisfeito? Não tem problema! Você pode substituir o 
attr_reader :saldo e o attr_writer :saldo por apenas attr_accessor :saldo, conforme 
ilustrado no Exemplo de código 20. 
1 
2 
3 
4 
class ContaBancaria 
 attr_accessor :saldo 
 ... 
end 
Exemplo de código 20 – Substituindo o attr_reader e o attr_writer pelo attr_accessor 
Pronto! Finalizamos a implementação da classe ContaBancaria. Confira a 
implementação completa dessa classe no Exemplo de código 21 (próxima página). 
 
16 
1 
2 
3 
4 
5 
6 
7 
8 
9 
10 
11 
12 
13 
14 
15 
16 
17 
18 
19 
20 
21 
22 
23 
24 
25 
26 
27 
28 
29 
39 
31 
32 
33 
34 
class ContaBancaria 
 attr_accessor :saldo 
 attr_accessor :numero 
 
 def initialize(numero, saldo_inicial) 
 @numero = numero 
 @saldo = saldo_inicial 
 end 
 
 def sacar(valor) 
 if valor <= @saldo 
 @saldo = @saldo - valor 
 return true 
 else 
 return false 
 end 
 end 
 
 def depositar(valor) 
 @saldo = @saldo + valor 
 return true 
 end 
 
 def transferir(valor, conta_destino) 
 if valor <= @saldo 
 @saldo = @saldo - valor 
 conta_destino.saldo = conta_destino.saldo + valor 
 return true 
 else 
 return false 
 end 
 end 
 
end 
Exemplo de código 21 – Implementação completa da classe ContaBancaria 
Atividade 14.6 
Na classe Pessoa, use o attr_accessor para os atributos @nome, @idade, @peso e 
@altura. 
 
 
17 
Atividade 14.7 
Na classe Pessoa, crie um método chamado imc, que calcula o IMC (Índice de Massa 
Corporal) com base na @altura e no @peso. A fórmula do IMC é peso / altura². 
 Se o resultado for abaixo de 17: muito abaixo do peso; 
 Se o resultado for entre 17 e 18,49: abaixo do peso; 
 Se o resultado for entre 18,5 e 24,99: peso normal; 
 Se o resultado for entre 25 e 29,99: um pouco acima do peso; 
 Se o resultado for entre 30 e 34,99: um pouco obeso; 
 Se o resultado for entre 35 e 39,99: obesidade severa; 
 Se o resultado for acima de 40: obesidade mórbida. 
Resumindo 
Essa aula apresentou alguns conceitos da Programação Orientada a Objetos: objetos, 
classes, atributos e métodos. Aprendemos também como criar e utilizar essas estruturas para 
construir pequenos programas. 
Referências 
POINT, T. Ruby Tutorial. Tutorials Point, 2015. Disponivel em: 
<http://www.tutorialspoint.com/ruby/>. Acesso em: 12 nov. 2015. 
RANGEL, E. Conhecendo Ruby. [S.l.]: Leanpub, 2014. 
SOUZA, L. Ruby - Aprenda a programar na linguagem mais divertida. 1ª. ed. São Paulo: 
Casa do Código, v. I, 2012. 
WIKIPÉDIA. Object-oriented Programming. Wikipédia, 2015. Disponivel em: 
<https://en.wikipedia.org/wiki/Object-oriented_programming>. Acesso em: 24 fev. 2015.