Lab4 Tiago Porto

aluno: Tiago Porto Barbosa
ano/sem: 2008/2o.
data do laboratório (6) : 03/11/2008

Introdução

O objetivo desse laboratório é introduzir a linguagem Ruby. Para isso, portou-se o laboratório 2 feito em java para ruby, mudando de uma linguagem com tipagem estática para uma com tipagem dinâmica.

Desenvolvimento

CLASSES PRINCIPAIS

Classe Aluno

require 'relatorio.rb'
require 'rela_queue.rb'
 
class Aluno
  def initialize(nome, queue)
    @conhecimento = 0
    @nome = nome
    @queue = queue
    @comportamento = set_comportamento(Esforcado.new(self))
  end
 
  def faz_e_entrega_relatorio
    @qualidade = (get_dedicacao*2 + get_inteligencia ) / 3
    @originalidade = (get_dedicacao + 2 * get_inteligencia ) / 3
    @rela = Relatorio.new(@qualidade, @originalidade, self)
    @queue.queue(@rela)
  end
 
  def get_conhecimento
    @conhecimento
  end
 
  def get_inteligencia
    @comportamento.get_inteligencia
  end 
 
  def get_dedicacao
    @comportamento.get_dedicacao  
  end
 
  def get_nome
    @nome
  end
 
  def set_comportamento(comportamento)
    @comportamento = comportamento
  end    
end

Classe Comportamento

require 'aluno.rb'
 
class Comportamento < Aluno
  def initialize(aluno)
    @aluno = aluno
  end
 
  def get_inteligencia
    @inteligencia
  end
 
  def get_dedicacao
    @dedicacao
  end
end

Classe Professor

require 'rela_queue.rb'
require 'aluno.rb'
 
class Professor
  def initialize(queue)
    @queue = queue
  end
 
  def corrigir_relatorio(rela)
    @nota = ( rela.get_qualidade + rela.get_originalidade + rand ) / 3 * 10
  end
 
  def corrigir_relatorios
    @rela = @queue.dequeue
    while @rela!=nil
      puts "#{@rela.get_aluno.get_nome} : #{corrigir_relatorio(@rela)}"
      @rela = @queue.dequeue
    end
  end
end

Classe Relatorio

require 'aluno.rb'
 
class Relatorio
  def initialize(qualidade, originalidade, aluno)
    @qualidade = qualidade
    @originalidade = originalidade
    @aluno = aluno
  end
 
  def get_qualidade
    @qualidade
  end
 
  def get_originalidade
    @originalidade
  end
 
  def get_aluno
    @aluno
  end
end

Classe RelaQueue

require 'relatorio.rb'
 
class RelaQueue
  def initialize
    @fim = 0
    @inicio = 0
  end
 
  def queue(relatorio)
    @array ||= {}  
    @array[@fim] = relatorio 
    @fim = (@fim + 1) % 10
  end
 
  def dequeue
    if @inicio!=@fim
      @valor = @array[@inicio]
      @inicio = (@inicio + 1) % 10
      @valor
    else
      nil
    end
  end  
end

Classes AlunoITA, AlunoUSP e AlunoUnicamp
Essas classes herdam da classe Aluno e tem o metodo set_comportamento alterado para impor restrições.

require 'comportamento'
require 'aluno.rb'
 
class AlunoITA < Aluno
  def initialize(nome, queue)
    super(nome, queue)
  end
 
  def set_comportamento(comportamento)
    if comportamento.class == Burro
      raise Exception.new
    end
    super.set_comportamento(comportamento)
  end
end
require 'comportamento'
require 'aluno.rb'
 
class AlunoUSP < Aluno
 
  def initialize(nome, queue)
    super(nome,queue)
  end
 
  def set_comportamento(comportamento)
    if comportamento.class == Summa  
      raise Exception.new
    elsif comportamento.class ==  SafoPreguicoso 
      raise Exception.new
    end
    super.set_comportamento(comportamento)
  end
 
end
require 'comportamento'
require 'aluno.rb'
 
class AlunoUnicamp < Aluno
  def initialize(nome, queue)
    super(nome,queue)
  end
 
  def set_comportamento(comportamento)
    if comportamento.class == Summa  
      raise Exception.new
    elsif comportamento.class ==  SafoPreguicoso 
      raise Exception.new
    end
    super.set_comportamento(comportamento)
  end
end

Classes Summa, SafoPreguicoso, Esforcado, Imprevisivel, Pemba e Burro
Essas classes herdam de Comportamento, para ter os metodos get_inteligenci e get_dedicacao padrões, porem algumas classes alteram esses metodos.

