RGSS3 - Aula 4: Classes e Módulos

[Brandt]

RGSS3 - Aula 4: Classes e Módulos

por Masked

1.Classes

1.1. O que são classes?

1.2. Como se cria uma classe?
1.2.1. Herança

1.3. Variáveis locais, de classe e globais

1.4. Como chamar um método dentro de uma classe?

1.5. attr

2. Módulos

2.1. O que são módulos?

2.2. Como criar um módulo?

2.3. Como se referir a algo de dentro de um módulo?

2.4.Para quê usar módulos?



3. Include

4. Exercícios

1. Classes:

1. O que são classes?

As classes são blocos, ela pode conter métodos, variáveis e condições, elas também podem executar métodos de outras classes ou dela mesma.

2. Como se cria uma classe?

Para criar uma classe usa-se o comando "class", seguido dele vem o nome da classe (que deve ser iniciado com letra maiúscula e não pode conter espaços, em vez disso, use o "_" ou underline) ele aparece em azul escuro no Editor de Scripts. No final, deve ser escrito um end. Assim, o código ficaria:

class nome_da_classe
end

seguindo o nome, pode ser atribuída uma herança para a classe.

        2.1. Herança

O que são heranças?

Heranças são um jeito de atribuir uma super classe para outra, como o próprio nome já diz, a herança faz com que a nova classe herde o conteúdo de sua super classe.

Como atribuir uma herança?

Para atribuir uma herança a uma classe, deve se adicionar um "<" e escrever o nome da super classe em seguida, então:

class nome_da_classe < nome_da_super_classe
end

3. Variáveis locais, de classe e globais:

Essa parte é uma informação adicional para a aula de variáveis, existem quatro tipos de variável, mas explicarei apenas três deles (os mais comuns):

1. variável local: é usada dentro do bloco em que foi declarada, então se você declarar uma variável "a" dentro de um método uma variável "a" fora dele, a variável "a" existirá dentro ou fora do método, mas não serão a mesma variável, e sim duas variáveis locais "a" cada uma com um valor independente.

2. Variável de instância de classe: é usada dentro da classe em que foi declarada, deve conter um "@" no início do nome. Se você declarar a variável "@x" na classe "A" e "@x" na classe "B", a variável não será a mesma, cada uma terá seu valor independente da outra.

3. Variável global: pode ser usada em TODO O SISTEMA, elas devem conter "$" no começo do nome. Se você declarar a variável "$n" na classe "A" e "$n" na classe "B" você não vai estar declarando uma nova variável, mas sim alterando a mesma variável.

4. Como chamar um método dentro de uma classe?:

Os métodos dentro de uma classe podem ser acessados por outras classes, para isso digita-se no editor:

nome_da_classe.nome_do_metodo(argumentos)

5. attr

O que é attr?

O attr é um método padrão (existe em todas as classes) que cria um método para uma classe que retorna o valor de uma variável de instância, basicamente ele cria um método assim:

def nome_da_variavel_de_instancia_sem_o_@
return @nome_da_variavel_de_instancia
end

Como usá-lo?

Existem três modos de usar o attr:

attr_accessor: o attr_accessor é usado pra criar o método, lê-lo e modificá-lo

attr_reader: o attr_reader é usado para criar e ler o método.

attr_writer: o attr_writer é usado para criar e modificar o método.

Qualquer dos modos que você escolher, deve-se escrever no editor, em qualquer parte do script:

attr_accessor/writer/reader       :nome_da_variavel_de_instancia

O :nome_da_variavel_de_instancia é um Symbol, ele aparece em laranja no editor, Symbols são variáveis com valores similares a Strings, pois são um texto, porém, diferente das strings, não pode haver espaço em um symbol.

2. Módulos:

1. O que são módulos?

Módulos são muito parecidos com classes, eles são blocos onde podem ser armazenadas constantes ou métodos, além de outros módulos...

2. Como criar um módulo?

Para criar um módulo usa-se o comando "module", seguido pelo nome do módulo ( assim como o nome das classes, ele deve ser iniciado em maiúscula e não pode conter espaços ) que aparece em azul escuro no editor.

3. Como se referir a algo de dentro de um módulo?

Para se referir a uma constante (uma variável com valor não alterável(apesar de, no RGSS, ele poder ser modificado, mas é algo não recomendado), elas devem ter seu nome iniciado em Maiúscula) de dentro de um módulo, digita-se no editor:

Nome_do_modulo::Nome_da_constante/metodo/modulo

Essa é uma das maiores diferenças do módulo para uma classe, seu conteúdo pode ser acessado mais facilmente, sem a necessidade de usar métodos adicionais como o attr.

4. Para quê usar módulos?

