Desenvolvimento Código Aberto

A classe Time é uma abstração de datas e horários. O tempo é armazenado internamente como o número de segundos com fração desde a época de 01 de janeiro de 1970 00:00 UTC. A classe Time trata os padrões GMT (Greenwich Mean Time) e UTC (Tempo Universal Coordenado) como equivalente. GMT é a maneira mais antiga de se referir a estes tempos de base.

Time: http://ruby-doc.org/core-2.2.0/Time.html

Ruby – Time

Exemplo:

Neste exemplo imprimimos datas e horários através da classe Time.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# time.rb

# Utiliza classe de tempo
tempo = Time.new

# Imprime data e hora
puts "Dia: " + String(tempo.day) + "/" + 
               String(tempo.month) + "/" + 
               String(tempo.year)
               
puts "hora: " + String(tempo.hour) + ":" +
                String(tempo.min) + ":" +
                String(tempo.sec)
               
# Imprime data com formato               
puts "Data Formatada: " + tempo.strftime("%d-%m-%Y %H:%M:%S")

Um erro de aplicativo é um erro de tempo de execução que não pode necessariamente ser evitado escrevendo um código livre de erros. Erros de tempo de execução podem ocorrer por uma variedade de razões. No entanto, nem todos os erros devem ser tratados como exceções em seu código. Em alguns casos, um erro de programa pode refletir uma condição de erro esperada ou de rotina. Neste caso, você pode querer evitar o uso de tratamento de exceção para lidar com o erro do programa. Em outros casos, um erro de programa reflete uma condição de erro inesperado que pode ser manipulado em seu código. Por exemplo, mesmo que você tenha verificado para garantir que existe um arquivo, ele pode ser excluído antes que você possa abri-lo, ou ele pode estar corrompido.

A falha do sistema é um erro de tempo de execução que não pode ser tratado por meio de programação de uma maneira significativa. Por exemplo, qualquer método pode lançar uma exceção OutOfMemory se o Runtime for incapaz de alocar memória adicional

O Ruby utiliza blocos para manipular exceções, todo o código contido no bloco pode ser manipulado com a instrução Rescue que previne a interrupção do programa e trata o erro, Ensure que assegura o termino da execução do bloco, Retry que executa novamente o inicio do bloco e o próprio Raise que força uma exceção. A classe Exception o ajuda a manipular os erros como por exemplo, exibindo suas mensagens.

Exception: http://www.ruby-doc.org/core-2.2.0/Exception.html

Ruby – Exception

Exemplo:

Neste exemplo utilizamos os conceitos básicos de tratamento de exceção para manipular erros.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Erros.rb

# Para validar instruções crie um bloco
puts "Erro numero 1: \n\n"
begin

  # Define valores
  numero1 = 10
  numero2 = 0

  # Tenta dividir por zero
  resultado = numero1 / numero2

# Previne o erro e imprime mensagem de erro
rescue Exception => ex
  puts "Houve um erro: " + ex.message

#Garante final da execução do bloco
ensure
  puts "coloque algo aqui caso queira ter certeza da execução." 

end

# Gera seu próprio erro
puts "\nErro numero 2: \n\n"
begin

  # Define valores
  valor1 = 5
  valor2 = 6

  # Raise gera um erro especifico
  if (valor2 > valor1)
    raise "Valor 2 não pode ser maior que o valor 1"
  end

# Rescue impede a interrupção do programa e exibe mensagem
rescue Exception => ex
  puts "Houve um erro: " + ex.message

end

Em português iterador, é um objeto que permite a um programador examinar uma coleção ou container. Vários tipos de iteradores são frequentemente fornecidos através de uma interface de container. Apesar da interface e semântica de um determinado iterador serem fixas, iteradores são frequentemente implementados em termos de estruturas subjacentes a uma implementação de container e são muitas vezes ligados intimamente ao container para permitir a semântica operacional do iterador.

Observe que um iterador percorre e também dá acesso aos elementos de dados em um container, mas não realiza iteração (isto é, não sem alguma liberdade significativa tomada com este conceito ou com uso trivial da terminologia). Um iterador tem um comportamento semelhante a um cursor de banco de dados. Iteradores datam da linguagem de programação CLU de 1974.

Collection

É uma coleção, às vezes chamada de um recipiente (container), é simplesmente um objeto que agrupa vários elementos em uma única unidade. Coleções são usadas ​​para armazenar, recuperar, manipular e comunicar dados agregados, ou seja uma coleção é um objeto que contém outros objetos, existem outras coleções com diferentes capacidades.