require 'aluno.rb'
require 'comportamento.rb'
 
class Summa < Comportamento 
  def initialize(aluno)
    @inteligencia = 1
    @dedicacao = 1
    super
  end 
end
require 'aluno.rb'
require 'comportamento.rb'
 
class SafoPreguicoso < Comportamento  
  def initialize(aluno)
    @inteligencia = 1
    @dedicacao = rand * 0.5
    super
  end
 
  def get_dedicacao
    @dedicacao = rand*0.5
  end
end
require 'comportamento'
require 'aluno.rb'
 
class Esforcado < Comportamento
  def initialize(aluno)
    @inteligencia = 0.5
    @dedicacao = 1
    super
  end  
end
require 'comportamento'
require 'aluno.rb'
 
class Imprevisivel < Comportamento
  def initialize(aluno)
    @inteligencia = rand
    @dedicacao = rand
    super
  end
 
  def get_inteligencia
    @inteligencia = rand
  end
 
  def get_dedicacao
    @dedicacao = rand
  end
end
require 'comportamento'
require 'aluno.rb'
 
class Pemba < Comportamento
  def initialize(aluno)
    @inteligencia = rand*(0.5)
    @dedicacao = rand*(0.5)
    super
  end
 
  def get_inteligencia
    @inteligencia = rand*(0.5)
  end
 
  def get_dedicacao
    @dedicacao = rand*(0.5)
  end
end
require 'comportamento'
require 'aluno.rb'
 
class Burro < Comportamento
  def initialize(aluno)
    @inteligencia = 0
    @dedicacao = 0
    super
  end
end

TESTANDO

Classe Simulador
A classe Simulador serve para ter uma interação com o usuário e assim testar as classes portadas para Ruby.

require 'rela_queue.rb'
require 'aluno.rb'
require 'professor.rb'
require 'esforcado.rb'
require 'comportamento.rb'
require 'safo_preguicoso.rb'
 
class Simulador
  def simular
    puts "Quantos alunos existem? "
    @num_alunos = gets.to_i
    @lista_de_alunos = []
    @queue = RelaQueue.new
    @num_alunos.times do |i|
      begin
        puts "Aluno #{i+1}"
        puts "Nome do aluno: "
        @nome = gets
        puts "Qual o tipo de aluno:\n\t1.Esforcado\n\t2.SafoPreguicoso\nDigite o numero: "
        @lista_de_alunos[i] = Aluno.new(@nome, @queue)
        @tipoDeAluno = 0
        while  @tipoDeAluno!=1 && @tipoDeAluno!=2 
          @tipoDeAluno = gets.to_i
          if @tipoDeAluno == 1
            @lista_de_alunos[i].set_comportamento(Esforcado.new(@lista_de_alunos[i]))
            break
          elsif @tipoDeAluno == 2
            @lista_de_alunos[i].set_comportamento(SafoPreguicoso.new(@lista_de_alunos[i]))
            break
          else 
            puts "Digite novamente: "
          end
        end
      rescue
        retry
        raise "Falha"
      ensure
      end
        @lista_de_alunos[i].faz_e_entrega_relatorio
    end
    if @num_alunos == 0
      puts "Não há alunos para fazer e entregar relatorio!"
    else
      @prof = Professor.new(@queue)
      puts "Notas dos alunos:"
      @prof.corrigir_relatorios
    end
  end
end

Teste de Simulator

lab41.jpg

Classe TestInteressante
Essa classe traz os testes feitos no laboratório 2 para verificar as especificações do funcionamento do simulador de entrega de relatório

require 'aluno.rb'
require 'aluno_i_t_a.rb'
require 'aluno_u_s_p.rb'
require 'aluno_unicamp.rb'
require 'burro.rb'
require 'comportamento.rb'
require 'esforcado.rb'
require 'imprevisivel.rb'
require 'main.rb'
require 'pemba.rb'
require 'professor.rb'
require 'rela_queue.rb'
require 'relatorio.rb'
require 'safo_preguicoso.rb'
require 'summa.rb'
require 'test/unit'
 
