mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-27 11:18:51 +00:00
852 lines
33 KiB
Objective-C
852 lines
33 KiB
Objective-C
---
|
|
language: Objective-C
|
|
contributors:
|
|
- ["Eugene Yagrushkin", "www.about.me/yagrushkin"]
|
|
- ["Yannick Loriot", "https://github.com/YannickL"]
|
|
- ["Levi Bostian", "https://github.com/levibostian"]
|
|
translators:
|
|
- ["David Hsieh", "http://github.com/deivuh"]
|
|
lang: es-es
|
|
filename: LearnObjectiveC-es.m
|
|
---
|
|
Objective C es el lenguaje de programación principal utilizado por Apple para los sistemas operativos OS X y iOS y sus respectivos frameworks, Cocoa y Cocoa Touch.
|
|
Es un lenguaje de programación para propósito general que le agrega al lenguaje de programación C una mensajería estilo "Smalltalk".
|
|
|
|
|
|
```objective_c
|
|
// Los comentarios de una sola línea inician con //
|
|
|
|
/*
|
|
Los comentarios de múltiples líneas se ven así.
|
|
*/
|
|
|
|
// Importa los encabezados de Foundation con #import
|
|
// Utiliza <> para importar archivos globales (generalmente frameworks)
|
|
// Utiliza "" para importar archivos locales (del proyecto)
|
|
#import <Foundation/Foundation.h>
|
|
#import "MyClass.h"
|
|
|
|
// Si habilitas módulos para proyectos de iOS >= 7.0 u OS X >= 10.9 en
|
|
// Xcode 5, puedes importarlos de la siguiente manera:
|
|
@import Foundation;
|
|
|
|
// El punto de entrada de tu programa es una función llamada
|
|
// main con un tipo de retorno entero.
|
|
int main (int argc, const char * argv[])
|
|
{
|
|
// Crear un autorelease pool para manejar la memoria al programa
|
|
NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
|
|
// Si se utiliza el conteo automático de referencias (ARC),
|
|
// utiliza @autoreleasepool:
|
|
@autoreleasepool {
|
|
|
|
// Utiliza NSLog para imprimir líneas a la consola
|
|
NSLog(@"Hello World!"); // Imprimir el string "Hello World!"
|
|
|
|
///////////////////////////////////////
|
|
// Tipos y variables
|
|
///////////////////////////////////////
|
|
|
|
// Declaraciones de primitivos
|
|
int myPrimitive1 = 1;
|
|
long myPrimitive2 = 234554664565;
|
|
|
|
// Declaraciones de objetos
|
|
// Pon el * como prefijo de los nombre de las variables para declaraciones
|
|
// de objetos de tipos fuertes
|
|
MyClass *myObject1 = nil; // Tipo fuerte
|
|
id myObject2 = nil; // Tipo débil
|
|
// %@ es un objeto
|
|
// 'description' es una convención para mostrar el valor de los objetos
|
|
NSLog(@"%@ and %@", myObject1, [myObject2 description]);
|
|
// imprime => "(null) and (null)"
|
|
|
|
// String
|
|
NSString *worldString = @"World";
|
|
NSLog(@"Hello %@!", worldString); // imprime => "Hello World!"
|
|
// NSMutableString es una versión mutable del objeto NSString
|
|
NSMutableString *mutableString = [NSMutableString stringWithString:@"Hello"];
|
|
[mutableString appendString:@" World!"];
|
|
NSLog(@"%@", mutableString); // imprime => "Hello World!"
|
|
|
|
// Literales de caracteres
|
|
NSNumber *theLetterZNumber = @'Z';
|
|
char theLetterZ = [theLetterZNumber charValue]; // o 'Z'
|
|
NSLog(@"%c", theLetterZ);
|
|
|
|
// Literales de enteros
|
|
NSNumber *fortyTwoNumber = @42;
|
|
int fortyTwo = [fortyTwoNumber intValue]; // o 42
|
|
NSLog(@"%i", fortyTwo);
|
|
|
|
NSNumber *fortyTwoUnsignedNumber = @42U;
|
|
unsigned int fortyTwoUnsigned = [fortyTwoUnsignedNumber unsignedIntValue]; // o 42
|
|
NSLog(@"%u", fortyTwoUnsigned);
|
|
|
|
NSNumber *fortyTwoShortNumber = [NSNumber numberWithShort:42];
|
|
short fortyTwoShort = [fortyTwoShortNumber shortValue]; // o 42
|
|
NSLog(@"%hi", fortyTwoShort);
|
|
|
|
NSNumber *fortyOneShortNumber = [NSNumber numberWithShort:41];
|
|
unsigned short fortyOneUnsigned = [fortyOneShortNumber unsignedShortValue]; // o 41
|
|
NSLog(@"%u", fortyOneUnsigned);
|
|
|
|
NSNumber *fortyTwoLongNumber = @42L;
|
|
long fortyTwoLong = [fortyTwoLongNumber longValue]; // o 42
|
|
NSLog(@"%li", fortyTwoLong);
|
|
|
|
NSNumber *fiftyThreeLongNumber = @53L;
|
|
unsigned long fiftyThreeUnsigned = [fiftyThreeLongNumber unsignedLongValue]; // o 53
|
|
NSLog(@"%lu", fiftyThreeUnsigned);
|
|
|
|
// Literales de punto flotante
|
|
NSNumber *piFloatNumber = @3.141592654F;
|
|
float piFloat = [piFloatNumber floatValue]; // o 3.141592654f
|
|
NSLog(@"%f", piFloat); // imprime => 3.141592654
|
|
NSLog(@"%5.2f", piFloat); // imprime => " 3.14"
|
|
|
|
NSNumber *piDoubleNumber = @3.1415926535;
|
|
double piDouble = [piDoubleNumber doubleValue]; // o 3.1415926535
|
|
NSLog(@"%f", piDouble);
|
|
NSLog(@"%4.2f", piDouble); // imprime => "3.14"
|
|
|
|
// NSDecimalNumber es una clase de punto-fijo que es más preciso que float o double
|
|
NSDecimalNumber *oneDecNum = [NSDecimalNumber decimalNumberWithString:@"10.99"];
|
|
NSDecimalNumber *twoDecNum = [NSDecimalNumber decimalNumberWithString:@"5.002"];
|
|
// NSDecimalNumber no tiene la capacidad de utilizar los operadores estándares
|
|
// +, -, * , /, por lo que cuenta con sus propios operadores:
|
|
[oneDecNum decimalNumberByAdding:twoDecNum];
|
|
[oneDecNum decimalNumberBySubtracting:twoDecNum];
|
|
[oneDecNum decimalNumberByMultiplyingBy:twoDecNum];
|
|
[oneDecNum decimalNumberByDividingBy:twoDecNum];
|
|
NSLog(@"%@", oneDecNum); // imprime => 10.99 como NSDecimalNumber es inmutable
|
|
|
|
// Literales BOOL
|
|
NSNumber *yesNumber = @YES;
|
|
NSNumber *noNumber = @NO;
|
|
// o
|
|
BOOL yesBool = YES;
|
|
BOOL noBool = NO;
|
|
NSLog(@"%i", yesBool); // prints => 1
|
|
|
|
// Objecto arreglo
|
|
// Puede contener diferentes tipos de datos, pero deben de ser un objeto de
|
|
// Objective-C
|
|
NSArray *anArray = @[@1, @2, @3, @4];
|
|
NSNumber *thirdNumber = anArray[2];
|
|
NSLog(@"Third number = %@", thirdNumber); // imprime => "Third number = 3"
|
|
// NSMutableArray es una versión mutable de NSArray, permitiendo el cambio
|
|
// de los elementos del arreglo y el agrandado o encojimiento del objeto arreglo.
|
|
// Conveniente, pero no tan eficiente como NSArray en cuanto a rendimiento.
|
|
NSMutableArray *mutableArray = [NSMutableArray arrayWithCapacity:2];
|
|
[mutableArray addObject:@"Hello"];
|
|
[mutableArray addObject:@"World"];
|
|
[mutableArray removeObjectAtIndex:0];
|
|
NSLog(@"%@", [mutableArray objectAtIndex:0]); // imprime => "World"
|
|
|
|
// Objecto Diccionario
|
|
NSDictionary *aDictionary = @{ @"key1" : @"value1", @"key2" : @"value2" };
|
|
NSObject *valueObject = aDictionary[@"A Key"];
|
|
NSLog(@"Object = %@", valueObject); // imprime => "Object = (null)"
|
|
// NSMutableDictionary también está disponible como un objeto mutable
|
|
NSMutableDictionary *mutableDictionary = [NSMutableDictionary dictionaryWithCapacity:2];
|
|
[mutableDictionary setObject:@"value1" forKey:@"key1"];
|
|
[mutableDictionary setObject:@"value2" forKey:@"key2"];
|
|
[mutableDictionary removeObjectForKey:@"key1"];
|
|
|
|
// Objeto de Set
|
|
NSSet *set = [NSSet setWithObjects:@"Hello", @"Hello", @"World", nil];
|
|
NSLog(@"%@", set); // imprime => {(Hello, World)} (el orden puede variar)
|
|
// NSMutableSet también está disponible como un objeto mutable
|
|
NSMutableSet *mutableSet = [NSMutableSet setWithCapacity:2];
|
|
[mutableSet addObject:@"Hello"];
|
|
[mutableSet addObject:@"Hello"];
|
|
NSLog(@"%@", mutableSet); // prints => {(Hello)}
|
|
|
|
///////////////////////////////////////
|
|
// Operadores
|
|
///////////////////////////////////////
|
|
|
|
// Los operadores funcionan como en el lenguaje C
|
|
// Por ejemplo:
|
|
2 + 5; // => 7
|
|
4.2f + 5.1f; // => 9.3f
|
|
3 == 2; // => 0 (NO)
|
|
3 != 2; // => 1 (YES)
|
|
1 && 1; // => 1 (and lógico)
|
|
0 || 1; // => 1 (or lógico)
|
|
~0x0F; // => 0xF0 (negación bitwise)
|
|
0x0F & 0xF0; // => 0x00 (AND bitwise)
|
|
0x01 << 1; // => 0x02 (acarreamiento a la izquierda bitwise (por 1))
|
|
|
|
///////////////////////////////////////
|
|
// Estructuras de control
|
|
///////////////////////////////////////
|
|
|
|
// Declaraciones If-Else
|
|
if (NO)
|
|
{
|
|
NSLog(@"I am never run");
|
|
} else if (0)
|
|
{
|
|
NSLog(@"I am also never run");
|
|
} else
|
|
{
|
|
NSLog(@"I print");
|
|
}
|
|
|
|
// Declaración Switch
|
|
switch (2)
|
|
{
|
|
case 0:
|
|
{
|
|
NSLog(@"I am never run");
|
|
} break;
|
|
case 1:
|
|
{
|
|
NSLog(@"I am also never run");
|
|
} break;
|
|
default:
|
|
{
|
|
NSLog(@"I print");
|
|
} break;
|
|
}
|
|
|
|
// Declaración de ciclos While
|
|
int ii = 0;
|
|
while (ii < 4)
|
|
{
|
|
NSLog(@"%d,", ii++); // ii++ incrementa ii en la misma línea, luego de
|
|
// utilizar su valor
|
|
} // imprime => "0,"
|
|
// "1,"
|
|
// "2,"
|
|
// "3,"
|
|
|
|
// Declaración de ciclos For
|
|
int jj;
|
|
for (jj=0; jj < 4; jj++)
|
|
{
|
|
NSLog(@"%d,", jj);
|
|
} // imprime => "0,"
|
|
// "1,"
|
|
// "2,"
|
|
// "3,"
|
|
|
|
// Declaraciones foreach
|
|
NSArray *values = @[@0, @1, @2, @3];
|
|
for (NSNumber *value in values)
|
|
{
|
|
NSLog(@"%@,", value);
|
|
} // imprime => "0,"
|
|
// "1,"
|
|
// "2,"
|
|
// "3,"
|
|
|
|
// Objeto de ciclos For. Puede ser utilizado con cualquier tipo de objecto de
|
|
// Objective-C
|
|
for (id item in values) {
|
|
NSLog(@"%@,", item);
|
|
} // imprime => "0,"
|
|
// "1,"
|
|
// "2,"
|
|
// "3,"
|
|
|
|
// Declaraciones Try-Catch-Finally
|
|
@try
|
|
{
|
|
// Tus declaraciones aquí
|
|
@throw [NSException exceptionWithName:@"FileNotFoundException"
|
|
reason:@"File Not Found on System" userInfo:nil];
|
|
} @catch (NSException * e) // utiliza: @catch (id exceptionName) para atrapar
|
|
// todos los objetos
|
|
{
|
|
NSLog(@"Exception: %@", e);
|
|
} @finally
|
|
{
|
|
NSLog(@"Finally. Time to clean up.");
|
|
} // imprime => "Exception: File Not Found on System"
|
|
// "Finally. Time to clean up."
|
|
|
|
// Los objetos NSError son útiles para argumentos de función para los
|
|
// errores de usuario.
|
|
NSError *error = [NSError errorWithDomain:@"Invalid email." code:4 userInfo:nil];
|
|
|
|
///////////////////////////////////////
|
|
// Objetos
|
|
///////////////////////////////////////
|
|
|
|
// Crea una instancia de objeto alocando memoria e inicializándola
|
|
// Un objeto no es completamente funcional hasta que ambos pasos hayan sido
|
|
// completados
|
|
MyClass *myObject = [[MyClass alloc] init];
|
|
|
|
// El modelo de programación orientada a objetos de Objective-C es basada en
|
|
// el envío de mensajes a instancias de objetos
|
|
// En Objective-C no se llama a un método; se envía un mensaje
|
|
[myObject instanceMethodWithParameter:@"Steve Jobs"];
|
|
|
|
// Limpiar la memoria que se utilizó en el programa
|
|
[pool drain];
|
|
|
|
// Fin de @autoreleasepool
|
|
}
|
|
|
|
// Fin del programa
|
|
return 0;
|
|
}
|
|
|
|
///////////////////////////////////////
|
|
// Clases y funciones
|
|
///////////////////////////////////////
|
|
|
|
// Declara tu clase en archivo de encabezado (MyClass.h)
|
|
// Sintaxis de declaración de clase:
|
|
// @interface NombreDeClase : NombreDeClasePadre <ProtocolosImplementados>
|
|
// {
|
|
// type nombre; <= declaraciones de variables;
|
|
// }
|
|
// @property tipo nombre; <= declaración de propiedades
|
|
// -/+ (tipo) Declaración de método; <= Declaración de método
|
|
// @end
|
|
@interface MyClass : NSObject <MyProtocol> // NSObject es la clase de objeto
|
|
// base de Objective-C.
|
|
{
|
|
// Declaraciones de variables de instancia (puede existir en el archivo de
|
|
// interfaz o de implementación)
|
|
int count; // Acceso protegido por defecto.
|
|
@private id data; // Acceso privado (Más conveniente de declarar en el
|
|
// archivo de implementación)
|
|
NSString *name;
|
|
}
|
|
// Notación conveneinte para acceso público de las variables para generar un
|
|
// método setter
|
|
// Por defecto, el nombre del método setter 'set' seguido del nombre de
|
|
// variable @property
|
|
@property int propInt; // Nombre del método 'setter' = 'setPropInt'
|
|
@property (copy) id copyId; // (copy) => Copia el objeto durante la asignación
|
|
// (readonly) => No se le puede asignar un valor fuera de @interface
|
|
@property (readonly) NSString *roString; // utiliza @synthesize en
|
|
// @implementation para crear un accesor
|
|
// Puedes personalizar el nombre del getter y del setter en lugar de utilizar
|
|
// el nombre por defecto "set".
|
|
@property (getter=lengthGet, setter=lengthSet:) int length;
|
|
|
|
// Métodos
|
|
+/- (return type)methodSignature:(Parameter Type *)parameterName;
|
|
|
|
// + Para métodos de clase:
|
|
+ (NSString *)classMethod;
|
|
+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight;
|
|
|
|
// - Para métodos de instancia:
|
|
- (NSString *)instanceMethodWithParameter:(NSString *)string;
|
|
- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number;
|
|
|
|
// Métodos de constructor con argumentos
|
|
- (id)initWithDistance:(int)defaultDistance;
|
|
// Los nombres de los métodos de Objective-C son muy descriptivos.
|
|
// Siempre nombra los métodos de acuerdo con sus argumentos
|
|
|
|
@end // Define el final de la interfaz
|
|
|
|
|
|
// Para acceder a las variables públicas desde el archivo de implementación,
|
|
// @property genera un método setter automáticamente. El nombre del método
|
|
// es 'set' seguido de un nombre de variable @property:
|
|
MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia del objeto MyClass
|
|
[myClass setCount:10];
|
|
NSLog(@"%d", [myClass count]); // imprime => 10
|
|
// O utilizando los métodos getter y setter personalizados en @interface:
|
|
[myClass lengthSet:32];
|
|
NSLog(@"%i", [myClass lengthGet]); // imprime => 32
|
|
// Por conveniencia, puedes utilizar la notación de punto para asignar y
|
|
// acceder a las variables de una instancia de objeto.
|
|
myClass.count = 45;
|
|
NSLog(@"%i", myClass.count); // imprime => 45
|
|
|
|
// Llama a métodos de clase:
|
|
NSString *classMethodString = [MyClass classMethod];
|
|
MyClass *classFromName = [MyClass myClassFromName:@"Hello"];
|
|
|
|
// Llama a métodos de instancia:
|
|
MyClass *myClass = [[MyClass alloc] init]; // Crea una instancia de objeto Myclass
|
|
NSString *stringFromInstanceMethod = [myClass instanceMethodWithParameter:@"Hello"];
|
|
|
|
// Selectors
|
|
// Una forma dinámica de representar métodos. Utilizados para llamar métodos
|
|
// de una clase, pasar métodos a través de funciones para avisar a otras clases
|
|
// para que lo llamen, y para guardar métodos como una variable.
|
|
// SEL es el tipo de dato. @selector() devuelve un selector del nombre de
|
|
// método proveído methodAparameterAsString:andAParameterAsNumber: es un nombre
|
|
// para un método en MyClass
|
|
SEL selectorVar = @selector(methodAParameterAsString:andAParameterAsNumber:);
|
|
if ([myClass respondsToSelector:selectorVar]) { // Revisa si la clase contiene el método
|
|
// Debe de poner todos los argumentos de método en un solo objeto para mandar una
|
|
// función performSelector.
|
|
NSArray *arguments = [NSArray arrayWithObjects:@"Hello", @4, nil];
|
|
[myClass performSelector:selectorVar withObject:arguments]; // Calls the method
|
|
} else {
|
|
// NSStringFromSelector() devuelve un NSString del nombre de método de un selector dado
|
|
NSLog(@"MyClass does not have method: %@", NSStringFromSelector(selectedVar));
|
|
}
|
|
|
|
// Implementa los métodos de un archivo de implementación (MyClass.m):
|
|
@implementation MyClass {
|
|
long distance; // Variable de instancia de acceso privado
|
|
NSNumber height;
|
|
}
|
|
|
|
// Para acceder a una variable pública del archivo de interfaz, utiliza '_' seguido del
|
|
// nombre de la variable:
|
|
_count = 5; // Hace referencia a "int count" de la interfaz de MyClass
|
|
// Accede variables definidas en el archivo de implementación:
|
|
distance = 18; // Hace referencia a "long distance" de la implementación de MyClass
|
|
// Para utilizar una variable @property en el archivo de implementación, utiliza
|
|
// @synthesize para crear una variable de acceso:
|
|
@synthesize roString = _roString; // _roString ahora está disponible en @implementation
|
|
|
|
// Lamado antes de llamar algún método o instanciar cualquier objeto
|
|
+ (void)initialize
|
|
{
|
|
if (self == [MyClass class]) {
|
|
distance = 0;
|
|
}
|
|
}
|
|
|
|
// Contraparte para inicializar un método. Llamado cuando el contador de referencias
|
|
// del objeto es cero
|
|
- (void)dealloc
|
|
{
|
|
[height release]; // Si no utilizas ARC, asegúrate de liberar las variables de
|
|
// objeto de las clases
|
|
[super dealloc]; // y llama el método dealloc de la clase padre
|
|
}
|
|
|
|
// Los constructores son una manera de crear instancias de una clase
|
|
// Este es el constructor por defecto que es llamado cuando el objeto es inicializado.
|
|
- (id)init
|
|
{
|
|
if ((self = [super init])) // 'super' es utilizado para acceder a los
|
|
// métodos de la clase padre.
|
|
{
|
|
self.count = 1; // 'self' es utilizado para que el objeto se llame a sí mismo.
|
|
}
|
|
return self;
|
|
}
|
|
// Se pueden crear constructores que contiene argumentos
|
|
- (id)initWithDistance:(int)defaultDistance
|
|
{
|
|
distance = defaultDistance;
|
|
return self;
|
|
}
|
|
|
|
+ (NSString *)classMethod
|
|
{
|
|
return @"Some string";
|
|
}
|
|
|
|
+ (MyClass *)myClassFromHeight:(NSNumber *)defaultHeight
|
|
{
|
|
height = defaultHeight;
|
|
return [[self alloc] init];
|
|
}
|
|
|
|
- (NSString *)instanceMethodWithParameter:(NSString *)string
|
|
{
|
|
return @"New string";
|
|
}
|
|
|
|
- (NSNumber *)methodAParameterAsString:(NSString*)string andAParameterAsNumber:(NSNumber *)number
|
|
{
|
|
return @42;
|
|
}
|
|
|
|
// Objective-C no tiene declaraciones de métodos privados, pero pueden ser simulados.
|
|
// Para simular un método privado, crea un método en @implementation pero no en @interface.
|
|
- (NSNumber *)secretPrivateMethod {
|
|
return @72;
|
|
}
|
|
[self secretPrivateMethod]; // Calls private method
|
|
|
|
// Métodos declarados dentro de MyProtocol
|
|
- (void)myProtocolMethod
|
|
{
|
|
// statements
|
|
}
|
|
|
|
@end // Declara el final de la implementación
|
|
|
|
///////////////////////////////////////
|
|
// Categorías
|
|
///////////////////////////////////////
|
|
// Una categoría es un grupo de métodos diseñados para extender una clase.
|
|
// Te permiten agregar nuevos métodos a una clase existente por propósitos
|
|
// de organización. Éstos no deben de serconfundidos con subclases.
|
|
// Las subclases existen para CAMBIAR la funcionalidad de un objeto mientras
|
|
// que las categoríasle AGREGAN funcionalidad de un objeto.
|
|
// Las categorías te permiten:
|
|
// -- Agregar métodos a una clase existente por propósitos de oganización.
|
|
// -- Extender clases de objetos de Objective-C (ejemplo: NSString) para
|
|
// agregar tus propios métodos.
|
|
// -- Agregar la habilidad de crear métodos protegidos y privados para las clases.
|
|
// NOTA: No sobreescribas los métodos de las clases base en una categoría
|
|
// aunque tengas la habilidad de poder hacerlo. Sobreescribir métodos puede
|
|
// causar errores en la compilación después entre diferentes categorías y
|
|
// puede arruinar el propósito de las categorías de solo AGREGAR funcionalidad.
|
|
// Utiliza subclass para sobreescribir métodos.
|
|
|
|
// Aquí una clase base simple, Car.
|
|
@interface Car : NSObject
|
|
|
|
@property NSString *make;
|
|
@property NSString *color;
|
|
|
|
- (void)turnOn;
|
|
- (void)accelerate;
|
|
|
|
@end
|
|
|
|
// Y la implementación de la clase simple, Car
|
|
#import "Car.h"
|
|
|
|
@implementation Car
|
|
|
|
@synthesize make = _make;
|
|
@synthesize color = _color;
|
|
|
|
- (void)turnOn {
|
|
NSLog(@"Car is on.");
|
|
}
|
|
- (void)accelerate {
|
|
NSLog(@"Accelerating.");
|
|
}
|
|
|
|
@end
|
|
|
|
// Ahora, si quisieramos crear un objeto Truck (Camión), crearíamos una
|
|
// subclase de Car (Carro) como si le cambiaramos de funcionalidad de Car
|
|
// para que se comporte como un camión. Pero digamos que únicamente queremos
|
|
// agregar funcionalidad al Car (Carro) existente. Un buen ejemplo sería
|
|
// limpiar el carro. Así que crearíamos una cateog®iea para agregar los
|
|
// métodos de limpieza:
|
|
// Archivo @interface: Car+Clean.h (NombreBaseDeClase+NombreDeCategoria.h)
|
|
#import "Car.h" // Asegúrate de improtar la clase que deseas extener.
|
|
|
|
@interface Car (Clean) // El nombre de la categoría está dentro de (),
|
|
// seguido del nombre de la clase base
|
|
|
|
- (void)washWindows; // Nombres de los nuevos métodos que le agregamos
|
|
// a nuestro objeto Car
|
|
- (void)wax;
|
|
|
|
@end
|
|
|
|
// Archivo @implementation: Car+Clean.m (NombreBaseDeClase+NombreDeCategoria.m)
|
|
#import "Car+Clean.h" // Importa el archivo de @interface de la categoría Clean
|
|
|
|
@implementation Car (Clean)
|
|
|
|
- (void)washWindows {
|
|
NSLog(@"Windows washed.");
|
|
}
|
|
- (void)wax {
|
|
NSLog(@"Waxed.");
|
|
}
|
|
|
|
@end
|
|
|
|
// Cualquier instancia del objeto Car tiene la habilidad de utilizar una
|
|
// categoría. Todo lo que necesitan es importarlo:
|
|
#import "Car+Clean.h" // Importa todas las diferentes categorías que
|
|
// necesites utilizar
|
|
#import "Car.h" // También debes de importar la clase base para su
|
|
// funcionalidad original
|
|
|
|
int main (int argc, const char * argv[]) {
|
|
@autoreleasepool {
|
|
Car *mustang = [[Car alloc] init];
|
|
mustang.color = @"Red";
|
|
mustang.make = @"Ford";
|
|
|
|
[mustang turnOn]; // Utiliza métodos de la clase base Car.
|
|
[mustang washWindows]; // Utiliza métodos de la categoría Clean de Car.
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Objective-C no tiene declaraciones para métodos protegidos, pero los puedes
|
|
// simular. Crea una categoría conteniendo todos los métodos protegidos,
|
|
// luego importa ÚNICAMENTE al archivo @implementation de una clase que
|
|
// pertenece a la clase Car.
|
|
@interface Car (Protected) // Nombrando la categoría 'Protected' para
|
|
// recordar que los métodos están protegidos
|
|
|
|
- (void)lockCar; // Los métodos enlistados aquí solo puedens ser creados
|
|
// por objetos Car
|
|
|
|
@end
|
|
// Para utilizar los métodos protegidos, importa la categoría,
|
|
// luego implementa sus métodos:
|
|
#import "Car+Protected.h" // Recuerda, importa únicamente el archivo
|
|
// de @implementation
|
|
|
|
@implementation Car
|
|
|
|
- (void)lockCar {
|
|
NSLog(@"Car locked."); // Las instancias de Car no puede utilizar
|
|
// lockCar porque no se encuentra en @interface
|
|
}
|
|
|
|
@end
|
|
|
|
///////////////////////////////////////
|
|
// Extensiones
|
|
///////////////////////////////////////
|
|
// Las Extensions te permiten sobreescribir atributos de propiedades de
|
|
// acceso público y métodos de un @interface
|
|
// Archivo @interface: Shape.h
|
|
@interface Shape : NSObject
|
|
|
|
@property (readonly) NSNumber *numOfSides;
|
|
|
|
- (int)getNumOfSides;
|
|
|
|
@end
|
|
// Puedes sobreescribir la variable numOfSides o el métodos getNumOfSlides
|
|
// para modificarlos con una extensión:
|
|
// Archivo @implementation: Shape.m
|
|
#import "Shape.h"
|
|
// Las extensiones se encuentran en el mismo archivo que el archivo
|
|
// de @implementation
|
|
@interface Shape () // () después del nombre de la clase base declara
|
|
// una extensión
|
|
|
|
@property (copy) NSNumber *numOfSides; // Hacer numOfSlides copy en lugar
|
|
// de readonly.
|
|
-(NSNumber)getNumOfSides; // Hacer que getNumOfSides devuelva un NSNumber
|
|
// en lugar de un int.
|
|
-(void)privateMethod; // También puedes crear una nuevos métodos privados
|
|
// dentro de las extensiones
|
|
|
|
@end
|
|
// @implementation principal:
|
|
@implementation Shape
|
|
|
|
@synthesize numOfSides = _numOfSides;
|
|
|
|
-(NSNumber)getNumOfSides { // Todas las declaraciones dentro de extensions
|
|
// deben de ser dentro de @implementation
|
|
return _numOfSides;
|
|
}
|
|
-(void)privateMethod {
|
|
NSLog(@"Private method created by extension. Shape instances cannot call me.");
|
|
}
|
|
|
|
@end
|
|
|
|
///////////////////////////////////////
|
|
// Protocolos
|
|
///////////////////////////////////////
|
|
// Un protocolo declara métodos que pueden ser implementados por cualquier otra
|
|
// clase. Los protocolos no son clases. Simplementen define una interfaz que
|
|
// otros objetos deben de implementar.
|
|
// Archivo @protocol: "CarUtilities.h"
|
|
@protocol CarUtilities <NSObject> // <NSObject> => Nombre de otro protocolo
|
|
// que se incluye en éste
|
|
@property BOOL engineOn; // La clase que lo adopta debe de utilizar
|
|
// @synthesize para todas las @properties definidas
|
|
- (void)turnOnEngine; // y todos los métodos definidos
|
|
@end
|
|
// A continuación una clase ejemplo que implementa el protcolo
|
|
#import "CarUtilities.h" // Importar el archivo @protocol.
|
|
|
|
@interface Car : NSObject <CarUtilities> // El nombre del protocolo dentro de <>
|
|
// No necesitas los nombres de @property o métodos aquí para CarUtilities.
|
|
// Estos solo es requerido por @implementation.
|
|
- (void)turnOnEngineWithUtilities:(id <CarUtilities>)car; // También Puedes
|
|
// utilizar protocolos
|
|
// como datos.
|
|
@end
|
|
// El @implementation necesita que se implementen @properties y métodos
|
|
// del protocolo.
|
|
@implementation Car : NSObject <CarUtilities>
|
|
|
|
@synthesize engineOn = _engineOn; // Crear una declaración @synthesize para el
|
|
// @property engineOn.
|
|
|
|
- (void)turnOnEngine { // Implementa turnOnEngine como quieras. Los
|
|
// protocolos no definen
|
|
_engineOn = YES; // cómo implementas un método, con tal de que lo implementes.
|
|
}
|
|
// Puedes utilizar un protocolo como data mientras sepas quee métodos y variables
|
|
// tiene implementado.
|
|
- (void)turnOnEngineWithCarUtilities:(id <CarUtilities>)objectOfSomeKind {
|
|
[objectOfSomeKind engineOn]; // Tienes acceso a las variables
|
|
[objectOfSomeKind turnOnEngine]; // y los métodos del objeto
|
|
[objectOfSomeKind engineOn]; // Puede o no puede ser YES. La clase lo
|
|
// implementa como se quiera.
|
|
}
|
|
|
|
@end
|
|
// Las instancias de Car ahora tienen acceso al protocolo.
|
|
Car *carInstance = [[Car alloc] init];
|
|
[carInstance setEngineOn:NO];
|
|
[carInstance turnOnEngine];
|
|
if ([carInstance engineOn]) {
|
|
NSLog(@"Car engine is on."); // imprime => "Car engine is on."
|
|
}
|
|
// Asegúrate de revisar si un objeto de tipo 'id' implementa un protocolo antes
|
|
// de llamar a sus métodos:
|
|
if ([myClass conformsToProtocol:@protocol(CarUtilities)]) {
|
|
NSLog(@"This does not run as the MyClass class does not implement the CarUtilities protocol.");
|
|
} else if ([carInstance conformsToProtocol:@protocol(CarUtilities)]) {
|
|
NSLog(@"This does run as the Car class implements the CarUtilities protocol.");
|
|
}
|
|
// Las categorías también pueden implementar protcolos: @interface Car
|
|
// (CarCategory) <CarUtilities>
|
|
// Puedes implementar varios protocolos:
|
|
// @interface Car : NSObject <CarUtilities, CarCleaning>
|
|
// NOTA: Si dos o más protocolos dependen entre sí, asegúrate de declararlos
|
|
// de manera adelantada:
|
|
#import "Brother.h"
|
|
|
|
@protocol Brother; // Declaración adelantada. Sin ésto, el compilador
|
|
// tira un error.
|
|
|
|
@protocol Sister <NSObject>
|
|
|
|
- (void)beNiceToBrother:(id <Brother>)brother;
|
|
|
|
@end
|
|
|
|
// Ver si el problema es que Sister depende de Brother,
|
|
// y Brother dependa de Sister.
|
|
#import "Sister.h"
|
|
|
|
@protocol Sister; // Estas líneas detienen la recursión, resolviendo el problema.
|
|
|
|
@protocol Brother <NSObject>
|
|
|
|
- (void)beNiceToSister:(id <Sister>)sister;
|
|
|
|
@end
|
|
|
|
|
|
///////////////////////////////////////
|
|
// Bloques
|
|
///////////////////////////////////////
|
|
// Los bloques son declaraciones de código, tal como una función, pueden
|
|
// ser utilizados como data.
|
|
// A continuación un bloque simple con un argumento entero que devuelve
|
|
// un el argumento más 4.
|
|
int (^addUp)(int n); // Declarar una variable para almacenar el bloque.
|
|
void (^noParameterBlockVar)(void); // Ejemplo de una declaración de variable
|
|
// de bloque sin argumentos.
|
|
// Los bloques tienen acceso a variables del mismo ámbito. Pero las variables
|
|
// son solo readonly y el valor pasado al bloque es el valor de la variable
|
|
// cuando el bloque es creado.
|
|
int outsideVar = 17; // Si modificamos outsideVar después de declarar addUp,
|
|
// outsideVar AÚN es 17.
|
|
__block long mutableVar = 3; // __block hace que las variables se puedan
|
|
// escribir en bloques.
|
|
addUp = ^(int n) { // Remueve (int n) para tener un bloque que no recibe
|
|
// ningún parámetro
|
|
NSLog(@"You may have as many lines in a block as you would like.");
|
|
NSSet *blockSet; // También puedes declarar variables locales.
|
|
mutableVar = 32; // Asignar un nuevo valor a la variable __block.
|
|
return n + outsideVar; // Declaraciones de retorno son opcionales.
|
|
}
|
|
int addUp = add(10 + 16); // Llama al bloque de código con argumentos.
|
|
// Los bloques son usualmente utilizados como argumentos a funciones que
|
|
// son llamados más adelante o para callbacks.
|
|
@implementation BlockExample : NSObject
|
|
|
|
- (void)runBlock:(void (^)(NSString))block {
|
|
NSLog(@"Block argument returns nothing and takes in a NSString object.");
|
|
block(@"Argument given to block to execute."); // Calling block.
|
|
}
|
|
|
|
@end
|
|
|
|
|
|
///////////////////////////////////////
|
|
// Manejo de memoria
|
|
///////////////////////////////////////
|
|
/*
|
|
Para cada objeto utilizado en una aplicación, la memoria debe de ser alocada
|
|
para ese objeto. Cuando la aplicación termina de utilizar ese objeto, la
|
|
memoria debe de ser desalocada para asegurar la eficiencia de la aplicación.
|
|
Objetive-C no utiliza garbage collection, y en lugar de eso utiliza conteos
|
|
de referencias. Mientras haya al menos una referencia del objeto (también
|
|
conocido como tener un objeto de adueñado), entonces el objeto estará
|
|
disponible para su uso.
|
|
|
|
Cuando una instancia es dueña un objeto, su contador de referencia incrementa
|
|
por uno. Cuando el objeto es liberado, el contador de referencia decrementa uno.
|
|
Cuando el conteo de referencia es cero, el objeto es removido de la memoria.
|
|
|
|
Con todas las interacciones de los objetos, sigue el patrón de:
|
|
(1) Crear e lobjeto, (2) utiliza el objeto, (3) libera el objeto de la memoria.
|
|
*/
|
|
|
|
MyClass *classVar = [MyClass alloc]; // 'alloc' asigna uno al conteo de
|
|
// referencias de classVar. Devuelve un
|
|
// puntero al objeto
|
|
[classVar release]; // Decrementa el conteo de referencias de classVar's
|
|
// 'retain'
|
|
// 'retain' adueña la instancia de objeto existente e incrementa el conteo de
|
|
// referencia por uno. Devuelve un puntero al objeto.
|
|
MyClass *newVar = [classVar retain]; // Si classVar es liberado, el objeto
|
|
// aún se queda en memoria porque newVar
|
|
// es el dueño.
|
|
[classVar autorelease]; // Remueve el adueñamiento de un objeto al final del
|
|
// bloque @autoreleasepool. Devuelve un puntero al objeto.
|
|
|
|
// @property puede utilizar 'retain' y 'assign' también para pequeñas
|
|
// definiciones convenientes
|
|
@property (retain) MyClass *instance; // Libera el valor viejo y retiene
|
|
// uno nuevo (referencia fuerte)
|
|
@property (assign) NSSet *set; // Apunta a un nuevo valor sin retener/liberar
|
|
// una referencia vieja (débil)
|
|
|
|
// Conteo Automático de Referencias (ARC)
|
|
// Debido a que el manejo de memoria puede ser un dolor, en Xcode 4.2 y iOS 4
|
|
// se introdujo el Conteo Automático de Referencias (ARC).
|
|
// ARC es una funcionalidad del compilador que agrega retain, release y
|
|
// autorealase automáticamente, así que al
|
|
// utilizar ARC, no se debe de utilizar retain, release o autorelease.
|
|
MyClass *arcMyClass = [[MyClass alloc] init];
|
|
// ... código utilizando arcMyClass
|
|
// Sin ARC, necesitarás llamar: [arcMyClass release] luego de terminar de
|
|
// utilizar arcMyClass. Pero con ARC, no hay necesidad. Insertará
|
|
// automáticamente la declaración de liberación.
|
|
|
|
// Mientras que para los atributos de @property 'assign' y 'retain', con ARC
|
|
// utilizarás 'weak' y 'strong'
|
|
@property (weak) MyClass *weakVar; // 'weak' no adueña el objeto. El conteo de
|
|
// referencias de la instancia original
|
|
// es fijado a ceor, weakVar automáticamente recibe el valor de nil para
|
|
// evitar cualquier 'crashing'.
|
|
@property (strong) MyClass *strongVar; // 'strong' se adueña del objeto.
|
|
// Asegura que el objeto se quede en memoria.
|
|
|
|
// Para variables regulares (no variables de @property), utiliza lo siguiente:
|
|
__strong NSString *strongString; // Por defecto. La variables de retenida en
|
|
// memoria hasta que se salga del ámbito.
|
|
__weak NSSet *weakSet; // Referencia débil a un objeto existente. Cuando el
|
|
// objeto existente es liberado, weakSet le es asginado
|
|
// un valor nil
|
|
__unsafe_unretained NSArray *unsafeArray; // Como __weak, pero unsafeArray no
|
|
// es asginado a nil cuando el objeto
|
|
// existente es liberado.
|
|
|
|
```
|
|
## Lecturas sugeridas
|
|
|
|
[Wikipedia Objective-C](http://es.wikipedia.org/wiki/Objective-C)
|
|
|
|
[Programming with Objective-C. Libro PDF de Apple](https://developer.apple.com/library/ios/documentation/cocoa/conceptual/ProgrammingWithObjectiveC/ProgrammingWithObjectiveC.pdf)
|
|
|
|
[iOS For High School Students: Getting Started](http://www.raywenderlich.com/5600/ios-for-high-school-students-getting-started)
|