Cómo Empezar A Desarrollar Aplicaciones Android

¿Cómo Empezar A Desarrollar
Aplicaciones Android?
James Revelo agosto 1, 2014 Android Studio, Fundamentos 6 Comments
El día de hoy veremos cómo Desarrollar Aplicaciones Android. A lo largo de este artículo
estudiaremos la instalación del IDE Android Studiocomo entorno de desarrollo y que
configuraciones debemos llevar a cabo para un optimo funcionamiento.
Finalmente crearemos una pequeña aplicación estilo “Hello World” para comprobar el
funcionamiento del entorno de programación.
INSTALANDO EL ENTORNO DE DESARROLLO
HERRAMIENTAS A UTILIZAR
Desarrollar para Android requiere un entorno basado en ciertas tecnologías integradas. En
primera instancia necesitamos las librerías y herramientas de los dueños, es decir,
el SDK(Software Delevelopment Kit) de Android. Con ello tendremos habilitado el camino
para generar nuevas aplicaciones en consola.
Como lenguaje de desarrollo usaremos Java para construir las aplicaciones. Además se usa
el metalenguaje XML para el diseño de interfaces a través de Parsing (Temas que veremos
más adelante).
También se usa un sistema de construcción automatizado llamado Gradle. Esta herramienta
emplea al javac (Java Compiler) para programar mediante “Scripting“ el funcionamiento
de la integración modular de nuestra aplicación. Si nunca has escuchado de ella no te
preocupes, más adelante hablaremos sobre los detalles importantes.
DESCARGAR ANDROID SDK, ANDROID STUDIO Y EL JDK

En cuanto a la herramienta para la edición y construcción, Google ha recomendado un
nuevoIDE llamado Android Studio, para que no trabajemos directamente en consola.
Además integra a Gradle para simplificar la construcción de nuestras aplicaciones. De modo
que primero visitaremos el sitio oficial para descargar este paquete con el siguiente botón:
Android Studio
Y como ya sabes, para obtener nuestra Maquina Vitual Java es necesario obtener el JDK.
Así que descárgalo desde aquí:
JDK 1.8
INSTALANDO JAVA DEVELOPMENT KIT

Cuando hayas descargado el JDK, solo ejecuta su instalador y sigue los pasos. Esta
herramienta nos dará el soporte para ejecutar Android Studio y el funcionamiento
de Gradle:
INSTALANDO ANDROID STUDIO

El primer paso es ejecutar el instalador de Android Studio:
Una vez instalado el entorno completo debemos registrar una nueva variable de
entorno para indicarle a Android Studio, donde se aloja la máquina virtual. Para ello nos
dirigiremos a
Inicio > Equipo > Propiedades del sistema:
Ahora vamos a Configuración avanzada del sistema:

Realizados estos pasos estaremos en la ventana Propiedades del Sistema. Buscaremos la
pestaña Opciones avanzadas y presionaremos el botón “Variables de Entorno…”.
Aparecerán dos Groupbox, uno llamado” Variables de usuario” y otro llamado “Variables
del Sistema”.
Pulsaremos el botón “Nueva…” en Variables del sistema y agregaremos una nueva variable
llamada JAVA_HOME. A esta nueva variable le asignaremos un String que represente la
ruta del directorio donde se encuentra instalado nuestro JDK.
Luego ejecutaremos Android Studio. Si te pide importar características de una versión

anterior solo dejas la opción predeterminada y presionas OK.
CREAR UN NUEVO PROYECTO EN ANDROID STUDIO
La primera vez que ejecutas Android Studio, aparecerá un asistente de presentación. Por
ahora elegiremos la opción “New Project…” (Nuevo proyecto) para comprobar la
estabilidad del entorno.
Se nos pedirá el nombre de la aplicación (Application Name), el dominio de tu

empresa omarca (Company Domain) y el nombre del paquete (Package Name). En este
caso he nombrado la aplicación como “Test” y “herprogramacion” para el dominio. No
uses letras capitales en el nombre de tu compañía, ya que se producirían errores.
Ahora seleccionaremos los Form Factors o Factores de Forma sobre los que se construirá el
proyecto. Por lo que seleccionamos “Phone and Tablet” (Teléfono y Tableta).
Adicionalmente debes escoger el SDK mínimo “Minimum SDK” que soportará tu
aplicación.
Por defecto viene seleccionada la última versión de la plataforma, que en este momento que
escribo el articulo es Android L Lollipop. Si el asistente no te deja cambiar la versión, no te
preocupes, luego veremos cómo acceder a versiones anteriores. Así que presiona “Next”.
El siguiente menú nos permite cual será la actividad principal de nuestra aplicación.
UnaActividad es un patrón de ejecución visual que se relacionará con las entradas
proporcionadas por el usuario para conseguir sus objetivos. Luego profundizaremos en este
concepto, por ahora elige Actividad en blanco (Blank Activity).
En este paso podemos cambiar el nombre de la actividad (Activity Name), el nombre del
Layout (Layout Name) relacionado y el titulo (Title). Si gustas deja los valores
predeterminados y luego entenderemos un poco más esta estructura. Finalmente
clickea“Finish” para comenzar.
Como ves, el entorno es muy acogedor, sencillo y con un diseño claro. Tenemos un espacio
al lado izquierdo que muestra la jerarquía de los proyectos (“Project“), un espacio de
trabajo en el centro y una previsualización (“Preview”) de la aplicación en la derecha.
Android Studio se apoya en la herramienta de Software Gradle para automatizar

lacompilación, depuración, testeo y despliegue de nuestras aplicaciones Android. Pero por
ahora no te preocupes, más adelante estudiáremos todos estos conceptos, ya que en este
momento solo nos interesa ver ejecutándose nuestra aplicación de prueba.
USANDO EL SDK MANAGER
Antes de proseguir ejecutáremos una herramienta llamada SDK Manager. Para ello presiona
el siguiente icono:
SDK Manager nos informa que complementos tenemos hasta el momento instalados en
nuestra maquina y cuáles no. Yo te recomendaría seleccionar todo lo que haya disponible e
instalarlo, ya que en algún momento necesitaras testear diferentes plataformas Android.
Obviamente se requerirá gran cantidad de tiempo de descarga para ejecutar esta tarea, pero
tendrás un robusto entorno de desarrollo.
Si no deseas instalar todo, entonces solo instala los complementos recomendados. Si usas un
Pc con arquitectura Intel entonces selecciona en la categoría “Extras“ el complemento Intel
x86 Emulator Accelerator (HAXM installer). Este plugin optimizará la ejecución de
nuestrosAVDs(Concepto que veremos en instantes).
Ahora presionaremos el botón “Install packages” para pasar a la fase de instalación. Te

recomiendo cierres todos las aplicaciones que se están ejecutando en tu PC. Cierra también
el Android Studio, ya que esta aplicación mantiene en lectura archivos que necesita el SDK
Manager, lo que podría producir errores de instalación. En seguida acepta las licencias de
todos los grupos de complementos y clickea “Install“.
Una vez terminada la instalación el siguiente paso que es abrir de nuevo Android
Studio y crear un nuevo Dispositivo Virtual Android (AVD).
¿QUÉ ES UN AVD (ANDROID VIRTUAL DEVICE)?
Un AVD o Dispositivo Virtual Android es una máquina virtual que ejecuta la plataforma
Android seleccionada, para comprobar la funcionalidad de nuestra aplicación construida.
El SDK trae consigo una pequeña aplicación de gestión de AVDs llamada AVD
Manager. Así que la ejecutaremos para crear un nuevo dispositivo virtual.
Debido que aun no tenemos dispositivos creados veremos una lista vacía. Ahora dirígete a la
pestaña “Device Definitions”, donde encontraremos definiciones disponibles para un nuevo
dispositivo.
La lista de dispositivos es grande, hay varios modelos creados por Google para diferentes
gustos. Para este ejemplo he decidido usar un teléfono móvil genérico con resolución
QVGA. Te recomiendo elijas un teléfono que use baja cantidad de recursos en memoria si
tu computadora es limitada.
Una vez hayas seleccionado, presiona el botón “Create AVD…”:
Lo que sigue es configurar los requerimientos de hardware del AVD en él asistente que se
acaba de ejecutar. En él podemos modificar el nombre del dispositivo (AVD Name),
cambiar el modelo (Device), cambiar la versión de Android con que se ejecutará (Target).
También podemos elegir con que arquitectura de procesamiento móvil (CPU/ABI) se
ejecutará y muchas características más.
La versión de Android del proyecto debe ser la misma en el AVD. De lo contrario Android
Studio desplegará un error de incompatibilidad de SDKs.
Activa la opción “Hardware Keyboard Present“ si deseas que el AVD interprete el teclado
de nuestro PC como su teclado propio. Selecciona también la opción “Use Host GPU“ para
que tu tarjeta gráfica esté disponible en la ejecución.
Una vez configurado presiona OK. En seguida se desplegará un diálogo con un reporte que
confirma que atributos se le asignaron al AVD.
A continuación iniciaremos el AVD presionando el botón “Start…“:

A continuación aparecerá otro dialogo que contiene algunas opciones de preconfiguración
antes del lanzamiento de AVD. Por ejemplo, la primera opción que encontramos es “Scale
display to real size“, esta opción permite representar el display del dispositivo en escala real
en tu monitor. Luego hablaremos de las demás opciones, por ahora presiona “Launch“ para
ejecutar nuestro AVD.
Luego del proceso de carga (dependiendo de tu hardware así mismo será el tiempo de
carga), Android estará ejecutándose en el AVD:
Si eres buen observador, verás que puedes seguir las acciones actuales del proceso de carga
viendo la herramienta logcat de la herramienta DDMS del SDK.
Como ves esta herramienta se encuentra en la barra inferior llamada “Android“. Si te fijas
bien además del logcat nos muestra que procesos están activos en el AVD (lado izquierdo),
como por ejemplo el calendario, servicio de correo, reloj, etc.
EJECUTAR UNA APLICACIÓN EN ANDROID STUDIO
Para correr tu aplicación dirígete al editor y presiona “Run app”:
En este momento Gradle comienza la compilación y empaquetado de nuestra aplicación.

Una vez terminada aparecerá una ventana que nos indica con que AVD ejecutaremos la
aplicación. Elegiremos el AVD recién iniciado con el Radio Button “Choose a running
device“ y confirmaremos la acción.
Podemos ver el proceso de instalación de la aplicación en el cuadro de herramientas inferior
llamado “App“.
Una vez finalizada la instalación tendremos a nuestra aplicación desplegando ese tan deseado
mensaje “Hello World“.
Puedes confirmar la ejecución de tu aplicación en el DDMS.
En mi caso la aplicación test representa el proceso 1001 en el AVD.

Cabe aclarar que aunque Google nos recomienda comenzar a usar desde ya Android Studio,
aun sigue en versión Beta y puede contener ciertos errores. Es importante estar pendiente de
nuevas actualizaciones para Android Studio.
Por lo general se despliega una alerta de color azul que te indica que hay una nueva
actualización de Software. O si deseas comprobar ve a Help > Check Updates.
RECOMENDACIONES PARA ACELERAR EL AVD
Soy consciente de que en algunos equipos con recursos regulares la ejecución de un AVD
puede ser tediosa. Si es tu caso puedes seguir algunos de los siguientes consejos:
APROVECHAR LA ARQUITECTURA INTEL

Instalar el Acelerador de dispositivos virtuales Android si usas arquitectura Intel. En caso
de que uses otro fabricante puedes investigar si tu micro tiene capacidad de aceleración de
Virtualización.
USAR VERSIONES ANTIGUAS DE ANDROID

Usa dispositivos de gama baja y versiones operativas de Android anteriores. Por ejemplo, si
usas la compilación Jelly Bean (API 16) podrás reducir considerablemente los recursos
necesarios de ejecución. Y si adicionalmente usas un AVD QVGA ayudarías a disminuir la
presión sobre tu hardware.
USAR TU PROPIO DISPOSITIVO MÓVIL

Usar tu propio dispositivo Android en modo depuración USB. Este proceso tarda mucho
menos que esperar una tardía ejecución del AVD. Para activar este modo solo sigue los
siguientes pasos:
1. Ve a Ajustes.
2. Luego selecciona Opciones del desarrollador.
3. Luego marca Depuración de USB.

En algunas versiones esta opción viene oculta por defecto. Si es tu caso, entonces la
habilitaremos con la siguiente configuración.
3.1 Ve a Ajustes y busca busca Acerca del dispositivo:
3.2 Presiona 7 veces la opción Número de compilación. Te darás cuenta que todo salió
bien porque aparecerá un Alert que dice “Ya eres un programador“.
3.3 Sigue los primeros pasos que indiqué arriba.
4. Ejecutar la aplicación y seleccionarlo como dispositivo de ejecución.
Si deseas que siempre se ejecute con tu teléfono entonces configuraremos el proyecto de la

siguiente manera: Iremos a la lista “app” y elegiremos “Edit Configurations…“.
Luego dirígete al Group Box llamado Target Device y selecciona el Radio Button “USB
Device“.
Al aplicar los cambios ejecuta la aplicación, espera su instalación y listo:
ERROR “USB DEVICE NOT FOUND”

En algunos casos el controlador de tu teléfono móvil aun no ha sido instalado
convenientemente, así que Android Studio presentará el error “USB device not found“.
Si es tu caso, entonces debes seguir los siguientes pasos:
1. Despliega la barra de servicios de tu escritorio:
2. Luego selecciona la opción que dice “Conectado como un dispositivo USB“:

3. Luego cambia a “Dispositivo multimedia“:
Una vez seleccionada esta opción, tu PC comenzará a reconocer un canal más completo para
la comunicación USB. Solo espera que Windows busque automáticamente el controlador y
lo instale.
Inmediatamente Android Studio reconocerá tu dispositivo.
Introducción A Java Para
Desarrollo Android
James Revelo agosto 8, 2015 Fundamentos 10 Comments
En este artículo repasarás los conceptos básicos del lenguaje Java con el fin de recordar y
fortalecer tus conocimientos.
Esto permitirá acercarte mucho más al Desarrollo Android y evitar que te pierdas en
algunostutoriales donde se usan funcionalidades de Java.
Cabe aclarar que esta no es una guía para enseñarAlgoritmia o un curso profundo de
programación Java. Simplemente quiero resaltar aquellos aspectos que serán de vital
importancia estudiar antes de crear aplicaciones Android.
Asumiré que ya tienes instalado el JDK y que conoces las potencialidades de la máquina
virtual de Java y como esta permite ejecutar secuencias en gran variedad de plataformas.
1. EJEMPLO: APLICACIÓN HELLOWORLD EN JAVA
Comencemos recordando la estructura general de un programa Java.
Recrearemos el famoso ejemplo “Hello World”, donde el objetivo principal es imprimir una
sola línea de caracteres en la consola. Para ello ve a un editor de texto como bloc de notas y
pega el siguiente código.
public class PruebaJava {

public static void main(String args[]) {
System.out.print("Recordando Java...");
}
}
Ahora guarda el archivo con extensión .java con el nombre de “PruebaJava.java” en algún
directorio de fácil localización.
Ahora abre tu consola de comandos y escribe la siguiente línea para compilar el archivo:
javac PruebaJava.java
Con ello, ya está listo el archivo PruebaJava.class. Lo que significa que ya puedes ejecutar
el programa con el comando:
java PruebaJava
Si todo ha salido bien, entonces podrás ver en consola el mensaje.
"Recordando Java..."
Este ejemplo muestra la creación de una clase sencilla con un método main(). Recuerda que
este método actúa como el punto de inicio de la aplicación. En él se ejecutan las acciones
fundamentales de la app. Si no lo incluyeras, la ejecución arrojaría un error.
La impresión del texto se logra con el método System.out.println(), solo incluyes el
texto que deseas proyectar encerrado en comillas dobles (" ").
2. PAQUETES DE CLASES
Los paquetes son estructuras de directorios que agrupan tus recursos Java para evitar
colisiones de nombres. Por ejemplo, si tuvieses una clase en el
paquetecom.herprogramacion.modelo.Archivo no habría problema en tener una clase
con el mismo nombre en com.herprogramacion.utilidades.Archivo.
Como ves, esta división aísla las características de ambas clases y así puedes nombrarlas
igual.
Las siguientes son características fundamentales para crear un sistema de paquetes:
▪ El nombre de los paquetes debe ser en minúsculas para evitar conflictos con los nombres de las clases,
las cuales usan notación CamelCase. Nada de nombres comoCom.FinaNzas.CuENTAs.
▪ Solamente los paquetes exclusivos del lenguaje pueden comenzar con la palabra java ojavax.
▪ Asegura que la estructura de los paquetes sean únicos. Generalmente se usa como convención el
dominio de internet de las compañías a la inversa. En mi caso seríacom.hermosaprogramacion.
▪ Existen casos donde el nombre de la compañía no funciona. Por ejemplo: cuando el dominio usado
contiene una palabra reservada; cuando hay caracteres especiales como'-'; o si el paquete comienza
con dígitos numéricos. Para solucionarlo antepón un guion bajo para complementar '_'.
3. APUNTAR TU CÓDIGO CON COMENTARIOS
Los comentarios son bloques de texto significativo que serán ignorados por el compilador
Java. Al igual que otros lenguajes como C++, Php, Javascript, etc., estos permiten detallar
las características de tu código, con el fin de comprender su funcionamiento por toda persona
interesada en el desarrollo.
Es posible realizar comentarios de línea simple, donde solo se escribe una línea comentada a
través de barras verticales //.
// Ejecución del bucle interno
O también comentar múltiples líneas si incluyes el texto dentro de /* */.
/*
Este conjunto de instrucciones
genera una serie de números aleatorios
con el fin de sumar sus magnitudes
*/
Comentarios TODO en Java— Existen IDEs que permiten la creación de comentarios tipo
TODO. Con ellos se puede apuntar sobre el código tareas pendientes, preguntas sin resolver,
optimizaciones por realizar, etc.
Su propósito es dinamizar el código para que el programador recuerde eventos necesarios
que completarán el desarrollo rápidamente.
Por ejemplo…
En Android Studio los comentarios TODO se escriben de la forma //TODO:
[comentarios].
//TODO-james: Recuerda crear una prueba unitaria para el resultado del parsing para esta petición.
Se escribe la palabra TODO( en Español sería “Por hacer”) y luego especificas la acción. Si
deseas añades el nombre de la persona encargada.
La ventaja es que podrás ver en forma de lista todos los comentarios TODO dentro del
proyecto o el archivo actual.
4. TIPOS DE DATOS PRIMITIVOS
El manejo de la información en Java es soportado en varios tipos de datos elementales.
Al igual que en otros lenguajes, Java soporta

