Curso de Desarrollo de Aplicaciones iOS7 para Iphone e Ipad

16 marzo 2014
Categories: curso de desarrollo de aplicaciones móviles, curso desarrollo aplicaciones iphone e ipad, Curso ios7

Destinatarios

Programadores con conocimientos en Programación Orientada a Objetos y Bases de Datos Relacionales que tenga interés en programar aplicaciones para dispositivos móviles de Apple: Iphone e Ipad.

Requisitos

Haber entendido y practicado el Curso Básico de Objective C.

Temario

Si estás interesado en seguir formándote tenemos una serie de cursos gratuitos:

Cursos Gratuitos

También disponemos de algunos cursos de pago por si son de tu interés:

https://cursosdedesarrollo.com/tienda/

Curso de Angular:

Angular

 

Curso de Objective C: Switch y Manejo de excepciones

15 marzo 2014
Categories: mango excepciones Objective C, Objective C switch

Switch

Esta sentencia nos va a permitir realizar una condicional múltiple respecto al valor de una variable, pongamos un ejemplo:

        int j=0;
        
        switch (j) {
            case 1:
                NSLog(@”La variable j vale 1″);
                break;
            case 2:
                NSLog(@”La variable j vale 2″);
                break;
            default:
                NSLog(@”La variable j no ha entrado en ninguno de los casos”);
                break;

        }

En este caso estamos inicializando una variable entera j a 0. Y luego en el switch ponemos entre () la variable j. Esto significa que será la variable que evaluaremos para saber exactamente que valor tiene. Empezará a comprobar por el primer caso, que estamos comprobando si su valor es 1. Si es así ejecutará el bloque de código que hay justo después, incluyendo el break, Por lo tanto si su valor es 1 sacará un mensaje por consola y saldrá del switch, ya que el break funciona de una manera similar a los bucles.
Con el segundo caso pasará lo mismo si j vale 2 entrará en el bloque de código del caso 2.


Con el default para algo parecido, si no ha encontrado el valor entre los anteriores casos, se ejecutará el bloque de código que haya después del default. En este caso sacando un mensaje por la consola, indicando que no ha encontrado el valor entre el resto de los casos.

Manejo de excepciones

Con el manejo de excepciones trataremos de gestionar un fallo crítico de la aplicación en el caso de que algo sea probable que pueda fallar. Para ello tendremos tres bloques principales de código:
  • Try: o el Mundo de la piruleta: donde todo el mundo es feliz y todo se ejecutará. Es como cerrar los ojos e imaginarnos que todo saldrá bien. Es decir que todo lo que pongamos dentro del try se intentará hacer, sea o no posible. Falle o no falle realizas en intento de ejecutarlo.
  • Catch: o el mundo del cenizo: este bloque de código se ejecutará si algo falla, mientras que se genere una excepción de código en tiempo de ejecución que cumpla con el tipo de datos que pongamos en la condición del catch. El tipo de excepción más genérico es el NSException.
  • Finnaly: De todas maneras… : Independientemente de si algo falla en el Try o no. Siempre se ejecutará el bloque de código que haya dentro del finally, si lo incluimos ya que esta parte de la sentencia es opcional. 

Veamos un ejemplo de la sintaxis:

        @try {
            //Mundo de la piruleta donde cualquier cosa puede fallar
        }
        @catch (NSException *exception) {
            // Mundo del cenizo, donde algo ha fallado
        }
        @finally {
            // Código que se ejecutará en cualquiera de los casos

        }

Esto sería una sentencia try-catch completa. Después de cada parte se incluye un bloque de código que va {}. En el catch como puede verse, tenemos una condición. En este caso es la excepción más genérica de todas, así que independientemente de qué excepción se de siempre se ejecutará esa parte del código.

