Computación I

Objetos

Objetivos: Presentar los objetos como tipos de datos abstractos.

Temas:

Objetos.
El ejemplo de la tortuga.
Clases.
Construcción de objetos y referencias.
Métodos e invocación de métodos.

Objetos

Para aumentar la productividad al escribir programas, es primordial recurrir a biblioteca de software. En cada lenguaje de programación existen innumerables bibliotecas de software que pueden simplificar enormemente el problema que se pretende resolver. El dilema del programador se reduce a escoger adecuadamente la biblioteca útil a sus propósitos.

En Java se puede acceder a estas bibliotecas por medio de los objetos. Para que el lector entienda mejor qué es un objeto recurriremos a una alegoría. Un objeto es un robot que recibe órdenes y las ejecuta con gran eficiencia y precisión. Siendo un robot, carece de inteligencia. No es capaz de interpretar las órdenes, de modo que las realiza sin cuestionar lo que se le pide.

Sin embargo, esto significa que se debe ser extremadamente cuidadoso con las órdenes que se le entrega a un objeto/robot. Si la orden que se le entrega no es razonable, el robot la llevará a cabo de todas formas, incluso si significa su autodestrucción.

Un robot/objeto sólo es capaz de realizar las actividades para la cual fue diseñado. Cualquier otra orden, por simple que sea, será incapaz de llevarla a cabo. Lo interesante es que estas órdenes son dadas por medio de un programa.

El ejemplo de la tortuga

A modo de ejemplo, uno de estos robot/objetos será una tortuga:

Esta tortuga es un robot que sabe llevar a cabo órdenes de movimiento como (i) avanzar un cierta distincia en una dirección o (ii) cambiar su dirección en un ángulo dado:

En su parte inferior, la tortuga posee un rodillo con pintura que marca el camino por donde va pasando. Por lo tanto, después de un cierto número de órdenes se puede observar el rastro de la tortuga:

La tortuga también recibe órdenes para cambiar el color del rodillo. Puede dejar un rastro rojo, verde, azul y negro.

Clases

No todos los objetos son tortugas. Hay objetos que saben archivar información en disco y hay objetos que saber recuperar información archivada en disco. Otros objetos pueden ser calculadoras que saben estimar el área bajo una curva (la integral), calcular el máximo de una función o multiplicar matrices. Tales objetos aceptan órdenes distintas de las que realiza una tortuga.

El tipo de órdenes que un objeto/robot puede llevar a cabo depende de la fábrica en donde fueron manufacturados. En Java (y en los lenguajes orientados a objetos), una fábrica de objetos se denomina clase. Por ejemplo la fábrica en donde se arman las tortugas se llama Tortuga (la primera T con mayúscula). La fábrica de objetos para almacenar información en disco se llama TextWriter.

Construcción de objetos y referencias

En un programa se pueden fabricar objetos mediante la siguiente expresión:

    new Tortuga()

La evaluación de esta expresión construye un objeto en la fábrica de tortugas. Para fabricar objetos TextWriter se usa:

    new TextWriter("datos.txt")

En este caso, entre paréntesis se indica cuál es el nombre del archivo que almacenará la información. En general, entre paréntesis se especifican los atributos del objeto. Aún cuando todos los archivos de texto son producidos en la misma fábrica, no todos van a escribir en el mismo archivo.

De la fábrica uno no obtiene directamente el objeto. Cada robot tiene un teléfono celular al que se puede llamar para darle órdenes. Lo que uno obtiene de la fabricación es el número de ese teléfono. Ese número es conocido como la referencia del objeto.

La referencia de un objeto debe ser almacenada en variables del tipo adecuado. Por ejemplo para recordar la referencia de una tortuga, se necesita colocarla en una variable de tipo Tortuga:

    Tortuga tort; // (*)
    ...
    tort= new Tortuga(); // (**)