números enteros, flotantes, booleanos,caracteres, strings, etc.
La siguiente es una tabla con las palabras reservadas que representan los tipos de datos
primitivos principales:
Tipo de
dato Descripción
boolean Representa los estados binarios true (1) y false (0)
byte Representa a un número de 8 bits, cuyo rango se encuentra entre -128 y 127
short Número entero de 16 bits, cuyo rango se encuentra entre -37768 y 32762
int Es capaz de contener un número entero con signo de 32 bits, cuyo rango es {-231, 231-1}
long Representa un número entero de 64 bits con signo, con rango de {-263, 263-1}
Tipo de dato para el manejo de números de punto flotante con una precisión sencilla de
float 32bits
double Tipo de dato para el manejo de números de punto flotante con un doble precisión a 64bits
char Es un tipo de dato que representa un solo carácter Unicode de 16 bits
5. DECLARAR CONJUNTOS DE VALORES CON ARRAYS
Los arrays son objetos que contienen múltiples valores de un solo tipo. La cantidad de
elementos que contenga debe ser predefinida para que sea posible relacionar un índice a la
posición.
La anterior ilustración muestra la representación visual de un array con un tamaño de

10(length). Los índices están basados en cero, por lo que el primer elemento está en la
posición 0 y el ultimo en la posición tamaño-1.
El siguiente es un ejemplo donde creamos un array de enteros con tamaño 5. Luego
asignamos valores de ejemplo e imprimimos su contenido.
PruebaArray.java
class PruebaArray {
public static void main(String[] args) {
// Declaración del array
int[] arrayDeEnteros;
// Creamos 5 espacios para enteros

arrayDeEnteros = new int[5];
arrayDeEnteros[0] = 1;
System.out.println("arrayDeEnteros[0]: "
+ arrayDeEnteros[0]);
}
}
El resultado sería:
arrayDeEnteros[0]: 1
Como ves, tanto como la declaración y la inicialización del array requiere el uso de corchetes
para indicarle al compilador que será un array.
Si deseas obtener un valor del array en algún índice específico, entonces usa los corchetes
con el índice.
Incluso puedes declarar e inicializar en una sola línea. Los valores puedes asignarlos en
llaves, separando por comas.
int [] arrayDeEnteros = {1, 3, 5, 7, 9};
6. USO DE OPERADORES
Los operadores son caracteres especiales para indicar la realización de una acción entre
variables.
¿Qué tipo de operaciones?

Si hablamos de operadores aritméticos, entonces ya sabrás a que me refiero: suma, resta,
multiplicación, división, módulo.
También operaciones lógicas como el AND, OR, NOT.
O asignación de valores, incrementos, agrupación, entre otros.
La siguiente es una tabla de los operadores en Java. Al momento de usar operadores en tus
sentencias debes tener en claro que existe una precedencia, es decir, algunos tienen más
prioridad de ejecución que otros. La tabla está agrupa por niveles de importancia.
Operadores Precedencia
sufijo expr++ expr--
unarios ++expr --expr +expr -expr ~ !
multiplicativos * / %
aditivos + -
desplazamiento de bits << >> >>>
relacionales < > <= >= instanceof
igualdad == !=
AND para bits &
OR exclusivo para bits ^
OR inclusivo para bits |
AND lógico &&
OR lógico ||
operador ternario ? :
asignación = += -= *= /= %= &= ^= |= <<= >>= >>>
Como ves, son una gran cantidad de opciones para computar tus datos. Por lo que puedes
realizar infinidad de tareas en tus aplicaciones.
7. ESTRUCTURAS DE DECISIÓN
Este tipo de sentencias se usan para desviar el flujo de ejecución de nuestros programas
basados en una condición establecida.
La estructura de decisión más simple es la sentencia if. Esta comprueba la veracidad de una
expresión para tomar decisiones. Si el valor es verdadero (true), entonces las acciones
definidas en su bloque de instrucciones.
if(expresionBooleana){
/*
Bloque de instrucciones a ejecutar si la evaluación es true
*/
}
Por ejemplo…
PruebaIf.java
class PruebaIf {
int a = 2;
int b = 3;
if(a+b >2){
System.out.println("La suma de ambos números es mayor que 2");
}
}
}
El ejemplo anterior comprueba si la suma de las variables a y b es mayor que 2. Si es así,

entonces se imprime el mensaje de confirmación.
Pero… ¿Cómo evaluar un resultado adverso?
Usando la sentencia else (en español se lee “de otro modo”).
Al usar else para complementar una sentencia if, es posible controlar el flujo con otro bloque
de instrucciones alternativo.
if(expresionBooleana){
/*
Bloque de instrucciones a ejecutar si la evaluación es true
*/
}else{
/*
Bloque de instrucciones para resultado adverso
*/
}
En el caso del ejemplo anterior, podríamos imprimir el mensaje contrario diciendo que el
resultado es menor.
if(a+b >2){
System.out.println("La suma de ambos números es mayor que 2");
}else{
System.out.println("La suma de ambos números es menor que 2");
}
Ahora… ¿qué pasa si tienes más de un resultado a controlar?

En vez de usar else, usa la variación else if para evaluar múltiples condiciones. Por
ejemplo, si existiese una variable llamada comprasTotales, la cual contiene las compras
totales de un cliente específico y se deseara imprimir el grupo al que pertenece este cliente
según el momento, podríamos usar la variación else if.
if (comprasTotales < 200) {

System.out.println("Cliente Moderado");
} else if (comprasTotales >= 200 && comprasTotales < 1000) {
System.out.println("Cliente Común");
} else if (comprasTotales >= 1000) {
System.out.println("Cliente Estrella");
}
La sentencia switch en Java— Existen casos donde la sentencia if debe expandirse a varios
else if para comprobar la igualdad de un valor en específico. Esto puede ser un poco tedioso
en la redacción del código.
La sentencia switch existe para simplificar este tipo de situaciones. Esta estructura de
decisión múltiple permite comprobar varios casos para ejecutar las instrucciones correctas.
switch(dato){
default:
// Acciones por defecto
case valor1:
// Acciones para valor 1
break;
case valor2:
// Acciones para valor 2
break;
//...
case valorN:
// Acciones para valor N
break;
}
La sentencia case determina el valor que comprobarás. Si se cumple, entonces se ejecutan

las instrucciones contenidas. Una vez terminan, se cierra cada caso con la sentencia break.
default contiene las instrucciones a realizar para aquellos valores que no fueron
especificados particularmente.
Por ejemplo… analicemos como se contarían los votos de una elección.
String opcionElegida = "Carlos Valdez";
switch (opcionElegida) {
default:
System.out.println("Opción elegida inválida");
break;
case "Ramiro Córdoba":
votosRamiroCordoba++;
break;
case "Susana Feliciano":
votosSusanaFeliciano++;
break;
case "Michael Stewart":
votosMichaelStewart++;
break;
case "Camila Rengifo":
votosCamilaRengifo++;
break;
case "Carlos Valdez":
votosCarlosValdez++;
break;
}
8. BUCLES EN JAVA
Un bucle es una estructura de repetición que permite ejecutar un mismo conjunto de

instrucciones varias veces.
Veamos cuáles tenemos a disposición.
1. while: El bucle while ejecuta una y otra vez las mismas acciones mientras la condición
que se le ha establecido sea verdadera. Es la mejor opción, si no sabes con exactitud la
cantidad de iteraciones necesarias.
while(expresionBooleana){
/*
Bloque de instrucciones
*/
}
El siguiente ejemplo muestra cómo sumar los números del 1 al 10.

PruebaWhile.java
class PruebaWhile {
int suma = 0;
int contador = 1;
while (contador <= 10) {

suma += contador;
contador++;
}
System.out.println("La suma es: " + suma);

}
}
El código anterior mostraría el siguiente resultado:
La suma es: 55
2. do-while: Este bucle es una variación del anterior. Además de repetir las instrucciones
mientras la condición sea verdadera, permite ejecutar la primera instrucción sin comprobar
la condición.
Para ello es necesario incluir las acciones dentro de la sentencia do y al final comprobar con
la sentencia while
do{
/*
Conjunto de instrucciones
*/
}
while (expresionBooleana);
El ejemplo anterior podríamos traducirlo al bucle do-while de la siguiente forma:
EjemploDoWhile.java
class PruebaDoWhile {
int suma = 0;
int contador = 1;
do {
suma += contador;
contador++;
}
while (contador <= 10);
}
}
3. for: El bucle for se encarga de repetir las instrucciones hasta la condición impuesta en sus
argumentos llegue a ser falsa. Es la mejor opción si sabes la cantidad de veces que deseas
ejecutar una condición.
for (inicialización; condicionDeParada; incremento) {

/*
Conjunto de instrucciones
*/
}
La anterior sintaxis muestra tres partes del bucle:
▪ inicialización: Inicia la cuenta del bucle. Esto ocurre una sola vez.
▪ condicionDeParada: Expresión booleana que se relaciona con la inicialización para saber en qué
momento se detendrá el bucle.
▪ incremento: Expresión llamada al final de cada iteración, la cual permite incremento o decremento
de un valor.
A continuación traduzco el mismo ejemplo de la suma de números al bucle for.
PruebaFor.java
class PruebaFor {
int suma = 0;
for (int contador = 1; contador <= 10; contador++) {
suma += contador;
}

}
}
4. for-each: El bucle for-each (en español “para cada uno”) permite ejecutar un mismo
bloque de instrucciones por cada elemento de una lista de valores. Es ideal para recorrer
estructuras de datos.
for (<tipo> nombre : estructura){

/*
Conjunto de acciones
*/
}
Por ejemplo… imprimamos el mismo array visto con anterioridad.
class PruebaForEach {
int[] arrayDeEnteros = {1, 3, 5, 7, 9};
for (int entero : arrayDeEnteros) {

System.out.println(entero);
}
}
}
La variable entero es usada para guardar el elemento actual de la iteración. Esto permite que
imprimamos cada elemento del array .
9. DEFINICIÓN DE CLASES EN JAVA
Debido a que Java es un lenguaje orientado a objetos, es indispensable tener en claro cómo
usar clases y objetos.
Una clase es la abstración de las características de un objeto en particular. Esta define las
características (atributos) que posee y los comportamientos que tendrá (métodos).
En código, podemos comparar una clase con una especie de plantilla de la cual podemos
fabricar objetos.
Para declarar una clase debes usar la palabra reservada class y luego definir un bloque de
código que comprenda sus atributos y métodos.
Por ejemplo… la siguiente es una clase que describe a un cliente.
public class Cliente {

/*
Atributos
*/
private int idCliente;
private String nombre;
private String telefono;
private float saldo;
// Método que modifica al campo saldo

public void acumularSaldo(float excedente) {
saldo += excedente;
}
}
Restringir el alcance con modificadores de acceso— Los modificadores de acceso

determinan el alcance de atributos y métodos hacia otras clases. Existen 4 posibilidades de
implementación.
▪ public: Permite que una pieza de código sea visible en todos los niveles.
▪ protected: Con este modificador solo las clases que se encuentren en el mimo paquete pueden ver
y acceder a este código.
▪ sin modificador: Permite que solo las clases del paquete accedan al código. A diferencia
deprotected, este modificador no permite que las subclases tengan privilegios del código de su
superclase.
▪ private: Solo la clase donde está contenido el código, puede tener acceso.
Simplificando un poco, observa la siguiente tabla sobre modificadores Java.
Modificador Clase Paquete Subclase Mundo
public Si Si Si Si
protected Si Si Si No
sin modificador Si Si No No
private Si No No No
El modificador final en Java— Declara que un fragmento de código no puede cambiar.

Este modificador se puede usar en clases, atributos, métodos, parámetros y variables locales.
Declarar una clase como final asegura que esta no tenga subclases, de lo contrario se
produce un error.
public final class PruebaModificadorFinal{
}
public class SubclaseDeFinal extends PruebaModificadorFinal{
El código anterior produciría el siguiente error:
Al hacerlo sobre un método, significa que las subclases de una superclase no pueden
sobrescribir este método.
public class PruebaModificadorFinal {

public final void imprimirMensaje() {
System.out.println("Probando el modificador final en métodos");
}
}
public class SubclaseDeFinal extends PruebaModificadorFinal {
public void imprimirMensaje() {

System.out.println("Intentando sobrescribir método");
}
}
Intentar sobrescribir produce este error:
Usar final con un atributo obliga a que asignes el valor en la declaración o en todos sus
constructores. El compilador lanzará un error si intentas asignar un valor en otro lugar o si
quieres asignar por segunda vez.

final int numero;
PruebaModificadorFinal() {
Mira lo que pasa si no asignas un valor.
Los parámetros con final no se les pueden reasignar un valor distinto al que ya trae hacia el
método. Si se pasa por referencia un objeto, se asegura que no cambie la referencia, más no
el contenido del objeto.

int numero;
asignarNumero(3);
}
public void asignarNumero(final int numero) {

numero = 4;
// ...
}
Habrá error al intentar asignar un valor al parámetro.
Una variable local final debe ser inicializada obligatoriamente solo una vez. Intentar asignar
por segunda vez produciría un error.

int numero;
sumarNumero(3);
}
public void sumarNumero(int numero) {

final int suma = 0;
suma = this.numero + numero;

}
La variable suma del método sumarNumero() no permitirá ejecutar la segunda sentencia.

El modificador static en Java— Con static podemos declarar atributos y métodos como
parte de clase, en vez de ser parte de las instancias.
Hablamos de variables de clase cuando un atributo es marcado con static dentro de una
clase. Esto significa que la variable será común para todos los objetos y tendrá una posición
fija de memoria.
Cualquier instancia de una clase puede cambiar el valor de un atributo estático, sin embargo
también es posible hacerlo sin tener que crear una instancia.
Por ejemplo…
Se tiene la clase Enemigo, la cual tiene atributos como la cantidad de vida, maná, y
elataque. Cada uno de estos atributos varía según la instancia. Pero… ¿cómo saber cuántos
enemigos se han creado en total?
Puedes crear una variable de clase que cuente la cantidad. Algo como:
Enemigo.java
public class Enemigo {

private int vida;
private int mana;
private int ataque;
private static int numeroDeEnemigos = 0;
public Enemigo(int vida, int mana, int ataque) {

this.vida = vida;
this.mana = mana;
this.ataque = ataque;
// Incrementar la cantidad de enemigos

numeroDeEnemigos++;
}
}
Como ves, numeroDeEnemigos se crea como variable de clase y es incrementada en el

constructor. Para consultar su valor, puedes usar el operador punto como se hace
normalmente con un atributo, solo que desde el nombre de la clase.
Enemigo.numeroDeEnemigos
Análogamente podemos crear métodos de clase. Este tipo de métodos se pueden invocar
directamente desde la clase sin tener que crear una instancia. Sin embargo pueden ser
invocados por objetos, solo que no es recomendable porque no aclara su naturaleza.
Los métodos estáticos son útiles para obtener el valor de las variables de clase. Para obtener
la variable numeroDeEnemigos podrías usar el siguiente método.
public static int obtenerNumEnemigos(){

return numeroDeEnemigos;
}
Luego accederíamos a través de la clase de la siguiente forma:
Enemigo.obtenerNumEnemigos();
Otro propósito lo podemos ver en los métodos de clase para utilidades. Por ejemplo, el
método de clase asList() de la clase Arrays, permite convertir un array en una lista, sin
tener que crear una instancia.
Declaración de constantes en Java— Las constantes son elementos que no pueden cambiar
su valor a lo largo de programa. Para declararlas usa la combinación de los
modificadoresfinal y static.
public static final float GRAVEDAD_TIERRA= 9.9f;
Esta constante podrá usarse en todo el proyecto. Por convención de nombres se espera que
escribamos nombres en mayúsculas y separando las palabras con guiones bajos.
10. ENCAPSULACIÓN CON MÉTODOS SET Y GET
La encapsulación es un concepto de la programación orientada a objetos que se refiere a

limitar la visibilidad de los miembros de un objeto.
Esto significa que añades protección a los datos de tus objetos para mantener segura la
estabilidad e integridad de una unidad funcional en la aplicación.
Una de las formas de aplicar esta teoría es usar métodos set y get.
Normalmente cuando inicias creando tus primeras clases, accedes a los atributos de las
instancias de la siguiente forma:
miObjeto.atributo1 = 2;
miObjeto.atributo2 = "Cadena";
Usas el operador punto para obtener o asignar su valor de forma pública.
El papel que juegan los métodos set y get es restringir el acceso directo de tus atributos con
el modificador private y en su lugar construir método public que obtengan y asignen su
valor.
public class PruebaSetYGet{

private int atributo1;
private String atributo2;
private float atributo3;
public int getAtributo1() {

return atributo1;
}
public void setAtributo1(int atributo1) {

this.atributo1 = atributo1;
}
public String getAtributo2() {

return atributo2;
}
public void setAtributo2(String atributo2) {

}
public float getAtributo3() {

return atributo3;
}
public void setAtributo3(float atributo3) {

}
}
El código anterior muestra la existencia de tres atributos privados. Por cada uno existe un
método que comienza con las palabras en inglés “get” y “set”, donde get*() obtiene el
valor del atributo con la sentencia return y set*() asigna un nuevo valor a través de un
parámetro.
Así evitas el contacto directo y solo debes llamar a los métodos.
miObjeto.setAtributo1(2);
String atributo2 = miObjeto.getAtributo2();
Cuando uses Android Studio podrás generar estos métodos automáticamente al

presionar ALT + INSERT.
Luego seleccionas los atributos a los cuales deseas generar los métodos get y set.
11. EL OPERADOR NEW PARA CREAR OBJETOS EN
JAVA
Una vez tienes tu clase definida, ya es posible instanciar objetos que comiencen a contribuir
a la aplicación. La creación de un nuevo objeto se lleva a cabo del operador new.
Para crear un nuevo objeto de la clase Cliente sería:
Cliente clienteActual = new Cliente();
Uso de constructores— Si deseas personalizar la inicialización de los objetos de una clase,