Veamos un ejemplo más completo:

        NSArray *coches = @[@”Honda Civic”,
                               @”Nissan Versa”,
                               @”Ford F-150″];
        int indiceSeleccion = 3;
        @try {
            //Mundo de la piruleta donde cualquier cosa puede fallar
            NSString *coche = coches[indiceSeleccion];
            NSLog(@”The selected car is: %@”, coche);
        }
        @catch (NSException *exception) {
            // Mundo del cenizo, donde algo ha fallado
            NSLog(@”Tipo del fallo:%@”,exception.name);
            NSLog(@”Causa:%@”, exception.reason);
        }
        @finally {
            // Código que se ejecutará en cualquiera de los casos
            NSLog(@”En cualquiera de los casos!”);
        }

        

En este caso tenemos un array de tres posiciones del 0 al 2 y dentro del try intentamos acceder a la cuarta posición, que no existe. en este caso nos sacará los siguientes mensajes por pantalla:

2014-03-15 11:48:53.904 03_estructuras_de_control_bucles[4442:303] Tipo del fallo:NSRangeException
2014-03-15 11:48:53.904 03_estructuras_de_control_bucles[4442:303] Algo ha fallado:*** -[__NSArrayI objectAtIndex:]: index 3 beyond bounds [0 .. 2]

2014-03-15 11:48:53.904 03_estructuras_de_control_bucles[4442:303] En cualquiera de los casos!

Como podemos ver nos salta una excepción del tipo NSRangeException, lógico porque nos hemos ido de rango con el índice del array. Con la propiedad reason, nos indica el porqué.

Referencias

Curso Básico de Objective C:Estructuras de control:Incrementos, Arrays y Bucles

15 marzo 2014
Categories: Objective C arrays, Objective C bucles

Incrementos

Una de las características básicas de cualquier lenguaje son los incrementos y decrementos, para ello veremos cómo hacerlo en Objective C:
        int numero=0;
        
        
  • Preincremento: ++numero;
  • Postincremento:  numero++;
  • Predecremento: –numero;
  • Postdecremento: numero–;
La diferencia fundamental entre un pre y un post es que se ejecuta antes o después, respectivamente, el incremento o el decremento que el resto de operadores.

Arrays

El uso de arrays sucede como en otros lenguajes, permite tener un conjunto de elementos de un determinado tipo para almacenarlos en memoria.

Inicialización

Veamos un ejemplo de inicialización:
int array[5];
En este caso estamos creando un array de 5 números enteros. En la declaración colocamos primero el tipo de los datos luego en nombre de la variable y para finalizar el número de elementos que conformarán el array.
Para acceder a los elementos deberemos realizarlo mediante el índice. El índice va desde 0 hasta el número de elementos menos 1. En este ejemplo 0 será el primer elemento y 4 el último. 
Veamos un ejemplo de inicialización de un elemento del array:
array[0]=1;
 En este caso estamos dándole el valor 1 al primer elemento del array, el que tiene el índice 0.
Otro ejemplo:
array[4]=5;
En este caso estamos poniendo el valor 5 en el último elemento del array, cuyo índice es 4.

Bucles

Otras estructuras básicas son los bucles para ello veremos todos los distintos tipos en Objetive C mediante ejemplos de uso de arrays.

For

El bucle for, o como decía mi profesor de facultad, la ametralladora, permite realizar tres sentencias en su declaración.  Veamos un ejemplo:
        int i;
        for (i=0; i<5; i++) {
            array[i]=i;
            NSLog(@”%d”,i);
        }
En este caso estamos intentando recorrer un array de 5 posiciones. Tras declarar la variable i, empieza  la ejecución del for. Analicemos las tres partes del bucle. 
Primero está la inicialización, en este caso es la primera parte que hay definida entre los (), en la que inicializamos la variable i y le ponemos valor 1. Esto es lo primero que se ejecutará al entrar en el bucle. 
Después de esto entramos a la condición, que es lo siguiente que se ejecutará, siempre que se cumpla la condición seguiremos dentro del bucle. Como en el ejemplo se cumple pasaremos a ejecutar lo que hay dentro del bucle, es decir lo que haya dentro de las {}.
En el ejemplo realizamos una inicialización de los valores de un array, y se utiliza i para reflejar la variación del índice entre 0 y 4. Es decir en las 5 vueltas que da el bucle, i valdrá 0,1,2,3 y 4. Luego explicaremos porqué.
Por último está el incremento, que es lo que se ejecutará siempre que termine la ejecución del bucle en cada iteración. En este ejemplo estamos realizando un incremento en 1 de la variable i. Éste es el motivo de que el bucle de 5 vueltas completas ya que en cada vuelta i se incrementa en 1, por que cumplirá la condición impuesta hasta que i valga 5. 