Historicamente, o quadro de coleções têm sido bastante complexo, o que lhes deu uma reputação de ter uma grande curva de aprendizagem. Os exemplos mais conhecidos de frameworks de coleções são o C ++ Standard Template Library (STL). A nomenclatura das APIs e suas sintaxes podem mudar de uma linguagem de programação para outra.

Ruby – Container e Iterator

Array e Hash

O Ruby possui dois tipos de containers, eles pertencem as classes Array e Hash. Os Arrays são ordenados, coleções indexadas por números inteiros de qualquer objeto, um Hash é uma coleção como um dicionário de chaves únicas e seus respectivos valores.

Array: http://www.ruby-doc.org/core-2.2.0/Array.html

Hash: http://www.ruby-doc.org/core-2.0/Hash.html

Exemplo:

Neste exemplo criamos uma classe para representar um item musical que contem determinadas informações de uma musica. Utilizamos um container para armazenar as musicas representando um álbum e utilizamos o iterador para navegar e imprimir o conteúdo do container.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Containers.rb

# Define classe
class Album
  
  # Métodos
  attr_accessor :id, :musica, :duracao
  
  # Construtor
  def initialize(id, musica, duracao)
    @id = id
    @musica = musica
    @duracao = duracao
  end

end

# Cria Array (Lista)
afd = [
  Album.new(1, "Welcome to the Jungle ", "4:34"),
  Album.new(2,"It's So Easy","3:23"),
  Album.new(3,"Nightrain","4:28"),
  Album.new(4,"Out Ta Get Me","4:24"),
  Album.new(5,"Mr. Brownstone","3:49"),
  Album.new(6,"Paradise City","6:46"),
  Album.new(7,"My Michelle","3:40"),
  Album.new(8,"Think About You","3:52"),
  Album.new(9,"Sweet Child O' Mine","3:21"),
  Album.new(10,"You're Crazy","3:17"),
  Album.new(12,"Anything Goes","3:26"),
  Album.new(12,"Rocket Queen","6:13")]

# itera lista
puts "Album - Appetite for Destruction  - GNR\n\n"

# Itera lista
afd.each do |musicas|
  # Recupera objetos
  objeto =  musicas
  # Imprime objeto
  puts String(objeto.id).ljust(5) +
              objeto.musica.ljust(40) + objeto.duracao.rjust(5)
  
end

Um módulo é um conjunto de métodos e constantes. Os métodos em um módulo podem ser métodos de instância ou métodos do próprio módulo. Módulos também proporcionam um espaço de nomes (namespace) onde pode-se organizar o código e evitar possíveis colisões de nomenclaturas. Os métodos de instância se comportam como métodos em uma classe quando o módulo está incluído na classe, os métodos do módulo não se comportam da mesma forma. Por outro lado, os métodos de módulos podem ser chamados sem criar um objeto de encapsulamento, enquanto os métodos de instância não podem.

Module: http://www.ruby-doc.org/core-2.2.0/Module.html

Linguagens como C++ permitem que uma classe possa herdar mais de uma classe, Ruby não, entretanto existe o conceito chamado Mixing que nos permite utilizar está mesma funcionalidade através dos módulos.

Ruby – Modules – Mixing

Exemplo:

Neste exemplo criamos um modulo chamado Portas e um modulo chamado Janelas. A especificação de objetos Ruby não permite múltiplas heranças ou seja, não permite que minha classe chamada Casa possa herdar as classes Portas e Janelas ao mesmo tempo, no entanto existe um modo de criar esta mesma funcionalidade incluindo os módulos em minha classe.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Mixing.rb

# Define modulo
module Portas
  
  def porta(tipo)
    puts "Portas: " + tipo       
  end
      
end

# Define modulo
module Janelas
  
  def janela(tipo)
    puts "Janelas: " + tipo
  end
  
end

# Define classe 
class Casa
  
 # Inclui modulos
 include Portas
 include Janelas
 
 def modelo(tipo, cor)
   puts "Casa ----------------->>>> 1\n\n"
   puts "Modelo:" + tipo
   puts "Cor: " + cor
 end
 
end

# Cria instancia do objeto
minhaCasa = Casa.new

# utiliza objeto
minhaCasa.modelo("Sobrado", "Branco")
minhaCasa.porta("Azul")
minhaCasa.janela("Amarelas")

A programação orientada a objetos permite que classes possam herdar estados e comportamentos comuns usados de outras classes. Neste exemplo, bicicleta torna-se agora a superclasse da classe BicicletaMontanha. Na linguagem de programação Ruby, cada classe é permitido ter uma superclasse direta, e cada superclasse tem o potencial para um número ilimitado de subclasses.

Ruby – Herança – Sobreposição – Super

Override

