Lab4 Marcus Leandro

aluno: Marcus Leandro Rosa Santos
ano/sem: 2008/2o.
data do laboratório (num. da semana) : 06/08/2008 (2)

Introdução

Este laboratório, foi visada a prática da linguagem ruby que assim como java é orientada a objetos. foi realizado a conversão de uma tarefa feita anteriormente em java para ruby, com o intuito de familiarizar-mos com essa linguagem e vivenciar algumas de suas diferenças com relação ao java. Observa-se que esse é o nosso primeiro contato com uma linguagem dinâmica.

Desenvolvimento

Para a conversão do lab2 para ruby, adotei a sugestão da instrução desse lab, que era dividir o projeto em três arquivos, um para o teste, outro para a classe simulador, que no caso ficou com o arquivo principal (main) e outro que conteria todas as outras classes necessárias nesse lab.

Começarei com a o arquivo Classes que contem todas as classes exceto o Simulador e o Teste. Cabe ressaltar que foi feita algumas alterações com relação as classes que tinham no projeto em java. Nessa situação não é preciso da classe abstrata Comportamento, mesmo porque não temos classes abstratas em ruby e também, por ser uma linguagem de tipagem dinâmica não teria o porquê da existência de classes abstratas e interfaces, visto que essas visam o polimorfismo. Em ruby, qualquer variável é polimórfica de qualquer classe. Tambem foi retirado a classe RelaQueue<T>, pois em ruby tudo já é genérico

Abaixo segue o código fonte desse arquivo.

######## Classe Queue ########################### 
class Queue
  def initialize
    @array = Array.new 
  end   
 
  def queue(parametro)
    @array << parametro    
  end
 
  def dequeue
    if @array.length == 0 
      return nil      
    else
      auxiliar = @array.shift     
    end  
  end  
 
end
################################################
 
############ Classe Aluno ######################
class Aluno    
  def initialize(nome ,queue ) #Construtor. 
    @nome = nome
    @queue = queue
    @comportamento = Esforcado.new(self)
    @conhecimento = 0
  end
  #metodos:
  attr_reader :conhecimento
  attr_reader :nome
 
  def inteligencia
    @comportamento.inteligencia
  end
 
  def dedicacao
    @comportamento.dedicacao
  end  
 
  def comportamento(comportamento)
    @comportamento = comportamento
  end    
 
  def fazEEntregaRelatorio    
    qualidade = ( 2*(dedicacao) + inteligencia )/3
    originalidade = ( dedicacao + 2*(inteligencia) )/3
    rela = Relatorio.new(qualidade,originalidade,self)
    @queue.queue(rela)
    @conhecimento = @conhecimento + 1
  end  
end
##################################################
 
############# Classe AlunoITA ###################
class AlunoITA < Aluno
  #construtor:
  def initialize(nome, queue)
    super(nome,queue)
  end
 
  def comportamento(comportamento)
    raise "comportamento impossivel para esse tipo de aluno" if comportamento.class == Burro   
    super
  end  
end
##################################################
 
############## Classe AlunoUSP ##################
class AlunoUSP < Aluno
  def initialize(nome, queue)
    super(nome,queue)
  end
 
  def comportamento(comportamento)
     raise "comportamento impossivel para esse tipo de aluno" if ( comportamento.class == Summa || comportamento.class == SafoPreguicoso )
     super
  end
end
##################################################
 
############## Classe AlunoUnicamp ##################
class AlunoUnicamp < Aluno
  def initialize(nome,queue)
    super(nome,queue)
  end
 
  def comportamento(comportamento)
     raise "comportamento impossivel para esse tipo de aluno" if ( comportamento.class == Summa || comportamento.class == SafoPreguicoso )
     super
  end
end
##################################################
 
############## Classe Burro ##################
class Burro  
  #construtor:
  def initialize(aluno)
    @aluno = aluno
    @inteligencia = 0
    @dedicacao = 0
  end  
  attr_reader :dedicacao 
  attr_reader :inteligencia
