[ Aula RGSS ] - Superclasse e Métodos de uma classe

Aula 2 de métodos - Superclasse e Métodos de uma classe


1 - Introdução

Nesta aula irei explicar sobre superclasses e os métodos de uma classe.

2 - RGSS

2.1 - Métodos

Métodos são rotinas que podem ou não ser chamadas por outras classes e seu inicio é representado
pela palavra def e o fim pela palavra end
Ex:

Código:

class A
      # O Método initialize sempre é chamado ao iniciar a classe
      def initialize
        @teste = 0
      end
      def metodo
        p @teste
      end
    end
    # Inicia a classe
    a = A.new
    # Chama o método "metodo"
    a.metodo

Os métodos podem ser diversos e podem ou não ter argumentos.
Ex:

Código:

  class A
      # O Método initialize sempre é chamado ao iniciar a classe
      def initialize(argumento)
        @teste = 0
        p argumento
      end
      # Método com um argumento só
      def metodo1(valor)
        p valor
      end
      # Método com 2 argumentos
      def metodo2(valor1, valor2)
        p valor1, valor2
      end
      # Método com 2 ou 3 argumentos
      def metodo3(valor1, valor2, valor3 = 0)
        p valor1, valor2, valor3
      end
      # Método com infinitos argumentos
      # Os argumentos deste método são transformados em uma Array
      def metodo4(*valor)
        p valor
      end
      # Métodos com o sí mbolo = podem ser utilizadas também
      def metodo5=(valor)
        @teste = valor
      end
      # Métodos com valor retornável
      def metodo6
        return @teste
      end
    end
   
    # Inicia a classe
    # Chama o método initialize com seus argumentos
    a = A.new(10) # => 10
 
    # Chama o método "metodo1"
    a.metodo1(10) # => 10
    a.metodo1(20) # => 20
   
    # Chama o método "metodo2"
    a.metodo2(10, 20) # => 10, 20
    a.metodo2(20, "Texto") # => 20, "Texto"
   
    # Chama o método "metodo3"
    a.metodo3(10, 20) # => 10, 20, 0
    a.metodo3(20, "Texto") # => 20, "Texto", 0
    a.metodo3(20, "Texto", 10) # => 20, "Texto", 10
   
    # Chama o método "metodo4"
    a.metodo4(10, 20) # => [10, 20]
    a.metodo4(20, "Texto") # => [20, "Texto"]
    a.metodo4(20, "Texto", 10) # => [20, "Texto", 10]
    a.metodo4(20, "Texto", 10, 10, 10, 10, 10) # => [20, "Texto", 10, 10, 10, 10, 10]
   
    # Chama o método "metodo5"
    a.metodo5 = 10
   
    # Define teste como sendo o valor retornável de metodo6
    teste = a.metodo6
    p teste

2.2 - Superclasse

Superclasse é a classe daonde a nova classe retira todas as funções já pre-definidas e funciona como
uma base para a classe.
Ex:

Código:

 class A
      def initialize
        @teste = 10
      end
      def metodo1(valor)
        p valor, "método1"
      end
      def metodo2(valor)
        p valor, "método2"
      end
    end
    # classe B tem como superclasse A
    class B < A
      def metodo1(valor)
        p valor + 10, "método1"
      end
    end
    # Inicia A
    a = A.new
    a.metodo1(10) # => 10, "método1"
    a.metodo2(10) # => 10, "método2"
    # Inicia B
    b = B.new
    b.metodo1(10) # => 20, Método1
    # Chamaremos o método2
    # Veja que ele já existe na classe A mas não existe na classe B, portanto será chamado o da classe A
    b.metodo2(10) # => 10, "método2"
 

2.3 - Super
No RGSS temos uma função muito interessante: super. Ela chama o método com o mesmo nome da superclasse.
Ex:

Código:

  class A
      def initialize(valor=0)
        p valor
      end
      def teste
        p "A"
      end
    end
    class B < A
      def initialize(valor)
        super(10) # => 10
        super(valor) # => valor
        super(valor * 2) # => valor * 2
        super  # Quando não usamos paríªnteses ele chamara super(argumentos) automaticamente, não importantdo o níºmero de argumentos
        super() # Chamará sem usar argumento algum
      end
      def teste
        super
        p "B"
        p "C"
      end
    end
    a = A.new(10) # => 10
    a.teste # => "A"
    b = B.new(20) # => 10, 20, 40, 20, 0
    b.teste # => "A", "B", "C"

2.4 - attr_reader; attr_writer e attr_accessor

attr_reader é uma função do RGSS que funciona como um atalho para o método de leitura.
Não entendeu? Veja o exmemplo.

Código:

  class A
      def initialize
        @teste = 10
      end
      def teste
        return @teste
      end
      def teste=(valor)
        @teste = valor
      end
    end
    class B
      attr_reader :teste
      attr_writer :teste
      def initialize
        @teste = 10
      end
    end
    class C
      attr_accessor :teste
      def initialize
        @teste = 10
      end
    end
    # Classe A
    a = A.new
    a.teste = 20
    p a.teste # => 20
    # Classe B
    b = B.new
    b.teste = 20
    p b.teste # => 20
    # Classe C
    c = C.new
    c.teste = 20
    p c.teste # => 20
   
    # attr_reader :nome
    # def nome
    #  return @nome
    # end
   
    # attr_writer :nome
    # representa:
    # def nome=(valor)
    #  @nome = valor
    # end
   
    # attr_accessor :nome
    # representa:
    # def nome
    #  return @nome
    # end
    # def nome=(valor)
    #  @nome = valor
    # end

2.5 - alias

O alias muda o nome do método antigo para futura modificação e deverá ser chamado da seguinte maneira
alias novo_nome_do_metodo antigo_nome_do_metodo

Código:

class A
      def teste1
        p "A"
      end
      def teste2
        p "A"
      end
      def teste3(argumento)
        p argumento
      end
    end
    class A
     
      alias antigo_teste1 teste1
      alias antigo_teste2 teste2
      alias antigo_teste3 teste3
     
      def teste1
        # Chamo o método antigo
        antigo_teste1
        # Adiciono as funçíµes
        p "B"
        # Chamo o método antigo
        antigo_teste1
      end
     
      def teste2
        p "C"
      end
     
      def teste3(argumento)
        antigo_teste3(argumento)
        antigo_teste3(argumento)
        antigo_teste3(argumento)
      end
     
    end
    a = A.new
    a.teste1            # => "A", "B", "A"
    a.antigo_teste1      # => "A"
    a.teste2            # => "C"
    a.antigo_teste2      # => "A"
    a.teste3("D")        # => "D"
    a.antigo_teste3("D") # => "D", "D", "D"

3 - Final
Espero que tenham gostado e aprendido bastante com esta aula. Aguardem mais aulas.

Pô, assim irei aprender scripts, mesmo sendo RGSS.
+ Nivel