While

El bucle while funciona de una manera similar, al bucle for salvo que no tiene inicialización ni incremento, pongamos un ejemplo que funcione de una manera similar al anterior bucle for:
        i=0;
        while (i<5) {
            array[i]=i;
            NSLog(@”%d”,array[i]);
            i++;
        }
Como puede verse el bloque de código principal del bucle es casi idéntico, salvo por el incremento que está al final del bloque. Dicho incremento pretende simular el comportamiento del bucle for anterior. Así como la inicialización de la variable i, que actúa justo antes de entrar al bucle para colocar el valor de i a 0. 
De esta manera ambos bucles funcionan igual, ya que el bucle ejecutará las iteraciones mientras que se cumpla la condición ya que la inicialización, la condición y el incremento son los mismos en ambos bucles, ambos funcionan igual.

Do while

La diferencia del bucle do-While respeto al while es que el do-while al menos entrará una vez antes de comprobar la condición. Esto se puede ver mejor con un ejemplo:

        i=0;
        do{
            array[i]=i;
            NSLog(@”%d”,array[i]);
            i++;

        }while(i<5);

En este ejemplo, podemos ver la sintaxis principal, el while se coloca al final del bucle son su condición y después se pone un ;

En este ejemplo, también se ejecutará 5 veces el bucle, ya que la inicialización, la condición y el incremento son iguales al anterior ejemplo. Salvo que si alteráramos la condición para que finalizase antes. Pero podemos decir que un bucle do-while siempre se ejecutará al menos una vez.

break y continue

Estas dos palabras reservadas nos van a permitir alterar el comportamiento de los bucles, veamoslas en funcionamiento con un ejemplo:

        for (i=0; i<5; i++) {
            if(i<2){
                continue;
            }
            if(i==4){
                break;
            }
            NSLog(@”%d”,i);

        }

Como podemos ver en el ejemplo, estamos ante un bucle for que inicialmente debería dar 5 vueltas. Por su inicialización, condición e incremento. Pero dentro del bloque de código tenemos dos sentencias condicionales if.

En el primer if, se comprueba si i<2 por lo que se ejecutará al menos mientras que i es igual a 0 o a 1. Que es lo que sucederá en las dos primeras iteraciones del bucle. Por lo que en ambas iteraciones se ejecutará al continue. Lo que provoca el continue es que se vaya al final del bucle sin ejecutar nada más, se ejecute el incremento y se vuelva a analizar la condición. Por lo que no se ejecutará ni el segundo if ni el NSLog en las dos primeras vueltas.

En la tercera vuelta, no se cumple el primer if, ya que i vale 2, ni tampoco se cumple el segundo if ya que i no es igual a 4. Por lo que sí se ejecutará el NSLog. En la cuarta vuelta pasará lo mismo, porque i es igual a 3.

Pero en la quinta vuelta, i vale 4. Por lo que se sigue sin cumplir la condición del primer if, pero sí se cumple la condición del segundo if. Ya que i vale 4. Entonces se ejecutará el bloque de código correspondiente a ese if.

Ahí es cuando nos encontramos con el break. Lo que sucede al ejecutar un break, es que nos obliga a salirnos del bucle sin ejecutar nada más del bloque de código que tengamos. Por lo que no ocurrirá ninguna iteración más.

La salida completa por consola de este trozo de código podría ser similar a la siguiente:

2014-03-15 10:56:28.987 03_estructuras_de_control_bucles[4150:303] 2
2014-03-15 10:56:28.987 03_estructuras_de_control_bucles[4150:303] 3