Métodos Override (substituição), em programação orientada a objeto, é um recurso de linguagem que permite que uma subclasse ou classe filha possa fornecer uma implementação específica de um método que já é fornecido por uma de suas superclasses ou classes pai.

A implementação Override das subclasses substitui a implementação na superclasse, fornecendo um método que tem o mesmo nome, mesmos parâmetros ou assinatura, e mesmo tipo de retorno como o método na classe pai.

@ (Arroba – Ruby)

Uma variável associada ao sinal de arroba em Ruby significa uma variável da instancia ex: @variavavel.

Super

Usando super você irá chamar o mesmo método, mas, tal como definido na superclasse e consequentemente lhe fornecendo o resultado.

Exemplo:

Neste exemplo damos a classe BicicletaMontanha todos os mesmos campos e métodos da classe bicicleta, e ainda permite que seu código se concentre exclusivamente sobre as características que a tornam única. Isso faz do código de suas subclasses fáceis de ler. Usamos métodos Override neste exemplo de duas maneiras, para substituir um método da subclasse e adicionar mais um construtor com parâmetros.

No entanto, você deve tomar cuidado para documentar corretamente o estado e o comportamento que cada superclasse define, uma vez que o código não irá aparecer no arquivo de origem de cada subclasse.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Herança.rb

# Define classe
class Bicicleta

 # Define métodos assesores
 attr_accessor :modelo, :quadro, :rodas, :freios

 # Construtor
 def initialize(modelo, quadro, rodas, freios)
   @modelo = modelo
   @quadro = quadro
   @rodas  = rodas
   @freios = freios
 end  

 # Imprime modelo
 def imprimeModelo()
   puts "Modelo : " + @modelo
   puts "Quadro: "  + @quadro
   puts "Rodas: "   + @rodas
   puts "Freios: "  + @freios
 end

end

# Classe com Herança
class BicicletaMontanha < Bicicleta

 # Novos métodos assessores
 attr_accessor :marchas, :amortecedores, :garrafa, :gps

 # Construtor da classe
 def initialize(modelo, quadro, rodas, freios, marchas, amortecedores, garrafa, gps)

   # Super inicializa construtor da herança
   super(modelo, quadro, rodas, freios)

   # Inicializa variáveis
   @marchas = marchas
   @amortecedores = amortecedores
   @garrafa = garrafa
   @gps = gps

 end

 # Método Override - sobrepõe o metodo da classe super
 def imprimeModelo()

    puts "Modelo : " + modelo
    puts "Quadro: "  + quadro
    puts "Rodas: "   + rodas
    puts "Freios: "  + freios
    puts "Marchas: " + @marchas
    puts "Amortecedores: " + @amortecedores
    puts "Garrafa: " + @garrafa
    puts "Gps: " + @gps

 end

end

# cria instancia da classe Bicicleta
bike1 = Bicicleta.new("Street", "Aço", "Ferro", "Pastilhas")
puts "Bicicleta Numero ---> 1:"
bike1.imprimeModelo()

# Cria instancia da classe BicicletaMontanha
bike2 = BicicletaMontanha.new("Montain Bike", "Carbono", "Aluminio", "Disco", "10 M",
                              "RX 3000 oil", "Aliminio 500ml", "Discovery 300xs")
puts "\nBicicleta Numero ---> 2:"
bike2.imprimeModelo()

Escopo refere-se à vida e acessibilidade de uma variável. Quão grande é o alcance depende de onde uma variável é declarada. Por exemplo, se uma variável é declarada na parte superior de uma classe, ela será acessível a todos os métodos de classe. Se for declarada num método, em seguida, só pode ser utilizada em tal método.

Ruby – Escopo

O escopo de uma variável é a parte do programa que pode acessar uma variável. Quando você tenta acessar uma variável que não está no escopo, você normalmente tem um erro do compilador. Aqui estão algumas das regras de escopo:

1. Variáveis globais estão no escopo do programa e podem ser utilizadas dentro de classes.
2. Variáveis ​​de classe (campos estáticos) estão no escopo em todos os lugares na classe.
3. As variáveis ​​e parâmetros locais estão no escopo apenas dentro do método que os declarou.

Exemplo:

Neste exemplo utilizamos tipos de variáveis que possuem diferentes alcances dentro do programa e de sua respectiva classe. Utilize os comentários no código abaixo para entender os diferentes tipos de escopos.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Escopo.rb

$variavel_global = "olá sou uma variavel global e existo em todo programa"