class TestInteressante < Test::Unit::TestCase
  def test_meu_teste
    queue = RelaQueue.new
    aluno = AlunoITA.new("John Smith", queue)
    aluno.set_comportamento(SafoPreguicoso.new(aluno))
    assert_equal(1.0, aluno.get_inteligencia, 0.01)
    assert(aluno.get_dedicacao < 0.5)
    assert_raise(Exception) { aluno.set_comportamento(Burro.new(aluno)) }  
  end
 
  def testFuncionaComoOLab1
    queue = RelaQueue.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.set_comportamento( SafoPreguicoso.new(aluno3) )
      aluno4.set_comportamento( SafoPreguicoso.new(aluno4) )
    rescue
      retry
      raise Exception.new 
    end
 
    assert_equal(0.5, aluno1.get_inteligencia, 0.01)
    assert_equal(1, aluno1.get_dedicacao(), 0.01)
 
    assert_equal(1.0, aluno3.get_inteligencia(), 0.01)
    assert(aluno3.get_dedicacao != aluno3.get_dedicacao)
    assert(aluno3.get_dedicacao < 0.5)
 
    aluno1.faz_e_entrega_relatorio
 
    rela1 = queue.dequeue
    assert_equal(aluno1, rela1.get_aluno)
    assert(rela1.get_aluno.get_nome == "John Smith" )
    assert(rela1.get_qualidade < 0.9)
    assert(rela1.get_qualidade > 0.8)
    assert(rela1.get_originalidade < 0.7)
    assert(rela1.get_originalidade() > 0.6)
 
    aluno2.faz_e_entrega_relatorio
    aluno3.faz_e_entrega_relatorio
    aluno4.faz_e_entrega_relatorio
 
    prof.corrigir_relatorios
  end
 
  def testOsComportamentosFuncionamComoEspecificado
    queue = RelaQueue.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)
 
    assert_equal(0.5, esforcado.get_inteligencia(), 0.01);
    assert_equal(1, esforcado.get_dedicacao(), 0.01);
 
    assert_equal(0.0, burro.get_inteligencia(), 0.01);
    assert_equal(0.0, burro.get_dedicacao(), 0.01);
 
    assert_equal(1.0, summa.get_inteligencia(), 0.01);
    assert_equal(1.0, summa.get_dedicacao(), 0.01);
 
    assert_equal(1.0, safo.get_inteligencia(), 0.01);
    assert(safo.get_dedicacao != safo.get_dedicacao)
    assert(safo.get_dedicacao() < 0.5)
 
    assert(imprevisivel.get_inteligencia != safo.get_inteligencia)
    assert(imprevisivel.get_inteligencia < 1.0)
    assert(imprevisivel.get_dedicacao != safo.get_dedicacao)
    assert(imprevisivel.get_dedicacao < 1.0)
 
    assert(pemba.get_inteligencia != pemba.get_inteligencia)
    assert(pemba.get_inteligencia < 0.5)
    assert(pemba.get_dedicacao != pemba.get_dedicacao)
    assert(pemba.get_dedicacao < 0.5)
  end
 
  def testAsSubClassesDeAlunoTemRestricoes
    queue = RelaQueue.new 
    alunoITA = AlunoITA.new("John Smith", queue)
    alunoUSP = AlunoUSP.new("Mark Smith", queue)
    alunoUnicamp = AlunoUnicamp.new("Joseph Smith", queue)
    begin
      alunoITA.set_comportamento( SafoPreguicoso.new(alunoITA) )
      alunoITA.set_comportamento( Summa.new(alunoITA) )
      alunoUSP.set_comportamento( Burro.new(alunoUSP) )
      alunoUnicamp.set_comportamento( Burro.new(alunoUnicamp) )
    rescue
      retry
      raise Exception.new
    end
    assert_raise(Exception) { alunoITA.set_comportamento( Burro.new(alunoITA) ) }
    assert_raise(Exception) { alunoUSP.set_comportamento( SafoPreguicoso.new(alunoUSP) ) }
    assert_raise(Exception) { alunoUnicamp.set_comportamento( Summa.new(alunoUnicamp) ) }    
  end
end

Teste TestInteressante

lab42.jpg

CODIGO

Projeto do laboratório 4 para NetBeans

Conclusão

Verificou-se a grande vantagem do uso da tipagem dinamica: não necessidade de declarar os tipos das variaveis. Dessa forma, não era preciso transpor a classe de genéricos Queue<T>, pois cada variavel pode ser qualquer outro tipo de variavel.

Uma grande desvantagem de Ruby que foi perceptivel é a baixa velocidade de processamento, pois trata-se de uma linguagem interpretada.

Como não segui a dica de separar o programa em 3 arquivos com varias classes dentro, seguindo o padrão de java, criei um arquivo para cada classe e foi necessario dar "require" em todos, aumentando o codigo.

O tempo desse laboratório foi bem calculada e vale a pena ser feita no proximo ano.

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