Como habíamos explicado anteriormente sólo hay dos salidas por pantalla, cuando i vale 2 o 3.

Curso Básico de Objective C: Objetos NS:NSDate, NSArray, NSDictionary y NSString

13 marzo 2014
Categories: Clases NS Objective C, curso objective c

NSDate

Es uno de los objetos principales de la biblioteca Fundation, nos permite manejar fechas y traducirlas a Cadenas y viceversa. 
        NSDate *fecha   =[[NSDate alloc]init];
        NSLog(@”%@”, fecha );
Como podemos ver en el ejemplo una fecha puede ser inicializada como un objeto normal. Al intentar imprimirla por consola, nos saca un mensaje similar al siguiente:

2014-03-13 00:48:10.323 03_objetos_principales[1467:303] 2014-03-12 23:48:10 +0000

Donde la parte importante es:
2014-03-12 23:48:10 +0000

Que es la fecha inicial del momento en el que se ejecutó la sentencia. Como puede verse nos devuelve un formato cadena en el indica en el siguiente orden:

  • año
  • mes
  • dia
  • hora
  • minuto
  • segundo
  • franja horaria

Este es el formato anglosajón de fechas, aunque podríamos llegar a obtener la información en segundos desde el 1 de enero de 1970, de la siguiente manera:

        double segundosdesde1970=[fecha timeIntervalSince1970];
        NSLog(@”%f”,segundosdesde1970);

Aunque lo que normalmente nos suele interesar en disponer de una fecha un poco más legible por parte del usuario:

NSLog(@”Descripcion:%@”,[fecha descriptionWithLocale:[NSLocale currentLocale]]);

Lo cual nos saldrá una salida en nuestro idioma por defecto:

jueves, 13 de marzo de 2014 00:56:09 Hora estándar de Europa central

También suele ser interesante la generación de una fecha en base a una fecha que a nosotros nos interese:

NSDate *fecha2=[[NSDate alloc] initWithString:@”2001-03-24 10:45:32 +0600″];

Con este tipo de inicialización indicamos los datos de la fecha con el mismo orden que indicamos anteriormente y tendremos un objeto NSDate con la fecha indicada.

Y luego podríamos gestionar un salida por pantalla eligiendo los datos y el orden de los mismos gestionando el formato de la cadena de salida:

NSLog(@”%@”,[fecha2 descriptionWithCalendarFormat:@”%d/%m/%Y” timeZone:nil locale:[NSUserDefaults standardUserDefaults]]);

Esto nos proporciona una salida similar a la siguiente:

24/03/2001

NSArray

Los arrays son una necesidad a la hora de gestionar conjuntos de datos, para ello Objective C nos provee de esta clase que nos facilita las cosas a la hora de gestionar los arrays.

Veamos un ejemplo de inicialización de un array con dos elementos:

 NSArray * array= [NSArray arrayWithObjects:@”uno”, @”dos”, nil];

Como se puede ver tenemos un array con dos elementos, el primero es un cadena de caracteres con el valor uno y el segundo otra cadena. Para inicializar el array utilizamos un método de clase llamado arrayWithObjects que nos permite un número indefinido de parámetros. De lo único que debemos recordar es que debemos terminar con un último parámetro cuyo valor sea nil para terminar la definición de los elementos. Y nos devolverá el array con los objetos que le hemos indicado.

Es una manera muy fácil de rellenar estos arrays, veamos ahora las funciones típicas de uso de arrays, empezando por el atributo count:

NSLog(@”%lu”, (unsigned long)array.count);

Con count podemos ver el número de elementos que tiene el array.

Con el objectAtIndex podemos pedirle que nos devuelva el objeto que esté presente en una posición:

NSLog(@”%@”, [array objectAtIndex:0]);

for-each

Este tipo especial de bucle está preparado para recorrer colecciones de elementos, de una manera similar a cómo sucede en Java, veamos un ejemplo:
        for (id object in array) {
            NSLog(@”%@”, object);
        }
