Desenvolvimento Código Aberto

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)

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software. Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar.

Porque Usar Classes?

No mundo real, muitas vezes você vai encontrar muitos objetos individuais todos da mesma espécie. Pode haver milhares de outros bebês na existência, todos parecidos. Cada bebê foi construído a partir do mesmo conjunto de projetos(DNA) e, portanto, contém os mesmos componentes. Em termos de orientação a objetos, dizemos que o seu bebê é uma instância da classe de objetos conhecidos como bebê. Uma classe é o modelo a partir do qual objetos individuais são criados. Criando a classe bebê teremos um objeto bebê com seus atributos definidos:

Bebê

Classes Ruby

Em Ruby tudo é um objeto, então podemos dizer que tudo tem uma classe, deste modo Ruby possui alguns conceitos diferentes de outras linguagens de programação hibridas como por exemplo C++ e Java. Entretanto uma classe escrita em Ruby também possui os conceitos básicos da linguagem orientada a objeto e possui basicamente 3 partes distintas:

• A Definição da classe  (Nome da classe: Bebe).
• Os membros da classe (Atributos da classe: nome, peso, tamanho).
• Construtor da classe (Método: initialize).

Classe – Bebê

Exemplo:

Neste exemplo criamos uma classe chamada Bebe e criamos um construtor para inicializar os valores para cada bebê que for instanciado, e também utilizamos um recurso que nos permite não inicializar valores na classe simulando um construtor Overload, no qual permite instanciar um objeto Bebe com valores ou sem valores definidos podendo alimenta-los através de métodos ou atributos a qualquer hora.

Ruby

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

class Bebe

   # Define atributos
   attr_accessor :nome, :peso, :tamanho
   
   # Define construtor da classe (Efeito Overload)
   def initialize (nome = nil, peso=nil, tamanho=nil)
     @nome = nome 
     @peso = peso
     @tamanho = tamanho
   end
  
end

# Cria instância do Bebê construtor defindo
b1 = Bebe.new("Daniel", "3.5", "36")

# Cria instância do Bebê construtor overload
b2 = Bebe.new

# Alimenta valores nos atributos publicos
b2.nome="Sabrina"
b2.peso="2.7"
b2.tamanho="32"

# Imprime Bebês
puts "Bebê 1:", "Nome: " + b1.nome, "Peso: " + b1.peso, "Tamanho: " + b1.tamanho + "cm"

puts "\nBebê 2:", "Nome: " + b2.nome, "Peso: " + b2.peso, "Tamanho: " + b2.tamanho + "cm"

Métodos em sua forma mais simples são sub-rotinas e podem ser tanto um procedimento ou uma função, geralmente estão associados a um objeto, mas podem ser utilizados independente de estarem ou não dentro de uma classe, isto vai depender exclusivamente do paradigma de programação que você vai escolher programar.

Genericamente falando, métodos alimentam e retornam valores, no entanto existem vários tipos de métodos especialmente no paradigma de programação orientada a objeto, os mais comuns são chamados de Getters e Setter, servem especificamente para retornar e alimentar objetos, especificando ou validando alguma regra de negocio entre seu processo.

Ruby – Métodos – Getter e Setter

Exemplo:

Neste exemplo criamos uma simples variável global que é alimentada através do método Setter e retornada através do método Getter, este tipo de método é comumente visto dentro de classes na programação orientada a objeto.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Métodos.rb

# Define uma variável global 
$meuvalor = 0
 
# Os metodos mais comuns definem e retornam valores

# Retorna valor da variável global
def getValor()
  return $meuvalor
end

# Alimenta valor na variável global
def setValor(valor)
   $meuvalor = valor
end

# método para alimentar valor
setValor(10)

# método para retornar valor
puts "Meu valor é :", getValor()