Os módulos são extremamente úteis para criar uma área de configuração para o script, pois é muito mais simples configurar tudo nas constantes dos módulos do que no meio do corpo da classe. Esse é o uso mais comum de um módulo em um script.

3. Include

O include é um método padrão das classes, ele serve para pegar todo o conteúdo de um módulo para a classe, para isso digite no corpo da classe:

include Nome_do_metodo

4. Exercícios:

Esses são exercícios para ajudar na aprendizagem, eles estão separados por nível de dificuldade, acredito que todos que estudaram as quatro aulas consigam fazer todos, se achar que não consegue, vá pelo mais fácil, depois vá avançando e não desista! Se necessário, releia as aulas e pergunte se estiver com dúvidas quanto à proposta do exercício.

Fácil:

1. Crie um método que some duas variáveis e depois escreva o resultado na janela de depuração, depois chame esse método.

2. Crie um método que verifique o valor de uma variável, se o valor for menor que 5, o método escreve na janela de depuração "a variável é menor que 5!" se não, ele escreve "a variável é maior que 5!", depois chame esse método.

Intermediário:

1. Crie uma classe com os dois métodos dos exercícios 1 e 2 do nível fácil, depois, crie um método que, dependendo do argumento a ele atribuído, chame um dos dois métodos.

2. Crie um módulo e uma classe, a classe deve receber o conteúdo do módulo, neste, serão configuradas as variáveis usadas nos métodos dos exercícios 1 e 2 do nível fácil, faça com que a classe chame os dois métodos de modo que utilizem as variáveis configuradas.

Complexo:

1. Crie uma classe e um módulo, a classe deve receber o conteúdo do módulo e deve ter métodos que retornem o valor das constantes configuradas no módulo. Use esses métodos para obter o valor das variáveis usadas nos dois métodos dos exercícios 1 e 2 do nível fácil, além disso, crie um método que, dependendo do argumento que lhe for atribuído, chame um dos dois métodos e chame este outro método.

DESAFIO!

Crie uma classe que tenha todo o conteúdo da classe do primeiro exercício do nível difícil, depois, adicione três métodos: um deles checará se o argumento que lhe foi atribuído é Integer, Float, Array ou String, dependendo do resultado, ele escreverá na janela de depuração "a variável é Integer/Float/Array/String", o segundo checará se o primeiro argumento que lhe foi atribuído é igual ou diferente do segundo, se for diferente ele checará se o argumento é maior ou menor que o segundo e escreverá o resultado na janela de depuração. O último deverá checar se o argumento 1 é Integer ou Float, se for um dos dois e o segundo argumento também for, o método multiplica, subtrai, divide, multiplica ou potencia o primeiro pelo segundo dependendo do valor do terceiro argumento.

Lembre-se: Os exercícios são para ajudar na aprendizagem, se você apenas copiar as respostas dos outros não terá nenhum lucro, além disso, não é obrigatório que você faça todos os exercícios, mas pelo menos algum deles deve ser feito, garanto que os que fizerem os exercícios se sairão bem melhor que os que não se preocuparem em fazê-los.

Até mais então gente, nos vemos na nossa próxima aula!

[Raizen]

Ah vejo que está escrevendo aulas de Ruby xD, legal boa iniciativa, porém alguns toques a mais.

classes e módulos que não foi dito aqui, são objetos, alias tudo em Ruby é objeto, e esse é o principal foco da linguagem, e attr não é bem um método, ele é um atribulo, atributo é como se fosse uma pequena porção daquele objeto que ele está "atribuindo" valor xD, ou melhor retirando o valor.

Ex:

Corinthians é o objeto, ele tem um atributo nele que se chama tecnico, e o atributo que se chama tecnico tem valor "empate", logo.

Corinthians.tecnico == "empate".

Não sei se sacou a ideia xD, mas é isso ai, por isso é possível pegar variáveis de instância para utilizar como atributo. E consequentemente o reader lê algo que está contido no objeto... o accessor....

Enfim, de resto está legalz, malz ai sou meio critico para as coisas :), boa sorte escrevendo as aulas man.

[Brandt]

Oi Raizen,

Realmente não comentei os objetos, sei sim que eles são tudo no Ruby, quanto ao attr eu não sabia disso  , achei mesmo que fosse um método...Obrigado pelo toque, críticas construtivas são sempre bem vindas 

[Mepps]

Fácil

1. Crie um método que some duas variáveis e depois escreva o resultado na janela de depuração, depois chame esse método.

def soma(n1, n2)
 result = ((n1 + n2))
 p result
end

soma(3,4)
=> 7

2. Crie um método que verifique o valor de uma variável, se o valor for menor que 5, o método escreve na janela de depuração "a variável é menor que 5!" se não, ele escreve "a variável é maior que 5!", depois chame esse método.

