Hola clase en objetive-C

Aprende Objetive C paso a paso. iOS

0. Introducción
1. Nuestro primer programa en Objetive-C
2. Los comentarios en Objetive-C
3. Tipos de datos básicos en Objetive-C
4. Definición de variables en objetive-C
5. Inicialización de variables en objetive-C
6. Literales (cadenas) y constantes en objetive-C
7. Operadores en objetive-C
8. Bucles en objetive-C
9. Sentencias condicionales (if) en objetive-C
10. Sentencias condicionales (switch) en objetive-C
11. Números en objetive-C. La clase NSNumber
12. Funciones en objetive-C. Paso por valor y por referencia
13. Arrays en objetive-C
14. Punteros en objetive-C
15. Strings en objetive-C
16. Clases en objetive-C

0. Introducción a Objetive-C

Objetive C es un lenguaje utilizado por Apple para realizar aplicaciones en los sistemas operativos OS X e IOS. En este tutorial te enseñaremos a programar en Objetive C sin tener que utilizar XCode que es el entorno de desarrollo de Apple.

Para seguir este tutorial seguramente necesitaras tener un “mínimo” de conocimientos de programación

Simplemente con una conexión a Internet podrás realizar pequeños programas, compilarlos y ejecutarlos.

Para compilar y ejecutar tus programas vamos a utilizar la siguiente herramienta online:

http://www.tutorialspoint.com/codingground.htm

Es una herramienta online para compilar y ejecutar programas sin tener que tener instalado ningún tipo de compilador en tu máquina.

Vamos a realizar nuestro primer programa en Objetive C:

programa hola clase

programa hola clase

Compila el siguiente código en coding ground. Para ello tienes que elegir dentro de Códing Ground que vas a realizar un proyecto en Objetive C.

objetive c logo

objetive c logo

Te va a aparecer un entorno de desarrollo como el siguiente:

Herramienta coding ground

Herramienta coding ground

En él puedes observar que aparece por defecto un pequeño programa Hola Mundo que nosotros vamos a modificar un poco.



1. Nuestro primer programa en Objetive-C

En primer lugar vamos a copiar el siguiente programa:

#import <Foundation/Foundation.h>

@interface miClase:NSObject
- (void)miPrograma;
@end

@implementation miClase
- (void)miPrograma{
NSLog(@"¡Hola Clase! \n");
}
@end

int main()
{
miClase *miClase1 = [[miClase alloc]init];
[miClase1 miPrograma];
return 0;
}

Tras compilar el código anterior y ejecutarlo nuestro programa tiene que mostrar en la parte derecha “¡Hola Clase!”.

