Preparado por: Prof. Nelliud D. Torres OBJECT-KAREL SICI-3011 Preparado por: Prof. Nelliud D. Torres

Propósito de ObjectKarel El propósito de estudiar a ObjectKarel en adición a Otto y a Karel es para que el estudiante vaya conociendo el método actual de Programación Orientada a Objetos (OOP). No se pretende profundizar en las capacidades del programa ni en el concepto OOP ya que es un poco complejo y elaborado para el alcance del curso. Solo se desea que el estudiante tenga una idea de cuales son los conceptos para programar y pueda comparar los tres paradigmas de programación existentes: Programación espagueti (uso indebido del GOTO) Programación estructurada Programación Orientada a Objetos

Mundo de ObjectKarel Avenidas verticales Calles horizontales Beepers (pueden enumerarse) Paredes horizontales y verticales Puede haber más de un Robot en el mapa Norte, Sur, Este y Oeste

Introducción al mundo de Objetos La Programación Orientada a Objetos se basa en los conceptos de objetos y mensajes Cada Objeto posee información y métodos (formas) para procesar esa información. El procesamiento de información se logra utilizando mensajes que definen las acciones que el objeto-recipiente debe tomar con la información que posee. Los Robots actúan de acuerdo a los mensajes que se les envía. A estos Robots en OOP se les conoce como clases (CLASS)

Introducción al mundo de Objetos (Cont.) Cada nueva clase de Robot adquiere (inherits) las características (atributos) y métodos (formas de reaccionar a los mensajes) de la clase principal o de cualquier otra clase que ya este creada. Cada clase puede ofrecernos tantos objetos/robots como necesitemos utilizar para el programa. Los robots se transfiere al mundo utilizando helicópteros (aparecen bajo una coordenada en particular) y caen en una intersección avenida/calle. Cada robot tiene un diccionario con los nombres y las definiciones de los mensajes (métodos) a los cuales puede responder y que son determinados por la clase a la que pertence.

Introducción al mundo de Objetos (Cont.) El piloto del helicóptero pone al robot en las coordenadas que le indiquemos (avenida/calle) y el robot apuntará en donde especifiquemos (norte, sur, este, oeste). El piloto lee las instrucciones que le asignamos a los robots una por una y en el caso de que esa instrucción exista en el diccionario del robot, procede a ejecutarla. Los mensajes se envían al robot por un satélite que tiene unas limitaciones que solo le permite enviar un mensaje a la vez a cualquiera de los robots que existan. Por lo tanto cuando se le envía un mensaje a un robot, este lo ejecuta y no se puede enviar otro mensaje a cualquier otro robot hasta que el robot termine de ejecutar el mensaje enviado.

Objetos - Mensajes Los robots de la clase básica (objeto-robot) tienen la habilidad de responder a cinco mensajes. Estos mensajes y su correspondiente método (la forma en la que el robot actúa cuando recibe el mensaje) son: move() – El robot se mueve un paso adelante sin cambiar de dirección. Para evitar daños, el robot tiene una cámara que coteja si no hay una pared al frente. de haberla, el robot no ejecuta la instrucción y se apaga automáticamente (no explota). turnleft() – El robot gira 90 grados a la izquierda sin cambiar de esquina (avenida/calle). pickBeeper() – El robot recoge un beeper con su brazo mecánico y lo pone en una bolsa. Si no hay un beeper en la esquina en donde él se encuentra, ocurre un error (error shutoff) y entonces se apaga.

Objetos – Mensajes (cont.) putBeeper() – El robot coge un beeper de su bolsa y lo pone en la esquina en donde está ubicado. Si no hay un beeper en la bolsa, ocurre un error (error shutoff) y entonces se apaga. turnOff() – El robot se apaga y deja de ejecutar comandos. IMPORTANTE El formato para enviar estos mensajes es el siguiente: <nombre del objeto>.Mensaje(). Esto permite enviar mensajes a cada robot en particular. Por ejemplo si queremos enviar el mensaje de move() a un robot llamado Pepito, el formato sería; Pepito.move(). Ojo - El mensaje Move no existe en el diccionario del robot porque tiene su primera letra mayúscula. La que el robot reconoce es move.

