Introducción a ObjectiveC e IOS

Eduard Tomàs
Introducción al desarrollo en
iOS para desarrolladores
.NET
Master RIATec
10 apr

www.pasiona.com
info@pasiona.com
(+34) 669 333 333
@pasiona Barcelona Bilbao Madrid Londres
Pujades 350, 10ª planta Gran Vía 19-21, 2ª planta Pinar 5, 1 Northumberland Avenue
08019 · Barcelona 48008 · Bilbao 28006 · Madrid London · WC2N 5BW

Qué es

Microsoft Innovación Pasión
socio 100% alineado ligada a la mejora continua y basada somos grandes entusiastas de todo
partner 100% especializado en las nuevas oportunidades tecnológicas aquello que creamos y vemos crecer

Desarrollo Tecnología Experiencia
capacidad para realizar proyectos de soluciones a cada una de las necesidades o la garantía de la habilidad derivada
ámbito tecnológico con un fin de mejora empresariales que se platean en cada ámbito de años de vivencias y observación

Especialización Conocimiento Valores humanos
ofrecemos soluciones a medida con adquirido a través de la realización de guía de lo que hacemos y pretendemos
las mejores herramientas tecnológicas proyectos, formación e innovación tecnológica que nos enseña y nos conduce día a día

Servicios
Consultoría Proyectos Auditoría

Servicios Social Formación
profesionales Media

Innovación Azure

Eduard Tomàs
Key Consultant en pasiona Consulting
Divulgador Tecnológico en Fundación Techdencias

@eiximenis
etomas@pasiona.com eiximenis@techdencias.net

Agenda
Un nuevo entorno: XCode
Un nuevo lenguaje: ObjectiveC
Modelo de desarrollo de aplicaciones iOS

Tema 1
Un nuevo entorno: XCode

XCode
 Xcode juega en iOS/MacOS el rol de Visual
Studio
 IDE completo para desarrollar aplicaciones
iOS y MacOS
 Lenguajes: C/C++, ObjectiveC

Tema 2
Un nuevo lenguaje: ObjectiveC

Objective-C
 Conocido popularmente como “C with classes”
 NO es C++, NO tiene nada que ver con C++
 Soporte para
 OOP (Clases, interfaces, herencia…),
 Programación dinámica
 Gestión manual, semi-automática o
automática (GC) de memoria

Objective-C: Tipos simples
 A diferencia de .NET en objectiveC existen
tipos simples que NO son objetos (char, int,
float, double, long, struct,…)
 Para tratar con objetos NO se usan
