TEMA 10: Características de otros LOO.

• En SmallTalk todo es un objeto, incluso los tipos base de lenguaje y por tanto las constantes de estos.
• Tiene sólo herencia simple y con una clase base común: Object.
• Es débilmente tipado.
• Dispone de un browser de clases.
• Dispone de recolección de basura.
• Tenemos diversas implementaciones disponibles, una de ellas bastante sencilla de instalar y usar en diversos S.O.: Squeak SmallTalk.
• El equivalente a this de C++ es self.

• Hola mundo:

1:   "Hello world Program"
2:   'Hello World!' printNl !

• Cáculo del factorial de un número:

1:   factorial
2: "Answer the factorial of the receiver."
3: 
4: self = 0 ifTrue: [^ 1].
5: self > 0 ifTrue: [^ self * (self - 1) factorial].
6: self error: 'Not valid for negative integers'

• Ejemplo de llamada al factorial:

1:   Transcript show: 10 factorial.

• Ejemplo de un bucle:

1: 10 timesRepeat: [
2:    Transcript show:'hello'.
3:    Transcript cr.
4: ].

• Bucle for:

1: 1 to: 10 do:[ :i |
2:    Transcript show:i.
3:    Transcript show:' '.
4:    Transcript show:i sqt.
5:    Transcript cr.
6: ].

• Bucle sobre una coleccion:

1: #('a' 'b' 'c' ) do: [:each |
2:    Transcript show: each.
3:    Transcript cr.
4: ].

• Los […] que acompañan al do: ¡son un objeto!:

1: |myArray myOperation|
2: 
3: myArray := #('a' 'b' 'c' ).
4: myOperation := [:each |
5:                   Transcript show: each.
6:                   Transcript cr.
7:                ].
8: myArray do: myOperation.

• Dispone de herencia simple.
• Es fuertemente tipado pero de dispone de un tipo base id. Sería como una referencia a la clase base Object.
• En lugar de #include usa #import: #import <stdio.h>
• Los ficheros de cabecera usan la extensión .h y los de implementación .m.
• Los mensajes a objetos se envían con notación de SmallTalk: [obj method:parameter];

Puedes encontrar más en la página de la wikipedia.

• Declaración de una clase:

1:   // class.h
2:   @interface classname : superclassname { ... }
3:   +classMethod1;
4:   +(return_type) classMethod2;
5:   +(return_type) classMethod3: (param1_type)parameter_varName;
6:   -(return_type) instanceMethod: (param1_type)param1_varName
7:                                  secondParam: (param2_type)param2_varName;
8:   @end

• Implementación:

 1:   #import "class.h"
 2: 
 3:   @implementation classname
 4:   +classMethod {
 5:       // implementation
 6:   }
 7:   -instanceMethod {
 8:       // implementation
 9:   }
10:   @end

• Se admite dar nombre a argumentos de métodos:

1:   -(int)changeColorToRed:(float)red green:(float)green blue:(float)blue
2:   [myColor changeColorToRed:5.0 green:2.0 blue:6.0];

• Creación de objetos

1:   MyObject * o = [[MyObject alloc] init];
2:   ...
3:   -(id) init {
4:     self = [super init];
5:     if (self) {...}
6:     return self;
7:   }

• Dispone de clases e interfaces.
• Fuertemente tipado con herencia simple de clases y múltiple de interfaces.
• Genericidad que permite crear una biblioteca de colecciones muy amplia y que ha marcado un estándar entre los programadores.
• Recolección de basura.
• No tiene destructores, si finalizadores. No hay archivos de cabecera e implementación.
• No puede haber funciones libres, incluso la función main en Java debe formar parte de una clase.
• No dispone de espacios de nombres pero si de paquetes: package. Estos deben ser importados donde se usan mediante la orden import.

• Disponemos de dos paquetes de software relacionados con Java:
  • OpenJDK
  • OpenJRE
• Disponemos de un compilador (javac) y de la máquina virtual para ejecutar el código compilado (java).
• Formando parte del JRE se encuentra la biblioteca de clases de Java (JCL).
• No es imprescindible pero si conveniente, para desarrollar en Java es bueno disponer de un IDE:
  • Eclipse
  • NetBeans

