desarrollo de aplicaciones para iphone, capitulo 3
DESCRIPTION
Programación en Objetive-CTRANSCRIPT
Desarrollo de aplicaciones para iPhone
3
E_T
exto
(03)
.dot
Programación en Objective-C
DIP
047_
03_V
(02)
1
Unidad didáctica 3
Programación en Objective-C
ÍNDICE
MOTIVACIÓN ..................................................................................................3
PROPÓSITOS ..................................................................................................4
PREPARACIÓN PARA LA UNIDAD.............................................................................5
1. INTRODUCCIÓN A OBJECTIVE-C.......................................................................... 7
2. ESTRUCTURA DE ARCHIVOS ..............................................................................8
2.1. ARCHIVOS DE CABECERA................................................................................................. 9 2.2. ARCHIVOS DE IMPLEMENTACIÓN ........................................................................................ 11
3. ESTRUCTURAS DE CONTROL DE EJECUCIÓN............................................................12
4. MENSAJES Y TIPOS DE DATOS...........................................................................13
5. CLASES....................................................................................................15
5.1. CLASE NSSTRING ....................................................................................................... 15 5.2. CLASE NSARRAY ........................................................................................................ 16 5.3. CLASE NSMUTABLEARRAY ............................................................................................. 16 5.4. NSLOG ................................................................................................................... 16
6. GESTIÓN DE MEMORIA CON ARC....................................................................... 17
CONCLUSIONES ............................................................................................. 19
RECAPITULACIÓN ...........................................................................................20
AUTOCOMPROBACIÓN .......................................................................................21
SOLUCIONARIO..............................................................................................25
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
2
PROPUESTAS DE AMPLIACIÓN .............................................................................26
BIBLIOGRAFÍA ............................................................................................... 27
3
Unidad didáctica 3
Programación en Objective-C
MOTIVACIÓN
Las herramientas de desarrollo sin duda facilitan muchísimo las tareas de los
programadores. Pero no pueden hacer todo por nosotros. Somos los desarro-
lladores los que tenemos que escribir el código de las aplicaciones para que
hagan lo que queremos.
La siguiente cuestión, por tanto, es saber cómo se escribe ese código: ¿qué
lenguaje de programación se debe utilizar? ¿qué ficheros tengo que generar?
¿qué datos hay que manejar?
Este es el objetivo de este tema: dar a conocer al alumno los conceptos del len-
guaje de programación que utiliza el kit de desarrollo de Apple y que se sienta
cómodo para emplearlo en el desarrollo de sus propias aplicaciones.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
4
PROPÓSITOS
Conocer el lenguaje de programación Objective-C, familiarizarse con su sintaxis
y conocer sus peculiaridades.
5
Unidad didáctica 3
Programación en Objective-C
PREPARACIÓN PARA LA UNIDAD
Es altamente recomendable que, antes de empezar esta unidad, repases los
conceptos básicos de la programación orientada a objetos.
7
Unidad didáctica 3
Programación en Objective-C
1. INTRODUCCIÓN A OBJECTIVE-C
Tanto Mac OS X como iOS comparten el lenguaje de desarrollo Objective-C.
Este lenguaje es orientado a objetos.
Los creadores de Objective-C fueron Brad Cox y Tom Love en los años ochen-
ta. Ambos fundaron la empresa Stepstone donde se desarrolló Objective-C.
Más tarde, Steve Jobs y su empresa NeXT, la cual fundó al salir de la compañía
Apple, adquirieron una licencia del lenguaje Objective-C. No tardaron mucho
tiempo en lanzar al mercado su propio compilador y bibliotecas de este lenguaje
en las que se basaba la interfaz gráfica de la herramienta NeXTSTEP.
Fue en 1996 cuando NeXT fue adquirida por Apple e incluyó la plataforma
OPENSTEP, sucesora de NeXTSTEP, en su sistema operativo MAC OS X. Con
el paso del tiempo ha ido actualizándose hasta convertirse en lo que hoy cono-
cemos como los SDK de OSX y de iOS.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
8
2. ESTRUCTURA DE ARCHIVOS
Ya hemos aprendimos a utilizar las herramientas incluidas en el SDK de iOS.
Como mencionamos en su momento, para escribir el código de la aplicación se
utiliza la herramienta Xcode.
Cuando creamos una clase en Objective-C se crean dos tipos diferentes de ar-
chivos: un archivo de cabecera o interfaz (.h) y otro de implementación (.m).
#import <UIKit/UIKit.h> @interface Producto : NSObject { NSString* nombre; float precio; } @property (readwrite,nonatomic) int impuesto; -(void) inicializarProducto:(NSString*)nombre pre-cio:(float)precio puesto:(int)impuesto;//definición de métodos -(void) mostrarInformacion;//definición de métodos
@end
Figura 1. Ejemplo de archivo de cabecera o interfaz
9
Unidad didáctica 3
Programación en Objective-C
Por un lado, el archivo de cabecera/interfaz se utiliza para definir todos los
métodos y propiedades de la clase. Por otro, en el archivo de implementación
se escribe el código que hará funcionar todo lo que se haya definido en el archi-
vo de cabecera.
#import "Producto.h" @implementation Producto @synthesize impuesto; - (id)init { if (self = [super init]) { nombre=@""; precio=0; impuesto=0; } return self; } -(void)mostrarInformacion { NSLog(@"Objeto Producto: %@ Precio:%2.2f€ Impues-to:%d%% PVP:%2.2f€",nombre,precio,impuesto, (precio +(precio*impuesto)/100)); } -(void)inicializarProducto:(NSString*)nombreProducto pre-cio:(float)precioProducto impuesto:(int)impuestoProducto { nombre = nombreProducto; precio = precioProducto; impuesto = impuestoProducto; } @end
Figura 2. Ejemplo de archivo de implementación
2.1. ARCHIVOS DE CABECERA
Como podemos observar en el ejemplo de la Figura 1, se distinguen una serie
de directivas1. Estas son: import, interface y property.
1 Las directivas son comandos que se añaden a los archivos de Xcode para que este obtenga información de
la estructura de la aplicación que se está desarrollando.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
10
Import
Esta directiva se utiliza para incluir cualquier archivo de interfaz que nuestra apli-
cación necesite.
Interface
Sirve para describir todas las variables de instancia o atributos que proporciona
la clase. Esta directiva incluye:
el nombre de la clase,
la clase de la cual hereda
y, entre corchetes angulares, una lista de protocolos2.
Definición de métodos
La definición de métodos sigue la siguiente estructura:
Atributo que indica el tipo de método que puede ser de clase (+) o de
instancia (-).
Tipo de dato que devuelve el método entre paréntesis.
Nombre del método.
Si el método acepta algún parámetro, este irá precedido de dos puntos
seguidos del tipo de dato y el nombre de la variable.
Si acepta más parámetros, éstos se componen de una pequeña etique-
ta, precedida de dos puntos seguidos del tipo de dato y el nombre de
la variable.
Como ejemplos véanse los métodos inicializarProducto y mostrarInformación de
la Figura 1.
Property
Se utiliza con el fin de ayudar en el acceso y modificación de variables de la
instancia.
A las propiedades se les pueden añadir unos atributos. Estos pertenecen a tres
grupos: de acceso, asignación y concurrencia.
Los de acceso son:
readonly: propiedad de solo lectura.
readwrite: propiedad de escritura y lectura.
2 Un protocolo en Objective-C es una agrupación de métodos que son necesarios para poder utilizar una
funcionalidad concreta. Se verán en detalle en la siguiente unidad.
11
Unidad didáctica 3
Programación en Objective-C
El atributo de concurrencia es por defecto atomic. Normalmente usaremos en
su lugar nonatomic, que indica a Xcode que no debe preocuparse de las distin-
tas partes de la aplicación que utilizan la propiedad al mismo tiempo porque
permite la concurrencia de la variable.
Los de asignación pueden ser copy, weak y strong. En el apartado 6 veremos
en detalle el significado de estos modificadores.
2.2. ARCHIVOS DE IMPLEMENTACIÓN
Como podemos apreciar en el ejemplo de la Figura 2, se distinguen una serie de
directivas: import, implementation y synthesize.
Import
Esta directiva se utiliza para incluir un archivo de cabecera o interfaz asociado al
de implementación.
Implementation
Sirve para indicar a Xcode la clase que se va a implementar en el archivo de implementación.
Synthesize
Se utiliza en complemento a la directiva property definida en el archivo de ca-becera. Las dos directrices juntas otorgan al desarrollador un método fácil para
acceder y modificar el contenido de las variables de instancia.
@synthesize va a crear para cada propiedad X un método –X y –setX para con-
trolar y mejorar el acceso a las propiedades.En el ejemplo se nos generará el
método –(int)impuesto; y el método –(void)setImpuesto: (int)valorImpuesto;
Implementación de los métodos
Cada método definido en el archivo de cabecera será implementado en el ar-chivo de implementación. Escribiremos la misma sentencia que en el archivo de cabecera solo que esta vez la sentencia no acabará en punto y coma sino
que abriremos corchetes y entre ellos escribiremos la funcionalidad del método.
Como ejemplos, véanse los métodos inicializarProducto y mostrarInformación
de la Figura 2.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
12
3. ESTRUCTURAS DE CONTROL DE EJECUCIÓN
Las estructuras de control de ejecución son utilizadas para controlar el flujo de
la aplicación. Objective-C tiene las estructuras habituales que podemos encon-
trar en prácticamente todo lenguaje.
Condición If
Empleada para la toma de decisiones en el tiempo de ejecución de la aplica-
ción. Se compone por una condición y un else que se ejecutará cuando no se
cumpla la condición.
Bucle For
Utilizado para ejecutar operaciones un número de veces determinado. Está for-
mado por la inicialización del contador, la condición y el incremento del conta-
dor que se realizará en cada ciclo de ejecución.
Bucle While y Do while
Similar a la estructura for, sirve para ejecutar operaciones mientras se cumpla la
condición de entrada. También existe una variante de este bucle, la estructura
Do while.
13
Unidad didáctica 3
Programación en Objective-C
4. MENSAJES Y TIPOS DE DATOS
El lenguaje Objective-C posee varios tipo de datos. En este apartado se verán
los más influyentes a la hora de desarrollar una aplicación.
Tipos de datos primitivos
Son los tipos de datos más básicos. Algunos de ellos son:
Int: números enteros.
Float: números en coma flotante.
Double: números altamente precisos en coma flotante.
Tipos de datos objetos y punteros
Cuando desarrollamos en Objective-C, la mayoría de los datos que manejamos
son objetos. Para declarar una variable como un objeto de una clase especifica
es necesario utilizar los punteros.
Los punteros referencian la dirección de memoria donde se encuentra el objeto,
no el valor como es el caso de los datos primitivos. La nomenclatura para crear
un puntero es: el Tipo de dato seguido de un asterisco que precede el nombre
de la variable. Ejemplo: NSString *cadena.
Para poder utilizar correctamente un objeto es necesario asignar e inicializar el
objeto. La instrucción alloc se utiliza para reservar memoria y para poder inicia-
lizar un objeto utilizaremos la instrucción init. Veamos un ejemplo de una co-
rrecta asignación e inicialización de un objeto:
UILabel *myLabel;
myLabel=[[UILabel alloc] init];
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
14
Mensajes
Los mensajes o métodos son las herramientas de las que dispone el desarrolla-
dor para interactuar con los objetos. Objective-C tiene una nomenclatura pecu-
liar para los mensajes.
Primero se define el objeto al que se quiere mandar el mensaje y, a continua-
ción, el mensaje del cual se hará uso.
Producto *productoA; NSString nombre=@"Leche"; float euros=100.2; int porcentaje=2; [productoA inicializarProducto:nombre precio:euros impues-to:porcentaje];
Figura 3. Ejemplo de utilización de un mensaje
Hay dos referencias comunes a todas las clases; super y self. La referencia
super se utiliza para poder acceder a la clase padre mientras que self se utiliza
para referenciar así misma una clase cuando estamos en ella.
[super init];
[self mostrarInformacion];
Figura 4. Ejemplo de utilización de un mensaje
15
Unidad didáctica 3
Programación en Objective-C
5. CLASES
En Objective-C existen tres clases muy importantes que normalmente
el desarrollador utiliza en las aplicaciones. Antes de seguir, cabe destacar que
Objective-C no soporta herencia múltiple. Para solucionar este problema se uti-
lizan los protocolos que se mencionaron en el punto 2 de esta unidad.
5.1. CLASE NSSTRING
La clase NSString se utiliza para declarar objetos que almacenan cadenas de
caracteres. Existen dos maneras de inicializar un objeto de la clase NSString:
La primera es asignarle un valor directamente al objeto mediante la
creación de una cadena de caracteres entre comillas dobles y precedi-
da del símbolo @ que indica que se trata de un objeto literal. Esto evita
confundir los objetos literales NSString con las cadenas de texto de C.
La segunda forma de inicializar un objeto NSString es mediante un
alloc y el constructor initwithString seguido de una cadena de carac-
teres entre comillas dobles y precedida del símbolo @.
La tercera y última forma sería utilizando el constructor initwithFormat. Con este método podremos insertar números y cadenas en la declara-
ción de un NSString.
NSString *nombre; nombre=@"MasterD";
nombre=[[NSString alloc] initWithString:@"Estoy estu-diando con MasterD!"];
Figura 5. Ejemplo de inicialización de un NSString
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
16
5.2. CLASE NSARRAY
Con la clase NSArray podemos crear arrays estáticos, lo que significa que no
podremos modificar sus componentes una vez creado. Al crear un objeto de
este tipo deberemos pasarle una lista de objetos que queremos guardar, termi-
nando con nil para indicar que no hay más elementos.
La clase NSArray posee dos métodos muy utilizados en el desarrollo de aplicacio-
nes: count y objectAtIndex. Cuando necesitemos saber el número de elementos
que tiene el array utilizaremos count, mientras que si queremos acceder a un obje-
to que se encuentra en una posición determinada utilizaremos objectAtIndex.
NSArray *alumnos= [NSArray arrayWithOb-jects:@"Laura",@"Iván",nil];
int numeroAlumnos = [alumnos count];
NSString *alumno =[alumnos objectAtIndex:1];
Figura 6. Ejemplo de inicialización de un NSArray y el uso de sus métodos
5.3. CLASE NSMUTABLEARRAY
Al contrario que la clase NSArray, la clase NSMutableArray nos permite crear
arrays que sí serán dinámicos, lo que nos permitirá modificar sus dimensiones
en tiempo de ejecución. Esta clase también dispone de los métodos count y
objectAtIndex además de otros dos más: addObject, que permite añadir un
objeto al array, y removeObjectAtIndex, que se utiliza para eliminar un objeto
de la posición que le llega como parámetro.
NSMutableArray *alumnos= [NSMutableArray arrayWithOb-jects:@"Laura",@"Iván",nil];
int numeroAlumnos=[alumnos count];
[alumnos addObject:@"Fanny"];
[alumnos removeObjectAtIndex:1];
Figura 7. Ejemplo de inicialización de un NSMutableArray y el uso de sus métodos
5.4. NSLOG
Aunque NSLog no es una clase sino una función usada para depurar, vamos a
incluirlo en este punto del tema. NSLog es la herramienta que utilizaremos para
mostrar información usando la consola. Esta nos permite agregar trazas que
sirven para tener una idea más clara de lo que está sucediendo en la aplicación
o informar de situaciones excepcionales.
NSLog(@"%d",0);
NSLog(@"MasterD");
NSLog(@"%d",variable);
Figura 8. Ejemplo de NSLog
17
Unidad didáctica 3
Programación en Objective-C
6. GESTIÓN DE MEMORIA CON ARC
Debido a la escasa cantidad de memoria disponible para las aplicaciones y con
el añadido de que el dispositivo no libera automáticamente la memoria, esta es
un recurso prioritario que debemos gestionar de manera eficiente. El hecho de
que el iPhone no libere la memoria automáticamente nos obliga a los desarrolla-
dores a realizar un seguimiento relativamente manual de la misma.
Objective-C utiliza el “conteo de referencias”: se mantiene un contador del
número de variables que apuntan a un mismo objeto, y cuando éste llega a 0, el
entorno de elimina el objeto de la memoria recuperando su espacio. Hasta aho-
ra ese trabajo era en gran parte manual pues debíamos indicar cuando quería-
mos mantener una referencia a un objeto en el tiempo y cuando íbamos a dejar
de usarla, de forma que el entorno gestionara el contador de referencias.
Actualmente, y desde el SDK de iOS 5.0, Apple nos proporciona una ayuda a la
gestión de memoria llamada Automatic Reference Counting (ARC). Este sistema
implica que en general solo debemos preocuparnos de estas cuestiones cuando
definamos una property. Como vimos en el apartado 2.2, existen varios modifi-
cadores que afectan a la gestión de memoria de las propiedades:
strong: realiza una retención sobre el objeto, de forma que la propiedad
mantiene vivo al objeto. Al asignar un objeto a esta propiedad, el con-
tador de referencias aumenta y el objeto no podría ser liberado mien-
tras exista esta propiedad y apunte al objeto.
weak: realiza una asignación que no mantiene vivo al objeto. Es decir,
no aumenta el contador de referencias del objeto. Veamos un ejemplo:
a esta propiedad se le asigna un objeto cuyo contador es 1 (porque hay
otra variable en algún punto de la aplicación que también lo referencia).
Si en algún punto esa otra variable desaparece, el contador del objeto
pasaría a ser 0 y esta propiedad se dejaría apuntando a nil pues el ob-
jeto habría desaparecido. Se suele utilizar ampliamente en los delega-
dos y para conectar elementos de interfaz gráfica como veremos próxi-
mamente.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
18
copy: realiza una copia del objeto original en memoria. La copia es re-
tenida de la forma descrita en strong. Se utiliza habitualmente con pro-
piedades de tipo NSString.
Por otro lado, cuando definamos una variable en cualquiera de nuestros méto-
dos o clases, ésta vendrá caracterizada implícitamente con el modificador
__strong (equivalente al strong visto anteriormente a todos los efectos). De esta
forma, ambas declaraciones serían equivalentes:
NSMutableArray *array = [[NSMutableArray alloc] init]; NSMutableArray * __strong array = [[NSMutableArray alloc]
init];
De esta manera, el lenguaje cuida de que al crear un objeto, este esté disponible
al menos mientras exista la variable que hemos definido. De igual manera ten-
dremos el modificador __weak que no realizaría labor de retención alguna sobre
el objeto asignado y puede quedar apuntando a nil en cualquier momento.
19
Unidad didáctica 3
Programación en Objective-C
CONCLUSIONES
El lenguaje Objective-C es la base de el SDK de iOS.
Su sintaxis difiere en algunos aspectos de lenguajes como Java o .Net.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
20
RECAPITULACIÓN
El primer paso antes de disponerse a escribir código es estudiar el lenguaje que
vamos a utilizar. Gracias a esta unidad, dispones de las nociones básicas necesa-
rias para poder desarrollar en el lenguaje Objective-C.
21
Unidad didáctica 3
Programación en Objective-C
AUTOCOMPROBACIÓN
1. ¿Cuál de estas definiciones es verdadera?
a) Objective-C fue inventado por Brad Cox y Tom Love de la compañía
NeXT.
b) Es un lenguaje orientado a objetos.
c) Posee un sistema de gestión automática de memoria.
d) Todas son correctas.
2. ¿Qué dos archivos obtendremos al crear una clase?
a) Un archivo de implementación y otro de ejecución.
b) Un archivo de compilación y otro de implementación.
c) Un archivo de implementación y otro de cabecera.
d) Uno llamado de cabecera y otro de interfaz.
3. ¿Qué diferencia una propiedad con el modificador weak de otra con strong?
a) Las propiedades con strong solo pueden leerse pero no modificarse.
b) Con weak, la propiedad no cuenta como referencia a la hora de liberar el
objeto.
c) Las propiedades con weak solo pueden leerse pero no modificarse.
d) strong.al contrario que weak, sí realiza una copia del objeto que se pasa
a la propiedad.
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
22
4. ¿Qué directivas podemos encontrar en un archivo de implementación?
a) Property, synthesize e implementation.
b) Implementation, synthesize e import.
c) Implementation, synthesize e interface.
d) Property, synthesize e interface .
5. ¿Qué diferencia hay entre las directivas property y synthesize?
a) Ninguna, podemos utilizar las dos indistintamente.
b) Property se utiliza para incluir cualquier archivo de interfaz que nuestra apli-
cación necesite mientras que synthesize sirve para poder interactuar con los
atributos de los elementos o las variables de instancia incluidos/as.
c) La directiva property da a una instancia de variable la funcionalidad de
propiedad mientras que la directiva synthesize no.
d) Todas son falsas.
6. ¿Cuál de estas definiciones de métodos está bien formada?
a) -setNombre:(NSString*)nombre;.
b) -(void) setNombre:(String*)nombre;
c) +(void)setNombre:(NSString*)nombre(NSString*)apellido.
d) -(void)setNombre:(NSString*)nombre setApellido: (NSString*)apellido.
7. ¿Cuál de estas definiciones no es verdadera?
a) En el archivo de cabecera, la directiva import se utiliza para incluir cual-
quier archivo de interfaz que nuestra aplicación necesite.
b) La estructura de control de ejecución “if” sirve para la toma de decisio-
nes en el tiempo de ejecución de la aplicación.
c) Todas son falsas.
d) Float es un tipo de dato primitivo.
23
Unidad didáctica 3
Programación en Objective-C
8. ¿Qué representa un puntero a un objeto?
a) La dirección de memoria donde se encuentra el objeto.
b) El valor del objeto.
c) En Objetive-C no hay punteros.
d) Ninguna de las anteriores.
9. ¿Cuál de estas afirmaciones no es falsa?
a) Para poder utilizar correctamente un objeto es necesario utilizar los me-
todos init y autorelease.
b) Hay dos tipos de mensajes comunes en todas las clases: super y self.
c) Los arrays creados con la clase NSMutableArray son estáticos.
d) En Objective-C existen tres tipos de atributos para los métodos: de cla-
se, de instancia y compartidos.
10. Para informar por consola de situaciones excepcionales en la ejecu-ción, ¿qué usaremos?
a) NSLog.
b) NSString.
c) Objective-C no dispone de un método para informar de estas situacio-
nes.
d) NSDebug.
25
Unidad didáctica 3
Programación en Objective-C
SOLUCIONARIO
1. b 2. c 3. b 4. b 5. d
6. d 7. c 8. a 9. b 10. a
Unidad didáctica 3
Desarrollo de aplicaciones para iPhone
26
PROPUESTAS DE AMPLIACIÓN
Se recomienda practicar las estructuras vistas en esta unidad. Para
ampliar el conocimiento de Objective-C es recomendable leer el docu-
mento que Apple tiene en su página web:
http://developer.apple.com/library/ios.
27
Unidad didáctica 3
Programación en Objective-C
BIBLIOGRAFÍA
http://developer.apple.com/library/ios. RAY, J. y JOHNSON, S. Desarrollo de Aplicaciones para iPhone. Ma-
drid: Anaya Multimedia, 2010.