CLASES (CLASS) Cada robot independiente representa una instancia del modelo/familia de robots llamado Primitive-Robot. En OOP un tipo de objeto como este se llama clase (class) y determina las propiedades y la conducta de cada objeto que se deriva de ella. El formato para definir la clase Primitive-Robot es: class primitive_Robot { void move(); void turnLefft(); void pickBeeper(); void putBeeper(); void turnOff(); }; class = Palabra reservada que indica el principio de la clase. void = Indica que el método no va devolver ningún valor (bool). { } = Entre las llaves se declaran los métodos que pueden ser ejecutados por los miembros de la clase. Termina con punto y coma (;).

CLASES (CLASS) Cont. La instrucción para construcción de un robot que es miembro de la clase Primitive_Robot es; Primitive_Robot <name> (street, avenue, direction, number of beepers in bag); <name> = Nombre del robot que se ba a crear. Se puede utilizar letras mayúsculas y/o minúsculas, los números del 0 al 9 y el underscore ( _ ). street, avenue = Número positivo entero que indica el número de la calle (horizontal) y avenida (vertical). direction = Dirección inicial del robot (norte, sur, este u oeste) number of beepers in bag = Cantidad inicial de beepers que va a tener el robot en su bolsa. EJEMPLO: Primitive_Robot Karel (1, 5, East, 3);

CLASES (CLASS) Cont. La lista de mensajes que le podemos enviar al robot se llaman tareas (task). El formato para poder escribir esas instrucciones es el siguiente: task { <construction-initialization-robot1> . . . < construction-initialization-robot N> <statement-1> <statement-n> }

INHERITANCE Nos permite crear nuevas clases con nuevos métodos. En otras palabras, clases que nos pueden proveer nuevos robots con instrucciones adicionales (métodos) que se componen de las instrucciones básicas. En este caso el diccionario de un robot en particular esta sujeto a la clase a la que pertenece. El formato para declarar una clase es la siguiente: class <class-name> : <parent-class> { <list-of-methods> }; <definition-of-methods> <class-name> = Nombre de la nueva clase. <parent-class> = Nombre de una clase que ya existe. <list-of-methods> = Los nuevos métodos (mensajes) para el robot. <definition-of-methods> = Se explica más adelante.

Definición del Método de la nueva clase La definición de los métodos se pone después de la declaración de la clase. Utiliza el siguiente formato: void <class-name> :: <method-name> ( ) { <list-of-instructions> } void = Palabra reservada que establece que el método no va a devolver ningún valor. <class-name> = Nombre de la clase a la que pertenece el método. <list-of-instructions> = Lista de instrucciones. También se le llama bloque (block). Describe con instrucciones ya existentes como ejecutar el método.

Ejemplo de como crear clases/métodos class Robot_Derecho : Primitive_Robot { void turnright(); }; void Robot_Derecho :: turnright() turnleft(); } task Robot_Derecho Karel ( 1, 2, East, 0); Karel.move(); Karel.turnright(); Definición de la clase (objeto) que utiliza de referencia la clase Primitive_Robot. Definición del método turnright en donde se especifica cuales son las instruciones que lo definen. Código del programa en donde se define la lógica del mismo. Uso del método turnright para el robot llamado Karel.

ESTRUCTURAS DE CONTROL El formato básico de la instrucción IF es: if ( <condition> ) { <list-of-instructions> } FORMATO THEN/ELSE if ( <condition> ) <instruction-list-1> else < instruction-list-2>

ESTRUCTURAS DE CONTROL (cont.) Las condiciones para poder utilizar el IF son métodos que se encuentran en la clase Robot. Esta clase tiene (inherits) las propiedades y métodos de la clase Primitive_Robot más los métodos que permiten evaluar condiciones. En el próximo slide vemos la creación de la clase Robot. Ya esta clase al igual que la clase Primite_Robot están siempre definidas por que no tenemos que crearlas. Utilizamos ambas clases para crear nuestras propias clases con sus métodos.

