Clases y Módulos

R: Una clase se puede definir repetidamente. Cada definiicón se añade a la anterior. Si se redefine un método, el anterior es anulado y se pierde.

R: Desde Ruby 1.5.3, si. Una variable precedida con dos arrobas es una variable de clase, accesible desde los métodos de instancia y clase.

	    
	    class CountEm
	      @@children = 0
	      def initialize
	        @@children += 1
		@myNumber = @@children
	      end

	      def whoAmI
	        "Soy el hijo número #@myNumber (de #@@children)"
	      end

	      def CountEm.totalChildren
	        @@children
	      end
	    end
	    
	    c1 = CountEm.new
	    c2 = CountEm.new
	    c3 = CountEm.new
	    c1.whoAmI                # -> "Soy el hijo número 1 (de 3)"
	    c3.whoAmI                # -> "Soy el hiji número 3 (de 3)"
	    CountEm.totalChildren    # -> 3
	  

	    
	    class Foo
	      F = [0]                # -> pseudo variable de clase - array F
	      def foo
	        F[0] += 1
		puts F[0]
	      end
	    end
	  

R:

	    
	    class Foo
	      @a = 123            # (1)
	      def foo
	        p @a              # (2) ... nil not 123
	      end
	    end
	  

R: Un método singleton es una instancia de un método asignado a un objeto determinado.

Se crean incluyendo el objeto en la definición:

	    
	    class  Foo
	    end

	    foo = Foo.new
	    bar = Foo.new
	    def foo.hello
	      puts "Hola"
	    end
	    foo.hello
	    bar.hello
	  

	    Hola
	    prog.rb:10 undefined method 'hello' for #<Foo:0x4018d748> (NameError)
	  

Estos métodos son útiles si se quiere añadir un método a un objeto y no es adecuada la creación de una nueva clase.

R: Un método singleton de una objeto clase es un método de clase. (Realmente, el método de clase se define en la metaclase, pero esto es transparente). Otra forma de considerar esto es decir que un método de clase es un método cuyo receptor es una clase.

Todo ello se reduce al hecho de que se puede llamar a los métodos de clase sin tener instancias de esa clase (objetos) como receptor.

Vamos a crear un método singleton para la clase Foo:

	    
	    class Foo
	      def Foo.test
	        "Este es Foo"
	      end
	    end
	    
	    # Que se le puede llamar de la siguiente forma.
	    
	    Foo.test                 # -> "Este es Foo"
	  

Los métodos definicos en la clase Class pueden utilizarse como métodos de clase de cualquier clase (!).

R: Una clase singleton es una clase anónima que se crea mediante una subclase de la clase asociada a un objeto en concreto. Es otra forma de ampliar la funcionalidad asociada a un único objeto.

Retomemos la humilde Foo:

	    class Foo
	      def hello
	        print "hola"
	      end
	    end

	    foo = Foo.new
	    foo.hello
	  

Supongamos que se necesita añadir funcionalidad a nivel de clase para esta única instancia:

	    
	    class << foo
	      attr :name, TRUE
	      def hello
	        "hola, soy " + @name + "\n"
	      end
	    end

	    foo.name = "Tomás";
	    foo.hello           # -> "hola, soy Tomás"
	  

R: Una función de módulo es un método singleton privado definido en un módulo. En efecto, es similar a un método de clase (sección 8.5 anterior) que se puede llamar utilizando la notación Modulo.metodo:

	    
	    Math.sqrt(2)             # -> 1.414213562
	  

	    
	    include Math
	    sqrt(2)                  # -> 1.414213562
	  

	    
	    Module Test
	      def thing
	        # ...
	      end
	      module_function :thing
	    end
	  

R: Los módulos son colecciones de métodos y contantes. No pueden generar instancias. Las clases pueden generar instancias (objetos) y cada instancia tiene un estado (las variables de instancia).

Los modulos se pueden mezclar en las clases y otros módulos. Los métodos y constantes del módulo que se mezcla se añaden a la clase, aumentando su funcionalidad. Sin embargo, las clases no se pueden mezclar con nada.

Una clase puede heredar de otra pero no de un módulo.

Un módulo no puede heredar.

R: No, Sin embargo se puede incluir el módulo en una clase u otro mñodulo para simular una herencia múltiple (utilidad mixin )

Esto no crea una subclase (que requeriría herencia) pero genera una relación is_a? entre la clase y el módulo.

R: El módulo Comparable proporciona diversos operadores de comparación (<,<=,>,between? etc ...). Los define en términos de llamadas al método general de comparación <=>. Sin embargo, él mismo no define <=>.

Digamos que se desea crear una clase donde las comparaciones se toman en base al número de patas que tiene un animal:

	    
	    class MyClass
	      include Comparable
	      attr :legs
	      def initialize(name, legs)
	        @name, @legs = name, legs
	      end
	      def <=>(o)
	        return @legs <=> o.legs
	      end
	    end
	    
	    c = MyClass.new('gato',4)
	    s = MyClass.new('serpiente',0)
	    p = myClass.new('loro',2)

	    c < s            # -> false
	    s < c            # -> true
	    p >= s           # -> true
	    p.between?(s,c)  # -> true
	    [p, s, c].sort   # -> [serpiente, loro, gato]
	  

R: Se pueden definir en la definición de la clase y en el nivel superior.

	    
	    class Demo
	      def Demo.classMethod
	      end
	    end

	    def Demo.anotherClassMethod
	    end
	  

R: load carga y ejecuta un programa Ruby (*.rb).

require también carga un programa Ruby pero también módulos de extensión binarios de Ruby (Librerías compartidas o DLLs). Además require garantiza que un elemento nunca se carga más de una vez.

R: include mezcla un módulo con una clase u otro módulo. Los métodos del módulo se llaman utilizando el estilo de llamadas a funciones (sin receptor).

extend se utiliza para incluir un módulo en un objeto (instancia). Los métodos del módulo pasan a ser métodos del objeto.

R: self el receptor que se está en ejecución en ese momento - el objeto al cual se aplica el método. Una llamada a un método como una función implica la existencia de self como receptor.

R: Digamos que el fichero file1contiene:

	    
	    var1 = 99
	  

	    
	    require 'file1'
	    puts var1
	  

	    
	    prog.rb:2: undefined local variable or method 'var1' for #<Object:0x4019ac90> (NameError)