• Creación de una clase:

  1:     public class Model {
  2:       private Map<Character, FeatureVector> features;
  3:       /// Default constructor
  4:       public Model() {
  5:         features = new HashMap<>();
  6:       }
  7:       ...
  

• Herencia de clases:

  1:     package gtaligner;
  2:     import gtaligner.io.Messages;
  3:     import gtaligner.io.TextReader;
  4:     public class BWImage extends BufferedImage {
  5:        private int[] weights;
  6:        ....
  

• Herencia de interfaz:

  1:   public interface Sortable {
  2:      public bool isLessThan (Sortable b);
  3:   }
  4:   public class Line implements Sortable {...}
  

• Dispone de clases e interfaces.
• Fuertemente tipado con herencia simple de clases y múltiple de interfaces.
• Genericidad que permite crear una biblioteca de colecciones muy amplia.
• Recolección de basura.
• Tiene destructores pero se parecen más a los finalizadores de Java.
• No hay archivos de cabecera e implementación.
• Se recomienda desarrollar con VisualStudio o con la versión de código abierto visual studio code.

• El siguiente código de ejemplo está tomado de aquí.

1:   using System.Windows;
2:   namespace MyCalculatorv1
3:   {
4:       public partial class App : Application
5:       {
6:       }
7:   }

• Mono es una implementación libre y de código abierto de .Net, de la máquina virtual y del compilador de C#.
• Ha permitido disponer de esta tecnología en S.O. distintos a Windows.
• Dispone de su propio IDE: MonoDevelop.
• El compilador libre que teneis instalado de C# se llama mcs.

• Dispone de clases e interfaces.
• Fuertemente tipado con herencia simple de clases y múltiple de interfaces.
• Genericidad que permite crear una biblioteca de colecciones muy amplia (Gee).
• Liberación de memoria basada en cuenta de referencias.
• Tiene destructores como en C++.
• Permite añadir métodos a tipos enumerados.
• Dispone de la emisión de señales y ejecución de código diferido en el mismo lenguaje.
• Al igual que en C# dispone de propiedades.
• No hay archivos de cabecera e implementación.

• Un ejemplo sencillo:

 1:   using GLib;
 2:   class Droid {
 3:       public Droid (string n) {
 4:         name = n;
 5:       }
 6:       public string name {get; set;}  // propiedad: variable+set+get todo-junto
 7:   }
 8: 
 9:   int main () {
10:       Droid d = new Droid ("correo");
11: 
12:       stdout.printf("Nombre: %s\n", d.name);
13:       return 0;
14:   }

• Dispone de una web con la documentación de todas las bibliotecas que tienen una adaptación a Vala.
• Realmente el compilador de Vala es un traductor a C.
• Se puede parar la compilación en el instante en el que se genera el código C y verlo.
• El compilador de vala se llama igual: valac. Lo tenéis instalado en la máquina virtual.

• Dispone de clases e interfaces.
• Fuertemente tipado con herencia simple de clases y múltiple de interfaces.
• Genericidad al estilo de C++ (permite metaprogramación).
• Recolección de basura.
• Tiene destructores para clases parecidos a los finalizadores de Java y destructores similares a los de C++ para structs.

• Permite tener funciones libres, incluso permite anidar funciones.
• No dispone de espacios de nombres pero sí de módulos: module. Estos deben ser importados donde se usan mediante la orden import.
• Aquí dispones de un resumen de todas sus características.
• Existen tres compiladores de D. Todos ellos libres. Los puedes descargar de aquí.

• Haciendo uso de notación funcional:

   1:     // Sort lines
   2:     import std.stdio, std.array, std.algorithm;
   3: 
   4:     void main() {
   5:         stdin
   6:              .byLineCopy           // No es necesario usar () en la llamada
   7:              .array                // si no hay argumentos
   8:              .sort
   9:              .each!writeln;
  10:      }
  

• Uso de clases:

   1:      import std.stdio;
   2: 
   3:      class Base {
   4:         protected int y = 8;
   5:         private int n = 9;
   6:      }
   7: 
   8:      class Derived : Base {
   9:        public int get_n () { return n; } // We can access 'n' 'cause Base and
  10:                                          // Derived are declared in the same file!
  11:        public int get_k () { return k; }
  12: 
  13:        private int k = 0;
  14: 
  15:        ~this () {
  16:          writeln ("~Derived.");
  17:        }
  18:      }
  19: 
  20:      void main () {
  21:         Derived d = new Derived;
  22: 
  23:         writeln (d.get_k);
  24:      }
  

• Creado a finales de los años 80.
• Su desarrollador inicial fue Guido van Rossum.
• Toda la documentación sobre el lenguaje la puedes encontrar en la web del mismo: python.
• Python admite diversos paradigmas de programación, entre ellos el Orientado a Objetos. También soporta el concepto de módulos como mecanismo de división del código fuente en varios archivos.
• Actualmente puedes encontrar dos versiones de python empleadas en producción: La versión ptyhon2 y la versión python3. Ten en cuenta que son incompatibles a nivel de sintáxis. Nosotros emplearemos la versión 3.

• Se declaran y definen en el mismo archivo.
• Los métodos de instancia deben declarar explícitamente un primer parámetro que representa el objeto al que se le envia el mensaje. El convenio es llamarlo self.

• Los objetos se crean con la notacion que ya conocemos de C++:

  1:     myObject = myClass()
  

• El constructor invoca el método especial __init__:

  1:     def __init__(self):
  2:        self.data = []  # Obligatorio el uso de self
  

• Debemos emplear self para llamar a otros métodos de la clase:

   1:     class Bag:
   2:     def __init__(self):
   3:        self.data = []
   4: 
   5:     def add(self, x):
   6:        self.data.append(x)
   7: 
   8:     def addtwice(self, x):
   9:        self.add(x)
  10:        self.add(x)
  

• Podemos declarar variables y métodos de clase :

  class Complex:
     count = 0
  
     def onemore():
         Complex.count += 1
  
     def __init__(self, realpart = 0.0, imagpart = 0.0):
         self.r = realpart
         self.i = imagpart
         Complex.onemore()
  
     def rpart(this):
         return this.r
  
  x = Complex(3.0, -4.5)
  x2 = Complex()
  print ("x.r = ", x.rpart())
  print ("x2.r = ", x2.rpart())
  print ("Complex numbers created: ", Complex.count)
  # -------------- Output: --------------------
  

  x.r =  3.0
  x2.r =  0.0
  Complex numbers created:  2
  

• Admite herencia simple:

  class DerivedClassName(BaseClassName): ...

• Y también múltiple:

  class DerivedClassName(Base1, Base2,...,BaseN):...

• Técnicamente no existe la visibilidad privada de identificadores definidos en una clase, pero se puede obtener un resultado parecido empleando como prefijos/sufijos símbolos de subrayado.

• Los módulos son la manera que Python tiene de permitirnos separar el código que escribimos en diversos archivos.
• Cada fichero se convierte en un módulo llamado como el archivo pero sin la extensión .py.

• Los módulos se importan con la sentencia import:

  import name-of-module

• Los símbolos importados de un módulo pertenecen al espacio de nombres de ese módulo:

   1:     # Fibonacci numbers module,  file: fibmod.py
   2:     def fib(n):    # write Fibonacci series up to n
   3:       a, b = 0, 1
   4:       while a < n:
   5:         print(a, end=' ')
   6:         a, b = b, a+b
   7:       print()
   8:       ....
   9: 
  10:     # Main Program, file: main.py
  11:     import fibmod
  12:     fibmod.fib(200)
  

• Se puede hacer visible un símbolo de un módulo importado con la construcción:

  1:     from fibmod import fib
  2:     fib(120)
  

• Se admite el uso del carácter '*' como comodín:

  1:     from fibmod import *
  2:     fib(120)
  

• Se permite el renombrado:

  1:     from fibo import fib as fibonacci
  2:     fibonacci(120)
  

• Los módulos se importan desde el directorio actual o desde los directorios definidos en la variable: sys.path.
• Esta variable contiene una lista de directorios donde residen los módulos estándar que vienen con la instalación de python, p.e. el módulo sys.
• Para más información sobre módulos consulta el tutorial.

• Para depurar un programa en Python podemos hacer uso del módulo pdb.
• Este módulo define un depurador interactivo a nivel de código fuente. Podemos poner puntos de parada, ejecutar sentencias paso paso, movernos por la pila de llamadas, etc…
• Para más información consulta la página web de pdb.