Como puede verse tenemos un array y lo vamos a recorrer con el bucle. En cada una de las iteraciones tendremos un objeto llamado object que tendrá el valor del objeto que se encuentre en la posición que corresponda dentro de la iteración. Empezando por el primer objeto y terminando por el último. Así recorreremos el array de una manera muy cómoda.

Otras métodos interesantes

También disponemos de un método que nos permite si un objeto está presente dentro del array llamado containsObject :
       NSLog(@”%d”,[array containsObject:@”uno”]);
Como puede verle le pasamos como parámetro el objeto que estamos buscando. Nos devolverá un valor entero 1 si está 0 si no está. 
El método indexOfObject nos permite buscar un elemento en el array y nos devuelve la posición del objeto:
NSLog(@”%lu”,(unsigned long)[array indexOfObject:@”uno”]);
 Y ya por último el método   nos permite saber si dos arrays son iguales o no:
NSLog(@”%hhd”,[array isEqual:array]);

NSMutableArray

Con esta clase podremos manejar un array de objetos pero en el que podremos modificar dinámicamente en tiempo de ejecución el número de objetos que contiene. Veamos su inicialización:
NSMutableArray *arraymutable=[[NSMutableArray alloc]init];
Como vemos se inicializa como un objeto normal.
Para añadir objetos usaremos el método addObject  como en el ejemplo:
[arraymutable addObject:@”uno”];
También disponemos de un método que permite eliminar un objeto según su posición:
[arraymutable removeObjectAtIndex:0];
Evidentemente los NSMutableArray también pueden ser recorridos con un for-each, coger un elemento por su posición y contar el número de elementos:
        
        for (id object in arraymutable) {
            NSLog(@”%@”, object);
        }

        NSLog(@”%lu”, (unsigned long)[arraymutable count]);
        
        NSLog(@”%@”, [arraymutable objectAtIndex:0]);
       
        NSLog(@”%@”,arraymutable);

NSDictionary

Los NSDictionary nos van a permitir guardar pares de objetos en forma de listado.  Cada par dispone de una clave y un valor.  Veamos cómo inicializar un diccionario:

        NSDictionary *diccionario=[NSDictionary dictionaryWithObjects:[NSArray arrayWithObjects:@”uno”, @”dos”, nil] forKeys:[NSArray arrayWithObjects:@”1″,@”2″, nil]];

Como pude verse se utiliza el método dictionaryWithObjects la cual necesita dos parámetros un array con los valores y otro con las claves. En el ejemplo estamos inicializando dos arrays en la misma línea de inicialización del diccionario.

Para recoger el valor relacionado con una clave, usaremos el método objectForKey para lo cual necesitamos pasarle como parámetro la clave relacionada:

NSLog(@”%@”, [diccionario objectForKey:@”1″]);

Para recorrer el diccionario podemos usar un foreach, de la siguiente manera:

        for (NSObject* key in diccionario) {
            id value = [diccionario objectForKey:key];
            NSLog(@”Clave:%@”, key);
            NSLog(@”Valor:%@”, value);
        }

  También podemos recoger todos las claves y los valores con estos dos métodos:

        NSLog(@”%@”,[diccionario allKeys]);
        NSLog(@”%@”,[diccionario allValues]);       

NSMutableDictionary

Los NSMutableDictionary funcionan de una manera similar a los NSDictionary pero pudiendo modificar al vuelo los objetos que almacena. Veamos un ejemplo de inicialización:

        NSMutableDictionary *diccionariomutable=[[NSMutableDictionary alloc]init];

En este caso, lo estamos inicializando de manera vacía. Ahora intentaremos añadir un nuevo par al diccionario:
        [diccionariomutable setValue:@”uno” forKey:@”1″];

En este caso estamos añadiendo una cadena de caracteres como primer parámetro, el valor, y como segundo parámetro la clave relacionada. 

