PROGRAMACION ORIENTADA A OBJETOS “La inteligencia… es la capacidad de crear objetos artificiales, es especial, herramientas para hacer herramientas” Henry Bergson Introducción y profundización en el estudio de lenguajes orientados a objetos.
Diego Gutiérrez, Gabriel Rodríguez, Gonzalo Micelli, Miguel Guaymas
2011
Página | 2
Programación Orientada a Objetos Integrantes
GUAYMAS, Miguel A.
- 58828
GUTIERREZ, Diego A.
- 57972
MICELLI, Gonzalo D.
- 59192
RODRIGUEZ, Gabriel
- 57885
Profesor
Víctor Fernández
INFORMÁTICA I – 2011
UNIVERSIDAD TECNOLÓGICA NACIONAL – FACULTAD REGIONAL CÓRDOBA
INTRODUCCIÓN
Página | 3
Este trabajo surgió de la idea de profundizar el tema de objetos en programación, ya que últimamente era frecuente escuchar sobre lenguajes y programación orientada a objetos como un tipo de programación mas eficaz, versátil y fácil de realizar, por lo que esto nos causó cierto asombro y en base a esto fue lo que nos condujo a la elección del tema. En el contenido que veremos a continuación trataremos de descifrar algunas pequeñas inquietudes sobre la programación en C, más precisamente, lenguaje y programación basada en C orientado a objetos. En grandes libros sobre este tipo de programación, en especial en algunos textos universitarios, se cuidan en exceso el formalismo con lo que se tienen textos elegantísimos e irreprochables con los que es casi imposible enterarse de que se trata. Nosotros por nuestra parte, nos basaremos en un lenguaje básico y muchos y sencillos ejemplos para un mejor esclarecimiento de los conceptos y definiciones fundamentales y una buena interpretación de todo lo que tenga ver con programación orientada a objetos (POO, en adelante). Es muy importante citar y destacar en esta parte introductoria que cuando hacemos referencia a la programación orientada a objetos no estamos hablando de unas cuantas características nuevas añadidas a un lenguaje de programación, sino que invoca una nueva forma de pensar acerca del proceso de descomposición de problemas y de desarrollo de soluciones de programación. En primera instancia, con el fin de un mejor esclarecimiento de los conceptos previo a todo el contenido, empezaremos describiendo sobre la base de la POO y su principal, y a veces confundible diferencia con los lenguajes no orientados a objetos. Explicaremos detalladamente sobre los lenguajes, ANSI C, Smaltalk y Objective C, cuyos últimos dos lenguajes son la base fundamental de la programación sobre objetos, por lo que sobre ellos daremos un poco mas
Página | 4
de énfasis. Estos dos últimos se basan en las funciones de ANSI C y es un conjunto de extensiones de este mismo lenguaje. Trataremos de dejar claro este tema para su posterior análisis o debate, según las especificaciones del profesor. En las páginas siguientes esperemos que le sean de sumo agrado y que logre distinguir el propósito de usar esta maravillosa forma de, básicamente, pensar y descifrar los problemas y por supuesto, programar. Deseamos dejar de la mejor y eficaz forma, explícitamente todo el contenido.
Página | 5
INDICE
UNA BASE FUNDAMENTAL: LENGUAJE C................................................7 ANSI C E ISO C................................................................................................. 8 Propiedades..................................................................................................... 9 Ventajas........................................................................................................... 9 Variantes........................................................................................................ 10 Proceso de compilación..................................................................................10 Estructura básica de un programa en C.........................................................11 Tipos básicos y variables...............................................................................12 Funciones....................................................................................................... 13 Aplicaciones................................................................................................... 14 PROGRAMACIÓN ORIENTADA A OBJETOS.............................................15 ¿Qué es la programación orientada a objetos?.................................................15 La gran diferencia entre lenguajes orientados y no orientados a objetos.........16 ¿Qué es un objeto?............................................................................................ 17 ¿Que es un mensaje?........................................................................................ 19 ¿Qué es una clase?........................................................................................... 22 LOS TRES PRINCIPIOS DE LOS LENGUAJES ORIENTADOS A OBJETOS......24 Encapsulación................................................................................................... 24 Herencia............................................................................................................ 24 Polimorfismo..................................................................................................... 26 Otras características extras.............................................................................. 26 Abstracción.................................................................................................... 26
Página | 6 Recolección de basura................................................................................... 27 Sobrecarga..................................................................................................... 27 ALGUNOS LENGUAJES BASADOS EN POO.............................................27 Smalltalk........................................................................................................... 27 Adaptaciones de Smalltalk............................................................................. 28 Objective C........................................................................................................ 29 ¿Qué es Objective C?..................................................................................... 29 Características del lenguaje...........................................................................30 Compilador..................................................................................................... 39 Crear un ejecutable........................................................................................ 40 Cuadro comparativo C y Objective C.............................................................41 C++.................................................................................................................. 41 Tipos de datos................................................................................................ 42 Ejemplo de una clase..................................................................................... 43 C#..................................................................................................................... 43 Instrucciones de control.................................................................................44 Metas del diseño del lenguaje........................................................................47 Compiladores................................................................................................. 47 Cadena de caracteres.................................................................................... 48 CONCLUSIÓN....................................................................................49 BIBLIOGRAFÍA CONSULTADA...............................................................50
Página | 7
DESARROLLO UNA BASE FUNDAMENTAL: LENGUAJE C
Lenguaje C C es un lenguaje de programación creado en 1972 por Dennis M. Ritchie en los Laboratorios Bell como evolución del anterior lenguaje B (Se le dio el nombre "C" porque muchas de sus características fueron tomadas del lenguaje anterior B, ambos basados en BCPL. BCPL es la sigla en inglés de Basic Combined Programming Language (Lenguaje de Programación Básico Combinado). Fue diseñado por Martin Richards de la Universidad de Cambridge en 1966 . El primer compilador implementado fue escrito en 1967. El lenguaje fue descrito por primera vez en una conferencia informática en 1969. Años después, Dennis Ritchie lo utilizó como base para desarrollar B. Los lenguajes de los que surgió son lenguajes sin tipos, al contrario que el C que proporciona varios tipos de datos. Los tipos que ofrece son caracteres, números enteros y en coma flotante, de varios tamaños. Además se pueden crear tipos derivados mediante la utilización de punteros, vectores, registros y uniones. El lenguaje C se trata de un lenguaje categorizado de medio nivel pero con muchas características de bajo nivel. Dispone de las estructuras típicas de los lenguajes de alto nivel pero, a su vez, dispone de construcciones del lenguaje que permiten un control a muy bajo nivel. Trabaja con tipos de datos que son directamente tratables por el hardware de la mayoría de computadoras actuales, como son los caracteres, números y direcciones. Estos tipos de datos pueden ser manipulados por las operaciones aritméticas que proporcionan las computadoras. No proporciona mecanismos para tratar tipos de datos que no sean los básicos, debiendo ser el programador el que los desarrolle. Esto permite que el código generado sea muy eficiente y de ahí el éxito que ha tenido como lenguaje de desarrollo de sistemas. No proporciona otros mecanismos de almacenamiento de datos que no sea el estático y no proporciona mecanismos de entrada ni salida. Ello permite que el lenguaje sea reducido y los compiladores de fácil implementación
Página | 8
en distintos sistemas. Por contra, estas carencias se compensan mediante la inclusión de funciones de librería para realizar todas estas tareas, que normalmente dependen del sistema operativo. En 1973, este se había vuelto tan potente que la mayor parte del kernel Unix, originalmente escrito en el lenguaje ensamblador PDP-11/20, fue reescrita en C. Éste fue uno de los primeros núcleos de sistema operativo implementados en un lenguaje distinto al ensamblador. En 1978, Ritchie y Brian Kernighan publicaron la primera edición de El lenguaje de programación C, también conocido como La biblia de C. Este libro fue durante años la especificación informal del lenguaje. El lenguaje descrito recibe habitualmente el nombre de "el C de Kernighan y Ritchie" o simplemente "K&R C" (Luego aparece el estándar ANSI C)
Al salir al mercado de la informática y ser una grata novedad, muchos programadores quisieron adaptar este tipo de lenguajes en otros propios, pero siguiendo la base en programación C, por lo que esto acarreaba mucha problemática y distintos tipos de lenguajes ¡de pronto todos hacían lenguajes C!
ANSI C e ISO C La primera estandarización del lenguaje C fue en ANSI, con el estándar X3.159-1989. El lenguaje que define este estándar fue conocido vulgarmente como ANSI C. Posteriormente, en 1990, fue ratificado como estándar ISO (ISO/IEC 9899:1990). El estándar está basado en el manual de referencia original de 1972 y se desarrolla con el mismo espíritu de sus creadores originales. La primera versión de estándar se publicó en 1988 y actualmente todos los compiladores utilizan la nueva definición. Una aportación muy importante de ANSI consiste en la definición de un conjunto de librerías que acompañan al compilador y de las funciones contenidas en ellas. Muchas de las operaciones comunes con el sistema operativo se realizan a través de estas funciones. Una colección de ficheros de encabezamiento, headers, en los que se definen los tipos de datos y funciones incluidas en cada librería. A finales de la década de 1970, C empezó a sustituir a BASIC como lenguaje de programación de microcomputadores predominante. Durante la década de 1980 se empezó a usar en los IBM PC, lo que incrementó su popularidad significativamente. Al mismo tiempo, Bjarne Stroustrup
Página | 9
empezó a trabajar con algunos compañeros de Bell Labs para añadir funcionalidades de programación orientada a objetos a C. El lenguaje que crearon, llamado C++, es hoy en día el lenguaje de programación de aplicaciones más común en el sistema operativo Microsoft Windows; mientras que C sigue siendo más popular en el entorno Unix. En parte a causa de ser de relativamente bajo nivel y de tener un modesto conjunto de características, se pueden desarrollar compiladores de C fácilmente. C se desarrolló originalmente (conjuntamente con el sistema operativo Unix, con el que ha estado asociado mucho tiempo) por programadores para programadores. Sin embargo, ha alcanzado una popularidad enorme, y se ha usado en contextos muy alejados de la programación de sistemas, para la que se diseñó originalmente.
Propiedades
Un núcleo del lenguaje simple, con funcionalidades añadidas
importantes, como funciones matemáticas y de manejo de archivos, proporcionadas por bibliotecas.
Es un lenguaje muy flexible que permite programar con
múltiples estilos. Uno de los más empleados es el estructurado "no llevado al extremo" (permitiendo ciertas licencias de ruptura).
Un sistema de tipos que impide operaciones sin sentido.
Usa un lenguaje de pre procesado, el preprocesador de C, para
tareas como definir macros e incluir múltiples archivos de código fuente.
Acceso a memoria de bajo nivel mediante el uso de punteros.
Interrupciones al procesador con uniones.
Un conjunto reducido de palabras clave.
Por defecto, el paso de parámetros a una función se realiza por
valor. El paso por referencia se consigue pasando explícitamente a las funciones las direcciones de memoria de dichos parámetros.
Punteros a funciones y variables estáticas, que permiten una
forma rudimentaria de encapsulado y polimorfismo.
Tipos de datos agregados (struct) que permiten que datos
relacionados (como un empleado, que tiene un id, un nombre y un salario)
P á g i n a | 10
se combinen y se manipulen como un todo (en una única variable "empleado").
Ventajas El lenguaje en c es muy eficiente puesto que es posible utilizar sus características de bajo nivel para realizar implementaciones óptimas. A pesar de su bajo nivel es el lenguaje más portado en existencia, habiendo compiladores para casi todos los sistemas conocidos. Proporciona facilidades para realizar programas modulares y/o utilizar código o bibliotecas existentes.
Variantes Este lenguaje fue la base fundamental y esencial para la creación de posteriores lenguajes de programación y ha influido especialmente a Vala, C#, Objective-C, C++, AWK, Java, entre otros. Desde el inicio del lenguaje han surgido varias ramas de evolución que han generado varios lenguajes: Objective-C es un primer intento de proporcionar soporte para la programación orientada a objetos en C, de escasa difusión, pero actualmente usado en Mac OS X y GNUstep. C++ diseñado por Bjarne Stroustrup fue el segundo intento de proporcionar orientación a objetos a C y es la variante más difundida y aceptada. Esta versión combina la flexibilidad y el acceso de bajo nivel de C con las características de la programación orientada a objetos como abstracción, encapsulación y ocultación. También el lenguaje C ha influido especialmente a Vala, C#, Objective-C, C++, AWK, Java, entre otros.
Proceso de compilación La compilación de un programa C se realiza en varias fases que normalmente son automatizadas y ocultadas por los entornos de desarrollo:
P á g i n a | 11
Preprocesado consistente en modificar el código
fuente en C según una serie de instrucciones (denominadas directivas de preprocesado) simplificando de esta forma el trabajo delcompilador. Por ejemplo, una de las acciones más importantes es la modificación de las inclusiones (#include) por las declaraciones reales existentes en el archivo indicado.
Compilación que genera el código objeto a partir del
código ya pre procesado.
Enlazado que une los códigos objeto de los distintos
módulos y bibliotecas externas (como las bibliotecas del sistema) para generar el programa ejecutable final.
Estructura básica de un programa en C La mejor forma de aprender un lenguaje es programando con él. El programa más sencillo que se puede escribir en C es el siguiente: main ( ) { } Como nos podemos imaginar, este programa no hace nada, pero contiene la parte más importante de cualquier programa C y además, es el más pequeño que se puede escribir y que se compile correctamente. En el se define la función main, que es la que ejecuta el sistema operativo al llamar a un programa C. El nombre de una función C siempre va seguida de paréntesis, tanto si tiene argumentos como si no. La definición de la función está formada por un bloque de sentencias, que esta encerrado entre llaves {}. Un programa algo más complicado es el siguiente: #include main ( ) { printf ("Hola amigos!\n");
P á g i n a | 12
} Con el visualizamos el mensaje Hola amigos! en el terminal. En la primera línea indica que se tengan en cuenta las funciones y tipos definidos en la librería stdio (standard input/output). Estas definiciones se encuentran en el fichero header stdio.h. Ahora, en la función main se incluye una única sentencia que llama a la función printf. Esta toma como argumento una cadena de caracteres, que se imprimen van encerradas entre dobles comillas " ". El símbolo \n indica un cambio de línea. Hay un grupo de símbolos, que son tratados como caracteres individuales, que especifican algunos caracteres especiales del código ASCII. Los más importantes son: \a
Alerta
\b
Espacio atrás
\f
Salto de página
\n
Salto de línea
\r
Retorno de carro
\t
Tabulación horizontal
\v
Tabulación vertical
\\
Barra invertida
\'
Comilla simple
\"
Comillas dobles
\OOO
Visualiza un carácter cuyo código ASCII es OOO en octal
\xHHH
Visualiza un carácter cuyo código ASCII es HHH en hexadecimal
Un programa C puede estar formado por diferentes módulos o fuentes. Es conveniente mantener las fuentes de un tamaño no muy grande, para que la compilación sea rápida. También, al dividirse un programa en partes, puede facilitar la legibilidad del programa y su estructuración. Las diferentes fuentes son compiladas de forma separada, únicamente las fuentes que han sido modificados desde la última
P á g i n a | 13
compilación, y después combinados con las librerías necesarias para formar el programa en su versión ejecutable.
Tipos básicos y variables Los tipos de datos básicos definidos por C son caracteres, números enteros y números en coma flotante. Los caracteres son representados por char, los enteros por short, int, long y los números en coma flotante por float y double. Los tipos básicos disponibles y su tamaño son:
Char
Carácter
(normalmente 8 bits)
Short
Entero corto con
(normalmente 16 bits)
signo Int
Entero con signo
(depende de la implementación)
Unsigne
Entero sin signo
d
(depende de la implementación)
Long
Entero largo con
(normalmente 32 bits)
signo Float
Flotante simple
(normalmente 32 bits)
Double
Flotante doble
(normalmente 64 bits)
Funciones Un programa C está formado por un conjunto de funciones que al menos contiene la función main. Una función se declara con el nombre de la función precedido del tipo de valor que retorna y una lista de argumentos encerrados entre paréntesis. El cuerpo de la función está formado por un conjunto de declaraciones y de sentencias comprendidas entre llaves Expresiones y operadores: Los distintos operadores permiten formar expresiones tanto aritméticas como lógicas. Los operadores aritméticos y lógicos son:
P á g i n a | 14
+, -
suma, resta
++, --
incremento, decremento
*, /, %
multiplicación, división, módulo
>>,
rotación de bits a la derecha,
<<
izquierda. &
AND booleano
|
OR booleano
^
EXOR booleano
~
complemento a 1
!
complemento a 2, NOT lógico
==, !
igualdad, desigualdad
&&, ||
AND, OR lógico
<, <=
menor, menor o igual
>, >=
mayor, mayor o igual
=
En estos operadores deben tenerse en cuenta la precedencia de operadores y las reglas de asociatividad, que son las normales en la mayoría de lenguajes. Se debe consultar el manual de referencia para obtener una explicación detallada. Además hay toda una serie de operadores aritméticos con asignación, como pueden ser += y ^=.
Aplicaciones Hecho principalmente para la fluidez de programación en sistemas UNIX. Se usa también para el desarrollo de otros sistemas operativos como Windows o GNU/Linux. Igualmente para aplicaciones de escritorio como OpenOffice.org, cuyo principal lenguaje de programación es C.
P á g i n a | 15
De la misma forma, es muy usado en aplicaciones científicas (para experimentos informáticos, físicos, químicos, matemáticos, entre otros, parte de ellos conocidos como modelos y simuladores), industriales (industria robótica, cibernética, sistemas de información y base de datos para la industria petrolera y petroquímica. Predominan también todo lo que se refiere a simulación de máquinas de manufactura), simulaciones de vuelo (es la más delicada, ya que se tienen que usar demasiados recursos tanto de hardware como de software para desarrollar aplicaciones que permitan simular el vuelo real de una aeronave. Se aplica por tanto, en diversas áreas desconocidas por gran parte de los usuarios noveles. Los ordenadores de finales de los 90 son varios órdenes de magnitud más potentes que las máquinas en que C se desarrolló originalmente. Programas escritos en lenguajes de tipo dinámico y fácil codificación (Ruby, Python, Perl...) que antaño hubieran resultado demasiado lentos, son lo bastante rápidos como para desplazar en uso a C. Aun así, se puede seguir encontrando código C en grandes desarrollos de animaciones, modelados y escenas en 3D en películas y otras aplicaciones multimedia.
PROGRAMACIÓN ORIENTADA A OBJETOS
¿Qué es la programación orientada a objetos? La programación orientada a objetos (POO) es un conjunto completo de conceptos e ideas. Es una manera de pensar en el problema al que va
P á g i n a | 16
dirigido un programa de ordenador y de afrontarlo, de modo más intuitivo e incluso más productivo. Una forma más cercana a como expresaríamos las cosas en la vida real que otros tipos de programación. Podríamos asegurar que es una diferente forma de ver, pensar y enfocar en como diseñar y programar soluciones a los problemas. Está basado en varias técnicas, incluyendo herencia, abstracción, polimorfismo y encapsulamiento (técnicas que explicaremos mas adelante). Su uso se popularizó a principios de la década de 1990. La POO no es difícil, pero es una manera especial de pensar, a veces subjetiva de quien la programa, de manera que la forma de hacer las cosas puede ser diferente según el programador. Aunque podamos hacer los programas de formas distintas, no todas ellas son correctas, lo difícil no es programar orientado a objetos sino programar bien.
La gran diferencia entre lenguajes orientados y no orientados a objetos Los lenguajes de programación tradicionales no orientados a objetos, como C, Pascal, BASIC, o Modula-2, basan su funcionamiento en el concepto de procedimiento o función. Una función es simplemente un conjunto de instrucciones que operan sobre una sucesión de llamadas a funciones, ya sean éstas del propio lenguaje, o desarrolladas por el mismo usuario. En un lenguaje orientado a objetos, toda entidad del problema se expresa a través del concepto de objetos. Los objetos son la idea central detrás de la POO. Ya no pensaremos en términos de estructuras, paquetes de datos, invocaciones a funciones, punteros; en cambio, pensamos típicamente en términos de objetos.
P á g i n a | 17
La mayoría de los lenguajes orientados a objetos tienen dos tipos distintos: aquellos tipos que son intrínsecos al lenguaje (tipos primitivos) y los tipos que pueden crear los usuarios del lenguaje (clases). Como puede adivinar, los tipos primitivos son normalmente tipos sencillos, como caracteres, cadenas, números, y las clases tienden a ser tipos más elaborados. El tener dos grupos discretos de tipos causa muchos problemas. Un problema se relaciona con la compatibilidad. Por ejemplo, digamos que usted quería tener una colección de ints en un sistema tradicional con estos dos grupos de tipos. Necesitaría crear una clase específicamente para mantener valores de tipo int. Y si quisiera una clase para mantener una colección de doubles, tendría que hacer lo mismo por ese tipo. La razón de estas dos clases distintas es que estos tipos primitivos normalmente no tienen nada en común. No son objetos reales, por eso no derivan de una clase base común. Dicho lo anterior, en lenguajes orientado a objetos (como es el caso de C++, Smalltalk, Objective C, C# y Java), el elemento básico no es la función, sino un ente denominado precisamente objeto.
¿Qué es un objeto? Un objeto es un conjunto de variables, atributos (o datos) y métodos (o funciones) relacionados entre sí. En primer lugar, un objeto no es un dato simple, sino que contiene en su interior cierto número de componentes bien estructurados. Por lo tanto, un objeto es la representación en un programa de un concepto, y contiene toda la información necesaria para abstraerlo: datos que describen sus atributos y operaciones que pueden realizarse sobre los mismos. Es una estructura con datos y métodos que manipulan los datos.
P á g i n a | 18
La idea de objeto es similar a la del mundo real: un objeto puede ser una silla, una mesa, un auto. Tu perro es un objeto. Vamos a basarnos en ejemplos cotidianos hasta elementales para entender mejor el concepto de objetos. Los objetos tienen dos características: estado y comportamiento. Por ejemplo un perro tiene un estado: nombre, color, raza, altura, y un comportamiento: ladrar, cavar, llorar, dormir, etc. Un auto es un objeto, ya que también tiene un estado: cantidad de puertas, color, tamaño, modelo, etc. y un comportamiento: acelerar, frenar, subir cambio, bajar cambio, girar izquierda, girar derecha, etc. Entonces podemos decir fácilmente ahora que un objeto es como un conjunto de datos o características y funciones relacionadas. A las funciones de los objetos (tales como acelerar en el caso del auto) de aquí en adelante las llamaremos métodos y a los datos los llamaremos atributos. Un ejemplo mas complicado de un objeto podría ser el siguiente:
Objeto: cuenta bancaria.
Atributos(datos): tipo, titular, saldo
Métodos (funciones): depositar, extraer.
La figura 1 muestra una representación visual de un objeto.
P á g i n a | 19 Fig. 1: Representación de un objeto
Los atributos del objeto (estado) y los métodos del objeto (comportamiento) están expresados por las variables (nombre y tipo) y las funciones que componen el objeto respectivamente. Cabe mencionar que el valor concreto de un atributo (dato o propiedad) de un objeto se llama estado. Para acceder a un estado de un objeto para ver su valor o cambiarlo se utiliza el operador punto. Por ejemplo: miCoche.color = rojo El objeto es miCoche, luego colocamos el operador punto y por último el nombre e la propiedad a la que deseamos acceder. En este ejemplo estamos cambiando el valor del estado de la propiedad del objeto a rojo con una simple asignación.
Un ejemplo de una bicicleta tomada como objeto seria como especifica la figura 2:
Bicicleta modelada como un objeto Atributos: * Velocidad * Cadencia * Marcha Métodos: * Cambiar marcha Fig. 2: Bicicleta como objeto
* Frenar * Cambiar cadencia
P á g i n a | 20
Recordar: Cuando se dice ATRIBUTOS se hace mención al dato concreto, cuando hablamos de METODOS nos referimos a las funciones que puede realizar el objeto.
¿Qué es un mensaje?
Normalmente, un único objeto por sí solo no es muy útil. En general, un objeto aparece como un componente más de un programa o una aplicación que contiene otros muchos objetos más. Es precisamente haciendo uso de esta interacción como los programadores consiguen una funcionalidad de mayor orden y modelar comportamientos mucho más complejos. Por si sola, la bicicleta (por poner una bicicleta en concreto) es incapaz de desarrollar una actividad. La bicicleta es realmente útil en tanto que otro objeto (persona) interactúa con ella (pedalea). La interacción entre objetos se produce mediante mensajes. Los mensajes son llamados a métodos de un objeto en particular. Cuando un objeto A quiere que otro objeto B ejecute una de sus funciones (métodos de B), el objeto A manda un mensaje al objeto B.
Fig. 3: Objeto A manda mensaje al objeto B a través de mensaje.
P á g i n a | 21
En ocasiones, el objeto que recibe el mensaje necesita más información para saber exactamente lo que tiene que hacer. Esta información se pasa junto con el mensaje en forma de parámetro. Ahora podemos marcar los tres puntos principales del mensaje.
El objeto al cual se envía el mensaje.
El método que debe ejecutar.
Los parámetros que necesita ese método. Ejemplificando nuevamente con la bicicleta; el objeto A manda el
mensaje de cambiar de marcha pero falta información aquí, que es a cual marcha debe cambiar (parámetro) y luego envía este mensaje al objeto B. La siguiente figura muestra las tres partes que componen un mensaje mediante un ejemplo:
Fig. 4: El objeto “persona (Tú)” manda el mensaje”cambiardemarcha” con el parámetro “marcha” al objeto”bicicleta (Túbicicleta)”
Con estas tres partes (objeto destinatario, método y parámetros) el mensaje es óptimo para que el objeto que recibe el mensaje ejecute el método. Cabe destacar dos ventajas importantes que los mensajes ofrecen: 1) El comportamiento de un objeto está completamente determinado (a excepción del acceso directo a variables miembro
P á g i n a | 22
públicas) por sus métodos, así que los mensajes representan todas las posibles interacciones que pueden realizarse entre objetos. 2) Los objetos no necesitan formar parte del mismo proceso, ni siquiera residir en un mismo ordenador para mandarse mensajes entre ellos (y de esta forma interactuar).
Las palabras "clase" y "objeto" se usan tanto en la programación orientada a objetos que resulta muy fácil confundir los términos y suelen causar diversas dudas a la hora de lograr definir ambas cosas. Existen varios objetos de un mismo tipo, o como diremos enseguida, de una misma clase. Por ejemplo, una bicicleta es una de las muchas bicicletas que existen en el mundo. Usando la terminología de la programación orientada a objetos, diremos que una bicicleta es una instancia de la clase de objetos conocida como bicicletas. Todas las bicicletas tienen algunos estados o atributos (color, marcha actual, cadencia actual, dos ruedas) y algunos métodos (cambiar de marcha, frenar) en común. Sin embargo, el estado particular de cada bicicleta es independiente del estado de las demás bicicletas. La particularización de estos atributos puede ser diferente. Es decir, una bicicleta podrá ser azul, y otra roja, pero ambas tienen en común el hecho de tener una variable “color”. De este modo podemos definir una plantilla de variables y métodos para todas las bicicletas. Las plantillas para crear objetos son denominadas clases.
¿Qué es una clase? Cuando programamos un objeto y definimos sus características y funcionalidades en realidad lo que estamos haciendo es programar una clase. Una clase es una plantilla que define las variables y los métodos que son comunes para todos los objetos de un cierto tipo.
P á g i n a | 23
En nuestro ejemplo, la clase bicicleta definiría variables miembro o atributos comunes a todas las bicicletas, como la marcha actual, la cadencia actual, etc. Esta clase también debe declarar e implementar los métodos o funciones miembro que permiten al ciclista cambiar de marcha, frenar, y cambiar la cadencia de pedaleo, como se muestra en la siguiente figura:
Fig. 5: Definición de la clase “bicicleta”
Después de haber creado la clase bicicleta, podemos crear cualquier número de objetos bicicleta a partir de la clase. Cuando creamos una instancia de una clase, el sistema reserva suficiente memoria para el objeto con todas sus variables miembro. Cada instancia tiene su propia copia de las variables miembro definidas en la clase.
Fig. 6: Objetos o instancias de la clase “bicicletas”
P á g i n a | 24
Una clase en C++ podría ser definida como se muestra a continuación:
class Aritmetica { public: inline int sumar (int a, int b) const { return a + b; } inline int restar (int a, int b) const { return a - b; } inline float multiplicar (int a, int b) const { return a * b; } inline float dividir (int a, int b) const { return a / b; }};
LOS TRES PRINCIPIOS DE LOS LENGUAJES ORIENTADOS A OBJETOS Según Bjarne Stroustrup, autor del lenguaje de programación C++, para que un lenguaje se llame a sí mismo orientado a objetos debe soportar tres conceptos: objetos, clases y herencia. Sin embargo, ha llegado a pensarse más comúnmente que los lenguajes orientados objetos son lenguajes construidos sobre el trípode encapsulación, herencia y polimorfismo. La razón de este cambio de filosofía es que con el paso de los años hemos llegado a darnos cuenta que la encapsulación y el
P á g i n a | 25
polimorfismo son partes tan integrantes de la construcción de sistemas orientados a objetos como la clases y la herencia.
Encapsulación Como ya mencionamos anteriormente, la encapsulación, a veces llamada ocultación de la información, es la capacidad de ocultar los procesos internos de un objeto a sus usuarios y proporcionar una interfaz para los miembros que quiera que el cliente tenga posibilidad de manipular directamente. Es básicamente, el hecho de empaquetar juntos datos y funcionalidad, dejando visible al exterior solo lo estrictamente necesario. Sin embargo, también hablamos de abstracción en el mismo contexto, por eso en esta sección aclararemos cualquier confusión relacionada con estos dos conceptos tan parecidos. La encapsulación proporciona el vínculo entre la interfaz externa de una clase -esto es, los miembros públicos visibles a los usuarios de la clase- y sus detalles de implementación interna. La ventaja de la encapsulación para el desarrollador de la clase es que puede exponer los miembros de una clase que quedaran estáticos, o inamovibles, mientras se ocultan los procesos internos más volátiles y dinámicos.
Herencia La herencia sirve para crear objetos que incorporen propiedades y métodos de otros objetos. Así podremos construir unos objetos a partir de otros sin tener que reescribirlo todo. Mediante esta técnica, se pueden crear (o derivar de otra) nuevas clases a partir de alguna anterior, de forma que las nuevas "heredan" las características de sus ancestros (propiedades y métodos). Entonces puede modificar la clase de la manera que quiera y crear objetos nuevos del tipo derivado. Esta habilidad es la esencia de la creación de una jerarquía de clases (del mismo aspecto que el árbol genealógico de una familia).
P á g i n a | 26
Es una herramienta clave para abordar la resolución de un problema de forma organizada, pues permite definir una relación jerárquica entre todos los conceptos que se están manejando. Por ejemplo, entendemos que un motor eléctrico deriva de la clase general de los motores, de la cual derivan también los de gasolina, diesel, vapor, etc. y que, sin dejar de ser motores, cada subclase tiene sus características peculiares. La herencia proporciona las siguientes ventajas:
Las clases derivadas o subclases proporcionan comportamientos especializados a partir de los elementos comunes que hereda de la clase base. A través del mecanismo de herencia los programadores pueden reutilizar el código de la superclase tantas veces como sea necesario.
Los programadores pueden implementar las llamadas superclases abstractas, que definen comportamientos genéricos. Las clases abstractas definen e implementan parcialmente comportamientos, pero gran parte de estos comportamientos no se definen ni se implementan totalmente. De esta forma, otros programadores pueden hacer uso de estas superclases detallando esos comportamientos con subclases especializadas. El propósito de una clase abstracta es servir de modelo base para la creación de otras clases derivadas, pero cuya implantación depende de las características particulares de cada una de ellas. Un ejemplo de clase abstracta podría ser en nuestro caso la clase vehículos. Esta clase sería una clase base genérica, a partir de la cual podríamos ir creando todo tipo de clases derivadas. Como lo que principalmente interesa al usuario de una clase es su
interfaz, son justamente algunos aspectos de esta interfaz los que se modifican, al objeto de adecuar la nueva subclase a las necesidades específicas del caso. Por lo general esta modificación de la interfaz se consigue de dos formas:
P á g i n a | 27
1. Añadiendo propiedades y/o métodos que no existían en la clase base
2. Sobrescribiendo propiedades del mismo nombre con distintos comportamientos (sobrecarga y/o polimorfismo).
Polimorfismo Una de las características fundamentales de la POO es el polimorfismo, que no es otra cosa que la posibilidad de construir varios métodos (funciones) con el mismo nombre, pero con relación a la clase a la que pertenece cada uno, con comportamientos diferentes. Dicho de simple manera, el polimorfismo sirve para que no tengamos que preocuparnos sobre lo que estamos trabajando, y abstraernos para definir un código que sea compatible con objetos de varios tipos. Esto conlleva la habilidad de enviar un mismo mensaje a objetos de clases diferentes. Estos objetos recibirían el mismo mensaje global pero responderían a él de formas diferentes; por ejemplo, un mensaje "+" a un objeto ENTERO significaría suma, mientras que para un objeto STRING significaría concatenación ("pegar" strings uno seguido al otro).
También es necesario definir un principio extra, pero no es tomado como fundamental a fin de mejores efectos prácticos
Otras características extras
ABSTRACCIÓN Denota las características esenciales de un objeto, donde se capturan sus comportamientos. Cada objeto en el sistema sirve como modelo de un "agente" abstracto que puede realizar trabajo, informar y cambiar su estado, y "comunicarse" con otros objetos en el sistema sin revelar cómo se implementan estas características. Los procesos, las funciones o los métodos pueden también ser abstraídos y cuando lo están, una variedad de técnicas son requeridas para ampliar una abstracción. El proceso de abstracción permite seleccionar las características relevantes dentro de un
P á g i n a | 28
conjunto e identificar comportamientos comunes para definir nuevos tipos de entidades en el mundo real. La abstracción es clave en el proceso de análisis y diseño orientado a objetos, ya que mediante ella podemos llegar a armar un conjunto de clases que permitan modelar la realidad o el problema que se quiere atacar.
SOBRECARGA Posibilidad de crear diferentes métodos dentro de una clase que comparten el mismo nombre, pero que aceptan argumentos diferentes y se comporten de forma distinta según la naturaleza de estos argumentos.
RECOLECCIÓN
DE BASURA
La recolección de basura o garbage collector es la técnica por la cual el entorno de objetos se encarga de destruir automáticamente, y por tanto desvincular la memoria asociada, los objetos que hayan quedado sin ninguna referencia a ellos. Esto significa que el programador no debe preocuparse por la asignación o liberación de memoria, ya que el entorno la asignará al crear un nuevo objeto y la liberará cuando nadie lo esté usando. En la mayoría de los lenguajes híbridos que se extendieron para soportar el Paradigma de Programación Orientada a Objetos como C++ u Object Pascal, esta característica no existe y la memoria debe desasignarse manualmente.
ALGUNOS LENGUAJES BASADOS EN POO Smalltalk Smalltalk es un lenguaje de programación que permite realizar tareas de computación mediante la interacción con un entorno de objetos virtuales e incluye todos los conceptos claves, como clases, métodos, mensajes y herencia. Todo el programa es una cadena de mensajes enviados a objetos. Metafóricamente, se puede considerar que un Smalltalk es un mundo virtual donde viven objetos que se comunican mediante el envío de mensajes
P á g i n a | 29
Todo en Smalltalk es un objeto y toda la computación es desarrollada mediante mensajes que son enviados entre los objetos. El trabajo más fuerte se hizo en los años 70, bajo el impulso de Alan Kay en los laboratorios Xerox PARC (Palo Alto Research Center): fue desarrollado en períodos de 3 o 4 años de duración usando la información y el aprendizaje obtenido en la iteración anterior para hacer un nuevo Smalltalk. Esto produjo el Smalltalk/72, Smalltalk/76 y el Smalltalk/80. Este último es el más conocido y el que suele ser llamado Smalltalk a secas. F Fue públicamente disponible a partir de 1980 y se puede asegurar que ha influido especialmente a Objective-C, Java, Self, Python, Ruby, AppleScript. Inicialmente debía ser un lenguaje para un ordenador personal llamado Dynabook dirigido a todo tipo de usuarios, incluyendo niños. Debía ser, por tanto, un sistema con un entorno intuitivo y fácil de programar. Aunque el proyecto Dynabook nunca se completó, el lenguaje tomó vida propia y continuó su camino. Es poco conocida la gran importancia que tuvo este desarrollo en la evolución posterior de la informática. De él parten muchas de las ideas de las modernas interfaces de usuario, como el uso de gráficos, ratón, ventanas y menúes desplegables. Un sistema Smalltalk esta compuesto por:
Máquina virtual Imagen virtual que contiene todos los objetos del sistema
Lenguaje de programación (también conocido como Smalltalk)
Biblioteca de Objetos reusables
Opcionalmente un entorno de desarrollo que funciona como un sistema en tiempo de ejecución.
ADAPTACIONES
DE
SMALLTALK
F-script es un lenguaje de script basado en Smalltalk diseñado para el
P á g i n a | 30
sistema de objetos de MacOS X (Cocoa). GNU Smalltalk es una implementación de Smalltalk-80 que funciona en la mayoría de los sistemas Unix. También hay una versión para MS-NT (sic. Será Windows NT, supongo). Little Smalltalk es una implementación mínima experimental que requiere muy poca memoria. Carece de rasgos importantes, como gráficos y una interfaz convencional. Fue la primera versión escrita fuera de Xerox Parc. Smalltalk/X es una implementación completa del lenguaje de programación y entorno de desarrollo Smalltalk. Hay versiones para Windows y varios tipos de Unix (incluyendo Linux). SmallWord es un intérprete de dominio público de Little Smalltalk escrito completamente en Java por el mismo autor. Spoon es un sistema mínimo derivado de Squeak. Squeak es un sistema gratuito y de código abierto con licencia Apple en cuyo desarrollo toman parte los mismísimos «padres» de Smalltalk, Alan Kay y Dan Ingalls. Hay versiones para Windows, Unix, Macintosh y otras plataformas. Sharp Smalltalk es una implementación de Smalltalk para ejecutarse nativamente en entorno .NET. Strongtalk es una revisión del lenguaje y sistema Smalltalk-80. Desarrollado a mediados de los 90 por LongView, una empresa posteriormente absorbida por Sun. Parece que sólo se distribuye para Windows. Talks2 es un completo entorno de desarrollo Smalltalk. Se ejecuta encima de la Máquina Virtual Java
Objective C ¿QUE ES OBJETIVE C?
P á g i n a | 31
Al igual que C++, Objective-C es una extensión de C para hacerlo orientado a objetos, pero a diferencia de C++, este leguaje está basado en ideas del mundo de Smalltalk, lo cual hace que Objective-C sea un lenguaje más limpio, pequeño y rápido de aprender que C++. Pero sin embargo Objective-C es un lenguaje mucho menos usado en cierta forma que el C++. El mundo de Mac OS X es quizá una excepción a esta regla debido a que Objective-C es el lenguaje para programar en Cocoa, la nueva API orientada a objetos de Mac OS X que tiene como objetivo mejorar la antigua API de programación de Carbon. A diferencia de otros lenguajes de las GCC, Objective-C no ha sido estandarizado por ningún organismo internacional, sino que fue NeXTSTEP, y ahora Mac OS X quienes han contribuido a crear este lenguaje. NeXT, la empresa que creó NeXTSTEP cedió la implementación de Objective-C a las GCC, y ambos están trabajando en mantener y mejorar el lenguaje. Debido a que Objective-C es una extensión de C compartible hacia atrás, muchas de las características de la sintaxis de C han sido heredadas por Objective-C, entre ellas: Sentencias de control de flujo. Los tipos de datos fundamentales, estructuras y punteros. Conversiones implícitas y explicitas entre tipos. Los ámbitos de las variables: Globales, estadísticas y locales. Las funciones y su sintaxis. Las directivas del preprocesador, aunque Objective-C añade más directivas del procesador, ya también añade las llamadas directivas del compilador.
P á g i n a | 32
Vale aclarar que los ficheros de código fuente de Objective-C tienen extensión .m, y en ellos podemos usar tanto la sintaxis de C como la de Objective-C. Las GCC cuyo significado es GNU C Compiler (compilador GNU para C), porque sólo compilaba el lenguaje C. Posteriormente se extendió para compilar C++, Fortran, Ada y otros, llamándose a la versión como GCC 2.95, que compila Objective-C++, que no es más que la combinación de Objective-C más C++. Los ficheros de Objective-C++ se caracterizan por tener la extensión .mm o .M.
CARACTERISTICAS DEL LENGUAJE : LENGUAJE DINÁMICO: Muchas decisiones que muchos lenguajes toman en tiempo de compilación, Objective-C las deja para el tiempo de ejecución. La gran ventaja de esta característica, son las herramientas de desarrollo, donde estas tienen acceso a todo runtime del programa, esto quiere decir que las herramientas de desarrollo pueden instanciar los objetos del programa, representarlos visualmente, personalizarlos, monitorizarlos y permite depurarlos de manera mas cómoda para el programador. Los tipos de dinamismo que diferencian Objective-C de otros tipos de lenguaje son los siguientes: MEMORIA DINAMICA: En los primeros lenguajes la cantidad de memoria que usaba un programa quedaba fijada durante su compilación durante su compilación. Con el tiempo los lenguajes comenzaron a ser conscientes de la importancia de que un programa pudiera decidir en tiempo de ejecución la cantidad de memoria que quería reservar. Por ejemplo C introdujo la función malloc() para reservar memoria dinámicamente.
P á g i n a | 33
TIPOS DINAMICOS: Asociar un tipo a una variable es una muy buena idea ya que ayuda al compilador a identificar errores de codificación. Por ejemplo mucho lenguajes no permiten asignar directamente cadenas a números (debido a que la cadena podría no contener un redondeo) Además la tipificación de los objetos le permite al compilador informar al programador de que está intentando acceder a un método o variable de instancia que no existe en el objeto. La tipificación de variables puede ser de dos tipos: TIPIFICACION ESTÁTICA, que se produce cuando es el compilador quien lleva la cuenta de los tipos de las variables para identificar errores, y TIPIFICACION DINAMICA, que se da cuando es el runtime del lenguaje el que en un tiempo de ejecución detecta y usa el tipo de las variables INTROSPECCION: Esta característica la tienen solo algunos lenguajes – como Objective-C o Java – de observar y manipular como datos el estado de su ejecución. Con la introspección podemos preguntar el tiempo de ejecución a un objeto, cosas como: A que clase pertenece, de que clase deriva, que métodos tiene, etc. ENLACE DINAMICO: Los lenguajes orientados a objeto reemplazan el concepto de llamada a función por el envió de mensajes. La diferencia radica en que el mismo mensaje puede ejecutar diferentes funciones dependiendo del objeto que reciba el mensaje. A esta capacidad que tienen los objetos de responder al mismo mensaje de distinta forma es a lo que se ha enviado a llamar POLIMORFISMO. CARGA DINÁMICA: Es una característica que pertenece a algunos lenguajes como Java u Objective-C, consiste en poder cargar solo un conjunto básico de clases al empezar el programa, y luego, en función de la evolución del flujo de programa ir cargando las clases de nuevos objetos que se necesiten instanciar. Para instanciar a un objeto, debemos llamar a los métodos alloc e init.
P á g i n a | 34
o
alloc: Sería el equivalente a new en Java o C++; reserva
memoria dinámica y pone a cero todas las variables de instancia del objeto. Es un método de clase Punto* p = [Punto alloc];
o
init: Sería el equivalente al constructor en Java o C++; se
encarga de inicializar las variables de instancia del objeto. Es un método de instancia
p = [p init];
Como ya se ha mencionado anteriormente acerca de la idea base de este tipo de el lenguaje “Objective-C”, el mismo es básicamente un lenguaje de programación diseñado para facilitar la programación orientada a objetos, en otras palabras se definiría como un conjunto de extensiones para el lenguaje ANSI C, teniendo como objetivo principal dotar a C de capacidad de programación orientada a objetos de forma sencilla, a comparación de otros tipos de lenguajes de programación. Cocoa , de API de programación orientada a objetos de Mac OS X tradicionalmente se ha dividido en dos característicos grupos de clases: Foundation framework: Son un conjunto de clases de apoyo que permiten representar estructuras de datos coplejas (entre ellos podemos encontrar a los arrays, listas, direccionarios, entre otros), y dentro de las que no se incluyen las clases relacionadas con la interfaz gráfica. Vale aclarar que esta librería es com{ún a Mac OS y iPhone OS. Application Kit Framework (appKit Framework): Abarca a todas las demas clases, ya sean aquellas clases relacionadas con la interfaz gráfica, con la impresión , acceso directo a audio y video, y todos los demás aspectos que podemos gestionar desde Cocoa. Dentro de AppKit nos podemos encontrar con otros Kit de desarrollo en determinadas tareas como ser: Image Kit , Quick Time, entre otras más. FRAMEWORK (marco) Y RUTIME (tiempo de ejecución)DE OBJECTIVEC:
P á g i n a | 35
Hoy en día para programar en Objective-C disponemos de dos frameworks distintos, ellos son los siguientes: 1.
FRAMEWORK de clases de GNU, que son originalmente un
conjunto de clases iniciales fabricado por NeXTSTEP para Objective-C que fueron abiertas bajo la licencia de GNU, y cuya clase base es la clase sObject. 2.
FRAMEWORK de clases de NeXTSTEP, es un conjunto de clases
desarrollado por el mismo en el año 1994, siendo la clase base inicial NSObject, y que hoy en día es usado por Mac OS X para implementar Cocoa. Como dato extra, se conoce que el código fuente del framework de clases de NeXTSTEP no está abierto. Actualmente el framework de clases GNU ha dejado de actualizarse y GNU también está haciendo una implementación de código fuente abierto del nuevo framework de clases de NeXTSTEP llamado llama GNUStep, vale aclarar que esta ultima utiliza la misma clase base NSObject así como el resto de clases del framework de NeXTSTEP, pero actualmente no está terminada. Para usar el framework de clases de GNU debemos de enlazar con el fichero libobject.a, a través del uso de la opción del enlazador –lobjc.Por el contrario, para enlazar con el framework de clases de NeXTSTEP debemos de enlazar con el framework Foundation.framework usando la opción del enlazador framework Foundation. Lógicamente podemos enlazar con ambos frameworks de clases usando ambas opciones durante el enlazado. Es importante no confundir los frameworks de Objective-C, que son librerías de clases, con el runtime de Objective-C, que es un conjunto de funciones de librería, escritas en C, en las que se basan las clases de Objective-C para alcanzar el máximo potencial característico de este lenguaje: Mac OS X se usa el runtime de NeXTSTEP, el cual actualmente da soporte al framework de clases de GNU, como al framework de clases de NeXTSTEP. Podemos pedir usar el runtime de GNU usando la opción del enlazador – fgnu – runtime, pero en este caso sólo tendremos acceso al
P á g i n a | 36
framework de clases de GNU, y además deberemos enlazar con la librería llamada libobjc – gnu.a usando la opción –lobjc – gnu. A continuación se describirá el método de programación en ambas clases: A.
PROGRAMAR CON EL FRAMEWORK DE CLASES DE GNU:
Normalmente cada clase Objective-C consta de dos ficheros: Uno con la extensión “.h” que contiene la interfaz, y otro con la extensión “.m” que contiene la implementación, debajo se mostrará un ejemplo de interfaz e implementación de una clase Objective-C llamada Saludos. Debemos tener en cuenta que estamos usando como clase base la clase Object situada en el fichero de cabecera . /* Saludos.h */ #import @interface Saludos: Object { Char* saludo: } - Init; - (void)setsaludo: (char*) un saludo; - (void)setsaludo: (char*) un saludo y: (char*) una coletilla; - (void)saluda; @end
/* Saludos.m */ #import “Saludos.h” #import
P á g i n a | 37
#import #import @ implementación Saludos - Init { If (self=[super init]) { Saludo=”Hola mundo”; } return self; } - (void) setSaludo: (char*) un saludo { Saludo=unSaludo; } - (void) setSaludo: (char*) unsaludo y: (char*) unacoletilla { Saludo=malloc (strlen (unsaludo)+strlen (unacoletilla)+1); Strcpy (saludo, unsaludo); Stracat (saludo, unacoletilla); } - (void) saluda { Printf(“%s\n”, saludo); } @end
P á g i n a | 38
Una vez que tengamos definida la clase, para instanciar y usar un objeto de esta clase, necesitamos un programa principal como el siguiente: /* pidesaludo.m */ #import “saludador.h”
Int main() { Saludador*s=[[saludador alloc] init]; [s saluda]; [s setsaludo: “hola de nuevo”]; [s saluda]; [s setsaludo: “hola buenos días,” Y: “encantado de verle”]; [s saluda]; [s free]; Return EXIT_SUCCESS; } Al estar usando el framework de clases de GNU, el programa puede ser compilado y enlazado con los comandos: $ GCC –C Saludos.m $ GCC –C pidesaludo.m $ GCC Saludos.o pidesaludos.o –lobjc –o pidesaludo
O bien realizar los tres pasos a la vez con el comando:
P á g i n a | 39
$ GCC pidesaludo.m saludo.m –lobjc –o pidesaludo B.
PROGRAMAR CON EL FRAMEWORK DE CLASES DE NeXTSTEP
A continuación se mostrarán unos ejemplos de cómo usar e implementar la clase Saludos del apartado anterior enlazando con el framework de clases de NeXTSTEP. La principal diferencia está en que ahora derivamos de NSObject en ves de Object. La segunda diferencia está en qie importamos el fichero en vez de importar el fichero . Para compilar y ejecutar ahora el programa podemos usar los comandos: $ GCC Saludator.m pidesaludo.m – framework Foundation – o pidesaludo $ ./pidesaludo
/* saludo */ #import @interface Saludo:NSObject { Char* saludo; } -init; -(void) setsaludo(char*)unsaludo; -(void) setsaludo(char*) unsaludo y(char*)unacoletilla; -(void) saluda; @end
P á g i n a | 40
*/ saludo */ #import “saludo.h” #import #import #import @implementacion saludos -init { If (self=[super init]) { Saludo=”hola mundo”; } Return self; } -(void) setsaludo:(char*)unsaludo { Saludo=unsaludo; } -(void) setsaludo:(char*) unsaludo y: (char*) unacoletilla { Saludo=malloc (strelen(unsaludo)+strlen(unacoletilla)+1); Strcpy (saludo, unsaludo); Strcat (saludo, unacoletilla); } -(void) saluda { printf (“%s\n”, saludo); }
P á g i n a | 41
@end
/* pidesaludo.m */ #import “saludos.h” Int main()
{
Saludos*s=[[saludos alloc]init]; [s saluda]; [s setsaludo: “hola de nuevo”]; [s saluda]; [s setsaludo: “hola buenos días,” Y: “encantado de verle”]; [s saluda]; [s release]; Return EXIT_SUCCESS; }
COMPILADOR El compilador a usar en este lenguaje será el GCC (GNU Compiler Collection), es escencialmente un conjunto de herramientas que proporciona GNU para programar en varios lenguajes y plataformas. Mac OS X y IPhone OS se apoyan en estas herramientas para realizar las tareas de compilación y enlazado de sus correspondientes aplicaciones.
COMPILANDO CON XCODE : Con el objetivo de mejorar tanto la productividad como la facilidad de uso de estas herramientas Apple creó Xcode, este es un IDE (Integrader Development
P á g i n a | 42 Environment) que permite realizar de forma gráfica las tareas comunes de programación, y que hace las correspondientes llamadas a las GCC para realizar las tareas características de compilación y enlazado de forma transparente al programador. XCODE, incluye la creación de compiladores del proyecto GNU (GCC), y puede compilar código C,C++, Objective-C, Objective-C++, Java y Apple Script, mediante una amplia gama de modelos de programación entre los más destacados Cocoa, Carbón y Java.
Se puede afirmar que Xcode mejora la productividad del programador en forma considerable.
CREAR UN EJECUTABLE: Como aclaramos anteriormente que Objective-C es una extensión al lenguaje C, entonces un programa en C se puede compilar en Objective-C sin la necesidad de efectuar ningún cambio. Debemos aclarar que solo se deben llevar a cabo dos cambios, un programa de Objective-C usa la sintaxis de C excepto por dos aspectos, ellos son los siguientes: El primer aspecto es que en vez de usar la directiva del procesador #include se ha usado la directiva del procesador #import. Ambas directivas realizan la operación de incluir un fichero dentro de otro fichero, pero a diferencia de #include la directiva #import asegura que el fichero incluido no se incluya nunca más de una vez, con lo que en los ficheros de cabecera incluidos nunca ás incluidos con esta directiva no es necesario hacer un control de inclusiones. Con la directiva del procesador #ifdef, tal como se acostumbra a hacer en C y C++. La otra direncia radica en que está en que la extensión de los ficheros Objective-C es .m, extensión usada por el comando GCC para saber que se trata de un programa en Objective-C. /* holamundo.m */ #import #import Int main()
P á g i n a | 43 { Printf(“hola mundo desde Objective-C\n”); Return EXIT_SUCCESS; } Para compilar y ejecutar este programa bastaría con ejecutar los comandos: $ GCC hola mundo.m -o holamundo $ ./holamundo Hola desde Objective-C
CUADRO
COMPARATIVO DE
Características Directiva del prepreprocesador En cadenas Compilador Archivo Herramienta gráfica
C
Y
OBJECTIVE C
Lenguaje C #include
Lenguaje Objective C #import
#ifdef Char * Turbo C, entre
#ifdef NSString GCC
otros .c
.h(interface)
No tiene
.m(implementación) X Code
C++ C++ es un lenguaje de programación diseñado a mediados de los años 1980 por Bjarne Stroustrup. La intención de su creación fue el extender al exitoso lenguaje de programación C con mecanismos que permitan la manipulación de objetos.
P á g i n a | 44
Al comienzo era una extensión del lenguaje C que fue denominada C with classes. El nombre C++ es también de ese año, y hace referencia al carácter del operador incremento de C (++), que significa “incremento de C”. En la actualidad, el C++ es un lenguaje versátil, potente y general. Su éxito entre los programadores profesionales le ha llevado a ocupar el primer puesto como herramienta de desarrollo de aplicaciones. El C++ mantiene las ventajas del C en cuanto a riqueza de operadores y expresiones, flexibilidad, concisión y eficiencia. Además, ha eliminado algunas de las dificultades y limitaciones del C original. La evolución de C++ ha continuado con la aparición de Java, un lenguaje creado simplificando algunas cosas de C++ y añadiendo otras, que se utiliza para realizar aplicaciones en Internet. Hay que señalar que el C++ ha influido en algunos puntos muy importantes del ANSI C, como por ejemplo en la forma de declarar las funciones, en los punteros a void, etc. En efecto, aunque el C++ es posterior al C, sus primeras versiones son anteriores al ANSI C, y algunas de las mejoras de éste fueron tomadas del C++. Un ejemplo de programación en C++(Hola mundo) es como el siguiente ejemplo: # include // Este header permite usar los objetos que encapsulan los descriptores stdout y stdin: cout(<<) y cin(>>)// using namespace std; int main() { cout << "Hola mundo" << endl; return 0;
TIPOS
DE DATOS
C++ tiene los siguientes tipos fundamentales:
Caracteres: char (también es un entero), wchar_t
Enteros: short int, int, long int, long long int
P á g i n a | 45
Números en coma flotante: float, double, long double
Booleanos: bool
Vacío: void
El modificador unsigned se puede aplicar a enteros para obtener números sin signo (por omisión los enteros contienen signo), con lo que se consigue un rango mayor de números naturales. Tipo Char Short Int Float Doublé
UN
Número de bits 8 16 32 32 64
EJEMPLO DE UNA CLASE EN
C++:
class Punto { //por omisión los miembros son 'private' para que sólo se puedan modificar desde la propia clase.// private: // Variable miembro privada int id; protected: // Variables miembro protegidas int x; int y; public: // Constructor Punto(); // Destructor ~Punto(); // Funciones miembro o métodos int ObtenerX(); int ObtenerY(); };
C# C♯ o C# (pronunciado si sharp en inglés) es un lenguaje de programación orientado a objetos desarrollado y estandarizado por Microsoft como parte de su plataforma .NET
P á g i n a | 46
Anders Hejlsberg lideró el proyecto de desarrollo de C#, el cual apareció en el mercado en el año 2001. Anteriormente, ya participó en el desarrollo de otros lenguajes como Turbo Pascal, J++ y Borland Delphi. Este lenguaje fue fuertemente influido por Java, C++, Lenguaje C, Delphi, Eiffel. La creación del nombre del lenguaje, C♯, proviene de dibujar dos signos positivos encima de los dos signos positivos de "C++", queriendo dar una imagen de salto evolutivo, del mismo modo que ocurrió con el paso de C a C++.
INSTRUCCIONES
DE CONTROL
La instrucción if-else es básicamente igual que en C, C++ y Java.
La diferencia de la instrucción switch con la versión de C, C++ y Java es que todo cuerpo perteneciente a un case debe de toparse con un break o un goto antes de toparse con otro case, a menos que dicho cuerpo esté vacío.
La instrucción for es básicamente igual que en C, C++ y Java.
La instrucción while es básicamente igual que en C, C++ y Java.
La instrucción do-while es básicamente igual que en C, C++ y Java.
La instrucción foreach realiza un ciclo a través de los elementos de una colección (grupo de objetos). El formato de esta instrucción es: foreach(tipo variable in coleccion) instruccion;. En este ciclo se recorre la colección y la variable recibe un respectivo elemento de dicha colección en cada iteración.
Al igual que en C y C++, la instrucción break permite forzar la salida de un ciclo omitiendo el código restante en el cuerpo del ciclo.
Al igual que en C y C++, la instrucción continue permite forzar la repetición temprana de un ciclo omitiendo el código restante en el cuerpo del ciclo.
P á g i n a | 47
La instrucción return es básicamente igual que en C, C++. Se
utiliza para devolver un valor y salir de un método. La instrucción goto se sigue utilizando en C♯ a pesar de toda la
polémica que esto conlleva.
Una clase en C# seria como se detalla a continuación: class Coche { public Coche(string marca, string modelo, string color, string numbastidor) { this.Marca=marca; this.Modelo=modelo; this.Color=color; this.NumBastidor=numbastidor; }
public double Velocidad { get { return this.velocidad;
P á g i n a | 48
} }
protected double velocidad=0; public string Marca; public string Modelo; public string Color; public string NumBastidor;
public void Acelerar(double cantidad) { // Aquí se le dice al motor que aumente las revoluciones pertinentes, y... Console.WriteLine("Incrementando la velocidad en {0} km/h", cantidad); this.velocidad += cantidad; }
public void Girar(double cantidad) { // Aquí iría el código para girar
P á g i n a | 49
Console.WriteLine("Girando el coche {0} grados", cantidad); }
public void Frenar(double cantidad) { // Aquí se le dice a los frenos que actúen, y... Console.WriteLine("Reduciendo la velocidad en {0} km/h", cantidad); this.velocidad -= cantidad;
METAS
DEL DISEÑO DEL LENGUAJE
El estándar ECMA lista las siguientes metas en el diseño para C♯:
Lenguaje de programación orientado a objetos simple, moderno y de propósito general.
Inclusión de principios de ingeniería de software tales como revisión estricta de los tipos de datos, revisión de límites de vectores, detección de intentos de usar variables no inicializadas, y recolección de basura automática.
Capacidad para desarrollar componentes de software que se puedan usar en ambientes distribuidos.
Portabilidad del código fuente
Fácil migración del programador al nuevo lenguaje, especialmente para programadores familiarizados con C y C++.
Soporte para internacionalización
P á g i n a | 50
Adecuación para escribir aplicaciones de cualquier tamaño: desde las más grandes y sofisticadas como sistemas operativos hasta las más pequeñas funciones.
Aplicaciones económicas en cuanto a memoria y procesado.
COMPILADORES En la actualidad existen los siguientes compiladores para el lenguaje C♯:
Microsoft.NET framework SDK incluye un compilador de C♯, pero no un IDE.
Microsoft Visual Studio, IDE por excelencia de este lenguaje, versión 2002, 2003, 2005, 2008 y 2010.
#develop, es un IDE libre para C♯ bajo licencia LGPL, muy similar a Microsoft Visual C#.
Mono, es una implementación GPL de todo el entorno .NET desarrollado por Novell. Como parte de esta implementación se incluye un compilador de C♯.
Delphi 2006, de Borland Software Corporation.
dotGNU Portable.NET, de la Free Software Foundation.
CADENAS
DE CARACTERES
El tipo de dato cadena se llama string.
Realmente la palabra clave string es un alias de la clase System.String de la plataforma .NET.
En C♯ las cadenas son objetos y no una matriz de caracteres, aun así, se puede obtener un carácter arbitrario de una cadena por medio de su índice (mas no modificarlo).
P á g i n a | 51
La forma más común de construir una cadena es por medio de una literal o constante: string str = "Una cadena";
El operador == determina si dos referencias hacen referencia al mismo objeto, pero al usar dicho operador con dos operandos tipo string se prueba la igualdad del contenido de las cadenas y no su referencia. Sin embargo, con el resto de los operadores relacionales, como < o >= se comparan las referencias.
Se pueden concatenar (unir) dos cadenas mediante el operador +.
Las cadenas son inmutables, una vez creadas no se pueden modificar, solo se pueden copiar total o parcialmente.
Las cadenas se pueden usar en las instrucciones switch.
CONCLUSIÓN Como hemos leído anteriormente en todas estas paginas, el trabajo consistió en explicitar arduamente todo esta gran forma de programación. Como primera instancia detallamos sobre la base de lo que es la POO, sin dejar de lado las definiciones fundamentales de la misma. Describimos los principios y características básicas de esta programación ya que sobre ellos se forman y se basan todos los lenguajes orientados a objetos; lenguajes que también explicamos y con ellos
P á g i n a | 52
concluimos que todos se basan en las mismas funciones y en la misma interpretación a la hora de resolver un algoritmo en computadora. Vimos que si bien cada lenguaje tiene sus características propias, muchos de ellos fueron influenciados por el lenguaje C y a su vez, cada uno de los mismos lenguajes orientados a objetos, fue una influencia para el siguiente lenguaje orientado a objetos. Todos fueron de alguna u otra forma influenciados (para el autor, motivado) para el desarrollo de otro lenguaje. Los lenguajes orientados a objetos, de los cuales nosotros solo hemos detallados solo 4, son muchos más, solo que hemos dado prioridades e informamos sobre los más principales y los que más se suelen escuchar y relacionar al hablar de POO. De mas estaría escribir sobre todos los demás lenguajes ya que se tornaría más denso y tedioso el trabajo y asi se perdería la finalidad con la que fue creado este trabajo. Considero personalmente que el desarrollo de este trabajo podría considerarlo, de una rígida forma, como una pequeña base introductoria para todo aquél lector que desee informarse y aprender sobre esta distinta forma de pensar y encarar un problema, hasta de la vida cotidiana.
BIBLIOGRAFÍA CONSULTADA
1. IZQUIERDO, Luis R. “Introduccion a la programación orientada a objetos”, Mayo de 2007. 2. ARCHER, Tom. A fondo C, trad. Inside C#, Madrir, España: McGraw-Hill, 2001. 3.
Wikipedia, extraído
art. de
“Programación
orientada
a
objetos”,
http://es.wikipedia.org/wiki/Programaci
%C3%B3n_orientada_a_objetos
P á g i n a | 53
4.
Wikipedia,
art.
“Objetos
(programación)”,
extraído
de
http://es.wikipedia.org/wiki/Objetos_(programaci %C3%B3n_orientada_a_objetos) 5. Diego Goméz, art. “Smalltalk”, extraído de http://swiki.agro.uba.ar/small_land/65 6. Rodoval, art. “Smalltalk” extraido de http://www.rodoval.com/paginalen.php?len=Smalltalk 7. Germán S. Arduino, art. “Intrducción Informal a Smalltalk” extraido de http://www.arsol.net/art/introst/introst.htm 8. MacProgramadores, “El lenguaje Objective-C para programadores C++ y Java”