Clase Robot (Condiciones) Aqui el método devuelve un valor buleano (True/False) El instrucciones de la clase IF es: class Robot : Primitive_Robot { bool frontIsClear(); //is the road/avenue clear? bool nextToABeeper(); //is there one or more beepers in the same corner? bool nextToARobot(); //is there another robot in the corner? bool facingNorth(); //is the robot facing North? bool facingSouth(); // is the robot facing South? bool facingEast(); // is the robot facing East? bool facingWest(); // is the robot facing West? bool anyBeepersInBeeperBag(); //are there any beepers in the bag? };

Definición de nuevos predicados La metodología OOP nos permiten crear nuevos predicados (condiciones) por los cuales podemos preguntar. El siguiente ejemplo permite preguntar si a la derecha hay espacio libre (clear): bool Checker_Robot :: rightIsClear() { turnLeft(); turnLeft(); \\or turnRight, since it has been defined if ( frontIsClear() ) return true; } return false; Definición del método rightIsClear() de la clase Cheker_Robot Devuelve el valor true (boolean) Devuelve el valor false (boolean)

Otro ejemplo de creación y uso de métodos class Replanter : Robot { void ReplantCorner(); void nextToOneReplantOne(); } void Replanter :: ReplantCorner() if ( ! nextToABeeper() ) putBeeper(); else nextToOneReplantOne(); void Replanter :: nextToOneReplantOne(); pickBeeper(); Se define la clase Replanter que a su vez utiliza los métodos de la clase Robot. Define dos nuevos métodos que va a utilizar los cuales son ReplantCorner() y nextToOneeplantOne(). Este método es utilizado por el método ReplantCorner. Explique para que se utilizan estos dos métodos.

Estructuras de repetición - loop La instrución LOOP Se utiliza cuando queremos que el robot ejecute un bloque de instrucciones una predertminada cantidad de veces. El formato del loop es el siguiente: loop (<number-of-repetitions>) { <list-of-instructions> } loop = Palabra reservada <number-of-repetitions> = Cantidad de veces que el robot ejecuta las instrucciónes. <list-of-instructions> = Cantidad de intrucciones. También se le dice el cuerpo (body) del ciclo loop.

Ejemplo que utiliza loop class Klm_Walker : Primitive_Robot { void moveKlm(); }; void Klm_Walker :: moveKlm(); loop (8) move(); } task Klm_Walker Karel (1, 2, East, 0); loop (10) Karel.moveKlm(); Karel.pickBeeper(); loop(5) Aquí creamos el método moveKlm() el cual permite al robot moverse ocho pasos con un solo comando.

Estructuras de repetición - while La instrución while Permite al robot ejecutar un bloque de instrucciones (repetidamente) mientras la condición sea cierta. El formato del while es el siguiente: while ( <condition> ) { <list-of-instructions> } while = palabra reservada que define la declaración. <condition> = La condición que se está probando y que debe dar cierto o falso. <list-of-instructions> = Cantidad de intrucciones. También se le dice el cuerpo (body) del ciclo while.

Ejemplo que utiliza while void Beeper_Manipulator :: go_pickBeeper() { while ( ! nextToABeeper() ) move(); } pickBeeper(); Este método llamado go_pickBeeper de la clase/objeto llamada Beeper_manipulator permite que el robot se siga moviendo y recogiendo beepers mientras exista una línea de ellos.

Ejemplo de una corrida A continuación vamos a mostrar una corrida con cada uno de sus pasos.

Ejemplo de una corrida - paso 1

Ejemplo de una corrida - paso 2

Ejemplo de una corrida - paso 3

Ejemplo de una corrida - paso 4

Ejemplo de una corrida - paso 5

Ejemplo de una corrida - paso 6

Ejemplo de una corrida - paso 7

Ejemplo de una corrida - paso 8

Ejemplo de una corrida - paso 9

Ejemplo de una corrida - paso 10

Ejemplo de una corrida - paso 11

Ejemplo de una corrida - paso 12

Ejemplo de una corrida - paso 13

Ejemplo de una corrida - paso 14

Ejemplo de una corrida - paso 15

Ejemplo de una corrida - paso 16

Comparación entre código que utiliza clases y otro que no utiliza clases