end
##################################################
 
############## Classe Pemba ##################
class Pemba
  #construtor:
  def initialize(aluno)
    @aluno = aluno
  end 
 
  def inteligencia
    return rand*0.5
  end
 
  def dedicacao
    return rand*0.5
  end
end
##################################################
 
############## Classe SafoPreguicoso ##################
class SafoPreguicoso 
  #construtor:
  def initialize(aluno)
    @aluno = aluno
    @inteligencia = 1
  end 
 
  def dedicacao
    return rand*0.5
  end  
 
  attr_reader :inteligencia 
end
##################################################
 
############## Classe Esforcado ##################
class Esforcado  
  #construtor:
  def initialize(aluno)
    @aluno = aluno
    @inteligencia = 0.5
    @dedicacao = 1
  end
 
  attr_reader :inteligencia
  attr_reader :dedicacao
 
end
##################################################
 
############## Classe Summa ##################
class Summa  
  #construtor:
  def initialize(aluno)
    @aluno = aluno
    @inteligencia = 1
    @dedicacao = 1
  end
 
  attr_reader :inteligencia
  attr_reader :dedicacao
end
##################################################
 
############## Classe Imprevisivel ##################
class Imprevisivel
  #construtor:
  def initialize(aluno)
    @aluno = aluno
  end
 
  def dedicacao
    return rand
  end
 
  def inteligencia
    return rand
  end
end
##################################################
 
############## Classe Professor ##################
class Professor
  def initialize(queue)
    @queue = queue
  end
 
  def corrigir_relatorios 
    rela_correcao = @queue.dequeue    
    while( rela_correcao != nil )
      nota = corrigir_relatorio(rela_correcao)
      puts "#{rela_correcao.aluno.nome} : #{nota}"
      rela_correcao = @queue.dequeue
    end    
  end  
 
  private
  def corrigir_relatorio(rela)
    nota = ( ((rela.qualidade  + rela.originalidade + rand)/3)*10 )
  end
 
end
##################################################
 
############## Classe Relatorio ##################
class Relatorio
  #//construtor:
  def initialize( qualidade , originalidade, aluno )
    @qualidade = qualidade
    @originalidade = originalidade
    @aluno = aluno
  end  
  attr_reader :qualidade
  attr_reader :originalidade
  attr_reader :aluno
end
##################################################

Observa-se uma substancial redução de código, fruto da grande disponibilidade de funções que a linguagem ruby fornece. Cabe salientar que está linguagem em relação ao java possui muito mais recurso, tornando a vida do programador muito mais fácil com relação a confecções de métodos.

Segue na sequencia o código fonte da classe Simulador que agora é o nosso main.

require 'Classes'
require 'Teste'
alunos = Array.new
rela = Queue.new
professor = Professor.new(rela); 
 
puts "***********Criacao dos alunos por parte do usuario.***********"
puts "entre com o numero de alunos a ser inserido:  "
string = gets.chomp
n = string.to_i
 