Un programa básico en Objetive-C suele tener las siguientes partes:

  • Comandos de preprocesamiento.
  • Generalmente todos los programas necesitan incluir librerías para realizar algo. Dependiendo de la funcionalidad del programa se incluyen unas librerías u otras.
    En nuestro caso pedimos que el compilador incluya la librería Foundation.h con la siguiente línea:
    #import <Foundation/Foundation.h>

  • Interfaz.
  • En nuestro caso nuestra clase miClase va a tener un método que vamos a llamar miPrograma:

    @interface miClase:NSObject
    - (void)miPrograma;
    @end

    Recuerda que para finalizar la sección colocamos la sentencia “@end”.

  • Implementación.
  • En esta sección se implementan los métodos definidos en la sección de interfaz. Es en esta zona donde se va incluyendo el código de los métodos anteriores.

    @implementation miClase
    - (void)miPrograma{
    NSLog(@"¡Hola Clase! \n");
    }
    @end

  • Rutina principal o Main.
  • En nuestro programa creamos un objeto de la clase miClase llamado miClase1 y llamamos al método miPrograma de dicho objeto “[miClase1 miPrograma]“.
    int main()
    {
    miClase *miClase1 = [[miClase alloc]init];
    [miClase1 miPrograma];
    rreturn 0;
    }

    Dentro de los métodos tendremos variables, sentencias y expresiones y comentarios. Más adelante veremos cada una de estos conceptos más en profundidad.

    2. Los comentarios en Objetive-C

    Como en C, los comentarios en un programa objetive-C van entre los caracteres /* y */. Todo lo que va entre estos caracteres no se ejecuta.

    Un ejemplo de comentario dentro de un programa sería el siguiente:

    /* ahora llamo a la siguiente función….*/

    Recuerda que todas las sentencias en objetive-C terminan en punto y coma “;”.

    3. Tipos de datos básicos en Objetive-C

    En esta sección vamos a ver los tipos de datos más básicos en objetive-C. Si necesitas algo más específico te recomiendo ver guías de referencia más completas.

    Enteros

    char (1 byte) comprende números enteros de -128 a 127 o de 0 to 255
    int (2 o 4 bytes) comprende números enteros de -32.768 a 32.767 o de -2.147.483.648 a 2.147.483.647
    short (2 bytes) comprende números enteros de -32.768 a 32.767
    long (4 bytes) comprende números enteros de -2.147.483.648 a 2.147.483.647

    Coma flotante

    float (4 bytes) comprende números en coma flotante de 1.2E-38 a 3.4E+38 precisión de 6 posiciones decimales
    double (8 bytes) comprende números en coma flotante de 2.3E-308 a 1.7E+308 precisión de 15 posiciones decimales

    void

    void no representa ningún valor.

    4. Definición de variables en objetive-C

    Veamos ejemplos de definición de variables en objetive-C:

    int a,b;
    short j,k,l;
    double m;

    5. Inicialización de variables en objetive-C

    Veamos ejemplos de definición e inicialización/asignación de valores de variables en objetive-C:

    int a,b=3;
    char c;
    a=5;
    c=’j';

    Ahora veamos un ejemplo de miniprograma en objetive-C el cual calcula el perímetro de un círculo tomando un radio dado:

    #import <Foundation/Foundation.h>
    int main ()
    {
    /* definition de variables: */
    int radio;
    float perimetro;
    /* initialización de variables*/
    radio = 5;
    perimetro = 2 * 3.14 * radio;
    NSLog(@"perímetro : %f\n", perimetro);
    return 0;
    }
    ¿Serías capáz de crear un programa que resolviese ecuaciones de segundo grado dándole tu los valores a, b y c de la fórmula?

    6. Literales (cadenas) y constantes en objetive-C

    Las cadenas en Objetive-C van siempre entrecomilladas. Por ejemplo, “hola” es un ejemplo de literal.

    Las constantes en Objetive-C se crean con la palabra reservada define. Un ejemplo sería el siguiente:

    #import <Foundation/Foundation.h>
    #define LADO 10
    int main()
    {
    int area;
    area = LADO * LADO;
    NSLog(@"El valor del área es: %d", area);
    return 0;
    }

    También puedes definir constantes con la palabra const. Veamos un ejemplo:

    #import <Foundation/Foundation.h>
    const int LADO = 10;
    int main()
    {
    int area;
    area = LADO * LADO;
    NSLog(@"El valor del área es: %d", area);
    return 0;
    }

    7. Operadores en objetive-C

    Los operadores de Objetive-C son los mismos que los de C o Java. Aquí te dejo un enlace para que le eches un vistazo si no te los conoces.
    Operadores en C

    8. Bucles en objetive-C

    Los bucles en objetive-C son iguales que los utilizados en C o en Java. Veamos unos ejemplos:

    Bucle infinito:

    #import <Foundation/Foundation.h>
    int main ()
    {
    for( ; ; )
    {
    NSLog(@"bucle infinito.\n");
    }
    return 0;
    }

    Bucle for:

    #import <Foundation/Foundation.h>
    int main ()
    {
    int a;
    for( a = 10; a < 20; a = a + 1 )
    {
    NSLog(@"item a: %d\n", a);
    }
    return 0;
    }

    Bucle while:

    #import <Foundation/Foundation.h>
    int main ()
    {
    int a = 1;
    while( a < 100 )
    {
    NSLog(@"item a: %d\n", a);
    a++;
    }
    return 0;
    }

    Sentencias condicionales (if) en objetive-C

    Al igual que los bucles, las sentencias if en objetive-C son iguales que los utilizados en C o en Java. Veamos unos ejemplos:

    if( a < 20 )
    {
    NSLog(@" es menor que 20\n" );
    }
    else
    {
    NSLog(@"a es mayor o igual que 20\n" );
    }
    ¿Serías capáz de crear un programa que con bucles creara triángulos del siguiente tipo?
    1
    1 1
    1 2 1
    1 3 3 1
    Con una constante se podría definir el número de filas que tendría el triángulo.

    Solución:

    #import <Foundation/Foundation.h>

    @interface SampleClass:NSObject
    - (int)pos:(int)fila andNum2:(int)columna;
    @end

    @implementation SampleClass
    - (int)pos:(int)fila andNum2:(int)columna{

    if (columna == 1) { return 1; }
    if (columna > fila) { return 0; }
    if (columna == fila) { return 1; }
    //int ret = 0;
    SampleClass *sampleClass = [[SampleClass alloc]init];
    //int ret = [pos:5 andNum2:4];// + [sampleClass pos:fila-1 andNum2:columna];
    int ret = [sampleClass pos:(fila-1) andNum2:columna-1] + [sampleClass pos:fila-1 andNum2:columna];

    return ret;}
    @end

    int main ()
    {
    SampleClass *sampleClass1 = [[SampleClass alloc]init];
    const int numfilas = 5;
    int i,j;
    for (i=1;i<=numfilas;i++){
    for (j=1;j<=i;j++){
    NSLog(@"%d\n",[sampleClass1 pos:(i) andNum2:j]);
    }
    NSLog(@"\n");
    }
    return 0;
    }

    Sentencias condicionales (switch) en objetive-C

    Las sentencias switch son identicas a las utilizadas en Java y C. Son sentencias muy útiles en ciertos casos donde se quiere preguntar por los distintos valores que adopta una variable.

    Veamos un ejemplo:

    #import <Foundation/Foundation.h>
    int main ()
    {
    /* local variable definition */
    int nota = 7;
    switch(nota)
    {
    case 10 :
    NSLog(@"Excelente\n" );
    break;
    case 9 :
    case 8 :
    case 7 :
    NSLog(@"Muy bien\n" );
    break;
    case 6 :
    NSLog(@"Aprobaste\n" );
    break;
    case 5 :
    NSLog(@"Muy raspado\n" );
    break;
    default :
    NSLog(@"Tienes que estudiar más\n" );}
    return 0;
    }
    Realiza el ejercicio anterior teniendo en cuenta que las notas se representan con letras. A, B, C y D son aprobados mientras que E y F son suspensos. Pon los mensajes que quieras.

    Números en objetive-C. La clase NSNumber

    Además de los tipos básicos como pueden ser int, float, etc, en Objetive-C se utiliza mucho la clase NSNumber la cual tiene algunos métodos para trabajar con números de todo tipo o incluso convertir esos números a string.

    Veamos un ejemplo de utilización de esta clase y posteriormente comentaremos algunas líneas de código:

    #import <Foundation/Foundation.h>
    @interface myclase:NSObject
    - (NSNumber *)suma:(NSNumber *)a masB:(NSNumber *)b;
    @end
    @implementation myclase
    - (NSNumber *)suma:(NSNumber *)a masB:(NSNumber *)b
    {
    float numero1 = [a floatValue];
    float numero2 = [b floatValue];
    float resultado = numero1 + numero2;
    NSNumber *result = [NSNumber numberWithFloat:resultado];
    return result;
    }
    @end

    int main()
    {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    myclase *myclase1 = [[myclase alloc]init];
    NSNumber *a = [NSNumber numberWithFloat:30.5];
    NSNumber *b = [NSNumber numberWithFloat:45.60];
    NSNumber *resultadofloat = [myclase1 suma:a masB:b];
    NSString *resultado = [resultadofloat stringValue];
    NSLog(@"La suma es %@",resultado);
    [pool drain];
    return 0;
    }

    float resultado = numero1 + numero2;
    NSNumber *result = [NSNumber numberWithFloat:resultado];

    En las líneas anteriores el resultado que es un número de tipo float se asigna al objeto result de la clase NSNumber. Para ello se utiliza el método numberWithFloat de la clase NSNumber al que se le pasa el parámetro resultado (que es un float).

    NSNumber *resultadofloat = [myclase1 suma:a masB:b];
    NSString *resultado = [resultadofloat stringValue];

    En estas líneas anteriores lo que se hace es que el objeto resultadofloat de la clase NSNumber va a contener la suma de los valores a y b. Para mostrar el resultado con posterioridad medinte la función NSLog se transforma el resultado numérico en un string (utilizamos por ello un objeto de la clase NSString).

    Modifica el ejemplo anterior para que la clase myclase tenga los métodos de multiplicación, división y resta también.

    SOLUCIÓN PARCIAL (solo se añade el método resta):

    #import <Foundation/Foundation.h>
    @interface myclase:NSObject
    - (NSNumber *)suma:(NSNumber *)a masB:(NSNumber *)b;
    /* defino la funcion resta*/
    - (NSNumber *)resta:(NSNumber *)a menosB:(NSNumber *)b;
    @end
    @implementation myclase
    - (NSNumber *)suma:(NSNumber *)a masB:(NSNumber *)b
    {
    float numero1 = [a floatValue];
    float numero2 = [b floatValue];
    float resultado = numero1 + numero2;
    NSNumber *result = [NSNumber numberWithFloat:resultado];
    return result;
    }
    /* código de la función resta*/
    - (NSNumber *)resta:(NSNumber *)a menosB:(NSNumber *)b
    {
    float numero1 = [a floatValue];
    float numero2 = [b floatValue];
    float resultado = numero1 – numero2;
    NSNumber *result = [NSNumber numberWithFloat:resultado];
    return result;
    }

    @end

    int main()
    {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    myclase *myclase1 = [[myclase alloc]init];
    NSNumber *a = [NSNumber numberWithFloat:30.5];
    NSNumber *b = [NSNumber numberWithFloat:45.60];
    NSNumber *resultadofloat = [myclase1 suma:a masB:b];
    NSString *resultado = [resultadofloat stringValue];
    NSLog(@@"La suma es %@@",resultado);
    /*AHORA VOY CON LA RESTA*/
    resultadofloat = [myclase1 resta:b menosB:a];
    resultado = [resultadofloat stringValue];
    NSLog(@@"La resta es %@@",resultado);
    [pool drain];
    return 0;
    }

    Funciones en objetive-C. Paso por valor y por referencia

    La diferencia entre pasar parámetros por valor y por referencia es la siguiente:

    Cuando paso parámetros (utilizando variables) por valor a un método, las variables origen no modifican su valor, simplemente le prestan su contenido al método para que realice su función.
    Por el contrario cuando paso parámetros por referencia, las variables pasadas si cambian de valor dentro del método verán su contenido modificado una vez ejecutado dicho método.

    Veamos todo esto con un ejemplo:

    #import <Foundation/Foundation.h>
    @interface myclase:NSObject
    - (void)swapporvalor:(int)num1 yNum2:(int)num2;
    - (void)swapporreferencia:(int *)num1 yNum2:(int *)num2;
    @end
    @implementation myclase
    - (void)swapporvalor:(int)num1 yNum2:(int)num2
    {
    int temp;
    temp = num1; /* Almaceno num1 en una variable temporal*/
    num1 = num2; /* coloco num2 en num1 */
    num2 = temp; /* coloco temp en num2 */
    }
    - (void)swapporreferencia:(int *)num1 yNum2:(int *)num2
    {
    int temp;
    temp = *num1; /* Almaceno num1 en una variable temporal */
    *num1 = *num2; /* coloco num2 en num1 */
    *num2 = temp; /* coloco temp en num2 */
    return;
    }
    @end
    int main ()
    {
    int a = 45;
    int b = 32;
    myclase *myclase1 = [[myclase alloc]init];
    NSLog(@"ANTES DEL SWAP, A vale: %d\n", a );
    NSLog(@"ANTES DEL SWAP, B vale : %d\n", b );
    /* LLAMADA A LA FUNCIÓN POR VALOR */
    [myclase1 swapporvalor:a yNum2:b];
    NSLog(@"DESPUES DEL SWAP POR VALOR, A vale : %d\n", a );
    NSLog(@"DESPUES DEL SWAP POR VALOR, B vale : %d\n", b );
    /* LLAMADA A LA FUNCIÓN POR REFERENCIA */
    [myclase1 swapporreferencia:&a yNum2:&b];
    NSLog(@"DESPUES DEL SWAP POR REFERENCIA, A vale : %d\n", a );
    NSLog(@"DESPUES DEL SWAP POR REFERENCIA, B vale : %d\n", b );
    return 0;
    }

    Veamos cómo definimos un método con una variable pasada por valor y otra por referencia

    - (void)swapporvalor:(int)num1 yNum2:(int)num2;
    - (void)swapporreferencia:(int *)num1 yNum2:(int *)num2;

    En la variable pasada por referencia los parámetros se definen como punteros (en vez de definirse int se definen como int *)

    [myclase1 swapporvalor:a yNum2:b];
    [myclase1 swapporreferencia:&a yNum2:&b];

    A la hora de hacer la llamada, cuando se llaman a los parámetros por referencia se le pasan las direcciones de las variables a y b (utilizando &a y &b). De esa manera en vez de utilizar una copia de la variable se utilizan las mismas variables y las modificaciones se realizan sobre las variables originales.

    Modifica el ejemplo anterior para que la clase myclase tenga dos métodos: dobleporvalor y dobleporreferencia en la que toma un parámetro por valor o por referencia y calcula su doble.

    Arrays en objetive-C

    Vamos a ver cómo funcionan los array en Objetive-C viendo un ejercicio práctico.

    #import <Foundation/Foundation.h>
    int main ()
    {
    int num[ 20 ]; /* num es un array de 20 números enteros */
    int i,j;
    /* vamos a inicializar los valores del array */
    for ( i = 0; i < 20; i++ )
    {
    num[ i ] = i + 1; /* le damos el valor a cada posición del array 1, 2, ... */
    }
    /* recorremos el array y mostramos los valores */
    for (j = 0; j < 20; j++ )
    {
    NSLog(@"Elemento[%d] = %d\n", j, num[j] );
    }
    return 0;
    }

    La declaración de un array en Objetive-C sigue el mismo patrón que en C.

    Tipodedatos nombredelArray [ Tamaño ];

    Un par de ejemplos de declaración de arrays serían los siguientes;

    int arrint[ 100 ];
    double arrdouble[ 20 ];

    La inicialización de los arrays se puede hacer como en el ejercicio o bien se pueden inicializar en el momento de la declaración de la siguiente manera:

    int arrint[ 3 ]={1,2,3};

    Modifica el ejemplo anterior para que los valores del array sean la sucesión de números de Fibonacci. Crea un array de 30 posiciones.
    Deberás de trabajar también con funciones.

    Punteros en objetive-C

    Un puntero es una variable que contiene la dirección de memoria de otra variable. Si queremos declarar un puntero a una variable entera por ejemplo lo podríamos declarar de esta manera:

    int *punt;

    La variable punt no contiene un entero, contiene una dirección de memoria de una variable entera. Los punteros se diferencian de otras variables porque en su declaración se utiliza un asterisco.

    Veamos un ejemplo de un pequeño programa que utiliza punteros:

    #import <Foundation/Foundation.h>
    int main ()
    {
    int num = 5; /* declaración e inicialización de un entero */
    int *punt; /* puntero a una variable entera */
    punt = # /* el puntero ahora apunta a num*/

    NSLog(@"Dirección de la variable num: %x\n", &num );
    NSLog(@"Dirección almacenada en el puntero punt: %x\n", punt );
    NSLog(@"Contenido de la variable apuntada por punt: %d\n", *punt );
    return 0;
    }

    Dos cosas:
    Para acceder a la dirección de memoria de una variable se utiliza el operador &:
    punt = #
    Para acceder al contenido de la variable de un puntero se utiliza el operador *:
    int num2 = *punt;

    Compila y ejecuta el código anterior. Comprueba que funciona correctamente.

    Strings en objetive-C

    Objetive-C utiliza la clase NSString para representar cadenas de caracteres. Como se verá a continuación trabajar con cadenas de caracteres en Objetive C es trabajar con objetos con la potencia y versatilidad que ofrecen.

    Veamos cómo se crea un string básico:

    NSString *saludo = @"Hola amigo!";

    Veamos ahora cómo podemos integrar el string anterior dentro de un pequeño programa en Objetive-C:

    #import <Foundation/Foundation.h>
    int main ()
    {
    NSString *saludo = @"Hola amigo!";
    NSLog(@"Saludo de un amigo: %@\n", saludo );
    return 0;
    }
    Compila y ejecuta el código anterior. Comprueba que funciona correctamente.

    La clase NSString tiene múltiples métodos como (double)doubleValue,(NSString *)capitalizedString,(BOOL)isEqualToString:(NSString *)aString,(NSString *)lowercaseString, etc.

    Crea un pequeño programa que pase las siguientes cadenas “Emma” y “emma” a minúsculas y compare si son iguales o diferentes. Para crear el programa tendrás que utilizar alguno de los métodos comentados arriba.

    Clases en objetive-C

    Las clases en Objetive C son la base de la programación orientada a objetos. Con las clases se pueden especificar tanto las características de los objetos con sus propiedades así como su interacción con el exterior (métodos). Tanto los datos como los métodos dentro de una clase se denominan miembros de la clase.

    Al crear un programa orientado a objetos en Objetive C tienes que tener en cuenta lo siguiente:

    * Las clases en Objetive-C se dividen en dos secciones llamadas @interface e @implementation.
    * Los objetos contienen variables de instancia.
    * Todos los programas orientados a objetos estan compuestos por objetos que interactuan unos con otros.
    * Las clases encapsulan y ocultan la implementación de los objetos.
    * Cuando defines una clase lo que estas creando es un molde para poder crear objetos posteriormente.
    * Todas las clases derivan de la superclase NSObject la cual proporciona métodos básicos como la inicialización y la ubicación en memoria.

    Veamos un ejemplo de una clase en Objetive-C:

    @interface cuadrado:NSObject
    {
    //variables de instancia
    double lado; // lado del cuadrado
    }
    @property(nonatomic, readwrite) NSString color; // Propiedad color
    -(double) area;
    @end

    Tienes que tener en cuenta que las variables de instancia solamente son accedidas por los métodos de la clase. En el ejemplo anterior lado es una variable de instancia.

    Las propiedades o @property se utilizan en Objetive-C para permitir que las variables de instancia de la clase puedan ser accedidas desde fuera de la clase. Como puedes observar las propiedades van precedidas de la cláusula @property seguidas de especificaciones de acceso como nonatomic, atomic, readonly, readwrite o strong. Se puede hacer un synthesize de la variable para que cree los getter y setter pero en las últimas versiones de XCode NO HACE FALTA.

    ¿Qué hacemos para crear objetos de una clase determinada?
    Muy sencillo los alojamos en memoria y los inicializamos.

    cuadrado cuadrado1 = [[cuadrado alloc]init];
    cuadrado cuadrado2 = [[cuadrado alloc]init];
    cuadrado cuadrado3 = [[cuadrado alloc]init];

    Veamos un ejemplo completo de clase cuadrado:

    #import <Foundation/Foundation.h>
    @interface cuadrado:NSObject
    {
    double lado; // lado del cuadrado
    }
    @property(nonatomic, readwrite) double lado; // Property
    -(double) area;
    @end

    @implementation cuadrado
    @synthesize lado;
    -(id)init
    {
    self = [super init];
    lado = 1.0;
    return self;
    }
    -(double) area
    {
    return lado*lado;
    }
    @end

    int main (int argc, const char * argv[])
    {
    NSAutoreleasePool * pool = [[NSAutoreleasePool alloc] init];
    double unarea = 0.0;
    cuadrado *cuadrado1 = [[cuadrado alloc]init]; // creamos un objeto de tipo cuadrado
    cuadrado1.lado=5.0;
    unarea = [cuadrado1 area];
    NSLog (@"Area del cuadrado:%f",unarea);

    NSLog (@"fin del programa");
    [pool drain];
    return 0;
    }

    Compila y ejecuta el código anterior. Comprueba que funciona correctamente.
    Crea también la clase cubo a partir de la clase cuadrado la cual tendrá los métodos área y volumen.
    Comprueba y verifica que te funciona también la clase cubo.

    One thought on “Aprende Objetive C paso a paso. iOS

    Deja un comentario

    Tu dirección de correo electrónico no será publicada. Los campos necesarios están marcados *

    Puedes usar las siguientes etiquetas y atributos HTML: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>