Resumen
¿Quiere desarrollar aplicaciones para algún sistema operativo de Apple? En este curso práctico encontrará cómo hacerlo. El libro está orientado a programadores autodidactas que pretenden iniciarse en la programación de los dispositivos de Apple. De forma progresiva se va dando significado a los muchos conceptos que encierra este apasionante lenguaje. La primera parte trata en profundidad todos los aspectos de Objective-C, el lenguaje de programación compartido por Mac OS X, iPhone y iPad para el desarrollo de sus aplicaciones. La segunda parte detalla cómo utilizar la librería de clases en que se basan los distintos sistemas operativos de la manzana. El texto contiene multitud de ejemplos prácticos que permiten entender los entresijos y secretos del lenguaje, y que, además, muestran la forma adecuada de crear programas potentes y eficientes. Con este libro, el lector conocerá a fondo el lenguaje Objective-C, y aprenderá con rapidez cómo utilizar de manera eficaz las librerías de programación en los distintos sistemas; y al finalizar su lectura podrá seguir aprendiendo por su cuenta, ya que tendrá una idea clara de qué librerías corresponde usar para cumplir cada requisito profesional con el que se vaya encontrando. Más Datos
- Título: Objective C. Curso práctico de formación para programadores Mac OS X, iPhone y iPad
- Autor: Fernando López Hernández
- ISBN: 978-84-938312-7-1
- 560 páginas
- Formato disponible: Papel
- Referencia: RC0029
Contenido adicional
Consultar Índice
Descargar Índice
Compartir en:
 