referencias, se usan punteros

 No existe un tipo booleano. Se usa:
 BOOL (typedef signed char)
 YES / NO (#defines a 1 y 0)
 El if() de ObjectiveC se evalúa a true si el valor
es !=0 y a false si es 0.

 Las structs de ObjectiveC no tienen NADA que
ver con las de .NET
 No pueden tener métodos
 No pueden tener datos privados
 Son las structs de C!

 Los arrays de ObjectiveC son parecidos a los
de .NET salvo que:
 No existen jagged arrays
 El nombre del array es un puntero a su
primer elemento

 En ObjectiveC existen los punteros
 Imprescinbibles para tratar con objetos (NO
hay referencias).
 La llamada a alloc devuelve un puntero
 Para declarar un puntero se usa Tipo*
 El valor nil (o NULL) significa que el puntero
apunta a nada.

Objective-C: Clases
 Mismo concepto que la clase de C#
 Se define en dos archivos (.h y .m)
 .h contiene la interfaz (@interface) de la
clase
 NADA que ver con interface de C#

Objective-C: Clases
 Ejemplo (.h)
#import <Foundation/Foundation.h>
@interface Person : NSObject
- (void)sayHello;
@end

 Ejemplo (.m)
#import "Person.h"
@implementation Person
- (void)sayHello {
NSLog(@"Hello, my name is HAL.");
}
@end

Objective-C: Instanciación
 NO existe operador new
 Instanciar un objeto es un proceso en 2 pasos
 Llamar al método alloc
 Llamar al método init
 En ObjectiveC no hay constructores. Se
usa init() para código de inicialización
custom

Objective-C: Instanciación
 Ejemplo:
Person *somePerson = [Person alloc];
[somePerson init];

 Aunque se suele combinar alloc e init:
Person *somePerson = [[Person alloc] init];

 Los corchetes ([ ]) son el operador de envío de
mensajes
 Equivale a llamar a un método en C#

Objective-C: Parámetros
 Forman parte del nombre del método
 Tienen un nombre “externo” y otro interno
- (void)sayHelloToName:(NSString *)aName;

- (void)sayHelloToName:(NSString *)aName {
NSLog(@"Hello %@, my name is HAL.", aName);
}

[somePerson sayHelloToName:@"Bill"];

 -(NSNumber*) addWithTwoNumbers:(NSNumber *)first

secondNumber:(NSNumber *)second;

 NSNumber* -> Tipo de vuelta

 addWithTwoNumbers: -> Nombre método + externo param 1

 (NSNumber*)first -> Tipo param 1 y nombre interno

 secondNumber: -> nombre externo param 2

 (NSNumber*)second -> Tipo param 2 y nombre interno

 -(NSNumber*) addWithTwoNumbers:(NSNumber *)first

secondNumber:(NSNumber *)second;

 El nombre de este método es:

 addWithTwoNumbers:secondNumber:

 Sobre este nombre se podría crear un selector para invocarlo

dinámicamente

Objective-C: Propiedades
 Las clases de ObjectiveC pueden tener
propiedades
@property (copy) NSString *name;

 Se pueden auto-implementar (en el .m) con:
@synthesize name = _name;

 @synthesize genera los métodos set y get
(llamados setName y name en este caso)

 Podemos implementarlas nosotros:
@property unsigned int age;

- (unsigned int)age { return _age; }
- (void)setAge:(unsigned int)age { _age = age; }

 Debemos añadir la variable de instancia
(_age). Podemos hacerlo en:
 @interface y que sea pública o protegida
 @implementation y que sea privada

@implementation Person {
unsigned int _age;
}

 Recuerda que los getters y setters son
métodos, por lo tanto se invocan mediante
paso de mensajes (corchetes)

 Aunque SOLO para las propiedades existe la
posibilidad de usarlas mediante la notación de
punto (.)

Objective-C: Memoria
 La gestión de memoria es uno de los grandes
quebraderos en ObjectiveC. Hay 3 modelos:
 Manual
 Semi-automática (ARC, Automatic
Reference Counting)
 Automática (GC, Garbage Collector)
 La última NO puede usarse en iOS

 El runtime de ObjectiveC lleva una cuenta de
cuantas referencias apuntan a un objeto. Si
este contador llega a 0 el objeto puede ser
destruido.
 La diferencia entre ARC y la gestión manual
es quien actualiza este contador.

 La gestión manual se basa en cuatro métodos
 alloc: reserva memoria y suma uno al
contador de referencias del objeto
 retain: Suma uno al contador de referencias
del objeto
 release y autorelase: Decrementa en uno el
contador de referencias

 La idea de la gestión manual es muy simple:
 El número de veces que se “reclama” un
objeto (alloc, retain) debe ser igual al
número de veces que se libera (release,
autorelase)
 Por cada llamada a alloc/retain debe haber
una llamada a release o autorelease.

 Usar un objeto DESPUÉS de que haya sido
liberado es un error y suele ser catastrófico
 No liberar un objeto nunca genera un memory-
leak

 La gestión manual es muy simple en objetos
de la pila pero se complica cuando se pasan
objetos entre ellos (p. ej. en propiedades).
 Cuidado al usar weak-references! (Al
guardar un puntero a un objeto sin llamar a
retain).

 La diferencia entre release y autorelease es
que el primero decrementa al acto el contador
y el segundo se espera al final del
autoreleasepool actual.
@autoreleasepool {
...
NSLog(@"Hello, World!");
/* En este punto se decrementan todos los contadores afectados
por autorelease */
}

 Para las propiedades podemos indicar como
queramos que se comporten:
 assign: Crea una weak reference
 retain: Crea una strong reference
 copy: Copia el objeto (clona)

@property (retain) Person *captain;

Objective-C: ARC
 Por suerte nos podemos olvidar de la gestión
manual de memoria gracias a ARC que sí que
está soportado en iOS

 NO hay ningún motivo para NO usar ARC y
usar la gestión manual de memoria!

Objective-C: ARC
 La primera norma al usar ARC es muy simple:
 NO llamar NUNCA a retain, release o
autorelease. Nunca. Jamás.
 Desde este punto de vista, puedes actuar
como si tuvieses un GC 

Objective-C: ARC
 Para las propiedades NO usaremos assign o
retain, en su lugar usaremos:
 weak: Para especificar una propiedad
mediante weak reference
 strong: Para especificar una propiedad
mediante strong reference

Objective-C: ARC
 ARC evita que un puntero que apunta a un
objeto eliminado siga apuntando a un espacio
de memoria “inválido” y lo asigna a nil.

Objective-C: Métodos estáticos
 ObjectiveC soporta métodos estáticos. Son los
que empizan por + en su declaración:
@interface Person : NSObject
- (void)sayHello;
+ (Person *)personWithName:(NSString *)name;
@end

 El método personWithName es un método
estático

Objective-C: Métodos init
 Si quieres crear un método init propio debes
declararlo que devuelve id:
- (id)init {
self = [super init];
if (self) { _ammo = 1000; }
return self; }

 self es el equivalente de this en C# y super es
el equivalente de base en C#

Objective-C: Nombres
 En Objective-C se busca que los nombres de
los métodos sean lo más informativos posibles
 No uses:
- (id)shoot:(Ship *)aShip;
 Usa mejor:
- (id)shootOtherShip:(Ship *)aShip;

Objective-C: Initialize
 El método estático initialize juega el mismo rol
que el constructor estático en C#
static Ship *_sharedShip;
+ (void)initialize {
if (self == [Ship class]) {
_sharedShip = [[self alloc] init];
}
}
+ (Ship *)sharedShip {
return _sharedShip;
}

Objective-C: Métodos privados
 Objective-C NO tiene métodos privados.
 Se simulan NO colocando el método en la
interfaz (@interface) de la clase
 Recuerda: Los “usuarios” de una clase solo
tienen acceso a su interfaz.

Objective-C: Categorías
 Una categoría ofrece un conjunto de métodos adicionales sobre

una clase. Lo más parecido que tiene C# son los métodos de

extensión

 Los métodos definidos en la categoría

 Pueden usar los métodos de la clase que categorizan

 Se pueden llamar con un puntero a la clase categorizada

Objective-C: Categorías
 Las categorías se declaran como una clase cuyo nombre es

ClaseQueSeExtiende (NombreCategoría):

 Se definen como clases normales (@interface e
@implementation)
 Dentro de una categoria
 self se refiere al objeto de la clase que se extiende

Objective-C: Métodos protected
 Objective-C NO tiene el concepto de métodos
protegidos
 Se pueden simular colocándolos todos en una
categoría e incluir el .h de dicha categoría tan
solo en las clases hijas.

Objective-C: Protocolos
 Un protocolo es un conjunto de métodos que
una clase debe implementar.
 Son como los interfaces de C# salvo que un
protocolo puede tener métodos “opcionales”.
 Una clase puede adoptar varios protocolos (al
igual que en C# implementar varias interfaces)

 La definición es con @protocol:
@protocol CoordinateSupport <NSObject>
@property double x;
- (NSArray *)arrayFromPosition;
- (double)magnitude;
@end

 La notación angular (<>) indica herencia de
protocolos (CoordinateSupport hereda del
protocolo NSObject)

 Para que una clase adopte un protocolo se
usa la notación angular:
@interface Person : NSObject <CoordinateSupport>
@property (strong) NSMutableSet *friends;
- (void)sayHello;
- (void)sayGoodbye;
@end

 Este código NO es correcto hasta que Person
no implemente los métodos del protocolo

 Al igual que las interfaces en C# un protocolo
define un tipo por si mismo.
 Aunque en Objective-C es un pesudo-tipo.
 Se puede indicar que un parámetro debe
adoptar un protocolo:
- (double)getDistanceFromObject:(id <CoordinateSupport>)theObject;

Tema 3
Modelo de desarrollo de
aplicaciones iOS

iOS – Modelo MVC
 Una aplicación iOS se construye mediante el
patrón MVC
 Modelo: Datos de la aplicación
 View: Vista que muestra los datos (nib file)
 Controller: Clase que enlaza la vista con el
modelo

iOS – Vistas
 Ficheros nib (.xib)
 Contienen los controles de la vista, sus
propiedades y los enlaces de eventos
 Equivaldría al XAML de WPF o a al
Form.Designer.cs de Winforms

iOS – Controladores
 Contienen outlets y acciones
 Outlet: Puntero que apunta a un control de
la vista controlada
 Action: Método llamado por un control de la
vista
 Outlets y acciones se asocian mediante
XCode

iOS – Controles son vistas
 Conceptualmente los controles iOS son vistas
 Algunos tienen su propio controlador
 Caso de controles “complejos”

iOS – App Delegate
 Clase encargada de inicializar la aplicación.
 Crea la vista inicial y su controlador
 Coloca la vista inicial en la ventana
 Tiene métodos para que iOS le informe de
ciertos casos (fin de aplicación, paso a back,
etc)
 Equivale a la clase App de WPF

iOS – Aplicación single-view
 Contiene:
 Una vista (fichero .xib)
 Un controlador
 Un application delegate

iOS – Rotación
 Puede ser:
1. Automática
2. Reposición de controles manual
3. Mediante dos vistas (landscape y portrait)
 90% de aplicaciones tendrán sufienciente con
(1)

iOS – Rotación automática
 iOS rota las vistas automáticamente
 Para que los controles se reposicionen
correctamente deben establecerse las
restricciones de posición
 Funcionan de forma parecida a la
propiedad Anchor de Winforms o Margin de
WPF

iOS – Reposición manual
 Para layouts complejos puede ser necesario
reposicionar los controles manualmente
 Usar método willAnimateRotationToInterfaceOrientation
del controlador para posicionar los controles
en su nueva posición

iOS – Rotación: dos vistas
 Para vistas complejas o funcionalidades
distintas según orientación deberemos usar
dos vistas
 Usar método willAnimateRotationToInterfaceOrientation
del controlador para cambiar la vista según la
orientación
 ¡Tener presente que todo está duplicado!

iOS – Aplicaciones multivista
 Constan de:
 N vistas (.xib) secundarias
 N controladores
 Una vista principal con el control que
permite el cambio de vista (ej Toolbar) y
que realiza el cambio
 El controlador de la vista principal

iOS – Control TableView
 Necesita un delegado

(UITableViewDelegate) y

un DataSource

(UITableViewDataSource)

iOS – Control TableView
 Lista de datos

 Agrupaciones de

datos

 Siempre tiene 1

columna

 Personalizable

iOS – Storyboards
 Permiten definir el flujo de una aplicación de
forma gráfica
 “Agrupan” varios ficheros nib en uno solo
 Solo iOS 5 o superior

Eduard Tomàs
@eiximenis
etomas@pasiona.com
eiximenis@techdencias.net

Gracias!

Introducción a ObjectiveC e IOS

Más contenido relacionado

La actualidad más candente (20)

Destacado (20)

Similar a Introducción a ObjectiveC e IOS (20)

Más de Eduard Tomàs (20)

Último (20)

Introducción a ObjectiveC e IOS