Estructuras principales en Android / Java

Buenos días a todos/as queridos Developers. ¿Qué tal las fiestas? Esto de la navidad es un funeral… en el mejor sentido de la palabra ¡eh! No penséis mal. En el artículo de hoy vamos a ver un tema interesante, y de muy novatillo, que son las Estructuras principales en Android/Java.

Pero antes, Iluminar un poco a vuestros compañeros con los gadgets que os han traido Papa Noel/Reyes Magos. A mí, por ejemplo, me han pillado un portátil nuevo. Aunque bien es cierto, que lo pille con un mes de adelanto, jijiji y el Destiny 2 para aprovechar los ratos muertos, ya sabéis como va esto.

Antes de continuar, como hago siempre, os invito a que os suscribáis a el “Círculo” que para quien no lo sepa. Se trata de una comunidad que estoy elaborando alrededor de la profesión para personas de habla hispana. Echarle un ojo, no os vais a arrepentir.

Visto esto, y un poco de publi, comenzamos con lo que interesa.

Nota: (Cuando hacemos referencia a Java o a Android nos referimos a los mismo, daros cuenta que Android es un framework gigante de Java en la mayoría de los aspectos)

El primer programa desarrollado en Java / Android

Como sabéis, o intuís para los más nuevos, todo programa hecho en Java debe contener al menos una clase. En el caso de programar desde Java, esta clase, la clase principal casi seguro, es la que incluirá nuestro método estático “main”. Siempre será la primera en arrancar y desde la que se desplegará todo nuestro programa.

El funcionamiento de Android es muy similar, lo que pasa que nosotros no vemos esta función cuando usamos el código de Android. Para hacer una similitud, sería nuestra actividad principal que implementa el método/función “OnCreate”.

Veamos un ejemplo de cada:

Estructuras principales de un programa en Java
Método principal donde inicia todo el programa Java

 

estructuras principales on-create en Android
Aquí vemos el método onCreate desde el que inicia nuestro programa Android

Por otro lado, tenemos la arquitectura del sistema operativo. También lo tenemos que mentar porque es muy importante sentar unas bases correctas que definan bien los pasos a seguir en nuestro aprendizaje.

Estructura de diagrama de software
Diagrama de software de un dispositivo Android

Inciso sobre los IDEs de desarrollo

Aunque no me guste, porque cada uno es libre de usar el IDE que quiera. Por si queréis seguir mis pasos, yo utilizo el estándar de Google que es Android Studio, no voy a explicar cómo instalarlo, bajar el Framework, crear el primer Hola Mundo, etc… es algo que me parece inútil meter aquí porque en todos los tutos que hay por ahí lo explican una y otra vez, y este no es un blog en el que vaya a enseñar a programar como tal, voy a enseñar a resolver problemas. Esos problemas que aparecen después de que sabes programar… ya lo entenderéis los más nuevos.

Tipos primitivos en Java / Android y las Estructuras principales

Antes de continuar por este punto, quiero hacer una definición. Los tipos primitivos no son objetos.

Actualmente, y dudo mucho que cambien en un futuro, tenemos 4.

 

  • Booleano
    • Son los valores estándar en la programación. Se trata del “true” y el “false”. Su principal función es la evaluación de estados.
  • Entero
    • Int: Número entero de 4 bytes.
      • Primitivo estándar en el uso de datos numéricos.
    • Short: Número entero de 2 bytes.
      • Primitivo que permite guardar la mitad de rango que el int.
    • Long: Numero entero de 8 bytes.
      • Primitivo semi-estándar que permite almacenar número con un rango doble que el int. Normalmente se usa para las fechas.
    • Byte: Número entero de 1 byte
      • Primitivo que se usa para almacenar números muy pequeños. Utilizado, por regla general, para la optimización del código.
    • Punto Flotante
      • Permite el uso de coma flotante en los resultados numéricos.
        • Float: flotante de 4 bytes.
        • Double: flotante de 8 bytes.
      • Carácter
        • Se usan 2 bytes para construir cada carácter y son considerados como “Unicode”.
        • Están diseñados para soportar internacionalización.
        • Solo están permitidos entre comillas simples, las comillas dobles no los permiten.
        • Tienen un aspecto hexadecimal: \u0008.
        • El byte menos significativo corresponde al “ASCII” de 8 bits.
        • También tenemos caracteres no visibles como pueden ser el salto de línea, la tabulación, etc…
          • \b
          • \t
          • \n
          • \r

 