Índice
Prefacio ...................................................................................................................... XIX
PARTE I: EL LENGUAJE OBJECTIVE-C
CAPÍTULO 1: EMPEZANDO A PROGRAMAR CON OBJECTIVE-C
Entornos de programación ........................................................................................... 3
Compilando con las GCC ............................................................................................... 5
Crear un ejecutable ................................................................................................... 6
Framework y runtime de Objective-C ....................................................................... 7
Programar con el framework de clases de GNU ....................................................... 8
Programar con el framework de clases de NeXTSTEP ............................................. 10
Clang, LLVM y LLDB ..................................................................................................... 11
Compilando con Clang ............................................................................................ 13
Crear una librería estática o dinámica .................................................................... 14
Compilación cruzada para iOS ................................................................................ 14
Compilando con Xcode ............................................................................................... 17
Crear un programa .................................................................................................. 19
Crear una librería de enlace estático ...................................................................... 22
Enlazar con la librería de enlace estático ................................................................ 24
Crear una librería de enlace dinámico .................................................................... 25
Enlazar con la librería de enlace dinámico .............................................................. 28
Crear un framework ................................................................................................ 30
Enlazar con el framework ....................................................................................... 32
Los ficheros de configuración Xcode ....................................................................... 33
Los workspaces ....................................................................................................... 35 CAPÍTULO 2: CARACTERÍSTICAS DEL LENGUAJE Qué es Objective-C ...................................................................................................... 37 Lenguaje fuertemente dinámico ................................................................................. 38 Memoria dinámica .................................................................................................. 39 Tipos dinámicos ...................................................................................................... 39 Introspección .......................................................................................................... 40 Enlace dinámico ...................................................................................................... 40 Carga dinámica ....................................................................................................... 41 Asociación, agregación y conexiones .......................................................................... 42 Componentes vs. frameworks ..................................................................................... 43 CAPÍTULO 3: OBJETOS Y CLASES Clases .......................................................................................................................... 45 La interfaz ............................................................................................................... 46 La implementación ................................................................................................. 48 Objetos ........................................................................................................................ 49 Instanciar objetos ................................................................................................... 50 Tipos estáticos y dinámicos ..................................................................................... 51 Variables de instancia ................................................................................................. 53 Métodos ...................................................................................................................... 54 Declaración de un método ...................................................................................... 54 Implementación de un método .............................................................................. 56 Name mangling ....................................................................................................... 57 Ejecutar un método ................................................................................................ 59 Número variable de parámetros ............................................................................. 60 Encapsulación.............................................................................................................. 61 Clases como estructuras de datos ............................................................................... 63 Clases sin clase base ............................................................................................... 63 Paso de objetos por valor ....................................................................................... 64 Objetos cadena ........................................................................................................... 65 Crear y manipular objetos cadena .......................................................................... 65 Formatos de codificación ........................................................................................ 66 Formatear cadenas ................................................................................................. 68 Imprimir cadenas formateadas ............................................................................... 70 Leer y escribir cadenas de ficheros y URLs .............................................................. 70 Tipos de datos de 32 y 64 bits ..................................................................................... 72 Tipos de datos GCC ................................................................................................. 72 Imprimir con diferentes tamaños de palabra ......................................................... 74 Declaraciones adelantadas de clase ............................................................................ 75 CAPÍTULO 4: PROFUNDIZANDO EN EL LENGUAJE Herencia ...................................................................................................................... 79
La clase raíz ............................................................................................................. 80
Redefinir métodos y variables de instancia ............................................................ 80
Los receptores especiales self y super .................................................................... 80
Objetos clase ............................................................................................................... 83
Los objetos clase ..................................................................................................... 83
La variable de instancia isa ..................................................................................... 85
Crear instancias de una clase .................................................................................. 86
Personalización con objetos clase ........................................................................... 87
Introspección .......................................................................................................... 87
Variables de clase ................................................................................................... 88
Inicializar un objeto clase ........................................................................................ 88
Otros receptores especiales ........................................................................................ 89
Ruta de un mensaje durante su ejecución .................................................................. 91
Objetos metaclase ...................................................................................................... 93
Objetos de instancia, clase y metaclase .................................................................. 93
Obtener la metaclase de una clase ......................................................................... 93
La variable de instancia super_class ....................................................................... 95
Métodos de la clase raíz en los objetos clase ......................................................... 95
Ciclo de vida de un objeto ........................................................................................... 97
Creación e inicialización .......................................................................................... 97
Implementar la inicialización ................................................................................ 104
Desinicialización y liberación ................................................................................ 108
Categorías ................................................................................................................. 109
Qué son las categorías .......................................................................................... 109
Declarar la interfaz de una categoría .................................................................... 110
Implementación de una categoría ........................................................................ 111
Sobrescribir métodos con categorías .................................................................... 113
Categorías en la clase raíz ..................................................................................... 113
Protocolos ................................................................................................................. 114
Declarar un protocolo ........................................................................................... 116
Adoptar un protocolo ........................................................................................... 117
Tipificación estática de protocolo ......................................................................... 118
Jerarquía de protocolos ........................................................................................ 121
El protocolo NSObject ........................................................................................... 122
Objetos protocolo ................................................................................................. 122
Declaración adelantada de protocolos ................................................................. 123
Protocolos informales ........................................................................................... 124
Proxies y delegados .............................................................................................. 125
Protocolos formales con métodos opcionales ...................................................... 127
Extensiones ............................................................................................................... 127
Clases abstractas ....................................................................................................... 129
Cluster de clases ........................................................................................................ 131 CAPÍTULO 5: EL RUNTIME DE OBJECTIVE-C Interactuar con el runtime de Objective-C ................................................................ 133
El sistema de paso de mensajes ................................................................................ 134
Los selectores........................................................................................................ 135
Ejecutar métodos a través de selectores .............................................................. 136
El patrón de diseño target-action ......................................................................... 137
Evitar errores en el envío de mensajes ................................................................. 138
Parámetros implícitos ........................................................................................... 139
Cómo se envían los mensajes ............................................................................... 140
Gestión de memoria por cuenta de referencias ........................................................ 142
Técnicas de gestión de memoria .......................................................................... 142
Mantener la cuenta de referencias de un objeto ................................................. 143
Métodos para cuenta de referencias .................................................................... 144
Política de gestión de cuenta de referencias ........................................................ 145
Retornar un objeto ............................................................................................... 146
Recibir un objeto de un ámbito superior .............................................................. 147
Métodos factory ................................................................................................... 147
Métodos setter ..................................................................................................... 148
Retenciones cíclicas .............................................................................................. 149
Referencias débiles ............................................................................................... 150
Validez de los objetos compartidos ...................................................................... 151
Autorelease pools ................................................................................................. 152
La clase raíz ............................................................................................................... 156
Creación, copia y liberación de objetos ................................................................ 157
Identificar objetos y clases .................................................................................... 158
Introspección de jerarquía de protocolos ............................................................. 160
Introspección de métodos .................................................................................... 161
Copia de objetos ....................................................................................................... 162
La interfaz NSCopying ........................................................................................... 162
La interfaz NSMutableCopying .............................................................................. 163
Método getter/setter y liberación de objetos agregados ..................................... 164
Gestión de excepciones ............................................................................................ 165
El bloque @try-@catch ......................................................................................... 165
Lanzar excepciones con @throw ......................................................................... 165
Usar varios bloques @catch ................................................................................. 167
El bloque @finally ................................................................................................. 168
Excepciones y errores ........................................................................................... 169
El handler de excepciones no capturadas ............................................................. 172
El handler de excepciones por defecto ................................................................. 173
Bloques sincronizados ............................................................................................... 174
CAPÍTULO 6: OBJECTIVE-C 2.0
Las propiedades ........................................................................................................ 177
Declarar propiedades ............................................................................................ 178
Implementar propiedades .................................................................................... 178
Acceso a propiedades ........................................................................................... 180
Modificadores de la propiedad ............................................................................. 180
Personalizar la implementación ............................................................................ 184
El operador punto ................................................................................................. 187
Redefinir modificadores de propiedad ................................................................. 191
Variables de instancia frágiles ............................................................................... 192
El recolector de basura ............................................................................................. 194
Activar el recolector de basura ............................................................................. 194
Técnicas de recolección de basura ....................................................................... 196
La librería auto ...................................................................................................... 200
Recolector de memoria con tipos fundamentales ................................................ 201
Gestión de memoria de objetos puenteados ....................................................... 202
Clases para recolección de basura ........................................................................ 204
Finalizar un objeto ................................................................................................ 206
Ventajas e inconvenientes .................................................................................... 208
Trazar la recolección de basura ............................................................................ 209 CAPÍTULO 7: LOS OBJETOS COLECCIÓN Objetos array ............................................................................................................ 211
Objetos arrays inmutables .................................................................................... 212
Objetos array mutables ........................................................................................ 215
Rangos y concatenaciones .................................................................................... 216
Copia de objetos array .......................................................................................... 217
Objetos array de punteros .................................................................................... 218
Objetos conjunto ....................................................................................................... 218
Objetos conjunto inmutables ............................................................................... 219
Objetos conjunto mutables .................................................................................. 221
Operaciones con conjuntos .................................................................................. 222
Objetos conjunto con repeticiones ....................................................................... 222
Recorrer los elementos de una colección ................................................................. 223
Enumeraciones ..................................................................................................... 223
Enumeraciones rápidas ......................................................................................... 224
Ejecutar un selector .............................................................................................. 225
Ordenar elementos ............................................................................................... 225
Filtrar elementos ................................................................................................... 227
Objetos diccionario ................................................................................................... 228
Objetos diccionario inmutables ............................................................................ 228
Objetos diccionario mutables ............................................................................... 231
Objetos diccionario de punteros ........................................................................... 231
Tipos fundamentales en colecciones ........................................................................ 232 CAPÍTULO 8: KEY-VALUE CODING Qué es KVC ................................................................................................................ 233
Tecnologías relacionadas ...................................................................................... 234
Terminología ......................................................................................................... 235
Métodos de acceso ................................................................................................... 235
Lecturas simples .................................................................................................... 236
Camino de claves .................................................................................................. 237
Representación dinámica de objetos .................................................................... 239
Escrituras simples ................................................................................................. 240
Soporte para escalares y estructuras .................................................................... 242
Lectura de propiedades uno a muchos ................................................................. 242
Escritura de propiedades uno a muchos ............................................................... 244
Validar una propiedad ............................................................................................... 245
Métodos KVC para validación ............................................................................... 245
Métodos de patrón para validación ...................................................................... 246
Operadores en caminos de claves ............................................................................. 248
Descripción de las propiedades ................................................................................. 248 CAPÍTULO 9: KEY-VALUE OBSERVING Qué es KVO ............................................................................................................... 251
Registrar observadores ............................................................................................. 252
Registrar el objeto observador ............................................................................. 252
Recibir notificaciones de cambio .......................................................................... 253
Eliminar un objeto observador ............................................................................. 254
Notificaciones automáticas y manuales .................................................................... 255
Cóctel de punteros isa .......................................................................................... 255
Notificaciones automáticas ................................................................................... 255
Notificaciones manuales ....................................................................................... 256
Desactivar la notificación automática ................................................................... 257
Registrar propiedades dependientes .................................................................... 258 CAPÍTULO 10: APROVECHANDO TODA LA POTENCIA DEL LENGUAJE Directivas del preprocesador y compilador .............................................................. 261
Directivas del preprocesador ................................................................................ 261
Directivas del compilador ..................................................................................... 262
Zonas de memoria .................................................................................................... 268
Creación y gestión de zonas de memoria ............................................................. 269
Reservar y liberar memoria en una zona .............................................................. 269
Forwarding ................................................................................................................ 270
El método forward:: .............................................................................................. 271
Parámetros formales y reales ............................................................................... 272
Redefinir el forwarding ......................................................................................... 274
Delegados y herencia ............................................................................................ 276
Posing ................................................................................................................... 276
Mensajes remotos .................................................................................................... 278
Modificadores de tipo ........................................................................................... 280
Mensajes síncronos y asíncronos .......................................................................... 281
Paso de punteros .................................................................................................. 282
Paso de objetos ..................................................................................................... 284
Tipos de datos y constantes predefinidas ................................................................. 285
Tipos de datos predefinidos .................................................................................. 285
Constantes predefinidas ....................................................................................... 287
Optimización del acceso a métodos .......................................................................... 288
Estilos de codificación ............................................................................................... 289
Clases, categorías y protocolos formales .............................................................. 290
Prefijos .................................................................................................................. 290
Métodos y variables de instancia .......................................................................... 291
Funciones, variables globales y constantes .......................................................... 292
Variables locales ................................................................................................... 292
Objective-C++ ............................................................................................................ 292
PARTE II: FOUNDATION FRAMEWORK
CAPÍTULO 11: MANEJO DE FICHEROS Y DIRECTORIOS
Gestión del sistema de ficheros ................................................................................ 297
Crear, copiar y borrar ficheros y directorios ......................................................... 297
Enlaces y enlaces simbólicos ................................................................................. 299
Permisos ............................................................................................................... 299
Atributos ............................................................................................................... 300
Listar directorios ................................................................................................... 303
Acceso al contenido de los ficheros ...................................................................... 303
Directorio actual ................................................................................................... 304
Handles de ficheros ................................................................................................... 304
Crear un handle de fichero ................................................................................... 304
Leer y escribir ........................................................................................................ 305
Cerrar el handle de fichero ................................................................................... 305
Path utilities .............................................................................................................. 306
Localizar ficheros del sistema ............................................................................... 308
Resolver alias ............................................................................................................ 308
Servicios del workspace ............................................................................................ 310
Abrir ficheros ........................................................................................................ 311
Lanzar aplicaciones ............................................................................................... 311
Obtener información de ficheros .......................................................................... 313
Montar y desmontar unidades ............................................................................. 314
CAPÍTULO 12: LOS OBJETOS DATO
Qué son los objetos dato .......................................................................................... 315
Objetos dato inmutables ........................................................................................... 316
Creación a partir de un buffer ............................................................................... 316
Creación a partir de un fichero ............................................................................. 317
Acceder al buffer ................................................................................................... 317
Guardar el contenido del objeto dato ................................................................... 318
Objetos dato mutables .............................................................................................. 319
Creación ................................................................................................................ 319
Leer y modificar el contenido ............................................................................... 319
Copiar objetos dato .............................................................................................. 320
CAPÍTULO 13: ARCHIVADO Y SERIALIZACIÓN
Introducción .............................................................................................................. 321
Archivado .................................................................................................................. 322
Objetos codificadores y objetos codificables ........................................................ 323
Crear un objeto archivador ................................................................................... 325
Crear un objeto desarchivador ............................................................................. 326
Archivar un grafo de objetos ................................................................................ 327
Implementar un objeto codificable ...................................................................... 328
Codificar y decodificar tipos fundamentales ......................................................... 331
Codificación condicional ....................................................................................... 332
Restringir el soporte para objetos codificadores .................................................. 333
Serialización .............................................................................................................. 333
Listas de propiedades ........................................................................................... 334
API de serialización ............................................................................................... 335
CAPÍTULO 14: CONFIGURACIÓN DEL RUNTIME
Introducción .............................................................................................................. 337
Bundles ..................................................................................................................... 337
Estructura de un bundle moderno ........................................................................ 339
Información de configuración de un bundle ......................................................... 346
Paquetes y Finder ................................................................................................. 354
API para gestión de bundles ................................................................................. 355
Variables de entorno ............................................................................................ 362
El sistema de preferencias ........................................................................................ 362
Los dominios ......................................................................................................... 363
Acceso programático a las preferencias ............................................................... 367
Fijar las preferencias por defecto ......................................................................... 367 CAPÍTULO 15: GESTIÓN DE PROCESOS
Información de nuestro proceso ............................................................................... 369
Obtener información del proceso ......................................................................... 369
Obtener información del host ............................................................................... 370
Crear nuevos procesos .............................................................................................. 371
Obtener información sobre el proceso ................................................................. 371
Modificar el entorno de ejecución de un proceso ................................................ 372 CAPÍTULO 16: PROGRAMACIÓN MULTIHILO
Conceptos básicos ..................................................................................................... 373
Tipos de hilos ........................................................................................................ 374
Técnicas de sincronización .................................................................................... 375
Las señales ............................................................................................................ 376
Los bucles de sondeo ............................................................................................ 376
Consideraciones de diseño ................................................................................... 377
Alternativas a la programación multihilo .............................................................. 378
Los objetos operación ........................................................................................... 379
Protección multihilo .............................................................................................. 379
Crear hilos ................................................................................................................. 379
Crear hilos Foundation .......................................................................................... 379
Crear hilos POSIX................................................................................................... 382
Hilos POSIX en Foundation .................................................................................... 384
Configurar los hilos ............................................................................................... 385
Terminar los hilos .................................................................................................. 387
Programación con objetos operación ....................................................................... 388
Ejecución directa frente a colas de operación ...................................................... 388
Operaciones no-concurrentes y concurrentes ...................................................... 388
Operaciones no-concurrentes .............................................................................. 389
Dependencias entre operaciones ......................................................................... 391
Colas de operación ................................................................................................ 392
Multiplicador de matrices ..................................................................................... 394
Operaciones concurrentes .................................................................................... 402
Métodos sincronizados ......................................................................................... 403
Responder a errores ............................................................................................. 403 CAPÍTULO 17: COMUNICACIÓN Y SINCRONIZACIÓN
Comunicación y sincronización ................................................................................. 405
Los cerrojos ............................................................................................................... 406
Cerrojos POSIX ...................................................................................................... 406
Cerrojos Foundation ............................................................................................. 407
Los bloques sincronizados .................................................................................... 410
Secciones críticas en colecciones .......................................................................... 410
Barreras de memoria y variables volátiles ................................................................ 411
Operaciones atómicas ............................................................................................... 412
Cerrojos de sondeo ................................................................................................... 414
Condiciones ............................................................................................................... 414
Condiciones POSIX................................................................................................ 415
Condiciones Foundation ....................................................................................... 418
Pipes .......................................................................................................................... 420
Pipes BSD .............................................................................................................. 420
Pipes Foundation .................................................................................................. 421
Memoria compartida ................................................................................................ 423 CAPÍTULO 18: GESTIÓN DE EVENTOS
El gestor de ventanas ................................................................................................ 427
Gestión de eventos ................................................................................................... 428
Los bucles de sondeo de eventos .............................................................................. 430
Anatomía de un bucle de sondeo ......................................................................... 431
Los modos del bucle de sondeo ............................................................................ 432
Obtener y ejecutar el bucle de sondeo ................................................................. 433
Terminar el bucle de sondeo ................................................................................ 435
Tipos de fuentes ................................................................................................... 436
Los temporizadores .............................................................................................. 438
Ejecutar selectores en otros hilos ......................................................................... 440
Bucles de sondeo Core Foundation ...................................................................... 441
Las notificaciones ...................................................................................................... 443
Para qué sirven las notificaciones ......................................................................... 443
Cuándo usar notificaciones ................................................................................... 444
Los objetos notificación ........................................................................................ 445
Los centros de notificación ................................................................................... 446
Los centros de notificación distribuidos ............................................................... 447
Las colas de notificación ....................................................................................... 452 CAPÍTULO 19: PROGRAMACIÓN EN RED
Introducción a la programación en red ..................................................................... 455
Sockets BSD ............................................................................................................... 456
Implementar un cliente ........................................................................................ 457
Implementar un servidor ...................................................................................... 461
Resolución de nombres DNS ..................................................................................... 466
Objetos stream .......................................................................................................... 467
Políticas de bloqueo .............................................................................................. 467
Procesar el stream ................................................................................................ 469
Sockets con objetos Foundation ............................................................................... 477
Representar descriptores de fichero .................................................................... 477
Operaciones asíncronas ........................................................................................ 478
Escribir datos en background ................................................................................ 483
Programación en red con Core Foundation .............................................................. 484
CFSocket ............................................................................................................... 484
CFStream ............................................................................................................... 495
CFHTTP y CFFTP .................................................................................................... 495
Sistema de carga de URLs.......................................................................................... 503
Conexión síncrona ................................................................................................. 504
Conexión asíncrona ............................................................................................... 505
Bajar ficheros ........................................................................................................ 508 CAPÍTULO 20: OBJETOS DISTRIBUIDOS
Introducción .............................................................................................................. 513
Crear y acceder a objetos remotos ........................................................................... 513
Definir el objeto remoto ....................................................................................... 514
Exportar un objeto remoto ................................................................................... 515
Acceder al objeto remoto ..................................................................................... 516
Arquitectura, conexiones y proxies ........................................................................... 518
Las conexiones ...................................................................................................... 519
Los proxies ............................................................................................................ 520
Los puertos ................................................................................................................ 523
Envío y recepción de mensajes ............................................................................. 523
Registrar los puertos ............................................................................................. 525
Autorizar conexiones ................................................................................................ 525
Manejo de errores en la conexión ............................................................................ 526
ÍNDICE ALFABÉTICO ............................................................................................ 529 |
