Desarrollo de Aplicaciones para iPhone, Capitulo 3.

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


Í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


2

PROPUESTAS DE AMPLIACIÓN .............................................................................26

BIBLIOGRAFÍA ............................................................................................... 27

3

Unidad didáctica 3


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


4

PROPÓSITOS

Conocer el lenguaje de programación Objective-C, familiarizarse con su sintaxis

y conocer sus peculiaridades.

5

Unidad didáctica 3


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


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


BIBLIOGRAFÍA

http://developer.apple.com/library/ios. RAY, J. y JOHNSON, S. Desarrollo de Aplicaciones para iPhone. Ma-

drid: Anaya Multimedia, 2010.

Desarrollo de Aplicaciones para iPhone, Capitulo 3.

Documents

Transcript of Desarrollo de Aplicaciones para iPhone, Capitulo 3.