Por supuesto podemos coger el valor asociado a una clave:
        NSLog(@”%@”, [diccionariomutable objectForKey:@”1″]);
También podemos borrar todos los elementos del diccionario:
        [diccionariomutable removeAllObjects];
Borrar elementos por su clave:
        [diccionariomutable removeObjectForKey:@”1″];
Recorrer el diccionario:
        for (NSObject* key in diccionariomutable) {
            id value = [diccionariomutable objectForKey:key];
            NSLog(@”%@”, value);
        }

NSString

 La Clase NSString permite el almacenamiento de una cadena de caracteres. Veamos un ejemplo de  inicialización básico:

        NSString *cadena=[[NSString alloc]init];
        cadena=@”Literal”;

Con la propiedad length podemos saber la longitud de la cadena:

       NSLog(@”logitud: %lu”,(unsigned long)cadena.length);

 Ahora veremos una inicialización directa con un literal:

        NSString *otracadena=[[NSString alloc] initWithString:@”Otro Literal”];

Podemos inicializarla también mediante un formato con variables:
        NSString *cad=[[NSString alloc] initWithFormat:@”con formato %@”,cadena, nil];
Incluso recorrerla con un for:
        for (int i=0; i<cad.length; i++) {
            NSLog(@”%c”,[cad characterAtIndex:i]);
        }
Convertirla en mayúsculas:
        NSLog(@”%@”,[cad uppercaseString]);
minúsculas:
        NSLog(@”%@”,[cad lowercaseString]);
saber si es igual a otra cadena:
        NSLog(@”%d”,[cad isEqual:cad]);
saber si tiene un prefijo o un sufijo:
        NSLog(@”%d”,[cad hasPrefix:@”con”]);
        NSLog(@”%d”,[cad hasSuffix:@”Literal”]);

NSMutableString

Este tipo especial de cadena de caracteres es modificable sin la necesidad de crear nuevos objetos constantemente, veamos su inicialización:
NSMutableString *mutante=[[NSMutableString alloc]initWithFormat:@”Cadena con numero %d”, 3];
Podemos añadir contenido al final de la cadena:
        [mutante appendString:@” con apendice”];
Incluso hacer copias de cadenas:
        NSMutableString *nuevacadena=[cad mutableCopy];

NSNumber

Nos permite almacenar números enteros, aquí hay un ejemplo de inicialización y uso:
        NSNumber *numero=[[NSNumber alloc]initWithInt:7];
        NSLog(@”%d”,numero.intValue);
        NSLog(@”%@”,numero);

EJERCICIOS PROPUESTOS

  • Crea un nuevo proyecto que permita realizar estos ejercicios.
  • Crea una nueva clase que se llama Evento, que contenga los siguientes datos: identificativo numérico, nombre, lugar, fecha inicio, fecha fin, número de asistentes.
  • Crea un constructor sin parámetros y otro con parámetros en la clase Evento.
  • Dentro del main.m: crea un par de objetos de la Clase Evento. El primero inicializarlo con el constructor sin parámetros y el segundo con el constructor con parámetros.
  • Meter los datos en las propiedades del primer objeto mediante el uso de sus propiedades.
  • Modificar los datos del segundo objeto mediante los setter.
  • Crea un array estático de 3 objetos de tipo Evento.
  • Imprime por consola el segundo elemento del array.
  • Crea un array dinámico de 20 objetos de tipo Evento. 
  • Imprime por consola todos los datos de cada Evento del array dinámico. 
  • Eliminar el último objeto del array dinámico y vuelve a presentarlo por consola. 
  • Cre un diccionario dinámico que contenga los datos de un Evento como valores dentro del diccionario, las claves relacionadas con esos valores serán cadenas de caracteres con el nombre de la propiedad del objeto Evento. Es decir, en la clave @”nombre” deberá estar el nombre del evento, y el resto igual. 

Suscríbete al Boletín

Si quieres estar al tanto de las novedades del blog, ya sabes :)
* = campo obligatorio

powered by MailChimp!

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. ACEPTAR

Aviso de cookies