i=1
while(i<=n)
 
  puts "entre com o nome do #{i} aluno: "
  nome = gets.chomp
 
  puts "entre com a faculdade do aluno (ITA, USP ou Unicamp): "
  universidade = gets.chomp  
  while(universidade!="ITA" && universidade!="USP" && universidade!="Unicamp" )
    puts "entre com a faculdade do aluno (ITA, USP ou Unicamp): "               
    universidade = gets.chomp    
  end 
 
  if universidade == "ITA"
    alunos << AlunoITA.new(nome, rela)    
  elsif universidade == "USP"
    alunos << AlunoUSP.new(nome, rela)
  else
    alunos << AlunoUnicamp.new(nome, rela)
  end  
 
  puts "entre com o comportamento do aluno(SafoPreguicoso, Summa , Esfocado, Imprevisivel, Pemba e Burro): "
  comportamento = gets.chomp
  while(comportamento != "SafoPreguicoso" && comportamento != "Summa" && comportamento != "Esforcado" && comportamento != "Imprevisivel" && comportamento != "Pemba" && comportamento != "Burro")
    puts "entre com o comportamento do aluno(SafoPreguicoso, Summa , Esfocado, Imprevisivel, Pemba e Burro): "    
    comportamento = gets.chomp
  end   
 
  begin
    if (comportamento == "SafoPreguicoso")
      aluno = alunos.pop;
      aluno.comportamento(SafoPreguicoso.new(aluno))
      alunos.push(aluno)
    elsif (comportamento == "Pemba") 
      aluno = alunos.pop
      aluno.comportamento(Pemba.new(aluno))
      alunos.push(aluno)
    elsif (comportamento == "Esforcado")
      aluno = alunos.pop
      aluno.comportamento(Esforcado.new(aluno))
      alunos.push(aluno)
    elsif (comportamento == "Burro")
      aluno = alunos.pop
      aluno.comportamento(Burro.new(aluno))
      alunos.push(aluno)
    elsif (comportamento == "Imprevisivel")
      aluno = alunos.pop
      aluno.comportamento(Imprevisivel.new(aluno))
      alunos.push(aluno)
    else
      aluno = alunos.pop
      aluno.comportamento(Summa.new(aluno))
      alunos.push(aluno)
    end
 
  rescue Exception => e
    puts "Voce tentou fazer algo impossivel!" + e
  end 
  i = i+1 
end
 
for aluno in alunos 
  aluno.fazEEntregaRelatorio  
end
 
professor.corrigir_relatorios

Por fim, eis o arquivo de teste com a classe Teste que verifica o funcionamento do programa

require 'Classes' 
require 'test/unit'
 