puedes declarar una variación del constructor por defecto.
Un constructor es un mecanismo para crear tus objetos. Tienen casi la misma forma de un
método. La diferencia está en que no tiene tipo de retorno especificado y su nombre es el
mismo de la clase.
El siguiente es un constructor que permite asignar valores a todos los campos del cliente.
public class Cliente {

/*
Atributos
*/
private int idCliente;
private String nombre;
private String telefono;
private float saldo;
public Cliente(int idCliente, String nombre, String telefono, float saldo) {

this.idCliente = idCliente;
this.nombre = nombre;
this.telefono = telefono;
this.saldo = saldo;
}
// Método que modifica al campo saldo

public void acumularSaldo(float excedente) {
saldo += excedente;
}
}
12. HERENCIA DE CLASES
La herencia es el proceso de transmitir atributos y métodos de una clase a otra. Donde la clase
que se toma como base se le denomina superclase y la que hereda se le llama subclase.
Usa la palabra reservada extends para declarar que una clase hereda de otra.
Veamos un ejemplo entre una clase llamada Estudiante, la cual hereda de Persona.
Persona.java
public class Persona {

String nombre;
String telefono;
public Persona(String nombre, String telefono) {

this.nombre = nombre;
this.telefono = telefono;
}
public void obtenerInformacion() {

System.out.println("Nombre: " + nombre);
System.out.println("Teléfono: " + telefono);
}
}
Estudiante.java
public class Estudiante extends Persona {

private float nota1, nota2, nota3;
public Estudiante(String nombre, String telefono, float nota1, float nota2, float nota3) {
super(nombre, telefono);
this.nota1 = nota1;
this.nota2 = nota2;
this.nota3 = nota3;
}
// Sobrescribir método de la superclase

public void obtenerInformacion() {
super.obtenerInformacion();
System.out.println("Notas: " + nota1 + "," + nota2 + "," + nota3);
}
}
La referencia super representa a la superclase Persona, este facilita pasar los parámetros
necesarios, para la satisfacción de su constructor.
También invocamos el método obtenerInformacion() alojado en la clase padre, para
sobrescribir el de la clase Estudiante.
Si creáramos una instancia de ambas clases veremos como el
método obtenerInformacion()tiene dos comportamientos diferentes.
Main.java
public class Main {

Persona persona = new Persona("Carlos", "3445569");
persona.obtenerInformacion();
persona = new Estudiante("Arliz", "3445678", 3.4f, 4.5f, 1.0f);

persona.obtenerInformacion();
}
}
Lo anterior produciría el siguiente resultado:
Nombre: Carlos
Teléfono: 3445569
Nombre: Arliz
Teléfono: 34456678
Notas: 3.4, 4.5, 1.0
13. CONCEPTO DE CLASES ABSTRACTAS
Una clase abstracta es aquella de la cual no se pueden crear instancias directamente. Sin
embargo, se pueden crear subclases a partir de ellas. Definir una clase de este tipo requiere
usar la sentencia abstract en la declaración.
Este concepto permite organizar las clases semejantes. También obliga a los programadores
a sobrescribir métodos importantes que garanticen el correcto funcionamiento de un patrón.
Dentro de una clase abstracta puede que existan 0 o más métodos abstractos. Un método
abstracto es aquel que se declara pero no se implementa, con el fin de que las subclases si lo
hagan.
abstract int calcularIndice(int medida);
Por ejemplo…
Tenemos la clase Objeto3D para representar aquellos componentes que tienen vértices,
índices y una textura definida. Con esta clase podemos definir subclases
como Cubo,Esfera y Piramide. Aunque las tres son objetos tridimensionales, requieren un
renderizado distinto según su geometría. Por lo que el método para renderizar debe ser
abstracto y por ende la clase Objeto3D.
abstract public class Objeto3D {

List<Vertice> vertices;
List<Indices> indices;
Textura textura;
void crearGeometria() {
//...
}
void texturizar() {
// ...
}
// Método abstracto
abstract void renderizar();
public class Cubo extends Objeto3D {

void renderizar() {
// Implementación personalizada
}
}
public class Esfera extends Objeto3D {

void renderizar() {
// Implementación personalizada
}
}
14. CREAR INTERFACES EN JAVA
Las interfaces son un mecanismo para crear un tipo sin definir su implementación. Son
similares a las clases, solo que estás contienen constantes, firmas de métodos sin
implementar, métodos estáticos, métodos por defecto y tipos anidados.
Las clases normales pueden heredar los métodos de las interfaces. Sin embargo no se
considera Herencia si no Implementación.
Para crear una interfaz usa la palabra reservada interface. Al implementarla sobre una clase
usa implements.
public interface NombreInterfaz{
// Constantes...
// Firmas de métodos...
// Tipos...
}
Una interfaz no puede ser instanciada. Su propósito es proveer un camino para

forzar polimorfismo en una clase, exigiendo que se especifique un comportamiento sin
importar la forma en que se haga.
También es importante recalcar que una clase puede implementar varias interfaces. A lo que
se le llama herencia múltiple.
Conceptualmente una interfaz es un medio para comunicar dos elementos.
Por ejemplo…
Un médico puede comprender la información de la presión arterial de un paciente a través de
un estetoscopio. En este caso, el estetoscopio sería una interfaz.
Otro ejemplo sería relacionar un Leon con estados como ser Mamifero y Carnivoro. Ambas
condiciones son una interfaz que permite comunicar la supervivencia del león con recursos
y situaciones naturales, como es comer carne o alimentarse de leche.
public interface Mamifero{

void amamantar();
}
public interface Carnivoro{

void desgarrar();
}
public class Leon implements Mamifero, Carnivoro{
// Otras acciones dignas de un león
public void amamantar() {

// Acciones y condiciones para amamantar
}
@Override
public void desgarrar() {
// Acciones y condiciones para desgarrar
}
}
15. MANEJAR ERRORES CON EXCEPCIONES
Una excepción es un evento inusual que ocurre en la ejecución de un programa, el cual

interrumpe el flujo de instrucciones. Frecuentemente las condiciones que provocan el evento
son errores.
Cuando esto sucede, se crea un objeto del tipo Exception que contiene los datos del error.
Luego es pasado al sistema para informar del inconveniente.
Las expceciones se basan en la clase Throwable, la cual tiene implementado el
comportamiento para interrumpir el flujo en caso de que se presenten condiciones
específicas.
Cuando ocurren problemas graves en el proceso de la máquina virtual de Java esta lanza
objetos de tipo Error.
Por otro lado, si el problema no es tan grave para el sistema, se lanzan objetos del
tipoException o alguno de sus herederos
(RuntimeException, NullPointerException,IllegalAccessException, etc).
Por ejemplo…
Si tuvieses un método que solo asigna números positivos a un atributo sería conveniente
comprobar antes que el parámetro satisfaga la condición. Algo como:
PruebaExcepciones.java
public class PruebaExcepciones {
int valor;
for (int i = 1; i < 9; i++) {

PruebaExcepciones ejemplo = new PruebaExcepciones();
if (i != 7)
try {
ejemplo.asignarValor(i);
} catch (Exception e) {
e.printStackTrace();
}
else
try {
ejemplo.asignarValor(i * -1);
} catch (Exception e) {
e.printStackTrace();
}
}
}
public void asignarValor(int numero) throws Exception {

if (numero > 0)
valor = numero;
else
throw new Exception("No es posible asignar el número negativo " + numero);
}
}
El bucle escrito en el main cuenta desde 1 a 8, donde se asigna el valor del índice al atributo
de un objeto PruebaExcepciones nuevo. Como truco, al llegar a 7 multiplicamos por -
1 para producir un número negativo.
El método asignarValor() es marcado para lanzar excepciones con la
sentencia throwsjunto al tipo de excepción. Luego hacemos efectivo el lanzamiento si el
parámetro número es negativo.
Para manejar la excepción se usa un bloque try-catch, donde try recibe las instrucciones a
procesar y catch realiza las acciones en caso de que haya atrapado la excepción. En nuestro
caso imprimimos la pila de seguimiento sobre la excepción con printStackTrace(), la cual
indica las capas sucesivas donde ocurrió el inconveniente.
El resultado al ejecutar sería:
16. COLECCIONES DE OBJETOS EN JAVA
Las colecciones son objetos que agrupan elementos asociados en una misma estructura.
Hablo de listas, mapas, conjuntos, colas, etc.
La librería de las colecciones trae consigo componentes que generan el comportamiento de
las unidades que agruparán elementos. Veamos la definición de algunos:
▪ Collection: Representa la naturaleza de una colección como un conjunto de elementos agrupados,