def pega_enum(num)
  p((num < 5) ? "Menor que 5 | Valor => #{num}" : "Maior que 5 | Valor => #{num}")
end

pega_enum(20)

Intermediário:

1. Crie uma classe com os dois métodos dos exercícios 1 e 2 do nível fácil, depois, crie um método que, dependendo do argumento a ele atribuído, chame um dos dois métodos.

Nota: Não entendi muito bem . mas acho que é isso?

class RNT
  
  # Processo Principal
  def initialize
   puts %{Oque Deseja Fazer?}
   puts %{Digite Somar   (Para somar)}
   puts %{Digite Dividir (Para dividir)\n}
   puts %{\n}
   
   # Pega o alvo
   @result = gets.chomp
   @result.capitalize
   
   # caso
   case @result
    
   # Fluxo  (#Soma)
   when "Somar"
    puts %{Digite o Primeiro Numero:}
    @num1 = gets.chomp.to_i
    puts %{Digite o Segundo  Numero:}
    @num2 = gets.chomp.to_i
    soma(@num1, @num2)
    
    # Retorna ao Metodo Primario
    initialize
    
    # Fluxo (#Dividir)
    when "Dividir"
    puts %{Digite o Primeiro Numero:}
    @num1 = gets.chomp.to_i
    puts %{Digite o Segundo  Numero:}
    @num2 = gets.chomp.to_i
    divide(@num1, @num2)
    
    initialize
    
    # Se Não
    else
    puts %{ Operação Desconhecida}
    %{\n}
    initialize      
    end
   end
   
   # Soma
   def soma(n1,n2)
     retorno = n1 + n2
     puts retorno
   end
   
   # Divisao
   def divide(n1,n2)
     retorno = (( n1 / n2 ))
     puts retorno
    end
  end
  
  # Chama Classe
  call = RNT::new

2. Crie um módulo e uma classe, a classe deve receber o conteúdo do módulo, neste, serão configuradas as variáveis usadas nos métodos dos exercícios 1 e 2 do nível fácil, faça com que a classe chame os dois métodos de modo que utilizem as variáveis configuradas.

# Modulo
   module N01
   NUM1 = 5  
   NUM4 = 6
 end
 
class RNT
  include N01
  
  # Processo Principal
  def initialize
   puts %{Oque Deseja Fazer?}
   puts %{Digite Somar   (Para somar)}
   puts %{Digite Dividir (Para dividir)\n}
   puts %{\n}
   
   # Pega o alvo
   @result = gets.chomp
   
   # caso
   case @result
    
   # Fluxo  (#Soma)
   when "Somar"
    soma(N01::NUM1, N01::NUM4)
    
    # Retorna ao Metodo Primario
    initialize
    
    # Fluxo (#Dividir)
    when "Dividir"
    divide(N01::NUM1, N01::NUM4)
    
    initialize
    
    # Se Não
    else
    puts %{ Operação Desconhecida}
    %{\n}
    initialize      
    end
   end
   
   # Soma
   def soma(n1,n2)
     retorno = n1 + n2
     puts retorno
   end
   
   # Divisao
   def divide(n1,n2)
     retorno = (( n1 / n2 ))
     puts retorno
    end
  end
  
  # Chama Classe
  call = RNT::new

Complexo:
1. Crie uma classe e um módulo, a classe deve receber o conteúdo do módulo e deve ter métodos que retornem o valor das constantes configuradas no módulo. Use esses métodos para obter o valor das variáveis usadas nos dois métodos dos exercícios 1 e 2 do nível fácil, além disso, crie um método que, dependendo do argumento que lhe for atribuído, chame um dos dois métodos e chame este outro método.

# Modulo
   module N01
   NUM1 = 5  
   NUM4 = 6
 end
 
class RNT
  include N01
  
  # Processo Principal
  def initialize
   puts %{Oque Deseja Fazer?}
   puts %{Digite Somar   (Para somar)}
   puts %{Digite Dividir (Para dividir)\n}
   puts %{\n}
   
   # Pega o alvo
   @result = gets.chomp
   
   # caso
   case @result
    
   # Fluxo  (#Soma)
   when "Somar"
    soma(N01::NUM1, N01::NUM4)
    
    # Retorna ao Metodo Primario
    initialize
    
    # Fluxo (#Dividir)
    when "Dividir"
    divide(N01::NUM1, N01::NUM4)
    
    initialize
    
    # Se Não
    else
    puts %{ Operação Desconhecida}
    %{\n}
    initialize      
    end
   end
   
   # Soma
   def soma(n1,n2)
     retorno = n1 + n2
     puts retorno
   end
   
   # Divisao
   def divide(n1,n2)
     retorno = (( n1 / n2 ))
     puts retorno
    end
  end
  
  # Chama Classe
  call = RNT::new