En (*), la palabra Tortuga denota un tipo de variable que puede almacenar referencias de tortugas. Esto significa que la variable tort solo puede almacenar referencias de tortugas. En cambio en (**), Tortuga denota una fábrica de tortugas y se usa para fabricar un robot/objeto tortuga. No hay otras interpretaciones de la palabra Tortuga: ya sea se usa para declarar una variable, o bien para fabricar un objeto.

Es un error utilizar una variable de tipo Tortuga para referenciar objetos TextWriter:

    Tortuga tort;
    ...
    tort= new TextWriter("datos.txt"); // ¡Error!

Almacenar referencias a tortugas sólo en variables de tipo Tortuga es útil, porque así es fácil determinar qué órdenes saben realizar los objetos referenciados por variables de tipo Tortuga. Veremos que el compilador es capaz de detectar de inmediato cuando se ordena una operación que una tortuga no puede realizar.

Métodos e invocación de métodos

Cada objeto sabe recibir las órdenes para las que fue fabricado. En un lenguaje orientado a objetos, estas órdenes se denominan métodos. Por ejemplo una tortuga sabe avanzar y cambiar de dirección. Para hacer que una tortuga avance se usa la siguiente instrucción:

    tort.avanzar(60);

A esta categoría de expresión se le denomina invocación de un método. Se diferencia de la invocación de una función, por la aparición del objeto que recibe la orden. La invocación del método avanzar significa:

Comuníquese con la tortuga cuyo número celular está almacenado en la variable tort. La tortuga siempre estará lista para responder (el teléfono no está ocupado), ya que es de la propiedad exclusiva del programa que pidió su construcción.
Ordene a esa tortuga que avance en 60 unidades de distancia (puntos en la pantalla).
Espere hasta que la orden anterior sea cumplida.
Cuelgue el teléfono.

Todos las invocaciones de métodos tienen esta misma semántica. Lo único que cambia es la operación que debe realizar el objeto. La operación también puede consistir en pedir información acerca del estado del objeto. Por ejemplo, a una tortuga se le puede pedir su posición en la coordenada X de la pantalla mediante:

    int x= tort.coordx();

Como en el caso anterior, esta orden también significa comunicarse con el objeto, pero esta vez el objeto no realiza ninguna acción sino que entrega información acerca de su posición en la pantalla. Esta posición es el resultado de la evaluación de tort.coordx().

La tortuga posee los siguientes métodos:

void avanzar(int dist): Avanza en dist puntos en la pantalla hacia la dirección actual. La palabra void significa que este método no entrega ningún resultado.
void virarIzq(int ang): Vira hacia la izquierda en ang grados. La tortuta no avanza.
void virarDer(int ang): Vira hacia la derecha en ang grados.
int coordx(): Entrega su actual posición en la coordenada X de la pantalla.
int coordY(): Entre su posición en la coordenada Y.
void enRojo():
void enVerde():
void enAzul():
void enNegro(): Cambia el color del rodillo.

La forma general de invocar un método de un objeto (es decir, dar una orden al objeto) es la siguiente:

``referencia-objeto'' . ``nombre-método''(``argumentos'')

Aquí lo esencial es el . y los paréntesis que indican la invocación del método.

El tipo de la variable que referencia un objeto indica donde se fabricó un objeto y por lo tanto qué operaciones sabe realizar. Es un error invocar métodos desconocidos para ese objeto. Por ejemplo:

    TextWriter writer= new TextWriter("datos.txt");
    ...
    writer.avanzar(60); // ¡Error!

Ejemplo:

El siguiente programa da órdenes a la tortuga para que dibuje un cuadrado:

    Tortuga tort= new Tortuga();
    int i= 1;
    while (i<=4) {
      tort.avanzar(60);
      tort.virarDer(90);
      i= i+1;
    }

Resumen: La alegoría de los robots/objetos se puede resumir en la siguiente tabla:

Concepto	Alegoría
objeto	robot
clase	fábrica de robots
referencia	número de teléfono celular
métodos	comandos que conoce el robot
invocación	ejecución de un comando/orden/consulta

Tarea:

En los computadores del zócalo, visite la página http://www.dcc.uchile.cl/~lmateu/CC10A/Guias/ y realice la guía 1.