sin tener en cuenta características como su orden o duplicidad. Esta interfaz permite obtener
elementos, obtener el tamaño total de la colección, añadir elementos, eliminar elementos e iterar sobre
ellos.
▪ List: Una lista es una colección ordenada que puede contener duplicados. Para obtener sus elementos
se usa un sistema de índices basado en cero. Permite acceder a los elementos a través de sus índices
sin tener que recorrerla manualmente. Facilita la obtención del índice de cada elemento. Incluso
permite operar solo un segmento de la lista.
▪ Set: Un conjunto es una colección desordenada que no puede contener elementos duplicados.
Permite realizar todas las acciones comunes de una colección.
▪ Map: Un mapa es una colección que asigna claves a los elementos que contiene. A diferencia de una
lista que usa índices enteros, un mapa puede asignar strings a cada elemento de información. Basados
en esas claves podemos añadir, remover, etc.
▪ Iterator: Un iterador es un mecanismo para obtener los elementos de una colección de forma
secuencial. Le permite al programador usar el método next() para retornar en el elemento actual. El
siguiente es un ejemplo de un bucle for recorriendo una lista de strings.
▪ for (Iterator<String> i = lista.iterator(); i.hasNext(); ) {

▪ String valorActual = i.next();
▪ // ...
Los componentes anteriores producen gran cantidad de clases que nos permiten agrupar
datos, como por ejemplo:
▪ ArrayList: Lista basada en un array de tamaño variable, creada con base en la interfaz List.
▪ HashMap: Tabla hash basada en la implementación de Map. Cumple con todas las características de
Map y además permite añadir elementos con claves y valores nulos.
Veamos un ejemplo de ArrayList…
PruebaArrayList.java
import java.util.ArrayList;
import java.util.List;
public class PruebaArrayList {
List<String> lista = new ArrayList<String>();

lista.add("Draven");
lista.add("Sion");
lista.add("Teemo");
lista.add("Yasuo");
lista.add("Jax");
for (String elemento : lista) {

System.out.println(elemento);
}
}
17. CLASES GENÉRICAS EN JAVA O GENERICS
Los Generics son tipos que permiten crear implementaciones de clases, métodos e interfaces
basados en parámetros.
En el ejemplo anterior del ArrayList vimos cómo esta clase permite crear una lista de un
tipo específico contenido en cuñas "<>". Dicho tipo se le denomina parámetro y evita que
se realice casting de los elementos al momento de acceder a estos.
List<String> lista = new ArrayList<String>();

lista.add("Elemento");
String s = lista.get(0); // Nos evita el cast String s = (String)list.get(0)
Por ejemplo… si tuviésemos una clase llamada Barco la cual permite calcular características
como el peso total o la velocidad máxima, sería de utilidad poder tener precisión según las
propiedades del material empleado para su construcción.
En ese caso podríamos usar una clase genérica para satisfacer el enunciado “crear nuevo
barco a base de…”. Esto haría necesario la existencia de clases para los materiales
comoMetal, Madera, Aleacion, etc.
public class Barco<T> {

// Usamos T para abreviar "Tipo"
private T t;
public void calcularPesoTotal(){

// ...
}
public void obtenerVelocidadMaxima(){

// ...
}
}
Al usar el parámetro T, podemos referirnos a un tipo genérico que tendrá cosas en común y
así poder producir el mismo resultado sin importar cual se use.
Con la definición de la clase genérica, ya es posible crear barcos de todo material.
Barco<Metal> barcoDeMetal = new Barco<Metal>();

Barco<Madera> barcoDeMadera = new Barco<Madera>();
Barco<Aleacion> barcoDeAleacion = new Barco<Aleacion>();
18. CLASES ANIDADAS EN JAVA
El lenguaje Java permite que los desarrolladores declaren clases dentro de otras clases. Ellas
reciben el nombre de clases anidadas, donde la clase que contenedora se le denomina clase
externa.
class ClaseExterna {
class ClaseAnidada {
}
}
Una clase anidada puede ser declarada como estática o no estática y se comporta como un
miembro más de la clase externa. La primera es llamada clase anidada estática y la
segundaclase interna.
Las clases internas pueden acceder a otros miembros de la clase externa, incluso si estos son
privados. En cambio una clase anidada estática no tiene esta oportunidad.
¿Cuáles son las ventajas de usar clases anidadas?

▪ Facilita la agrupación de clases que usarán en un mismo lugar — Aumenta la accesibilidad de
una clase a otra para evitar comunicaciones complicadas.
▪ Se convierte en otro método para crear encapsulación—Al declarar una clase anidada como un
miembro privado, es posible restringir el acceso por otras clases.
▪ Orden y mantenibilidad del código— El hecho de haya una clase anidada reduce la creación de
más ficheros y mejora la interacción lógica de los miembros.
Veamos un ejemplo de clase anidada estática…
public class ScriptBaseDeDatos {
public static class ColumnasTablaPerro {

public static final String ID = "_id";
public static final String NOMBRE = "nombre";
public static final String RAZA = "raza";
public static final String PESO = "peso";
}
}
El ejemplo anterior muestra una clase externa llamada ScriptBaseDeDatos la cual contiene
una clase anidada estática llamada ColumnasTablaPerro. Esta representa las columnas de
una tabla perteneciente a una base de datos y contiene como miembros una serie de
constantes.
Si quisiéramos acceder algún campo desde algún lugar del proyecto lo haríamos de la
siguiente forma:
String id = ScriptBaseDeDatos.ColumnasTablaPerro.ID;
Uso de clases anónimas— Una clase anónima es un tipo de clase interna que se declara y se
instancia al mismo tiempo. Esta puede ser declarada dentro de bloque de códigos como el de
un método.
Su gran poder está en que en vez de ser tratadas como una declaración, se consideran una
expresión. Esto significa que puedes asignarlas a otra expresión existente dentro de un bloque
de código.
El ejemplo más común se da al momento de usar escuchas en la interfaz de Android. El

siguiente código muestra un botón al cual se le asigna una escucha para manejar los eventos
de click.
boton.setOnClickListener(
new View.OnClickListener() {
@Override
public void onClick(View v) {
// Acciones...
}
}
);
Como ves, existe un botón al cual se le asigna una nueva interfaz de escucha con el
métodosetOnClickListener(). Este método recibe una instancia del
tipo OnClickListener.
Justo en ese parámetro podemos crear una clase anónima que satisfaga este requerimiento
con el operador new.
Si te fijas, estamos definiendo el cuerpo de una nueva clase sin nombre (por algo le llaman
anónimas), donde sobrescribimos el método onClick().
El compilador no arrojará errores, porque sabe que el cuerpo de esta nueva clase
implementada en la línea dará como resultado una instancia OnClickListener.
19. HILOS: PROGRAMACIÓN CONCURRENTE EN JAVA
Los programas Java soportan la ejecución de múltiples hilos de trabajo. La clase que
permite crear este tipo de unidad de procesamiento es Thread.
Para crear un nuevo hilo se debe hacer uso de la interfaz Runnable, donde el código que se
ejecutará en el hilo se implementa en el controlador run().
Por ejemplo…
PruebaHilos.java
public class PruebaHilos {

new Thread(
new Runnable() {
public void run() {
System.out.println("Este método se ejecutó en un hilo");
}
}
).start();
}
Una vez has creado un nuevo objeto Thread indicando el componente Runnable, entonces
inicias su ejecución con el método start().
Sincronizar hilos en Java con synchronized— La sincronización es un mecanismo para
evitar que dos o más hilos generen fallos de ejecución o difuminen la lógica de la aplicación,
al acceder a un mismo recurso.
Para evitar este tipo de inconvenientes usaremos la palabra reservada synchronized. Esta
sentencia bloquea el control para que solo un hilo tenga acceso al recurso. Así que hasta que
un hilo no acabe la operación, el siguiente deberá esperar. Además permite que los hilos
otorguen visibilidad a los datos procesados.
class EjemploSincronizacion {
private int i = 0;
public synchronized int metodoSincronizado() {

return i++;
}
public int variacionMetodoSincronizado() {

synchronized (this) {
return i++;
}
}
}
El ejemplo anterior muestra como se sincroniza un método y una sentencia.
El método metodoSincronizado() evita que un hilo adicional lo invoque hasta que el actual
lo termine de procesar. Además hace visible el estado actual a todos los hilos.
Dentro de variacionDelMetodoSincronizado() se sincroniza una sentencia. En este
casosynchronized recibe el objeto en el que serán protegidas las sentencias. Ambas
definiciones funcionan igual.
20. INCLUIR ANOTACIONES EN EL CÓDIGO
El último tema de este artículo son las anotaciones.
Una anotación es un metadato que no tiene efecto en la lógica del programa.
Algunas utilidades de las anotaciones son:

▪ Informar al compilador sobre lugares del código donde deseamos detectar errores o suprimir alertas.
▪ Crear código a partir de los datos de la anotación. Esto se da en algunas herramientas como la librería
de parsing XML Simple Framework.
▪ Análisis en tiempo de ejecución.
Las anotaciones se identifican al ver que inician con el carácter '@'. Por
ejemplo @Override,@NonNull, @TargetApi, etc.
Estas se ubican junto al código que se desea marcar, ya sean métodos, parámetros, clase, etc.
@Override
protected void onCreate(Bundle savedInstanceState) {
// ...
}
Incluso pueden recibir valores para indicar una condición especial.
import android.annotation.TargetApi;
...
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class ActividadPrincipal extends ActionBarActivity {
// ...
}
Java trae consigo anotaciones predeterminadas que podemos usar para varios propósitos.
Veamos algunas:
▪ @Deprecated: Anotación que marca una pieza de código como obsoleta, lo que significa que ya no
es recomendable usarla de nuevo. Esta anotación permite que el compilador muestre una alerta que
le indique al desarrollador que probablemente hay una nueva versión del código o una mejor manera
de realizar la tarea.
Esto produciría el siguiente efecto en Android Studio al utilizar el método.
▪ @Override: Indica al compilador que el método marcado será sobrescrito con base a la superclase.
Es de gran utilidad para diferenciar los métodos y prevenir errores.
▪ @SuppressWarnings: Declara al compilador que no deseamos que se muestren alertas sobre

comportamientos incorrectos.
La ilustración muestra como al añadir la anotación con el atributo “deprecation” el método que antes
se marcaba como obsoleto, ahora luce normal.
Aprendiendo Sobre La
Arquitectura De Android
Android es un sistema operativo creado para ser independiente de cualquier tipo

de arquitectura de hardware en los dispositivos móviles. Esta característica hace que sea
tan atractivo ante los fabricantes y desarrolladores.
Adicionalmente su portabilidad, flexibilidad yseguridad les da ese toque de simpatía a las
personas interesadas en los sistemas de código abierto.
La arquitectura de Android debe ser estudiada antes de comenzar a programar. Por tal motivo,
en este artículo veremos cómo está constituido el interior de Android. Estudiaremos sus
características de operación en tiempo real y en queformato de archivo se encapsula una
aplicación Android.
Finalmente comprenderemos qué beneficios nos aporta el sistema automatizado de
construcción Gradle, dentro de los proyectos de Android Studio.
MODELO DE CAPAS EN LA ARQUITECTURA DE

ANDROID
Android está construido con una arquitectura de 4 capas o niveles relacionados entre sí. A
continuación veremos un diagrama ilustrativo extraído del libro Learning Android escrito
porMarko Gargenta y Masumi Nakamura:
El diagrama indica que la estructura de Android se encuentra construida sobre el Kernel de
Linux. Luego hay una capa de Librerías relacionadas con una estructura administradora
enTiempo de ejecución. En el siguiente nivel encontramos un Framework de apoyo para
construcción de aplicaciones y posteriormente vemos a la capa de Aplicaciones.
KERNEL DE LINUX
Android está construido sobre el núcleo de Linux, pero se ha modificado dramáticamente

para adaptarse a dispositivos móviles. Esta elección está basada en la excelente potabilidad,
flexibilidad y seguridad que Linux presenta. Recuerda que el Kernel de Linux esta bajo la
licencia GPL, así que en consecuencia Android también.
CAPA DE LIBRERÍAS O CAPA NATIVA

En esta capa se encuentran partes como la HAL, librerías nativas, demonios, las herramientas
de consola y manejadores en tiempo de ejecución. Veamos un poco el propósito de estos
conceptos:
▪ Hardware Abstraction Layer (HAL): Este componente es aquel que permite la

independencia del hardware. Quiere decir que Android está construido para ejecutarse en
cualquier dispositivo móvil sin importar su arquitectura física. El HAL actúa como
unaarquitectura genérica que representa a todos los posibles tipos de hardware existentes
en el mercado. Aunque por el momento no hay estándares de construcción en el hardware de
dispositivos móviles, el HAL permite que cada fabricante ajuste sus preferencias para que
Android sea funcional sobre su tecnología.
▪ Librerías nativas: Aquí encontramos interfaces de código abierto como OpenGL para el
renderizado de gráficos 3D, SQLite para la gestión de bases de datos, WebKit para el
renderizado de los browsers, etc. También librerías para soportar los servicios del sistema
como Wifi, posicionamiento, telefonía, y muchos más.
▪ Demonios (Daemons): Los demonios son códigos que se ejecutan para ayudar a un servicio
del sistema. Por ejemplo cuando se requiere instalar o actualizar una aplicación, el demonio
de instalación “installd” es ejecutado para administrar todo el proceso. O cuando los
desarrolladores vamos a ejecutar en modo de depuración nuestro teléfono desde un PC, se
ejecuta un demonio llamado adbd(Android Debug Bridge Daemon) para auxiliar a dicho
proceso.
▪ Consola: Al igual que otros sistemas operativos, Android permite que empleemoscomandos
de línea para la ejecución de procesos del sistema o explorar el sistema operativo.
▪ Manejadores en tiempo de ejecución: Si bien las aplicaciones Android están escritas en
lenguaje Java y son traducidas a bytecodes, estas no son interpretadas por la Maquina
virtual de Java. Android tiene su propia maquina virtual interpretadora de bytecodes
llamada Dalvik. Esta herramienta fue diseñada para ser flexible ante el diseño de hardware
de un dispositivo móvil. Además JVM no es de licencia GPL, así que Google decidió generar
su propia herramienta.
¿CÓMO FUNCIONA DALVIK?

Dalvik no cambia nada en el proceso de compilación, sencillamente interviene al final como
receptor de un archivo ejecutable producto de una recopilación de los archivos .class de
java.
Recuerda las fases de la construcción de una aplicación Java. El primer paso es generar el
código fuente (arhivos .java), luego este es traducido por el Java Compiler (javac) y
obtenemos un fichero tipo byte code (archivos .class). Finalmente la máquina virtual de Java
(JVM) interpreta en tiempo real este archivo y la aplicación es ejecutada.
La ejecución de Dalvik es ingeniosa, simplemente espera que javac traduzca la aplicación a
byte codes, cuando están listos los archivos, estos son compilados por el compilador
Dex. Esta herramienta traduce los byte codes de java a un estilo de byte codes nativos que
serán convertidos a un ejecutable .dex. Finalmente este archivo es ejecutado por una instancia
de Dalvik VM.
A continuación se muestra un diagrama comparativo de ambos procesos:
Aunque el proceso añade unos cuantos pasos más, no debes preocuparte por ello, ya que esta
tarea se le delega a la herramienta Gradle.
Google ha anunciado que Dalvik VM será reemplazada por una nueva máquina virtual
llamadaART (Android Runtime) en su nueva versión Android L. Por el momento no nos
preocuparemos por esta situación, pero es un dato muy importante a tener en cuenta.
FRAMEWORK PARA APLICACIONES

Esta es la capa que nos interesa a los desarrolladores, ya que en ella encontramos todas
laslibrerías Java que necesitamos para programar nuestras aplicaciones. Los paquetes con
más preponderancia son los android.*, en ellos se alojan todas las características necesarias
para construir una aplicación Android.
No obstante es posible acceder a clases como java.utils.*, java.net.* , etc. Aunque hay
librerías Java excluidas como la java.awt.* y java.swing.*.
En esta capa también encontraremos manejadores, servicios y proveedores de contenido que
soportaran la comunicación de nuestra aplicación con el ecosistema de Android.
CAPA DE APLICACIONES
Es la última instancia de funcionamiento de Android. Se centra en la ejecución, comunicación

y estabilidad de las aplicaciones preinstaladas por el fabricante o las que nosotros vamos a
construir. A ella acceden todos los usuarios Android debido a su alto nivel
de compresión ysimplicidad.
¿QUÉ TIPO DE ARCHIVO TIENEN LAS APLICACIONES

PARA ANDROID?
El resultado del proceso de construcción es un archivo comprimido con

formato .APK(Android Applicacion Package). Y dentro encontraremos los siguientes
componentes:
▪ Archivo Android Manifest: Este archivo es la definición de todas las características
principales que tendrá nuestra aplicación al ejecutarse en un dispositivo móvil. Con
características me refiero a los bloques que posee la aplicación, los permisos, su versión, las
versiones previas soportadas, las dimensiones de la pantalla, etc.
▪ Archivo classes.dex: Este será el fichero compilado preparado para ejecutarse en laMáquina
Virtual Dalvik.
▪ La carpeta Resources: Aquí encontramos todos los archivos externos que usamos para
construir nuestro proyecto, como por ejemplo nuestros iconos, audio, archivos planos de
texto, los archivos .xml de diseño, etc.
▪ Librerías nativas: El archivo .APK también contiene aquellas librerías de las cuales
depende la aplicación.
▪ Carpeta META-INF: En ella se guardan archivos que corresponden a las Firmas
Digitalesde tu aplicación. Con esta especificación puedes indicar que tu eres el creador y
dueño de la aplicación, además debes indicar tu ID de desarrollador para ser reconocido y
autenticado en procesos de comercialización (Google es muy riguroso en este tema).
EL SISTEMA AUTOMATIZADO DE CONSTRUCCIÓN

GRADLE Y ANDROID STUDIO
Gradle es una herramienta para automatizar el compilado, empaquetado, testeo y

liberación de aplicaciones que se basen en la JVM. Como te dije antes, ha sido creado para
expandir el uso de javac.
Cuando me refiero a “automatizar” significa que podemos programar nuestras propias
condiciones de construcción. Esto es posible a través de Scripting mediante DSL(Domain-
Specific-Language), un lenguaje claro y especializado, con énfasis en configurar y construir
aplicaciones con Gradle.
DSL permite generar una compilación basada en tareas programadas y relacionadas entre sí,
reduciendo la complejidad de dependencias y automatizando labores frecuentes. Su sencillez
permite dar instrucciones de manera declarativa e intuitiva al programador.
¿QUÉ VENTAJAS TIENE UTILIZAR GRADLE?
▪ Una de las mayores ventajas es que le entrega el poder del flujo de construcción al
programador. Esto quiero decir que decidimos el orden de ejecución de tareas. Asimismo
podríamos elegir que archivos compilar primero, cuando detener la compilación, establecer
condiciones para que se recompile o no el código y muchas situaciones más.
▪ Ejecuciones incrementales: El poder de esta característica le ahorra al programador gran
cantidad de tiempo de espera. Al haber construcciones incrementales podemos decidir hasta
que punto queremos que se compile nuestra aplicación, es decir, si no es necesario compilar
una parte del código debido a la ausencia de errores, entonces se procede a compilar la
sección que aun no ha sido probada.
▪ Múltiples versiones: Gradle permite que construyamos varias versiones de nuestra
aplicación. Por ejemplo, si deseas construir tu aplicación para Jelly Beans y
para Kitkatentonces solo debes especificar que el proyecto tendrá dos variantes de
empaquetado, configurando la versión del SKD usada para cada versión.
▪ La ejecución y las pruebas se pueden realizar en un mismo proyecto.
▪ Ejecución en paralelo de tareas: Puedes ejecutar tareas en hilos diferentes para optimizar
el proceso de construcción.
Esas son las características más importantes, sin embargo, hay muchas más. Si lo deseas, te
invito a visitar el Sitio Oficial de Gradle para que te enteres de los avances de la
herramienta, revisar la documentación y descargar libros que te ayuden a comprender su
potencial.
Estructura De Un Proyecto En
Android Studio
James Revelo agosto 15, 2014 Android Studio 21 Comments
Como habíamos visto en el artículo introductorio a la programación en Android, el

proyecto de una aplicación está contenido en una jerarquía donde se ubican todos los archivos
de código fuente Java, los recursos, las configuraciones y los archivos de construcción
de Gradle.
El artículo de hoy tiene como fin comprender la estructura de archivos de un proyecto
en Android Studio. Esto nos permitirá investigar a fondo la lógica de construcción de una
aplicación.
También estudiaremos como está estructurado el archivo AndroidManifest.xml, que contiene
la carpeta “res”, veremos la utilidad de los archivos de diseño, los archivos R.java. Y
finalmente daremos un vistazo al código fuente.
CONTENIDO
▪ Directorios de un Proyecto en Android Studio

▪ ¿Qué es el ANDROID MANIFEST?
▪ ¿Qué utilidad tiene el archivo strings.xml?
▪ ¿Que hay dentro de la carpeta layout?
▪ La carpeta drawable en Android Studio
▪ Comprendiendo el propósito de la clase R.java
▪ La carpeta java de un proyecto en Android Studio
DIRECTORIOS DE UN PROYECTO EN ANDROID

STUDIO
Para comenzar la explicación, ejecuta Android Studio y selecciona el proyecto “Test”

quecreamos anteriormente. Ahora ubícate en el panel de la parte izquierda llamado “Project”,
el cual representa la estructura de tu proyecto. Como notas, están las carpetas .idea, app,
build, gradle y otros archivos de configuración.
La carpeta app es la que contiene todo lo relacionado con tu proyecto, es la carpeta que nos
interesa por el momento y donde incluiremos los archivos necesarios para que nuestra
aplicación sea empaquetada. Si despliegas su contenido veras tres carpetas: build, libs y src.
Por ahora ignoraremos los demás archivos.
Normalmente la mayor parte del tiempo y fuerzas las usaremos en la carpeta src(Source).
Dentro de ella se ubica la carpeta main, la cual contiene todos los archivos fuente Java para
nuestra aplicación. La carpeta res (Resources) que contiene los recursos del proyecto (iconos,
sonido, diseños, etc.) y el archivo AndroidManifest.xml.
¿QUÉ ES EL ANDROID MANIFEST?
Es un archivo XML que contiene nodos descriptivos sobre las características de una
aplicación Android. Características como los building blocks existentes, la versión de
SDK usada, los permisos necesarios para ejecutar algunos servicios y muchas más. En pocas
palabras el Android Manifest es un panorama de toda nuestra aplicación.
Si abres el archivo en el editor verás un código similar a este:
<?xml version="1.0" encoding="utf-8"?>

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
package="com.TUPAQUETE.test" >
<application
android:allowBackup="true"
android:icon="@drawable/ic_launcher"
android:label="@string/app_name"
android:theme="@style/AppTheme" >
<activity
android:name=".MyActivity"
android:label="@string/app_name" >
<intent-filter>
<action android:name="android.intent.action.MAIN" />
<category android:name="android.intent.category.LAUNCHER" />

</intent-filter>
</activity>
</application>
</manifest>
Todas las aplicaciones deben contener este archivo por convención. El nombre debe
permanecer intacto, ya que se usa como referencia para el parsing de nuestra aplicación.
Elnodo raíz de este documento se representa con la etiqueta <manifest> y por obligación
debe contener un hijo de tipo <application>.
En el código anterior podemos observar que manifest posee dos atributos, xmlsn:android y
package. El primero no debemos cambiarlo nunca, ya que es el namespace del archivo.
El atributo package indica el nombre del paquete Java que soporta a nuestra aplicación. El
nombre del paquete debe ser único y un diferenciador a largo plazo.
La etiqueta <application> representa como estará construida nuestra aplicación. Dentro de
ella definiremos nodos referentes a las actividades que contiene, las librerías incluidas,
losIntents, Providers, y demás componentes.
Algunos atributos de la etiqueta <application> son:
▪ allowBackup: Este atributo puede tomar los valores de true o false. Indica si la aplicación
será persistente al cerrar nuestro AVD.
▪ icon: Indica donde está ubicado el icono que se usará en la aplicación. Debemos indicar la
ruta y el nombre del archivo que representa el icono. En este caso apuntamos a las carpetas
drawable donde se encuentra ic_launcher.png. Icono por defecto que nos
proporciona Android Studio.
▪ label: Es el nombre de la aplicación que verá el usuario en su teléfono. Normalmente apunta
a la cadena “app_name” que se encuentra en el recurso strings.xml (Más adelante lo
veremos).
▪ theme: Este atributo apunta al archivo de recursos styles.xml, donde se define la
personalización del estilo visual de nuestra aplicación.
Dentro de <application> encontraremos expresada la actividad principal que definimos al
crear el proyecto Test. Usaremos <activity> para representar un nodo tipo actividad.
<activity> tiene dos atributos: name, el cual se refiere a la clase Java que hace referencia a
esta actividad (Comienza con un punto “.”). Y el atributo label que hace referencia al texto
que se mostrará en la cabecera de la actividad. En este caso es el mismo string “app_name”.
Por el momento estudiaremos hasta este punto. En próximos artículos veremos el proposito
de los nodos <intent-filter>, <action> y <category>.
¿QUÉ UTILIDAD TIENE EL ARCHIVO STRINGS.XML?
Dentro de la carpeta”res” encontraremos todos aquellos recursos tercerizados para nuestra

aplicación. Esta práctica de excluir los atributos de la aplicación a través de archivos
externos, permite reducir la complejidad de diseño en las interfaces.
Uno de los recursos más relevantes es el archivo strings.xml que se encuentra dentro de la
subcarpeta values. Este fichero almacena todas las cadenas que se muestran en
loswidgets (controles, formas, botones, vistas, etc.) de nuestras actividades.
Por ejemplo, si tuvieses un botón cuyo título es “Presiona aquí”, es recomendable incluir
dicha cadena en tu archivo strings.xml.

Para declarar nuestro recurso de strings usaremos el nodo raíz <resources>. Para declarar las
cadenas usaremos la etiqueta <string> y estableceremos el atributo name como identificador.
Dentro de esta etiqueta pondremos el texto que se visualizará en el componente de interfaz.
Esta declaración es similar al uso de la etiqueta <h1>Texto</h1> en HTML.
Si abres el archivo, verás que se encuentran tres nodos del tipo <string> : “app_name”,
“action_settings” y “hello_world”.

<resources>
<string name="app_name">Test</string>
<string name="hello_world">Hello world!</string>
<string name="action_settings">Settings</string>
</resources>
app_name contiene el nombre de la aplicación. En este caso es “Test”, action_settings se

refiere al título del menú acciones y hello_world es el string para nuestro mensaje en pantalla
la actividad.
El archivo strings.xml es muy útil para los desarrolladores. Una de sus grandes utilidades es
facilitar el uso de múltiples idiomas en tu aplicación. Esto se debe a que puedes externalizar
las cadenas del código java y seleccionar la versión del archivo strings.xml con el lenguaje
necesitado.
Personalmente te recomiendo que uses este archivo siempre, incluye todo tu texto y no dejes
nada por fuera, tu aplicación te lo agradecerá en el futuro.
¿QUÉ HAY DENTRO DE LA CARPETA LAYOUT?
En la carpeta layout encontrarás los archivos de diseño de todas tus actividades. En mi caso
existe el archivo activiy_my.xml. Este archivo representa el diseño de la interfaz de mi
actividad principal. En el se establecerán todos los widgets que vaya a agregar a la actividad.
Construir la interfaz a través de nodos XML es mucho más sencillo que la creación a través
de código Java. Adicionalmente Android Studio nos ha dotado de un panel de diseño
estilo Drag and Drop, lo cual es una bendición para los desarrolladores, ya que facilita
demasiado la creación de una interfaz de usuario.
Este archivo de diseño comienza con un nodo raíz llamado <RelativeLayout>. Un Layout es
el contenedor principal que define el orden y secuencia en que se organizarán los widgets en
nuestra actividad. Existen varios tipos de Layouts, como por ejemplo el LinearLayout,
GridLayout, FrameLayout, etc.
Android Studio crea por defecto un RelativeLayout porque permite crear un grupo de
componentes con ubicaciones relativas. Quiere decir que se ubicaran por referencias y no por
valores absolutos. Esto permite ajustar nuestras aplicaciones a cualquier tipo de pantalla para
dispositivos móviles.
Si abres el archivo de diseño de tu actividad verás algo como esto:
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:layout_width="match_parent"
android:layout_height="match_parent"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
android:paddingBottom="@dimen/activity_vertical_margin"
tools:context=".MyActivity">
<TextView
android:text="@string/hello_world"
android:layout_width="wrap_content"
android:layout_height="wrap_content"/>
</RelativeLayout>
Veamos la utilidad de los atributos para <RelativeLayout>:
▪ layout_width: Es el ancho que tendrá el layout dentro de la actividad. Aunque se puede

especificar con unidades personalizadas, es recomendable usar match_parent para ajustarlo
al ancho del dispositivo.
▪ layout_height: Representa la dimensión vertical del layout. Usa match_parent para ajustarla
al dispositivo.
▪ paddingLeft, paddingRight: Es el espacio lateral existente entre el contorno del Layout y los
widgets. Su valor apunta al archivo de recursos dimens.xml ubicado en la carpeta “values”.
Este archivo contiene nodos de tipo <dimen> con valores density-indepent pixels (dp). Para
estos paddings se usa el nodo “activity-horizontal-margin”, cuyo valor estándar son16dp.
▪ paddingTop, paddingBottom: Es el espacio vertical existente entre el contorno del Layout y
los widgets. Su valor es igual a el nodo “activity-vertical-margin” de dimens.xml.
▪ context: Define el nombre del archivo Java que contiene la actividad donde el Layout será
acogido.
Con este diseñador solo ubicamos los componentes donde nos plazca y automáticamente son
generados como nodos en nuestro archivo.
Los lectores que han creado páginas web a través de frameworks

como DreamWeaver podrán entender rápidamente el concepto, debido a que diseñar la
interfaz de una aplicación Android es muy similar a crear aplicaciones HTML.
LA CARPETA DRAWABLE EN ANDROID STUDIO
Si has sido atento también podemos encontrar el icono de la aplicación en una serie de
carpetas que comienzan por el cualificador drawable. Estas carpetas se relacionan
directamente con el tipo de densidad de pantalla donde se ejecutará nuestra aplicación.
La mayoría de dispositivos móviles actuales tienen uno de estos 4 tipos de densidades:
▪ Mediun Dots per Inch(mdpi): Este tipo de pantallas tienen una densidad de 160 puntos por
pulgada.
▪ High Dots per Inch(hdpi): En esta clasificación encontraremos teléfonos cuya resolución
es de 240 puntos por pulgada.
▪ Extra high dots per inch(xhdpi): Resoluciones mayores a 340 puntos por pulgada
▪ Extra Extra high dots per inch(xxhdpi): Rangos de resoluciones mayores a 480 puntos por
pulgada.
Miremos una pequeña imagen ilustrativa:
La imagen muestra algunos ejemplos de dispositivos móviles cuya densidad se encuentra

dentro de los rangos establecidos. Al final podemos ver una categoría extra llamada xxxhdpi.
Esta denominación describe a la densidad de televisores de última generación que ejecutan
Android.
Sería excelente que definieras todos tus recursos gráficos en los distintos tipos de densidades.
Esta diversidad permitirá mayor compatibilidad con distintos dispositivos móviles.
COMPRENDIENDO EL PROPÓSITO DE LA CLASE

R.JAVA
El archivo R.java es una archivo que se autogenera dentro de la carpeta build, para linkear
todos los recursos que tenemos en nuestro proyecto al código Java.
Si abres el archivo podremos ver un código similar a este:
/*AUTO-GENERATED FILE. DO NOT MODIFY. *

* This class was automatically generated bythe
* aapt tool from the resource data itfound. It
* should not be modified by hand. */
package com.TUPAQUETE.test;
public final class R {

public static final class attr {
}
public static final class dimen {
public static final int activity_horizontal_margin=0x7f040000;
publicstaticfinalint activity_vertical_margin=0x7f040001;
}
public static final class drawable {
publicstaticfinalint ic_launcher=0x7f020000;
}
public static final class id {
public static final int action_settings=0x7f080000;
}
public static final class layout {
publicstaticfinalint activity_my=0x7f030000;
}
public static final class menu {
publicstaticfinalint my=0x7f070000;
}
public static final class string {
public static final int action_settings=0x7f050000;
public static final int app_name=0x7f050001;
public static final int hello_world=0x7f050002;
}
public static final class style {
/** Customize your theme here.
*/
public static final int AppTheme=0x7f060000;
}
}
Como ves, la clase R contiene clases anidadas que representan todos los recursos de nuestro
proyecto. Cada atributo tiene un dirección de memoria asociada referenciada a un recurso en
específico. Por ejemplo, la clase string posee el atributo hello_world, el cual representa
nuestro TextView en la actividad principal. Este recurso está ubicado en la
posición0x7f050002.
No modifiques el archivo R.java, el se actualiza automáticamente al añadir un nuevo

elemento al proyecto.
LA CARPETA JAVA DE UN PROYECTO EN ANDROID

STUDIO
Justamente era lo que iba a decir. Finalmente llegamos a la carpeta “java”. Aquí se alojarán
todos los archivos relacionados con nuestras actividades y otros archivos fuente auxiliares.
Al abrir nuestro archivo MyActivity.java veremos toda la lógica necesaria para que la
actividad interactúe de manera correcta con el usuario.
import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
public class MyActivity extends Activity {

@Override
protected void onCreate(Bundle savedInstanceState){
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_my);
}
@Override
public boolean onCreateOptionsMenu(Menu menu){
// Inflate the menu;this adds items to the actionbar if it is present.
getMenuInflater().inflate(R.menu.my, menu);
return true;
}
@Override
public boolean onOptionsItemSelected(MenuItem item){
// Handle action bar item clicks here. The actionbar will
// automatically handle clicks on the Home/Upbutton, so long
// as you specify a parent activity inAndroidManifest.xml.
int id = item.getItemId();
if(id == R.id.action_settings){
return true;
}
return super.onOptionsItemSelected(item);
}
}
Para toda actividad creada debemos extender una subclase de la superclase Activity. Más
adelante veremos que una actividad tiene un ciclo de vida y lo único que esta bajo nuestro
control es la manipulación de cada estado.
Si ya notaste, las actividades no tiene un punto de entrada main(). Esto se debe a que las
aplicaciones Android parten de múltiples puntos de ejecución. Pero esa característica será
objeto de estudio del próximo artículo.
Tutorial Básico Del Lenguaje
Xml
Este artículo tiene como fin abarcar las características principales sobre el lenguaje
XML.Con el fin de comprender el contenido de los archivos de recurso de un proyecto de
desarrollo en Android.
Veremos que es el lenguaje XML, por qué surge como herramienta de interoperabilidad,
cuáles son sus usos y cuál es la sintaxis para crear un documento XML.
¿QUÉ ES XML?
Sus siglas significan eXtensible Markup Language, que en español es Lenguaje de