# Define classe
class Escopo

  # Variável da classe existe em toda a classe
  # não precisa de uma instancia do objeto para existir
  @@variavel_estatica = 0

  # Existe para toda a classe e fora dela (Métodos públicos - Variável Privada)
  attr_accessor :variavel_publica

  # Construtor da classe
  def initialize()
    @@variavel_estatica += 1
    @variavel_publica = "publica existo em toda classe e sub-classes"
  end

  # Retorna variável estatica
  def self.variavel_estatica()
      return @@variavel_estatica
  end

  # Imprime variável global
  def imprimeVariavelGlobal()
    $variavel_global = "Variável global modificada na classe"
    puts $variavel_global
  end

  #Imprime variável publica
  def imprimeVariavelPublica()
    puts  variavel_publica
  end

  # Imprime variável local
  # Existe somente dentro do método
  def imprimeVariavelLocal()
    variavel_local = "Sou uma variável local e só existo dentro deste método"
    puts variavel_local
  end

end

# Imprime escopos
puts "---------------- Escopos ----------------\n\n"
puts "imprime variável global:"
puts $variavel_global
puts "Imprime variável da classe: "
puts Escopo.variavel_estatica

# Cria uma instancia da classe
escopo = Escopo.new

puts "Imprime variável global dentro da classe:"
puts escopo.imprimeVariavelGlobal
puts "Imprime variável privada com métodos públicos:"
puts  escopo.imprimeVariavelPublica
puts "Imprime variável local:"
puts  escopo.imprimeVariavelLocal
puts "Reimprime variável da instancia pois já existe um objeto instanciado: "
puts Escopo.variavel_estatica

Encapsulamento que em programação orientada a objetos significa separar o programa em partes, o mais isoladas possível. A idéia é tornar o software mais flexível, fácil de modificar e de criar novas implementações. Objetos restringem a visibilidade de seus recursos (atributos e métodos) aos outros usuários. Todo objeto tem uma interface, que determina como os outros objetos podem interagir com ele. A implementação do objeto é encapsulada, isso é, invisível ou visível  fora do próprio objeto.

Ruby – Encapsulamento – Public – Private – Protected

Tipos de Acesso

1. Public – deixa visível a classe ou membro para todas as outras classes, subclasses e pacotes.
2. Private – deixa visível o atributo apenas para a classe em que este atributo se encontra.
3. Protected – deixa visível o atributo para todas as outras classes e subclasses que pertencem ao mesmo pacote.  O protected é um intermediário entre public e private.

Publico VS Private

• Publico todas as classes podem usar os métodos e campos.
• Privado apenas a classe  podem usar os métodos e campos.

Por que Controlar o Acesso?

• Proteger informação privada.
• Esclarecer como outros programadores devem usar sua classe.
• Manter a implementação separado da interface.

Exemplo:

Imagine o seguinte cenário,  temos uma classe que é responsável por transações de cartões de credito geralmente este tipo de classe pertence a companhia de cartões de credito e foi desenvolvida por um outro programador e esta dentro de uma DLL ou OS, acontece que o desenvolvedor terceirizado cometeu um deslize deixando visível a propriedade numero do cartão. Um desenvolvedor malicioso pode facilmente capturar o numero do cartão referenciando o objeto.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# ControleAcesso.rb

# Define classe 
class CartaoCredito
  
  # Assessores publicos
  # Estes assessores não deveriam existir
  # pois podem ser utilizados por qualquer um
  attr_accessor :cartao_public, :valor_public
  
  # Estes métodos controlam os assessores privados
  # Os encapsulando e permitindo quaisquer tipo de validações
  # como por exemplo usuários que podem utilizar a função
  
  def setCartao(cartao)
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função 
    @cartao = cartao
  end
  
  def getCartao()
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função
    return @cartao
  end
  
    def setValor(valor)
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função 
    @valor = valor
  end
  
  def getValor()
    # Você pode criar uma validação para
    # ter certeza que o usuário pode utilizar esta função
    return @valor
  end
  
  # Declara setor privado
  private
  
  # Assessores privados
  attr_accessor :cartao, :valor 
  
end

# Os assessore públicos são visíveis para qualquer pessoa
c1 = CartaoCredito.new

# Acesso direto 
c1.cartao_public= "1234 5678 8900 1236"
c1.valor_public= 1234.56

puts "Acesso publico - Qualquer pessoa pode utiliza-lo"
puts "Cartão 1: " + c1.cartao_public + " ---- Valor: R$ " + String(c1.valor_public)

c2 = CartaoCredito.new

# c2.cartao="1234 5678 8900 1236"
# Caso tente acessar o metodo privado obterá o seguinte erro:
# private method `cartao=' called for #<CartaoCredito:0x00000001360e38>
# não possibilitando acesso direto ao assessor cartão