Las constantes en las estructuras principales

Las constantes son un tipo de “almacén” que se define para poder recordar mucho mejor los valores que no cambian durante toda la ejecución del programar. En Android, debido a su formato de Framework, hay muchas. Por norma general se presentarán en mayúsculas y tendrás unos nombres muy identificativos sobre el valor que almacenan.

Para poder definirlas se usará la palabra reservada “final”.  Cuando se usa esta palabra la constante tiene que definirse e inicializarse en la misma línea de ejecución.

  • final float NUMERO_PI = 3.1416;
  • final float CENTIMETROS_PULGADAS = 2.54;

Este tipo de dato tiene que definirse dentro de una clase y es accesible sin necesidad de instanciar un nuevo objeto de la clase.

<imagen de ejemplo de constantes>

Estructuras principales y la clase String

Esta es la clase “principal” en java. Es usada casi para todo por su posibilidad casi infinita del trato de cadenas de texto.

A diferencia de los tipos primitivos, String sí que es una clase con sus respectivos campos y funciones. Esto es importante recordarlo porque en otro lenguajes, String sí que se considera un tipo primitivo.

Para poner un ejemplo, que no sirva de distracción, solo es por comentarlo, “typescript” un lenguaje de programación web con base en Javascript.

Si queréis conocer más detalles técnicos sobre esta clase, te invito a que revises la documentación oficial donde podrás conocer todos las funciones y campos que contiene.

Documentación oficial de Android sobre la clase String.

Qué son las sentencias en las estructuras principales

Por sentencia se define una orden que le damos al programa mediante una o varias líneas de código.

Todas las sentencias terminarán en “;” (punto y coma). Este punto y coma le permite al compilador saber cuál es el final de la orden para poder comenzar a ejecutar la siguiente.

Hay muchos lenguajes de programación modernos que ya están obviando esta nomenclatura, pero he de reconocer, que si la usamos escribimos un código mucho más legible para el programador que venga después leer/usar nuestro código. Así que es una buena práctica que considero muy recomendable utilizar independientemente de si sea obligatorio o no.

Ejemplos:

  • Log.e(“error”, “Esto es una prueba”);
  • String resultado = respuesta.toString();
  • Int parse = Integer.parseInt(resultado);

En java, si no pusiéramos el “;” el programa no compilaría por error de sintaxis y nos saltaría una excepción.

Te dejo un vídeo interesante de mi amigo Juan por si queréis profundizar en el tema:

Pues hasta aquí yo creo que todo queda más o menos claro. Estas son los datos básicos sobre estructuras principales que necesitamos para poder comenzar a usar Android como framework de desarrollo y poder crear nuestras primeras aplicaciones móviles.

Para terminar, permíteme que te recuerde qué si te gusta la programación, o estás interesado en ella, (es lo lógico si estás aquí), puedes suscribirte al círculo. Una red que estoy montando alrededor de esta profesión. En ella encontrarás contenidos exclusivos, desarrollos conjuntos y un montón de cosillas más que son de interés. Aquí tienes el enlace:

¡El Círculo!

Espero que te haya gustado el contenido, si es así te agradecería que lo compartas con los botones sociales que verás por la web. Te estaré muy agradecido.

¡Nos vemos en el siguiente artículo! Un besito 😛

Deja una respuesta

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

4 × 4 =