Marcado Extendible. Es un lenguaje basado en etiquetas descriptivas, cuyo fin es
representar información de texto en forma jerárquica, y a su vez darle formato. XML cobra
importancia al surgir la necesidad de interoperabilidad entre dos sistemas de información,
ya que propone un puente de intercambio entre dos fuentes de datos distintas.
¿POR QUÉ CREARON XML?
Inicialmente se originó para manejar y estructurar opciones de configuración para sistemas

operativos o aplicaciones. Pero luego se elige para intercambiar información entre distintas
tecnologías, debido a que establece un solo formato para obtener datos. Esto facilita importar
y exportar información.
XML propone una sintaxis cómoda para las maquinas y los humanos, siendo un lenguaje
afable para la construcción de estructuras complejas.
¿QUÉ VENTAJAS TIENE USAR XML?

Aunque XML al principio no pretendió ser lo que es ahora, podemos encontrar excelentes
cualidades en el uso de esta tecnología, entre ellas tenemos:
▪ Independencia de datos y forma: Con XML puedes establecer la estructura de la

información y al mismo tiempo separar la forma en que se interpretará dependiendo el
contexto. Significa que si tienes un entorno A y un entorno B que usaran los datos de un
archivo XML, solo defines los datos y cambias su forma dependiendo de cada contexto.
▪ Extensibilidad: En cualquier momento puedes agregar nuevos componentes y atributos a un
archivo XML.
▪ Representación jerárquica: XML permite expresar anidaciones entre componentes. Lo que
permite establecer un comportamiento de nodos padre e hijo.
▪ Interoperabilidad: Esta característica es mortal en XML. Es lo máximo. Ya que permite
intercambiar información entre aplicaciones, módulos o sistemas sin importar la arquitectura
o tecnología usada.
¿LOS DOCUMENTOS XML SE COMPILAN O ALGO?
Estos archivos se analizan e interpretan por una herramienta llamada Parser(Analizador de

sintaxis). Su objetivo es leer los elementos en el documento. Para ello interpreta su jerarquía
y aplica el formato establecido para cada dato. Los parsers nos ayudan a obtener la
información de un documento XML de forma automatizada en un contexto.
Puedes encontrar Parsers en las librería System.Xml.XmlDocument de .NET
C#. Java también posee su propia librería estándar para parsear llamada Java built-in parser.
También existen otros como Saxon, Xerces, y muchos más.
En los navegadores como Google Chrome también implementan Parsers para convertir el
contenido de un archivo XML a texto con formato HTML.
ESTRUCTURA DE UN DOCUMENTO XML
OK, comencemos a estudiar las partes que conforman un documento XML y que sintaxis
debemos usar.
PRÓLOGO
El prólogo es una declaración XML no obligatoria que especifica algunas características del
documento, como por ejemplo la versión de XML que se usa o el tipo de encriptado. El
estilo de declaración sería como la siguiente línea:
Esta expresión usa como inicio la palabra reservada “xml” y un signo de interrogación de
apertura ‘?’. El atributo version hace referencia al estándar XML usado
y enconding indica el estándar de encriptado. Recuerda que el encriptado es la forma de
traducir los caracteres que hay en el documento en forma binaria.
Existen varias formas de encriptado, pero normalmente el estándar usado es UNICODE. Los
formatos más populares son el UTF-8 y UTF-16. El primer formato representa cada carácter
con 8 bytes y el segundo con 16 bytes.
COMENTARIOS
Para usar comentarios abrimos con la expresión “<!–” y cerramos con los caracteres “–>” .
Todo el texto que este comprendido entre estos símbolos será ignorado por el Parser. Veamos
un ejemplo:

Los comentarios son mensajes destinados al entendimiento del código por parte del
programador. Solo tiene fin informativo, así que serán pasados por alto a la hora del análisis
XML.
ELEMENTOS
También llamados Building Blocks. Son la base de un documento XML, ya que al fin y al
cabo ellos representan nuestra información. Al igual que en HTML, un elemento será
descrito por una etiqueta inicial envuelta en paréntesis angulares <elemento> y una etiqueta
de cierre con una barra inclinada antecedida al nombre del elemento </elemento>.
Y al texto que se encuentra en el interior del elemento se le llama contenido.
Por ejemplo, declaremos un elemento llamado tabla:
<tabla>[contenido]</tabla>
En casos donde el elemento no describe algún contenido podemos abreviar la etiqueta de la
siguiente forma:
<tabla/>
Con esta disposición reducimos a una sola expresión la apertura y cierre de un bloque de
construcción XML.
¿QUÉ DEBO TENER EN CUENTA PARA NOMBRAR UN

ELEMENTO XML?
Como en todas las gramáticas de los lenguajes computacionales hay restricciones para
declarar etiquetas de elementos, en XML no es la excepción. Estas son las reglas que debes
tener en cuenta cuando vayas a declarar el nombre de un elemento:
▪ Puede comenzar con un guión bajo “_”, una letra mayúscula o una letra minúscula del código.
▪ Puedes usar guiones ‘-‘ dentro del nombre de un elemento. Además puedes incluir dígitos
dentro de tu nombre.
▪ Las etiquetas son sensibles a mayúsculas y minúsculas. Procura abrir y cerrar un elemento
con el mismo nombre.
▪ Nunca, por lo que más quieras uses espacios los nombres, esto producirá un error de
Parsing.
▪ La palabra xml no puede ser usada en el inicio del nombre del elemento, ya que está
reservada.
Algunos ejemplos de buenos nombres serian:
<AutoDeCarrera>, <_cliente>, <estados-de-resultados>, <archivos1001>
EL ELEMENTO RAÍZ
Luego de haber declarado el prologo sigue el elemento raíz (root element). Este componente
representa la cabeza de la jerarquía estructural del archivo XML. Solo debe existir
únicamente un elemento raíz que describa el contexto.
Veamos un ejemplo de un documento XML que guarda la información sobre facturas de
unestablecimiento comercial:
<fila id_factura="1001" fecha="20/12/2014 12:01:23 "/>
En este caso el Parser no procesará correctamente la información debido a que cada nodo
<fila> esta al mismo nivel, por lo tanto no hay jerarquía. Es por eso que decides añadir un
elemento raíz que encierre el contenido llamado <factura>:
<factura>
</factura>
Con este detalle el parser ya puede comprender que está sucediendo en el modelo del
documento.
ELEMENTOS HIJOS
Luego de declarar tu raíz siguen los elementos que están por debajo. En el caso anterior,
<fila> era un elemento hijo de <factura>. Y los tres elemento fila estaban al mismo nivel, por
lo tanto eran hermanos. Es posible anidar un elemento dentro de otro, recuerda que estamos
siguiendo una jerarquía, así que cada elemento interior estará bajo la dependencia de su
padre.
ATRIBUTOS DE UN ELEMENTO EN XML

Son propiedades que caracterizan a los elementos. En el caso anterior <fila> tenía como
atributos a id_factura y fecha. Ambos representan datos relacionados a un elemento fila, que
describen sus funciones informativas.
Al igual que los elementos, los atributos tienen reglas para ser definidos:
▪ Los atributos deben contener un nombre y un valor de texto expresado a través del signo de
igualdad ‘=’.
▪ El valor debe estar contenido entre comillas simples o dobles. Ambas cumplen la misma
función, pero la elección depende de cada quien.
▪ Los nombres de los atributos cumplen exactamente las mismas reglas de la construcción de
nombres para elementos.
▪ Si un atributo no tiene valor establecido debes poner un vació entre comillas (” ” ó ‘ ‘).
▪ No deben haber nombres de atributos repetidos dentro de un elemento. Cada nombre ha de
ser único.
▪ Si deseas que el valor del atributo tenga comillas simples o dobles, establece
comolimitador a par de comillas que no serán usadas. Es decir, si deseas que tu atributo
tenga el valor “1234”, entonces debes delimitarlo con las comillas simples: ‘ “1234” ‘.
CONTENIDO DE ELEMENTOS
El contenido de los elementos permite describir el texto al cual se le dará formato. El
contenido lo expresas entre las etiquetas de apertura y cierra como vemos a continuación:
<frase>Ejemplo de contenido de un elemento</frase>
A la hora de establecer el texto en el contenido de un atributo o un elemento no podemos usar

algunos caracteres que están restringidos. Esto se debe a que son usados por la sintaxis
XMLy si el Parser llega a encontrar uno de estos elementos, tenderá a confundirse y a
generar errores de análisis.
Para solucionar este problema existen comodines dentro del estándar XML que representan
estos caracteres. Veamos una tabla ilustrativa:
Carácter Representación
& &
< <
> >
“ "
‘ '
De modo que si deseas emplear alguno de estos símbolos, debes reemplazarlo por la
expresión que lo representa.
¿CUÁNDO USO ATRIBUTOS O ELEMENTOS?

Esta es una gran pregunta, ya que parece ser confusa la manera en ubicar la información
dentro de un archivo XML.
Usaremos atributos cuando la información no se repita y además no requiere orden
lógico. Veamos el siguiente ejemplo sobre los datos de un estudiante:
<estudiante nombre="Carlos" apellido="Clavijo" teléfono="2230012"/>
En este caso la información es básica y atómica, no es necesario que extendamos a nuevos

elementos. Si añadimos nuevos elementos disminuiría la velocidad de parsing . Usa
elementos nuevos solo cuando sea estrictamente necesario.
Supongamos que deseamos representar las materias que está viendo el estudiante. Por ello
incluimos un nuevo atributo llamado materias:
<estudiante nombre="Carlos" apellido="Clavijo" teléfono="2230012"

materias="calculo, física mecánica, algoritmia, estadística"/>
Si se necesitara procesar cada materia individualmente, ¿crees que sería útil la estructura
actual del formato XML?
¡Claro que no!…ya que el valor de materias es solo una cadena, lo que implicaría un proceso
adicional de procesamiento de cadenas en nuestro contexto. Pero si usáramos elementos en
vez de ese atributo tendríamos lo siguiente:
<estudiante nombre="Carlos" apellido="Clavijo" teléfono="2230012">

<materia nombre="calculo" />
<materia nombre="física"/>
<materia nombre="mecánica"/>
<materia nombre="algoritmia"/>
<materia nombre="estadística"/>
</estudiante>
Con esta jerarquía podemos identificar de manera secuencial cada elemento materia para
conseguir procesar la información en orden.
USO DE CDATA EN XML
CDATA (character data) es una sección especial en un archivo XML, que le indica al
Parser que no interprete como lenguaje marcado todo lo que se encuentre adentro. Para los
que han usado Blogger de Google, sabrán que la plantilla XML de la cual se crea el
documento HTML del blog usa esta sección.
Es común usar esta sección para incluir código CSS o Javascript, para que el Parser no lo
interprete como marcado, debido a que usan frecuentemente los caracteres de escape
restrigindos (‘&’, ‘<‘, ‘>’,… ).
La sección CDATA se inicia y termina de la siguiente forma:
<![CDATA[
[Contenido no interpretable como marcado]
]]>
Después de que el Parser haya analizado el documento XML, todo el texto en las
seccionesCDATA habrá quedado intacto.
¿QUÉ SON NAMESPACES EN XML?
Son una forma de agrupar atributos o elementos bajo un mismo encabezado para
diferenciarlos de otros. Esto permite contextualizar los bloques de tal forma que sean
distinguidos en situaciones diferentes.
Puedes asemejarlo con los namespaces de C++ o los paquetes de Java. Dentro de estos
espacios son referenciados objetos de información que solo conciernen a este nombre de
espacio. Lo cual permite diferenciar el uso de la información.
Veamos el siguiente ejemplo:
<biblioteca>
<libro >
<titulo>Fundamentos de programación</titulo>
<paginas>213</paginas>
<capitulo>
<titulo>Introducción</titulo>
</capitulo>
</libro>
</biblioteca>
Este documento describe los libros que se encuentran en una biblioteca. Como ves, la
etiqueta <biblioteca> es el nodo principal, en su interior está la etiqueta <libro> y dentro de
él empezamos a definir componentes que hacen parte de la estructura de un libro como
el titulo, las páginas y los capítulos.
¿Qué notas?… ¡exacto!, el libro tiene una etiqueta <titulo> para referirse al nombre del libro,
y a su vez cada capítulo tiene una etiqueta <titulo> para referirse al nombre del capítulo.
Cualquier persona puede entender esta ambigüedad debido a que es una representación visual
y estructural, pero…. ¿podemos decir lo mismo de Parser?
Esta situación haría que el parser se confundiera y provocará malos resultados cuando
busquemos información. El parser se preguntaría:
El elemento <libro> es padre de <capitulo>, pero ambos tienen como hijo a <titulo>, ¿qué
sucede?
Justamente en este tipo de situaciones contextuales es donde intervienen los namespaces.
¿CÓMO DEFINO UN NAMESPACE?
Bueno, antes de definirlos debemos conocer primero que son URLs, URIs y URNs.
Uniform Resource Locator (URL): Es un formato que permite obtener recursos de alguna
ubicación.
Popularmente conocemos este concepto debido a que frecuentemente buscamos páginas web
en internet con ellas. A continuación vemos su estructura:
[Esquema]://[Dominio]:[Puerto]/[Ruta]?[Query]#[Id]
Podemos tomar el ejemplo de URL de este sitio:
http://www.hermosaprogramacion.com
Aunque no usa todo el formato, podemos identificar que el esquema usado es HTTP y el
dominio seria “hermosaprogramacion”.
▪ Uniform Resource Identifier(URI): Es solo una cadena única que representa algo y puede
tener el formato de las URLs y URNs.
▪ Uniform Resource Name(URN): Es un nombre que identifica algún objeto para
diferenciarlo de los demás. Normalmente tienen el siguiente formato:
urn:[identificador del namespace]:[cadena especifica del namespace]
El ISBN de un libro puede representarse a través de un esquema URN. Por ejemplo:
Urn:ISBN:9098231847381
Las URLs y URNs pueden ser URIs. Una URL muestra la ruta única de un recurso y una
URN un nombre único. Ambas pueden representar una URI que posibilite la creación de
namespaces en nuestros archivos XML.
¿CÓMO CREAR UN NAMESPACE?
Para crear un namespace primero debemos elegir una URI que nos permite diferenciar su
contexto. Por lo general se usa un formato URL ya que el dominio de cada compañía es
único, lo que asegura una identificación que no se repetirá. Cabe destacar que aunque la URI
tenga un formato URL no significa que la URI sea una URL.
Para mi caso en particular usaré la siguiente URI:
"http://www.hermosaprogramacion.com/namespaces/ejemplos/noEjemplo"
Hay dos formas de relacionar un elemento a un namespace. En la primera simplemente

debemos asignar a los elementos que deseemos dentro del documento la URI para que se
incorpore al namespace. La forma de establecerla es a través de la palabra reservada “xmlns”
y luego asignarle el valor de la URI. Es muy similar a la declaración de un atributo dentro de
un componente.
xmlns="URI"
EJEMPLO DE UN NAMESPACE EN XML