# Você deve permitir acesso aos assessores privados
# através do encapsulamento utilizando métodos públicos
# O método correto seria:

c2.setCartao("4567 1234 7890 3456")
c2.setValor(3456.89)

puts "\nAcesso privado - Você permite que utilizem através de métodos"
puts "Cartão 2: " + c2.getCartao + " ---- Valor: R$ " + String(c2.getValor)

Construtores são métodos especiais chamados pelo sistema no momento da criação de um objeto. Eles não possuem valor de retorno, porque você não pode chamar um construtor para um objeto, você só usa o construtor no momento da inicialização do objeto. Construtores representam uma oportunidade de inicializar seus dados de forma organizada. Construtores são obrigatórios em uma classe, mas não é preciso declara-los, caso não declare um construtor por default a declaração é:  Classe.new

Ruby – Métodos Estáticos

Static

Declaração de  um tipo de Classe, método, propriedade ou variável que pertence exclusivamente a sua própria classe, classes estáticas não podem ser instanciadas. Métodos e variáveis estáticas não precisam ser instanciadas, em Ruby a palavra Static significa da classe e é substituída por self para métodos e @@atributo para atributos.

Exemplo:

Neste cenário queremos saber quantos bebês foram instanciados, para isto criamos um contador no construtor do objeto e a cada objeto criado o contador aumenta nos mostrando no final a quantidade exata de novos objetos de uma classe. Visto que nosso contador pertence a classe e não a cada instancia de cada classe, neste caso para usar o contador não precisamos instanciar a classe graças a declaração self para o método e @@ para o atributo.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# ClassesReferencia.rb

# Define classe bebê
class Bebe

  # Define atributos da classe (estático)
  @@quantidade = 0

  # Define método da classe
  def self.quantidade
    return @@quantidade
  end

  # Define construtor da classe
  def initialize()
    @@quantidade = @@quantidade + 1
  end
end

# Intancias de objetos bebês
Daniela = Bebe.new
Rodrigo = Bebe.new
Tamara  = Bebe.new
Mateus  = Bebe.new

# Imprime quantidade de instancias da classe Bebe
puts "Parabéns !!!!!"
puts "Você teve " + String(Bebe.quantidade) + " bebês"

Referência na ciência da computação é registro que aponta o local em que se encontram armazenados os dados que identificam outro dado. Nas linguagens tradicionais variáveis são como canecas fixas e os primitivos são pequenos o suficiente para caber dentro da caneca. Os objetos são grandes para caber dentro de variáveis. Variáveis guardam números que localizam um objeto e a localização do objeto é chamada de referência. O Ruby possui apenas objetos então variáveis referenciam outros objetos.

Ruby – Referências

Exemplo:

Neste cenário temos um bebê recém nascido que precisa ser registrado no cartório, para isto vamos criar um objeto bebê e através de um método de outro objeto chamado cartório vamos cadastrar os dados do bebê referenciando o objeto ao nosso bebê, tenha em mente que Ruby possui apenas objetos deste modo não possuímos tipos primitivos como outras linguagens de programação e não precisamos definir o tipo de cada objeto quando fazemos uma referencia a uma variável.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# ClassesReferencia.rb

# Define classe bebê
class Bebe
  # Define atributos
  attr_accessor :codigo, :nome, :peso, :tamanho, :nomepai, :nomemae, :genero
end

# Define classe cartório
class Cartorio
  
  # Cria método da classe(estático)
  # Transfere objetos por referencia
  def self.registro(codigo, dados, bebeRef )

    # Alimenta objeto bebe
    bebeRef.codigo = codigo
    bebeRef.nome=    dados[0]
    bebeRef.peso=    dados[1]
    bebeRef.tamanho= dados[2]
    bebeRef.nomepai= dados[3]
    bebeRef.nomemae= dados[4]
    bebeRef.genero=  dados[5]
    
    # Imprime registro
    puts "Registro:" + String(bebeRef.codigo)
    puts "nome: " + bebeRef.nome
    puts "Peso: " + bebeRef.peso + " tamanho: " + bebeRef.tamanho
    puts "Genero: " + bebeRef.genero
    puts "Pai: " + bebeRef.nomepai
    puts "mãe: " + bebeRef.nomemae

  end
end

# Cria instância do Bebê
bebe = Bebe.new

# Preenche ficha do cartório
fichaRegistro = ["Samanta Amaral", "2.8kg", "36cm", 
                 "Roberto Amaral", "Marcia Amaral","Feminino" ]

# Registra bebê
# Passa objeto ficha e objeto bebe por referencia
Cartorio.registro(123456, fichaRegistro, bebe)