class Teste < Test::Unit::TestCase
  def test_funciona_como_o_lab1
    #criando os objetos
    queue = Queue.new
    prof = Professor.new(queue)
 
    aluno1 = Aluno.new("John Smith", queue)
    aluno2 = Aluno.new("Mark Smith", queue)
    aluno3 = Aluno.new("Joseph Smith", queue)
    aluno4 = Aluno.new("Robert Smith", queue)
    begin
      aluno3.comportamento(SafoPreguicoso.new(aluno3))
      aluno4.comportamento(SafoPreguicoso.new(aluno4))
    rescue Exception => e
      puts "Nao deveria lançar erro!"      
    end
    #teste de aluno_esforcado
    assert_equal(0.5, aluno1.inteligencia, 0.01)
    assert_equal(1, aluno1.dedicacao, 0.01)
 
    #teste de alunosafo
    assert_equal(1, aluno3.inteligencia, 0.01)
    assert(aluno3.dedicacao != aluno3.dedicacao)
    assert(aluno3.dedicacao < 0.5)
 
    #alunos comecam a fazer os relas
    aluno1.fazEEntregaRelatorio
 
    #roubamos o relatório do primeiro aluno para investigá-lo
    rela1 = queue.dequeue
    assert_equal(aluno1, rela1.aluno);
    assert(rela1.aluno.nome =="John Smith")
    assert(rela1.qualidade < 0.9)
    assert(rela1.qualidade > 0.8)
    assert(rela1.originalidade < 0.7)
    assert(rela1.originalidade > 0.6)
 
    # os outros continuam a fazer os relas
    aluno2.fazEEntregaRelatorio
    aluno3.fazEEntregaRelatorio
    aluno4.fazEEntregaRelatorio
 
    #deve exibir a coreção dos relas dos aluno2, aluno3, e aluno4, nesta ordem
    #pois "roubamos" o relatório do aluno1
    prof.corrigir_relatorios
  end
 
  def testOsComportamentosFuncionamComoEspecificado
    queue  = Queue.new
    aluno1 = Aluno.new("John", queue)
    summa = Summa.new(aluno1)
    pemba = Pemba.new(aluno1)
    imprevisivel = Imprevisivel.new(aluno1)
    safo = SafoPreguicoso.new(aluno1)
    esforcado = Esforcado.new(aluno1)
    burro = Burro.new(aluno1)
 
    #teste de esforcado
    assert_equal(0.5, esforcado.inteligencia, 0.01)
    assert_equal(1, esforcado.dedicacao, 0.01)
 
    #teste de burro
    assert_equal(0, burro.inteligencia, 0.01)
    assert_equal(0, burro.dedicacao, 0.01)
 
    #teste de summa
    assert_equal(1, summa.inteligencia , 0.01)
    assert_equal(1, summa.dedicacao , 0.01)
 
    #teste de safo
    assert_equal(1, safo.inteligencia, 0.01)
    assert(safo.dedicacao != safo.dedicacao) #deve ser randomica
    assert(safo.dedicacao < 0.5)
 
    #teste de imprevisivel
    assert(imprevisivel.inteligencia != imprevisivel.inteligencia) #deve ser randomica
    assert(imprevisivel.inteligencia < 1.0);
    assert(imprevisivel.dedicacao != imprevisivel.dedicacao) #deve ser randomica
    assert(imprevisivel.dedicacao < 1.0)
 
    #teste de pemba
    assert(pemba.inteligencia != pemba.inteligencia) #deve ser randomica
    assert(pemba.inteligencia < 0.5)
    assert(pemba.dedicacao != pemba.dedicacao) #deve ser randomica
    assert(pemba.dedicacao < 0.5)
  end
 
  def testAsSubClassesDeAlunoTemRestricoes
    queue = Queue.new()
    alunoITA = AlunoITA.new("John Smith", queue)
    alunoUSP = AlunoUSP.new("Mark Smith", queue)
    alunoUnicamp = AlunoUnicamp.new("Joseph Smith", queue)
    begin
      alunoITA.comportamento( SafoPreguicoso.new(alunoITA) )
      alunoITA.comportamento( Summa.new(alunoITA) )
      alunoUSP.comportamento( Burro.new(alunoUSP) )
      alunoUnicamp.comportamento( Burro.new(alunoUnicamp) )
    rescue Exception => e
      puts "Não deveria lançar erro!"
    end
 
    begin
      alunoITA.comportamento(Burro.new(alunoITA))
      puts "Deveria lançar erro!"
    rescue Exception => e
 
    end
 
    begin
      alunoUSP.comportamento(SafoPreguicoso.new(alunoUSP))
      puts"Deveria lançar erro!"
    rescue Exception => e
    end
 
    begin
      alunoUnicamp.comportamento( Summa.new(alunoUnicamp))
      puts "Deveria lançar erro!"
    rescue Exception => e
    end
 
  end  
end

Abaixo segue o teste realizado que verifica a classe teste e a função main. É só verificar a imagem abaixo.

imagem1.jpg

Ora, os resultados obtidos nesse projeto em relação ao feito em java são os mesmo com a única vantagem que em java o aplicativo rodou mais rápido o que evidencia a maior efiência, pelo menos notada por mim, do java em relação ao ruby.

Conclusão

Por fim, posso dizer que o ruby é mais vantajoso em relação ao java por não precisar definir o tipo de uma variável, ele também tem mais métodos disponíveis o que possibilita um código mais enxuto. Nota-se também que o ruby é mais OO que java, pois tudo é classe e que temos plimorfismos em tudo, pois em uma variável pode entrar qualquer coisa.

Como desvantagem, não gostei da forma como a linguagem acusa os erros, ela espera a gente ter que executar para evidencia-los, possibilitando uma tortuosa tarefa para debugar, quando se erra, diferentemente do java, que na fase de escrita do código já acusa vários erros, possibilitando uma programação mais tranquila e por fim achei essa linguagem (o ruby) muito lenta. para programas de desempenho ela deixa muito a desejar.

Add a New Comment
Unless otherwise stated, the content of this page is licensed under Creative Commons Attribution-ShareAlike 3.0 License