Veamos un caso hipotético donde supondremos que necesitamos dar formato a los valores
actuales de pares de divisas más populares del Foreign Exchange.
<forex fecha-actual="19/08/2014"
xmlns=" http://www.hermosaprogramacion.com/namespaces/ejemplos/no1">
<par nombre="EURUSD" current="1.323"/>
<par nombre="EURGPB" current="1.845"/>
<par nombre="AUDUSD" current="0.8976"/>
</forex>
Como ves, hemos declarado la URI en el nodo raíz. Esto significa que todos los componentes
dentro del elemento también harán parte del namespace identificado con la URI establecida.
Este estilo de declaración se le llama namespace implícito o por defecto.
La otra forma se le llama declaración explícita. Haremos exactamente lo mismo que en la
forma implícita solo que esta vez seleccionamos que elementos específicos queremos que
hagan parte del namespace, a través un sistema de etiquetado:
<FX:forex fecha-actual="19/08/2014"
xmlns:FX=" http://www.hermosaprogramacion.com/namespaces/ejemplos/no1">
<par nombre="EURUSD" current="1.323"/>
<par nombre="EURGPB" current="1.845"/>
<par nombre="AUDUSD" current="0.8976"/>
</FX:forex>
Si prestas atención, hemos usado la etiqueta “FX” en la declaración de la URI del

namespace. Puedes poner el nombre que deseas y anteponer dos puntos ‘:’ para hacer
efectiva su declaración. Al usarse se usan los dos puntos delante de ella como vemos en el
inicio de las etiquetas de apertura y cierra de la etiqueta <forex>.
Este nombre permite personalizar la declaración de los elementos que pertenecerán al
namespace además del acceso hacia ellos.
Apliquemos este concepto de namespaces al ejemplo de la biblioteca que puede llegar a tener
problemas.
<b:biblioteca
xmlns:b="http://www.hermosaprogramacion.com/namespaces/ejemplos/no2">
<b:libro >
<b:titulo>Fundamentos de programación</b:titulo>
<b:paginas>213</b:paginas>
<capitulo xmls="http://www.hermosaprogramacion.com/namespaces/ejemplos/no2-capitulo">
<titulo>Introducción</titulo>
</capitulo>
</b:libro>
</b:biblioteca>
Ahora ya podemos diferenciar ambas etiquetas <titulo>, ya que ambas pertenecen a

namespaces diferentes. El primero lo declaramos explicito para definir todos los elementos
que obedecerán a la etiqueta <b> y el segundo fue implícito en el elemento interior capitulo.
Así cuando el parser analice este documento entenderá que:
{http://www.hermosaprogramacion.com/namespaces/ejemplos/no2}titulo
{http://www.hermosaprogramacion.com/namespaces/ejemplos/no2-capitulo}titulo
son dos elementos totalmente distintos.
USANDO XPATH PARA EXTRAER DATOS DE UN

DOCUMENTO XML
Por supuesto!, para extraer información de un archivo XML debemos usar el

lenguaje XPath. Este lenguaje permite navegar a través de la estructura jerárquica de
documentos que implementen el Document Object Model(DOM). Pero en esta ocasión no
entraremos en detalle sobre este tema, queda en tus manos comprender el acceso a
documentos con jerarquías.
Si has visto en los archivos layout XML de Android Studio, es muy frecuente que se pida
el valor de los nodos <string> de esta forma:
"android:text="@string/name""
Esa sentencia nos indica que el atributo texto de las vistas se encontrará almacenado en el
archivo strings.xml que tenga el nombre name.
Como notas, XPath funciona con un estilo de navegación a través de barras laterales y
expresiones regulares para encontrar el elemento que necesitamos.
Uso De Recursos En Android

¿Recién te has iniciado al mundo del Desarrollo Android y ya te topaste con la carpeta res?
¿Sabías que dentro de ella se ubican los recursos en Android?
Seguramente ya habrás utilizado sin darte cuenta los recursos que vienen por defecto al crear
unnuevo proyecto en Android Studio. Sin embargo es importante conocer la naturaleza,
funcionamiento y ventajas que tiene usar por separado archivos para imágenes, strings,
estilos, etc.
Sigue leyendo y aprenderás sobre los tipos de recursos que existen, la funcionalidad del
archivo R.java, creación de recursos alternativos, acceso de recursos a través de XML y Java,
obtención de valores y el uso de los recursos del sistema.
¿QUÉ SON LOS RECURSOS EN ANDROID?
Los recursos son archivos o datos externos que soportan el comportamiento de nuestra
aplicación Android. Con ello me refiero a imágenes, strings, colores, estilos, etc.
Formalmente en un proyecto, estos elementos se encuentran en la carpeta src/main/res. Allí
encontrarás subdirectorios que agrupan los diferentes tipos de recursos.
La idea del uso de recursos es dividir el código de tu app para mantener independencia. Todo
con el fin de agregar variaciones de los archivos para adaptar la aplicación a diferentes tipos
de pantallas, idiomas, versiones, dimensiones, configuraciones de orientación, etc.
Por ejemplo…
No es lo mismo el espacio de un teléfono móvil a una tableta. Sin embargo se pueden crear
variaciones de los recursos para que la aplicación se adapte a la densidad de pantalla de cada
uno.
TIPOS DE RECURSOS
Los grupos de recursos se dividen en subdirectorios. Cada uno de ellos contiene archivos que
cumplen una función específica dentro de la aplicación. Debes respetar esta estructura de
documentos para no tener problemas en la ejecución.
La siguiente es una tabla de la mayoría de los tipos de recursos que podemos crear:
Nombre del
subdirectorio Contenido
animator/ Alberga archivos XML con animaciones de propiedades para objetos.
anim/ Contiene archivos XML que representan animaciones especiales para views.
Aquí encontrarás archivos XML con definiciones de listas de estados de color
(Color State List). Estas listas determinan el color de un
color/ componente dependiendo del estado en que se encuentre.
Recursos gráficos que puedan ser proyectados en pantalla. Generalmente

encontrarás archivos de imagen como .png, .jpg o .gif, sin embargo es posible
usar otros como: archivos nine-patch, listas de estado, drawables con múltiples
drawable/ niveles, drawables con figuras 2D definidas en XML, y muchas más.
Contiene el icono de la aplicación para evitar distorsión entre varias densidades

mipmap/ de pantalla.
layout/ Archivos XML que contienen definiciones de la interfaz de usuario.
Archivos XML que establecen las características para los menús usados en la
interfaz. Normalmente contienen definiciones sobre los ítems albergados en un
menu/ menú y las agrupaciones entre ellos.
Almacena aquí todos aquellos archivos que deseas leer directamente como un
raw/ flujo de caracteres estándar (InputStream).
Archivos XML que contienen datos simples como enteros, strings, booleanos,
colores. Puedes agrupar estos elementos en las siguientes convenciones de
archivos:
▪ strings.xml para cadenas
▪ colors.xml para definiciones de colores en hexadecimal.
▪ dimens.xml para dimensiones de márgenes, padding, tamaños, etc.
▪ styles.xml para los estilos de interfaz que tendrá la aplicación.
values/ ▪ arrays.xml para arreglos de elementos.
Contiene archivos XML con definiciones especiales requeridas en acciones con

el framework de Android. O para usos que requieras en tus requerimientos,
xml/ como parsear una estructura XML directamente en la aplicación.
RECURSOS ALTERNATIVOS EN ANDROID
Un recurso alternativo es una variación de un recurso, que se ajusta a una característica de

configuración en el dispositivo móvil donde se ejecuta la aplicación.
Esto se logra a través de una tabla de calificadores creada por Google que estandariza todas
las configuraciones posibles que se puedan presentar.
Un calificador es un mecanismo gramatical que especifica el propósito de un recurso. Su
sintaxis es la siguiente:
<nombre_recurso>-<calificador>
De seguro ya vas comprendiendo un poco porque al crear un nuevo proyecto en Android

Studio vienen varias carpetas para el recurso mipmap.
Esto se debe a que cada variación contiene un calificador para especificarle a la aplicación
que al momento de variar la densidad de pantalla, escoja el recurso que se ajuste a esta
configuración.
Por ejemplo mipmap-hdpi contendrá la variación del recurso ic_launcher.png para

aquellos dispositivos con densidades de pantalla altas (~240dpi). Esta condición es
especificada por el calificador hdpi.
Esto significa que la imagen debe estar especialmente creada para ajustarse a esta densidad.
Así mismo, las demás imágenes deben ser creadas a la medida de su calificador.
Todas las variaciones responden a un mismo identificador, por eso tienen el mismo nombre
de archivo "ic_launcher.png".
Precedencia de calificadores— Los calificadores tienen orden precedencia, es decir, para
usar más de un calificador en un recurso es necesario ubicar primero los calificadores con
mayor importancia. Si se desobedece esa secuencia, habrá calificadores que no tengan efecto.
La siguiente tabla muestra los calificadores existentes en orden de precedencia.
Calificador Valores/Sintaxis Ejemplo/Definición
Código Móvil del mcc732-mnc101 (Operador Claro en

País mccxxx-mncxxx Colombia)
Idioma y región xx-rXX es-rCO (Español en Colombia)
ldrtl(lectura de derecha a
izquierda),ldrtl(lectura de izquierda a
Dirección del layout ldrtl, ldrtl derecha)
Ancho mínimo de la
pantalla sw<N>dp sw480dp, sw240dp
Ancho disponible w<N>dp w600dp, w1024dp
Altura disponible h<N>dp h180dp
▪ small: dispositivos QVGA con tamaños de

320x426dps.
▪ normal: dispositivos HVGA con tamaños de
320x470dps.
▪ large: dispositivos VGA con tamaños de
480x640dps.
Tamaño de la small, normal, ▪ xlarge: dispositivos HVGA con largo de
pantalla large, xlarge 720×960 dps.
Aspecto de la ▪ long: pantallas amplias.

pantalla long, notlong ▪ nolong: pantallas reducidas.
▪ port: Orientación estilo portrait (vertical).

Orientación de la ▪ land: Orientación
pantalla port, land estilo landscape(horizontal).
▪ car: El dispositivo está conectado a un coche.

▪ desk: El dispositivo está conectado a un PC.
▪ television: El dispositivo está conectado a
un TV.
car, desk, ▪ appliance: El dispositivo está conectado a un
television, elemento sin especificar.
Modo UI appliance, watch ▪ watch: El dispositivo es un reloj.
▪ night: Modo nocturno activado.

Modo nocturno night, notnight ▪ notnight: Modo nocturno desactivado.
▪ ldpi: Low-density, densidades de máximo

120dpi.
▪ mdpi: Medium-density, máximo 160dpi.
▪ hdpi: High-density, máximo 240dpi.
▪ xhdpi: Extra-high-density, máximo 320dpi
ldpi
▪ xxhdpi: Extra-Extra-High-Density, máximo
mdpi
hdpi 480dpi.
xhdpi ▪ xxxhdpi: Extra-extra-extra-high-density
xxhdpi máximo 640dpi.
xxxhdpi ▪ nodpi: aquí puedes situar objetos que no
Densidad de nodpi quieres redimensionar sea cual sea la densidad.
pantalla tvdpi ▪ tvdpi: Densidades asociadas a smart tvs.
Tipo de pantalla notouch ▪ notouch: Dispositivo sin pantalla táctil.
táctil finger ▪ finger: Dispositivo con pantalla táctil.
▪ keysexposed: El dispositivo tiene un teclado

disponible.
▪ keyshidden: El dispositivo tiene un teclado
físico, pero este está deshabilitado y
keysexposed tampoco existe un teclado táctil.
Disponibilidad del keyshidden ▪ keyssoft: El dispositivo tiene un teclado táctil,
teclado keyssoft ya sea que esté habilitado o no.
▪ nokeys: El dispositivo no tiene un teclado

físico.
▪ qwerty: El dispositivo tiene un teclado físico
nokeys del tipo “qwerty”.
Método primario de qwerty ▪ 12key: El dispositivo tiene un teclado físico
entrada de texto 12key con teclas numéricas.
▪ navexposed: El teclado de navegación está

Disponibilidad de disponible.
las teclas de navexposed ▪ navhidden: El teclado de navegación no está
navegación navhidden disponible.
▪ nonav: No una forma de navegación que no

sea la pantalla táctil.
▪ dpad: El dispositivo tiene un teclado
direccional para navegar.
nonav ▪ trackball: El dispositivo tiene una esfera de
dpad seguimiento para navegar.
Método primario de trackball ▪ wheel: El dispositivo tiene una rueda de
navegación no táctil. wheel navegación para navegar.
Versión de Android vN v17, v21
Para asociar múltiples calificadores a un recurso es necesario que los separes por guiones
siguiendo el orden anterior.
Por ejemplo…
Declaremos la variación del subdirectorio values para la dirección de lectura izquierda-
derecha y orientada al idioma inglés.
values-ldrtl-en/
Es sencillo, solo buscamos el orden de ambas características en la tabla. Primero va el sentido
de lectura, así lo ubicamos separado por guion. Luego sigue el idioma, por lo que
anteponemos un nuevo guion y añadimos el indicador en en segunda posición.
CREAR RECURSOS EN ANDROID STUDIO
Para crear nuevos recursos en Android debes situarte en la carpeta res y luego añadir un
nuevo subdirectorio o archivo de recurso, dependiendo del caso.
Por ejemplo, si deseas crear un subdirectorio para recursos tipo raw, entonces presionas click
derecho en la carpeta res, selecciona New y luego eliges Android resource directory.
Esto abrirá un asistente que te permite seleccionar el tipo de recurso y aquellos calificadores
que deseas incluirle.
Por ejemplo, si deseáramos añadir un calificador para los recursos raw orientados a idioma
inglés, seleccionamos el calificador Locale. Este desplegará una lista para elegir el idioma y
las ubicaciones. Prueba elegir idioma inglés y ubicación Estados Unidos.
Al confirmar, tendremos nuestro nuevo subdirectorio en la carpeta res.
Para agregar un nuevo archivo de recurso es el mismo procedimiento. Presionas click

derecho, dirígete a la opción New en el subdirectorio deseado y luego asignas un nombre u
otros campos que se requieran, dependiendo del tipo de recurso.
Por ejemplo… al intentar crear un nuevo archivo dentro de res/values nos exigirán el
nombre.
ACCEDER A LOS RECURSOS EN ANDROID
Hasta ahora ya sabemos cómo agrupar los tipos de recursos y definir archivos XML para
algunos de ellos.
Lo que sigue es comprender el acceso a sus valores desde el proyecto. Los recursos pueden
ser accedidos en el código Java o en el código XML.
Para obtener la referencia de un recurso es necesario que se le asigne un identificador que lo

diferencie y le indique al programador donde se encuentre.
Cada identificador se ubica en una clase llamada R a través de una constante entera. Esta
clase es generada automáticamente por una herramienta del SDK llamada appt, por lo que
no es recomendable editarlo manualmente.
Cada tipo de recurso existente dentro de la carpeta res es una clase anidada estática del
archivo R.java.
Por ejemplo, el subdirectorio drawable puede ser accedido como R.drawable.
Ahora, si deseas obtener el identificador de un recurso, entonces usas el operador
punto para acceder a los miembros de cada clase interna.
Por ejemplo, se tiene una imagen cuyo identificador es imagen_gato. Para acceder a su
contenido solo navegas de la siguiente forma R.drawable.imagen_gato.
El archivo R.java en un proyecto tendría un aspecto similar al siguiente:
Acceder a los recursos desde Java— Ya vimos de forma general como podríamos obtener
el ID de un recurso con la clase R. La sintaxis formal de acceso es la siguiente:
[<nombre_paquete>.]R.<tipo_recurso>.<nombre_recurso>
Donde,
▪ [<nombre_paquete>.] es el nombre del paquete donde se encuentran alojados los recursos.

No uses ninguno, si te estás refiriendo al paquete local.
▪ <tipo_recurso> es una de las agrupaciones de recursos como por ejemplo xml.
▪ <nombre_recurso> es el nombre del archivo asignado o el identificador de un elemento.
Existen muchas formas de implementar las referencias de los recursos dependiendo de la
situación.
Por ejemplo…
1. Uno de los primeros usos que verás al crear un nuevo proyecto en Android Studio es la
asignación de un layout a una actividad.
@Override
setContentView(R.layout.activity_main);
}
En este caso se usa el método setContentView() para indicar el layout que dará forma
visual a la actividad. El ejemplo muestra que será el recurso R.layout.activity_main, el
cual representa al archivo activity_main.xml guardado en el subdirectorio layout.
2. Otro ejemplo lo vemos al momento de asignar un recurso de menú para crear la action bar
de una actividad.
@Override
public boolean onCreateOptionsMenu(Menu menu) {
// Inflate the menu; this adds items to the action bar if it is present.
getMenuInflater().inflate(R.menu.menu_main, menu);
return true;
}
En este caso se pasa el ID del archivo menu_main.xml alojado en el subdirectorio menu. Es

por eso que usamos la referencia R.menu.menu_main.
3. También podemos usar recursos al momento de asignar el contenido a un ImageView
(elemento que representa imágenes en la pantalla).
ImageView imagen = (ImageView) findViewById(R.id.imagen);

imagen.setImageResource(R.drawable.avatar);
Primero se obtiene el image view a través del método findViewById() y luego se le asigna
el identificador del drawable R.drawable.avatar con el métodosetImageResource().
4. Tal vez uno de los más populares sea asignar un string a un TextView con el
métodosetText(), el cuál recibe el identificador de un recurso tipo texto.
TextView titulo = (TextView) findViewById(R.id.titulo);

titulo.setText(R.string.texto_titulo);
Por el momento nos estamos refiriendo a la referencia de los recursos, pero…
¿Cómo obtener los valores directamente?

La respuesta está en la clase Resources.
Este elemento representa la ubicación de los recursos y su contenido. Podemos obtener una
instancia dentro de una actividad con el método getResources().
A través de ella podemos acceder a los valores de cualquier tipo de recurso. Todo a través de
sus métodos get*().
Si deseas obtener un recurso tipo string, entonces invocas a getString(), el cual recibe
como parámetro el ID del recurso:
Resources resources = getResources();

String appName = resources.getString(R.string.app_name);
De forma similar, podemos obtener el valor entero de un recurso tipo color:
Resources resources = getResources();

int color = resources.getColor(R.color.colorAzul);
Para los arrays de strings también existe su correspondiente método:
Resources res = getResources();

String[] campeones_adc = res.getStringArray(R.array.campeones_adc);
Acceder a los recursos desde XML— Esta forma de referencia se da cuando dentro de un
recurso definido en un archivo XML necesitamos usar el valor de otro recurso.
Por ejemplo, cuando a un componente <TextView> dentro de un layout le asignamos el valor
de un string definido en el archivo strings.xml.
<TextView
android:layout_height="wrap_content"
android:text="@string/titulo_texto" />
La forma en que se asigna el ID depende de la siguiente sintaxis:
@[<nombre_paquete>:]<tipo_recurso>/<nombre_recurso>
Donde,
▪ @[<nombre_paquete>:] se refiere al paquete java donde está alojado el recurso (no pones
nada si son los recursos locales).
▪ <tipo_recurso> es el tipo de recurso representado como clase anidada en R.java. Por
ejemplo string.
▪ <nombre_recurso> es el nombre del archivo sin extensión o el valor del
atributoandroid:name del componente.
Veamos algunos ejemplos:
1. Supón que dentro del recuro values/dimens.xml defines el padding de los textos de la
siguiente forma.
dimens.xml
<resources>
<dimen name="padding_textos">16dp</dimen>
</resources>
Ahora decides utilizarlo en el atributo android:padding de un texto. Para ello solo usas la
sintaxis vista anteriormente refiriéndote a los recursos de tipo dimen.
<TextView
android:text="Texto"
android:padding="@dimen/padding_textos"/>
Cada vez que intentes asignar un recurso en un atributo, Android Studio te ayudará con una
búsqueda emergente para una selección más rápida.
2. Dentro del tema de la aplicación también es posible asignar valores de recursos. Supón
que asignarás un azul índigo como color primario al tema. Para ello declaras el valor en tu
recurso values/colors.xml.
<resources>
<color name="colorPrimario">#3F51B5</color>
</resources>
Luego estableces el atributo colorPrimary con este recurso.
<resources>
<style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
<item name="colorPrimary">@color/colorPrimario</item>
</style>
</resources>
Acceder a los recursos del sistema— Android contiene en su framework varias constantes
de recursos que nos permitirán acceder a estilos, tamaños, colores, layouts, etc.
En ocasiones es de utilidad usarlos para evitar la declaración de elementos que ya existen.
Para usarlos debemos referirnos al paquete android en cada acceso que realicemos.
Un buen ejemplo sería el uso de colores predeterminados.
<resources>
<style name="AppTheme" parent="@android:style/Theme">

<item name="android:windowBackground">@android:color/white</item>
</style>
</resources>
El anterior estilo asigna el color blanco almacenado en el paquete del sistema al background
de las actividades de la aplicación.
Otro ejemplo sería al momento de tomar las acciones del Up Button de una actividad dentro
del método onOptionsItemSelected(). Este elemento está predeterminado por el sistema
ya que nosotros no lo construimos, sin embargo podemos recibir sus eventos con el
identificadorandroid.R.id.home:
@Override
public boolean onOptionsItemSelected(MenuItem item) {
int id = item.getItemId();
switch (id) {
case android.R.id.home:
// Acciones
return true;
}
return super.onOptionsItemSelected(item);
}
EJEMPLOS DE RECURSOS
A continuación veremos de forma general como se crean algunos archivos de recurso en

definición XML que pertenecen al subdirectorio values y son de uso frecuente.
Existen tipos de recursos que requieren explicaciones más detalladas como los estilos y los
layouts, por lo que serán tratados individualmente en artículos separados.
Recursos de colores en Android— Todo archivo XML para recursos debe contener un nodo
raíz del tipo <resources>.
Dentro de un archivo de colores (colors.xml) los elementos deben ser declarados con la
etiqueta <color>. Debes asignar un nombre único con el atributo name y su contenido es un
color en forma hexadecimal que empieza por el símbolo numeral '#'.

<resources>
<color name="colorAzul">#0057ff</color>
<color name="colorRojo">#ff0044</color>
</resources>
El anterior código contiene dos recursos de color.
Android Studio te permite modificar el color a través de un asistente que se inicia al

seleccionar el recuadro de color. Este se encuentra justo al lado izquierdo.
El asistente te permitirá personalizar al máximo el color que deseas. Desde seleccionar
manualmente la cantidad de azul, rojo, verde y alfa, hasta copiar el color de un pixel en tu
escritorio.
Recursos strings en Android— Los recursos de tipo strings nos permiten almacenar valores
que representan texto en nuestra aplicación.
Son de gran utilidad, ya que puedes crear variaciones de idioma para cada recurso string.
Como ya has visto, el archivo values/strings.xml ha sido designado por convención para
contener este tipo de recursos.
Los elementos más comunes son strings simples con un solo contenido y arrays de strings
que asocian varios elementos a un solo nombre.
Los strings simples se definen con la etiqueta <string>. Para darle un identificador usa el
atributo name y asigna un nombre distintivo.
<string name="nombre_string">texto_string</string>
Los arrays se declaran con <string-array> y asignarles un nombre con el atributo name.
Cada elemento irá en su interior declarado con un elemento <item> y su contenido será el
texto que representa.
Veamos un ejemplo…
<resources>


<string name="app_name">Mis Pruebas</string>


<string-array name="campeones_adc">
<item>Caitlyn</item>
<item>Draven</item>
<item>Jinx</item>
<item>Varus</item>
<item>Tristana</item>
</string-array>
</resources>
El anterior código muestra en la parte superior tres strings simples y en su parte inferior un
array de strings con 5 ítems.
Una ventaja de usar Android Studio es que permite extraer textos hacia el
archivo strings.xmla través de un asistente.
Si estuvieses definiendo un layout donde se encuentra el siguiente TextView:
<TextView
android:text="Descripción de tareas"/>
Verás que el valor del atributo android:text aparecerá marcado.

Este warning te está diciendo que sería buena idea extraer ese texto plano a un recurso string.
Si presionas ALT+ENTER en esa posición, verás una lista de opciones. La que nos interesa
esExtract string resource.
Si seleccionas esta opción se desplegará un asistente que nos permitirá trasladar el texto plano
al archivo strings.xml con su respectivo identificador.
Una vez asignes el nombre, confirmas y ya tendrás tu nuevo recurso creado. Incluso el acceso
por el text view será reemplazado.
<TextView
android:text="@string/descripcion_tareas"/>
Recursos para dimensiones en Android— Los recursos de dimensión permiten almacenar

valores de medidas basadas en las características de la pantalla del dispositivo.
Por convención, las dimensiones se incluyen dentro del archivo res/dimens.xml para
diferenciar su naturaleza. Cada recursos de dimensión se especifica con la etiqueta <dimen>,
a la cual debe añadírsele el atributo name para diferenciar su existencia. En su contenido se
indica un número junto a la unidad de medida a implementar.
<dimen name="nombre_dimension">dimension</dimen>
Los siguientes son los tipos de medida que puedes usar:
▪ dp: Medida basada en la densidad de pantalla, donde 1dp equivale a 1px. Esto significa que
si la densidad varia, entonces las medidas en dp variarán dependiendo del factor. Esta unidad
es muy útil para mantener el aspecto de los views en un layout.
▪ sp: Es una medida similar a los dp, solo que su variación de proporciones se basa en el tamaño
de la fuente del texto. Por lo que es buena opción usarla cuando definamos tamaños para los
textos.
▪ pt: Representa un factor de 1/72 puntos por pulgadas según el tamaño real de la pantalla.
▪ px: Medida en pixeles de la pantalla. Debido a la gran variedad de tamaños de pantalla, no
es recomendable adaptar los elementos basados en pixeles.
▪ mm: Representa un milímetro basados en el tamaño real de la pantalla.
▪ in: Medida en pulgadas basadas en el tamaño real de la pantalla.
El siguiente es un ejemplo donde se muestra una dimensión para el margen superior de un
text view y su tamaño de fuente.
<resources>
<dimen name="margen_superior">16dp</dimen>
<dimen name="fuente_texto">24sp</dimen>
</resources>
Uso De Strings En Android
Como Recursos De Texto
En este artículo veremos el uso de strings en Android para el manejo de recursos de texto en
nuestras aplicaciones. Esto implica conocer muy bien el archivo strings.xml y las etiquetas
XML que podemos usar dentro de él.
Nos apoyaremos en la potencia de Android Studio al momento de generar automáticamente
strings dentro de los recursos.
También veremos el formateo y la aplicación de estilos a las cadenas. Casos para el uso de
caracteres especiales como apostrofes, comillas dobles, signos mayor qué y menor qué, etc.
Incluso la aplicación de marcado HTML para representar mejor el contenido.
Finalmente terminaremos con la explicación de la clase Spannable, la cual facilita el

estilizado de strings de forma programática. Y creación de apps con múltiples idiomas.
EL ARCHIVO STRINGS.XML EN ANDROID
Antes de comenzar con la explicación, necesitas crear un proyecto nuevo en Android

Studiopara ir comprobando a la par los casos de estudio.
Para ello…
1. Abre Android Studio, ve a File > New > New Project… para crea un nuevo proyecto.
2. Una vez que el asistente de creación se abra, cambia el nombre del proyecto por “Uso De
Strings En Android” y confirma.
3. Ahora solo presiona Next y deja el soporte de versiones por defecto.
4. Debido a que este proyecto solo es para probar strings, elegiremos una actividad en blanco
como pantalla principal.
5. Ahora cambia el nombre de la clase a ActividadPrincipal al igual que su layout y menú.
Al título asígnale “Recursos Strings En Android”.
Como viste en el artículo Uso De Recursos En Android los recursos de texto son guardados
en el archivo res/values/strings.xml.
La etiqueta básica de contenido es <string>, cuyo contenido es una cadena de caracteres.
Al abrir este archivo en nuestro proyecto actual tendríamos el siguiente contenido:
<resources>
<string name="app_name">Uso De Strings En Android</string>

</resources>
La primera cadena representa el nombre de la aplicación y de la actividad principal que

acabamos de crear. El string "hello_world" contiene el texto que va en
un TextViewgenerado automáticamente dentro del layout de la actividad. Y el tercer string
es el texto para el action button que se encuentra en la action bar.
Cada uno de los elementos que representan texto dentro de strings.xml tiene un identificador
asociado en el archivo R.java representado por el atributo name. Si observas el su contenido
verás una clase estática interna llamada string, donde los campos son constantes con los
identificadores:
Como ves, cada una de las cadenas usadas en el atributo name es convertida en una constante
entera que representa al string en el código Java. Esta conexión permite que accedamos a los
recursos con facilidad.
No te preocupes por la gran cantidad de identificadores agregados automáticamente por
Android. Simplemente son elementos que se necesitan para mantener la compatibilidad de
versiones, es inevitable que estén allí.
LA ETIQUETA <STRING>
Representa un string simple que al momento de ser compilado produce un tipo String para
el código Java.
Para declarar este elemento dentro de strings.xml es necesario que exista un padre del
tipo<resources> o de lo contrario no se reconocerá. Esto se muestra en la siguiente sintaxis:

<resources>
<string name="nombre_string">contenido_string</string>
</resources>
Para acceder al contenido de un string a través del código, se usa la clase R de la siguiente
forma:
R.string.nombre_string
Por otro lado, en una definición XML se accede así:
@string/nombre_string
Como ya vimos, el valor del atributo name representa el identificador de cada

etiqueta<string>.
Si revisas el archivo res/layout/actividad_principal.xml verás que el TextView existente
referencia el string hello_world en su atributo android:text.
<TextView
android:text="@string/hello_world" />
En la vista de diseño de Android Studio podemos percibir el valor del texto gracias al árbol
de componentes, el panel de propiedades y obviamente reflejado en la previsualización.
¿Cómo hacer para obtener el valor de un string en código?
Uno de los métodos es usar la clase Resources, la cual representa la carpeta res dentro del
código. Esta provee métodos get*() para conseguir varios tipos de valor almacenados en
recursos.
En este caso particular sería el método getString(). Solo pasas como parámetro el
indicador y así obtendrás su contenido.
Por ejemplo… obtengamos el valor del string app_name y asignémoslo al text view de la
actividad. Esto lo haremos dentro del controlador onCreate() de ActividadPrincipal.
@Override
setContentView(R.layout.actividad_principal);
TextView helloWorld = (TextView)findViewById(R.id.hello_world);
String nombreAplicacion = getResources().getString(R.string.app_name);

helloWorld.setText(nombreAplicacion);
Ejecuta la app y tendrás el cambio:
También puedes usar el método getString() desde la actividad sin llamar a la

claseResources.
String nombreAplicacion = getString(R.string.app_name);
Otra alternativa es el método getText(), el cual retorna en un tipo CharSequence. Este

método difiere a getString() en la capacidad de obtener el string con estilos (ej. cambio de
color de fuente).
helloWorld.setText(getText(R.string.hello_world));
ARREGLO DE STRINGS CON LA ETIQUETA <STRING-

ARRAY>
Otra forma de contener elementos de texto en los recursos es a través de arreglos. La etiqueta
que nos permitirá este funcionalidad es <string-array>.
El identificador de este componente se define con el atributo name y cada elemento del
arreglo se representa con elementos hijos del tipo <item>. El contenido de cada item sería
un string.

<resources>
<string-array name="nombre_arreglo">
<item>contenido_string</item>
...
</string-array>
</resources>
El acceso a un array de strings en java se realiza con la clase anidada estática R.array.
R.array.nombre_array
En XML se antepone la sentencia @array.
@array/nombre_array
Por ejemplo…
Uno de los usos comunes de un array de strings se da en el view Spinner. Recuerda que este
control despliega una lista opciones para selección del usuario.
Comprobémoslo cambiando el text view de la actividad por un spinner de la siguiente forma.
<Spinner
android:id="@+id/spinner"
android:layout_alignParentTop="true"
android:layout_centerHorizontal="true" />
Ahora dentro de strings.xml añade el siguiente array de strings.
<string-array name="posiciones">
<item>Top</item>
<item>Mid</item>
<item>Bot</item>
<item>Jungla</item>
</string-array>
Este contiene las posiciones de los jugadores en el juego League Of Legends.

Para asignar los ítems al spinner sin usar un adaptador usamos el atributo android:entries.
Este recibe la referencia de un array que contenga las opciones. Solo basta acceder a
posiciones con definición XML.
<Spinner
android:layout_centerHorizontal="true"
android:entries="@array/posiciones"/>
También puedes hacerlo a través del panel de propiedades en Android Studio.
Limpia el código de onCreate() que ya no usarás y ejecuta la aplicación.

Ahora, si deseas obtener el valor de un array de strings en el código, entonces usa la el
métodoResources.getStringArray().
String[] posiciones = getResources().getStringArray(R.array.posiciones);
CREACIÓN DE PLURALES CON LA ETIQUETA

<PLURALS>
Los plurales son strings que representan diferentes cantidades de un texto según la situación.
Por ejemplo…
Al realizar una búsqueda de elementos en tu aplicación tal vez quieras informarle al usuario
cuantos fueron encontrados. Puede que no se haya encontrado ninguno, o tal vez uno o quizás
varios.
Si deseas presentar la información en una frase sería algo como:
“n elementos encontrados”
Donde se reemplazaría n por la cantidad. Por lo tanto al tener la expresión n=1, el resultado
sería:
“1 elementos encontrados”
Esta sería una solución para abarcar todas las opciones, pero produce resultados anómalos.
Necesitaríamos tres tipos de frases para poder mantener la integridad de nuestra gramática.
▪ “No se encontraron elementos”

▪ “Se encontró un elemento”
▪ “Se encontraron n elementos”
Con el fin de solucionar este lio existen los plurales. Recursos que contienen una serie de
elementos que representan la variación de una oración dependiendo del número de elementos
mencionados.
Su implementación se basa en la etiqueta <plurals>. Su ID se genera a partir del

atributoname y cada variación se define como un elemento hijo del tipo <item>.
La cantidad de elementos del ítem se asigna con el atributo quantity y su contenido es el
string a guardar.

<resources>
<plurals name="nombre_plural">
<item quantity=["zero" | "one" | "two" | "few" | "many" | "other"]>contenido_string
</item>
</plurals>
</resources>
Las constantes que se ven para quantity definen cantidades estándar. Veamos una tabla con
las definiciones:
Valor Descripción
zero Se refiere a el número 0 si el lenguaje necesita este tipo de interpretación
one Se refiere a la unidad (1)
two Constante para la representación especial de 2 unidades.
few Se refiere a una cantidad pequeña de unidades dependiendo del lenguaje
many Se refiere a una gran cantidad de elementos.
other Constante para cuando no se necesita un tratamiento específico.

Cabe aclarar que la interpretación de cada constante varía de un lenguaje a otro, por lo que
habría que asesorarse ante la traducción de plurales.
La única forma para acceder a un plural es a través de código.
R.plurals.nombre_plural
Ejemplo de plurales— Vamos a crear un plural que se refiera a una cantidad hipotética de
productos encontrada en una búsqueda.
Para ello limpiamos el método onCreate() de la actividad y reemplazamos el spinner
anterior por un text view.
<TextView
android:text="New Text"
android:id="@+id/textView"
android:layout_centerHorizontal="true" />
El plural que añadiremos a strings.xml tendrá tres casos disponibles. El no encontrar un

valor, encontrar uno solo y encontrar varios.
<string name="zero">No se encontraron productos</string>
<plurals name="noProductosEncontrados">
<item quantity="one">Se encontró %d producto</item>
<item quantity="other">Se encontraron %d productos</item>
</plurals>
Ahora obtendremos el valor de un plural en onCreate() con el

métodoResources.getQuantityString(). Este recibe el ID del plural como primer
parámetro, el segundo parámetro es la cantidad de elementos encontrados y el tercero será el
número que reemplace los placeholders %d.
@Override
TextView textView = (TextView) findViewById(R.id.textView);
Random random = new Random();

int cantidad = random.nextInt(9);
if (cantidad == 0) {
textView.setText(R.string.zero);
} else {
String string = res.getQuantityString(
R.plurals.noProductosEncontrados,
cantidad,
cantidad);
textView.setText(string);
}
Si te fijas, el caso "zero" no se incluye en el plural. Esto sucede porque al parecer el

framework de Android no interpreta el 0 como la ausencia de elementos, lo que hace que se
incluya en el caso "other". Con eso tendríamos el resultado:
"Se encontraron 0 productos"
Para evitarlo, creamos un nuevo string simple con el valor correcto y luego usamos
un if para diferenciar entre ambos resultados producidos por la cantidad aleatoria producida
con la claseRandom.
Cuando creas un plural Google recomienda añadirle como mínimo los
casos "one" y "other"para el soporte de la mayoría de lenguajes. Además indica que el
caso "one" debe tener el placeholder %d para darle el tratamiento en otros lenguajes donde
“1” no se interpreta como en el español. Esto facilita la comprensión y trabajo a los
traductores.
Si ejecutas la aplicación tendrías resultados similares a la siguiente ilustración.
USO DE CARACTERES ESPECIALES EN STRINGS
Existen casos donde deseamos poner caracteres especiales dentro de nuestros recursos strings
como lo son acentos, símbolos o caracteres que hacen parte de XML. Sin embargo hacerlo
de forma estática no produce resultados deseados.
Para comprobarlo volvamos a nuestra aplicación. Limpia el método onCreate() y crea un

nuevo string con el siguiente valor.
<string name="frase">"Su activo más valioso puede ser su voluntad de persistir más que cualquier otra
persona"</string>
Asigna el recurso al text view y corre la aplicación.
¿Cuál es el resultado?
Las comillas no aparecerán.
Las comillas dobles y los apóstrofos no serán interpretados por el framework de Android a
no ser que antepongas una barra vertical (\' y \"). Esto se debe a que las secuencias de
caracteres en Java usan estos símbolos como escape para representar dichos elementos.
El ejemplo anterior quedaría de la siguiente forma.
<string name="frase">\"Su activo más valioso puede ser su voluntad de persistir más que cualquier otra
persona\"</string>
Para el apostrofo es igual. Agregamos el backslash para subsanar el escape.
<string name="apostrofos">Donde procrastinar significa \'Diferir, aplazar\'</string>

Otra opción es encerrar todo el string con comillas dobles y usar los apóstrofos de forma
normal.
<string name="apostrofos">"Donde procrastinar significa 'Diferir, aplazar'"</string>
Sin embargo este mecanismo no funciona a la inversa.
<string name="frase">'"Ser discutido, es ser percibido"'</string>
Se produciría un error como este:
De forma similar podemos usar las otras secuencias de escape que existen para los strings en
Java.
Secuencia de escape Descripción
\t Inserta una tabulación
\b Inserta un retroceso
\n Inserta nueva línea
\r Inserta retorno de carro
\f Comienzo de página
\' Comilla simple o apóstrofo
\" Comillas dobles
\\ Backslash
Por ejemplo, si quisiéramos introducir una nueva en un string usaríamos la secuencia \n.
<string name="nueva_linea">-Hola!\n-Habláme\n-Como va todo?\n-Bien bien :D</string>
Caracteres especiales de acceso a recursos— Recuerda que el arroba '@' y el signo de

interrogación '?' permiten acceder al valor de un recurso en XML. Lo que significa que son
caracteres restringidos.
Si intentas usarlos en la primera posición de un string, se producirá un error de interpretación.
La solución consiste en usar comillas dobles para evitar el inconveniente.
<string name="interrogacion">"?"</string>
<string name="arroba">"@"</string>
Si estos símbolos son usados en otra posición no es necesario usar las comillas.
<string name="info_correo">Tu correo es: correo@gmail.com</string>
Caracteres de escape en XML— En el artículo Tutorial Básico Del Lengueje Xml vimos
que hay 5 caracteres que no pueden ser usados normalmente dentro de los contenidos de una
etiqueta, ya que hacen parte de la notación XML.
Carácter Representación
& &
< <
> >
“ "
‘ '
Algunos ejemplos serían…
Ampersand :
<string name="ampersand_mal">Johnson & Johnson</string>
<string name="ampersand_correcto">Johnson & Johnson</string>
Menor qué:
<string name="menor_que_mal">3<2</string>
<string name="menor_que_correcto">3<2</string>
Mayor qué:
<string name="etiqueta"><string></string>
Comillas dobles:
<string name="comillas_dobles_mal">"Coldplay"</string>
<string name="comillas_dobles_correcto">\"Coldplay\"</string>
Sorprende un poco que el primer ejemplo no funcione. Esto se debe a que el parser cambia
primero a texto plano los caracteres de escape XML y luego convierte el contenido resultante
en un tipo String de java. Por eso es necesario usar los escapes de java también.
Apóstrofos:
<string name="apostrofos_mal">Signo de escritura (') que se emplea para indicar la elisión de una
vocal.</string>
<string name="apostrofos_correcto">Signo de escritura (\') que se emplea para indicar la elisión de una
vocal.</string>
Uso de caracteres Unicode— También es posible usar las representaciones de caracteres

especiales a través del estándar Unicode. Simplemente haces referencia al código de cada
elemento anteponiendo \u. La siguiente tabla muestra algunos caracteres:
Si deseáramos usar las comillas, escribimos el código \u0022:
<string name="comillas_unicode">\u0022Capitan Teemo de servicio\u0022</string>
Otro ejemplo podría ser el uso del carácter que representa una octava en música con el
código\u266A.
<string name="octava_unicode">Te quiero yo… y tú a mi \u266A</string>

FORMATEO DE STRINGS EN ANDROID
Los recursos de strings también pueden ser formateados a través de parámetros especificados
por placeholders. Si tienes experiencia con la clase String de java, sabrás que el método
estático String.format() nos permite añadir formato.
Para conectar este método con un recurso string simplemente debes añadir placeholders que
indiquen el tipo de parámetro a reemplazar dentro de la cadena más la posición que se desea
ocupar.
Veamos un ejemplo:
<string name="string_formateada">¡Qué bien %1$s! Has alcanzado %2$d puntos</string>
El anterior ejemplo tiene dos parámetros: %1$s y %2$s. El primero representa un string en
java (%s) y su posición es determinada en el parser con 1$. El segundo es de tipo entero (%d)
y está en segunda posición 2$.
Ve al método onCreate() de la actividad y obtén el recurso string que acabos de ver. Luego
usa el método format() asignando dos valores correspondientes y por último setea el
resultado en el text view.
@Override

String recurso = res.getString(R.string.string_formateada);
String stringFormateada = String.format(recurso, "James", 120);
TextView texto = (TextView)findViewById(R.id.textView);

texto.setText(stringFormateada);
Al ejecutar la aplicación tendremos el siguiente resultado:

APLICAR MARCADO HTML EN UN RECURSO STRING
Como era de suponer, el contenido XML de un string puede ser estilizado usando marcado
Html. Podemos usar las siguientes etiquetas:
▪ <b>: Imprime el texto en negrilla.

▪ <i>: Transforma el texto a inclinación itálica.
▪ <u>: Subraya el texto.
Por ejemplo…
<string name="string_html"><i>Recursos</i> <u>String</u> Con Marcado <b>Html</b></string>
Si asignas el anterior string al text view en su definición XML, el parser automáticamente

interpretará las etiquetas Html y producirá el resultado anterior.
Por otro lado, para asignar el recurso programáticamente debemos usar el método
estáticoHtml.fromHtml() para traducir las etiquetas Html. De lo contrario, en tu string
saldrán las etiquetas textualmente.
@Override

String texto = res.getString(R.string.string_html);
CharSequence textoInterpretado = Html.fromHtml(texto);
TextView textView = (TextView)findViewById(R.id.textView);

textView.setText(textoInterpretado);
Si pruebas el código anterior verás que no se aplican los estilos. La solución está en usar
secuencias de escape, debido a que el parser al transformar el texto ha ignorado todo el html.
<string name="string_html"><i>Recursos</i> <u>String</u> Con Marcado

<b>Html</b></string>
¿Es posible usar etiquetas html como <br>, <p> o <strong>?

De la forma en que lo estamos haciendo hasta ahora no.
Sin embargo puedes ignorar completamente el contenido de una etiqueta <string> con la
cláusula CDATA. Con ello pasarías un código completo Html al método fromHtml() para que
este interprete la cantidad de etiquetas que pueda (no todas son aceptadas).
Probemos usando el código html que tiene la descripción del método fromtHtml() en la
documentación oficial.
<string name="string_html_cdata">
<![CDATA[
<div>
<h4>
<span>
public static
<a href="/reference/android/text/Spanned.html">Spanned</a>
</span>
<span>fromHtml</span>
<span>(<a href="/reference/java/lang/String.html">String</a> source)</span>
</h4>
<div>
<div> Added in <a href="/guide/topics/manifest/uses-sdk-element.html#ApiLevels">API level
1</a></div>
</div>
<div>
<div>
<p>Returns displayable styled text from the provided HTML string.
Any <img> tags in the HTML will display as a generic
replacement image which your program can then go through and
replace with real images.
</p>
<p>This uses TagSoup to handle real HTML, including all of the brokenness found in the wild.</p>
</div>
</div>
</div>
]]>
</string>
Al ejecutar la aplicación (obviamente después de haber cambiado la referencia del string

enonCreate()) tendremos los siguiente.
AÑADIR ESTILO AL TEXTO CON SPANNABLE

Existe otra forma para aumentar las capacidades de estilo de nuestros strings y es a través de
la interfaz Spannable.
Cuando un texto adquiere las características de la interfaz Spannable, este es capaz de
modificar su aspecto en varios sentidos, como el tamaño de la fuente, color, el formato de
sus caracteres, etc.
Para aprovechar esa capacidad se usa la clase auxiliar SpannableStringBuilder, la cual
permite construir un texto con marcas de estilo. Luego se aplica sobre esas marcas algunos
de los estilos contenidos en el paquete android.text.style.
Veamos un ejemplo donde ponemos la primera letra en negrilla de un string.
@Override
SpannableStringBuilder stringBuilder =
new SpannableStringBuilder(getString(R.string.hello_world));
stringBuilder.setSpan(new StyleSpan(Typeface.BOLD),0,1, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
TextView textView = (TextView)findViewById(R.id.textView);

textView.setText(stringBuilder);
En primera instancia creamos una instancia de SpannableStringBuilder con una copia del
string hello_world.
Luego a través del método setSpan() aplicamos el estilo con los siguientes parámetros.
public void setSpan(Object what, int start, int end, int flags)
▪ what: Un nuevo objeto del estilo de texto.

▪ start: Índice inicial del carácter donde se insertará el estilo.
▪ end: Índice del carácter final hasta donde se aplicará el estilo.
▪ flags: Banderas que determinan el comportamiento del texto cuando se aplica el estilo
La clase que proporciona el estilo de escritura es StyleSpan, por eso la usamos en el primer
parámetro. Su constructor recibe una constante del tipo Typeface para determinar si es
negrilla, itálica o cursiva. En este caso BOLD representa negrilla. Las otras constantes las
encuentras en la definición de la clase.
Debido a que solo necesitamos colocar en negrilla la primer letra, entonces el índice inicial
del string es 0 y el final será 1.
La bandera Spanned.SPAN_EXCLUSIVE_EXCLUSIVE evita que el tamaño del string cambie o
tenga tamaño 0.
Si ejecutas la aplicación tendrás el siguiente resultado.
Para cambiar el color puedes usar la clase ForegroundColorSpan de la siguiente forma.
@Override
SpannableStringBuilder stringBuilder =
new SpannableStringBuilder(getString(R.string.hello_world));
stringBuilder.setSpan(new ForegroundColorSpan(Color.RED),
0, 6, Spanned.SPAN_EXCLUSIVE_EXCLUSIVE);
TextView textView = (TextView) findViewById(R.id.textView);

textView.setText(stringBuilder);
}
Esta vez solo pasamos un nuevo objeto ForegroundColorSpan con la constante que
representa el color rojo Color.RED. El estilo es aplicado en la primera palabra.
Si ya revisaste el paquete android.text.style verás que existe una gran variedad de

posibilidades de personalización.
Si quieres ver más ejemplos puedes visitar este artículo introductorio a spannables en
Android.
SOPORTAR MÚLTIPLES LENGUAJES EN ANDROID
Es posible crear recursos alternativos para el archivo strings.xml y así mantener la

compatibildiad con varias ubicaciones y regiones.
Recuerda que para ello es necesario añadir los calificadores de idioma y región. Todo
depende del público al que va dirigido tu aplicación Android.
Veamos cómo hacer una pequeña traducción del español al inglés e italiano.
1. Modifica el contenido del archivo strings.xml con las siguientes cadenas.
<resources xmlns:tools="http://schemas.android.com/tools" tools:locale="es">

<string name="action_settings">Configuración</string>
<string name="etiqueta_estado_civil">Estado Civil</string>

<string name="boton_busqueda">Buscar</string>
<string-array name="estado_civil">
<item>Soltero</item>
<item>Casado</item>
<item>Viudo</item>
</string-array>
</resources>
El atributo tools:locale nos permite establecer el idioma por defecto del

archivosstrings.xml. En este caso español es.
2. Cambia el layout de la actividad principal con el siguiente diseño. La idea es tener un
encabezado gigante con la etiqueta "Estado Civil". En el centro irá un Spinner que se
alimenta del array estado_civil y al final un botón que contiene el texto
de boton_busqueda.
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
xmlns:tools="http://schemas.android.com/tools"
android:paddingBottom="@dimen/activity_vertical_margin"
android:paddingLeft="@dimen/activity_horizontal_margin"
android:paddingRight="@dimen/activity_horizontal_margin"
android:paddingTop="@dimen/activity_vertical_margin"
tools:context=".ActividadPrincipal">
<Button
android:id="@+id/button"
android:layout_alignParentBottom="true"
android:layout_marginEnd="43dp"
android:layout_marginRight="43dp"
android:text="@string/boton_busqueda" />
<Spinner
android:layout_centerInParent="true"
android:entries="@array/estado_civil" />
<TextView
android:id="@+id/textView"
android:text="@string/etiqueta_estado_civil"
android:textSize="50sp" />
</RelativeLayout>
Si ejecutas hasta aquí, tendrás lo siguiente:
3. A continuación crearemos las traducciones para cada uno de los strings que tenemos. Abre
el archivo strings.xml y selecciona la opción emergente Open Editor en la parte superior
del espacio de trabajo.
Otra forma de acceder al editor de traducciones es presionar click derecho sobre el
archivostrings.xml y seleccionar Open Translations Editor.
El editor de traducciones o Translations Editor es donde se gestionan los valores de idioma

para cada elemento.
Dentro de él encontrarás tres columnas. Key para representar el identificador de cada
string.Default Value que determina el valor por defecto del string. Untranslatable para
marcar un elemento como no traducible (una señal que informa a los traductores que
contrates).
4. El archivo res/values/strings.xml sin calificador se asigna al idioma por defecto que es el
inglés. Sin embargo nosotros tenemos cadenas en español en esa ubicación.
Presiona el icono del globo terraqueo en la parte superior izquierda y luego selecciona la
opción English (en).
Esto mostrará una nueva pantalla donde podremos ingresar la traducción directa al inglés de
cada string.
5. Lo siguiente es editar las casillas correspondientes y añadir las traducciones:
6. Ahora realiza el mismo procedimiento con la traducción italiana (Usé Google Translator,
quien sepa italiano podría colaborarme con mejores traducciones).
7. Abordemos la traducción del array de strings. Esto requiere la creación de strings
simples que se referencien dentro de cada ítem. De lo contrario, no tendremos la traducción
para estos elementos.
Crea tres nuevos recursos dentro de strings.xml. Luego asígnalos a las etiquetas <item> en
el orden establecido.
<string name="estado_soltero">Soltero</string>
<string name="estado_casado">Casado</string>
<string name="estado_viudo">Viudo</string>
<string-array name="estado_civil">
<item>@string/estado_soltero</item>
<item>@string/estado_casado</item>
<item>@string/estado_viudo</item>
</string-array>
Ahora asignemos los valores correspondientes en ambas traducciones.
Con esto tendríamos los siguientes archivos.

values-en/strings.xml

<resources>
<string name="boton_busqueda">Search</string>
<string name="etiqueta_estado_civil">Marital Status</string>
<string name="estado_casado">Married</string>
<string name="estado_soltero">Single</string>
<string name="estado_viudo">Widower</string>
</resources>
values-it/strings.xml

<resources>
<string name="action_settings">Configurazione</string>
<string name="boton_busqueda">Ricerca</string>
<string name="etiqueta_estado_civil">Stato Civile</string>
<string name="estado_casado">Sposato</string>
<string name="estado_soltero">Singolo</string>
<string name="estado_viudo">Vedovo</string>
</resources>
Si revisas la jerarquía de la carpeta res verás que tienes el subdirectorio values por defecto
más otros dos, values-en y values-it.
8. Prueba los recursos strings.xml cambiando el idioma en Ajustes > Idioma e

introducción de texto > Idioma.
Prueba usando inglés.
Con ello verás el siguiente resultado.
ORDENAR UNA TRADUCCIÓN EN ANDROID STUDIO
Finalmente te cuento que existe la posibilidad de contratar un servicio especial

de Google para ordenar la traducción de tu archivo strings.xml a cualquier idioma.
Este tiene un costo, sin embargo es un servicio profesional de buena calidad.
Puedes contratarlo seleccionando la opción Order a translation… que se encuentra en el

editor de traducciones.
Para ello es necesario que tengas una cuenta con Google. Subes tus recursos, seleccionas el
lenguaje para la traducción y finalmente pagas.
Un servicio simple que puedes considerar usar para tus proyectos.

Cómo Empezar A Desarrollar Aplicaciones Android

Cargado por

Información del documento

Descripción original:

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Cómo Empezar A Desarrollar Aplicaciones Android

Cargado por

Copyright:

Formatos disponibles

¿Cómo Empezar A Desarrollar

INSTALANDO EL ENTORNO DE DESARROLLO

DESCARGAR ANDROID SDK, ANDROID STUDIO Y EL JDK

INSTALANDO JAVA DEVELOPMENT KIT

INSTALANDO ANDROID STUDIO

Inicio > Equipo > Propiedades del sistema:

Ahora vamos a Configuración avanzada del sistema:

Luego ejecutaremos Android Studio. Si te pide importar características de una versión

CREAR UN NUEVO PROYECTO EN ANDROID STUDIO

Se nos pedirá el nombre de la aplicación (Application Name), el dominio de tu

Android Studio se apoya en la herramienta de Software Gradle para automatizar

USANDO EL SDK MANAGER

Ahora presionaremos el botón “Install packages” para pasar a la fase de instalación. Te

¿QUÉ ES UN AVD (ANDROID VIRTUAL DEVICE)?

A continuación iniciaremos el AVD presionando el botón “Start…“:

EJECUTAR UNA APLICACIÓN EN ANDROID STUDIO

Para correr tu aplicación dirígete al editor y presiona “Run app”:

En este momento Gradle comienza la compilación y empaquetado de nuestra aplicación.

En mi caso la aplicación test representa el proceso 1001 en el AVD.

RECOMENDACIONES PARA ACELERAR EL AVD

APROVECHAR LA ARQUITECTURA INTEL

USAR VERSIONES ANTIGUAS DE ANDROID

USAR TU PROPIO DISPOSITIVO MÓVIL

3. Luego marca Depuración de USB.

Si deseas que siempre se ejecute con tu teléfono entonces configuraremos el proyecto de la

ERROR “USB DEVICE NOT FOUND”

2. Luego selecciona la opción que dice “Conectado como un dispositivo USB“:

1. EJEMPLO: APLICACIÓN HELLOWORLD EN JAVA

Comencemos recordando la estructura general de un programa Java.

public class PruebaJava {

Si todo ha salido bien, entonces podrás ver en consola el mensaje.

Las siguientes son características fundamentales para crear un sistema de paquetes:

3. APUNTAR TU CÓDIGO CON COMENTARIOS

// Ejecución del bucle interno

O también comentar múltiples líneas si incluyes el texto dentro de /* */.

El manejo de la información en Java es soportado en varios tipos de datos elementales.

Al igual que en otros lenguajes, Java soporta

boolean Representa los estados binarios true (1) y false (0)

char Es un tipo de dato que representa un solo carácter Unicode de 16 bits

5. DECLARAR CONJUNTOS DE VALORES CON ARRAYS

La anterior ilustración muestra la representación visual de un array con un tamaño de

// Creamos 5 espacios para enteros

int [] arrayDeEnteros = {1, 3, 5, 7, 9};

¿Qué tipo de operaciones?

sufijo expr++ expr--

unarios ++expr --expr +expr -expr ~ !

desplazamiento de bits << >> >>>

relacionales < > <= >= instanceof

AND para bits &

OR exclusivo para bits ^

OR inclusivo para bits |

AND lógico &&

El ejemplo anterior comprueba si la suma de las variables a y b es mayor que 2. Si es así,

Ahora… ¿qué pasa si tienes más de un resultado a controlar?

if (comprasTotales < 200) {

La sentencia case determina el valor que comprobarás. Si se cumple, entonces se ejecutan

String opcionElegida = "Carlos Valdez";

Un bucle es una estructura de repetición que permite ejecutar un mismo conjunto de

Veamos cuáles tenemos a disposición.

El siguiente ejemplo muestra cómo sumar los números del 1 al 10.

while (contador <= 10) {

System.out.println("La suma es: " + suma);

El código anterior mostraría el siguiente resultado: