Instanciar en Android

Cuando se habla de "instanciar" en Android (o en

cualquier lenguaje de programación orientado a
objetos), significa crear un objeto específico de una
clase. En el contexto de Android, instanciar se refiere a
crear una instancia (objeto) de una clase que
representa un componente, como una Activity,
Fragment, ViewModel, Service, etc.

En el caso específico de Android, la instanciación de

componentes se realiza mediante el uso de la palabra
clave new. Por ejemplo, para crear una instancia de una
Activity, normalmente se crea una nueva clase que
extiende AppCompatActivity y se llama al constructor de
esa clase.

Sin embargo, en la práctica, la instanciación de

componentes de Android se realiza de manera diferente
en la mayoría de los casos. Las Activities y Fragments,
por ejemplo, se crean y gestionan automáticamente por
el sistema Android mediante el mecanismo de "inflado"
de la vista a partir de un archivo de diseño XML.

El uso de la instanciación de objetos en Android permite

crear y utilizar múltiples instancias de una clase, lo que
facilita la creación de interfaces de usuario interactivas
y permite que los componentes de la aplicación
interactúen entre sí.

En cuanto a las características de la instanciación,

algunas de las más importantes son:

1. Creación de objetos: La instanciación permite

crear objetos a partir de una clase definida.
Cada objeto puede tener su propio estado y
comportamiento.
 2. Reutilización de código: Al instanciar una
clase, se puede reutilizar el código que ha sido
definido en esa clase. Esto promueve la
modularidad y evita la duplicación de código.
3. Polimorfismo: La instanciación también
permite aplicar el concepto de polimorfismo, lo
que significa que un objeto puede ser tratado
como una instancia de su clase base o de
cualquiera de sus clases derivadas.
4. Gestión de memoria: El ciclo de vida de una
instancia se maneja automáticamente en
Android. Cuando un objeto ya no es necesario,
el recolector de basura de Java se encarga de
liberar la memoria asociada a esa instancia.

En resumen, la instanciación en Android (y en

programación en general) es el proceso de crear un
objeto a partir de una clase, lo que permite la creación
dinámica y el uso de múltiples instancias de
componentes en una aplicación.

Ciclo de vida de un Activity en Android

En Android, un Activity es un componente de la
aplicación que representa una única pantalla con una
interfaz de usuario. Cada Activity tiene un ciclo de vida
que comprende varias etapas y métodos que se llaman
en diferentes momentos del ciclo de vida. A
continuación, te explico las etapas principales del ciclo
de vida de un Activity:

Creación (onCreate()): Esta es la primera etapa del

ciclo de vida. Se llama cuando se crea la instancia del
Activity. Aquí es donde se inicializa la interfaz de
usuario y se realizan las tareas de configuración inicial.

Inicio (onStart()): Después de la creación, el Activity

pasa al estado "Iniciado". En esta etapa, el Activity se
vuelve visible para el usuario, pero aún no está
interactuable.

Resumen (onResume()): Después del estado

"Iniciado", el Activity pasa al estado "Resumido". Aquí
es cuando el Activity está en primer plano y
completamente interactuable con el usuario. Todas las
interacciones del usuario ocurren en esta etapa.

Pausa (onPause()): Si otro Activity entra en primer

plano o alguna otra interrupción ocurre, el Activity pasa
al estado "Pausado". En esta etapa, el Activity aún es
visible, pero ya no está en primer plano y no puede
realizar operaciones interactivas.

Detención (onStop()): Cuando el Activity se detiene,

pasa al estado "Detenido". Esto puede suceder cuando
el usuario navega a otro Activity o cuando la actividad
actual se detiene completamente.

Inicio (onRestart()): Si el Activity se detiene pero luego

vuelve a ser visible, se llama al método onRestart()
antes de que se vuelva a iniciar. Aquí puedes realizar
operaciones de reinicio y preparar la interfaz de usuario
para volver a la etapa "Resumido".

Destrucción (onDestroy()): Cuando el Activity se

cierra o se finaliza explícitamente mediante la llamada
al método finish(), se llama al método onDestroy(). Aquí
es donde se liberan los recursos y se realizan las tareas
de limpieza antes de que el Activity sea eliminado.

Durante el ciclo de vida de un Activity, el sistema puede

llamar a diferentes métodos dependiendo de cómo
interactúa el usuario con la aplicación y cómo el
sistema maneja los recursos.

Es importante tener en cuenta que el ciclo de vida

puede variar según la versión de Android y cómo el
sistema maneja las actividades en el fondo. También es
crucial administrar adecuadamente el ciclo de vida para
evitar problemas como pérdidas de memoria o
comportamientos inesperados.
 Ciclo de Vida de un Fragment
un Fragment es un componente de interfaz de usuario
en Android que representa un comportamiento o una
parte de la interfaz de usuario en una Activity. A
diferencia de una Activity que representa una pantalla
completa, un Fragment se puede considerar como una
"subactividad" que puede ser combinada o reutilizada
en diferentes Activities.

El ciclo de vida de un Fragment es similar al ciclo de

vida de una Activity, pero con algunas diferencias
importantes. Aquí están las principales etapas del ciclo
de vida de un Fragment:

Creación (onCreate()): Es la primera etapa del ciclo de

vida del Fragment. Se llama cuando el Fragment se
crea, pero aún no es visible para el usuario. Aquí es
donde se puede realizar la inicialización necesaria.

Creación de la vista (onCreateView()): Después de la

etapa de creación, el Fragment pasa por esta etapa. En
este punto, el Fragment crea y devuelve su vista
asociada a través del método onCreateView(). Aquí es
donde se infla el diseño y se configura la interfaz de
usuario del Fragment.
Inicio (onStart()): Cuando el Fragment se asocia con
una Activity y se hace visible para el usuario, se llama al
método onStart(). En esta etapa, el Fragment se vuelve
visible, pero aún no es interactuable con el usuario.

Resumen (onResume()): Después del estado

"Iniciado", el Fragment pasa al estado "Resumido". Aquí
es cuando el Fragment está en primer plano,
completamente visible y interactuable con el usuario.
Todas las interacciones del usuario ocurren en esta
etapa.

Pausa (onPause()): Si el Fragment pierde el foco o se

superpone por otra transacción, se llama al método
onPause(). El Fragment aún es visible, pero ya no está
en primer plano y no puede realizar operaciones
interactivas.

Detención (onStop()): Si el Fragment se detiene, pasa

al estado "Detenido". Esto puede suceder cuando la
Activity en la que se encuentra el Fragment se detiene
o cuando se realiza una transacción para reemplazar o
quitar el Fragment.

Destrucción de la vista (onDestroyView()): Cuando el

Fragment se destruye o se elimina de la Activity, se
llama al método onDestroyView(). Aquí es donde debes
liberar los recursos asociados a la vista.

Destrucción (onDestroy()): Finalmente, cuando el

Fragment se cierra o se finaliza explícitamente, se
llama al método onDestroy(). Aquí es donde se liberan
los recursos restantes y se realizan las tareas de
limpieza antes de que el Fragment se elimine por
completo.
Es importante señalar que, a diferencia de una Activity,
un Fragment puede existir independientemente y no
siempre tiene que estar adjunto a una Activity. Esto
permite una mayor flexibilidad en la reutilización de
componentes de interfaz de usuario en diferentes
contextos.
 Android Manifest
El archivo "AndroidManifest.xml" es un componente
fundamental en el desarrollo de aplicaciones Android.
Es un archivo de manifiesto que se encuentra en la raíz
del directorio del proyecto Android y contiene
información esencial sobre la aplicación. El Manifiesto
de Android describe las características y la
configuración básica de la aplicación para que el
sistema operativo Android pueda comprenderla y
administrarla adecuadamente.

El Android Manifest incluye información como:

1. Nombre del paquete (package): Es el

identificador único de la aplicación, que
generalmente sigue la convención de
nomenclatura inversa del dominio (por ejemplo,
com.ejemplo.app).
2. Componentes de la aplicación: Define las
Activities, Services, Broadcast Receivers y
Content Providers que componen la aplicación.
Estos componentes son puntos de entrada y
puntos de interacción con el sistema operativo y
otros componentes de la aplicación.
3. Permisos (uses-permission): Enumera los
permisos que la aplicación requiere para
acceder a determinadas funciones o recursos
del dispositivo (como acceso a Internet,
ubicación, cámara, etc.). Los usuarios deben
otorgar estos permisos durante la instalación o
en tiempo de ejecución, dependiendo de la
versión de Android y los permisos específicos.
4. Configuración de la aplicación: Incluye
información sobre la versión del código, la
versión del nombre de la aplicación, el nivel de
API mínimo requerido, el nivel de API objetivo,
el tema predeterminado, el icono de la
aplicación, etc.
5. Filtros de Intents (<intent-filter>): Permite
que la aplicación declare qué tipos de Intents
 (acciones o eventos) puede manejar. Por
ejemplo, una Activity puede declarar que puede
manejar Intents para ver imágenes o recibir
archivos.
6. Actividad principal (<activity-alias>): Define
la actividad principal de la aplicación, que se
inicia cuando el usuario inicia la aplicación
desde el lanzador de aplicaciones.
7. Configuración de seguridad (<application>):
Puede incluir configuraciones de seguridad,
como el uso de cifrado, la política de permisos,
certificados digitales, etc.

El Android Manifest es un archivo estático y se

mantiene sin cambios durante la vida útil de la
aplicación. Cada vez que se compila la aplicación, el
sistema operativo Android lee el Android Manifest para
obtener información sobre la aplicación y configurar
adecuadamente el entorno en tiempo de ejecución. Por
lo tanto, es crucial asegurarse de que el Android
Manifest esté correctamente configurado para
garantizar el buen funcionamiento de la aplicación y
cumplir con las políticas de la tienda de aplicaciones de
Android.

KOTLIN
val (value): Cuando declaramos una variable con val,
estamos creando una variable de solo lectura o una
constante. Una vez que se le asigna un valor, no puede
cambiar a lo largo de su ciclo de vida. Es decir, es
inmutable.

var (variable): Si declaramos una variable con var,

estamos creando una variable mutable, lo que significa
que su valor puede cambiar después de la
inicialización. Es decir, es una variable que puede ser
modificada.

Variables inmutables (constantes, no se pueden

cambiar una vez asignadas):

val nombreVariable: TipoDeDato = valorInicial

1. Tipos numéricos:

Byte: Números enteros de 8 bits.

Short: Números enteros de 16 bits.

Int: Números enteros de 32 bits.

Long: Números enteros de 64 bits.

Float: Números de punto flotante de 32 bits.

Double: Números de punto flotante de 64 bits.

2. Tipos de caracteres:

Char: Representa un solo carácter Unicode.

3. Tipos booleanos:

Boolean: Representa los valores true o false.

4. Tipos de cadenas:

String: Secuencia de caracteres.

5. Tipos de colecciones:

List: Lista inmutable.

MutableList: Lista mutable.

Set: Conjunto inmutable.

MutableSet: Conjunto mutable.

Map: Mapa inmutable (clave-valor).

MutableMap: Mapa mutable (clave-valor).

6. Tipos especiales:

Any: La raíz de la jerarquía de clases en Kotlin.

Unit: Representa la ausencia de valor, equivalente a

void en otros lenguajes.

Nothing: Tipo especial que no tiene instancias, se usa

para representar casos imposibles de alcanzar.

7. Tipos de datos nulos:

Todos los tipos mencionados anteriormente pueden ser

seguidos por “?” para indicar que pueden contener
valores nulos. Por ejemplo: Int?, String?, List<Int>?.

La Expresión if en Kotlin
La expresión if en Kotlin para que puedas bifurcar el
flujo de tus aplicaciones, al evaluar condiciones.

If Como Sentencia
La estructura de control if, te ayuda a conducir el flujo
de tu aplicación, basada en la evaluación de una
expresión que produzca un resultado booleano.
 La Expresión When en Kotlin
La expresión when en Kotlin, con el fin de manipular el
flujo de tus programas, a partir de varias entradas con
sus respectivas condiciones.

when Como Sentencia

La expresión condicional when te permite comparar el
valor de un argumento (sujeto) contra una lista de
entradas.

Las entradas tienen condiciones asociadas al cuerpo

que se ejecutará (condición -> cuerpo). Dichas
condiciones pueden ser:

 Expresiones

 Comprobaciones de rangos

 Comprobaciones de tipos

Funciones en Kotlin
Una función es un conjunto de instrucciones que
realizan una tarea específica, empaquetadas como
unidad.

La declaración comienza con la palabra clave fun y se

conforma de:
Las funciones lambda son una característica poderosa
de Kotlin que te permite crear bloques de código
anónimos que se pueden pasar como argumentos a
otras funciones o almacenar en variables. Estas
funciones son especialmente útiles cuando necesitas
realizar operaciones simples y concisas en colecciones
de datos o en situaciones donde solo se requiere una
pequeña porción de código.

val lambdaVariable: (parametros) -> TipoRetorno =

{ parametros -> expresion }

Donde:

Lambda Variable: es la variable que almacenará la

función lambda.
parametros: son los parámetros que puede aceptar la
función lambda (opcional).

Tipo Retorno: es el tipo de dato que la función lambda

devuelve (opcional).

{}: representa el cuerpo de la función lambda.

expresion: es la expresión o bloque de código que

contiene la lógica de la función lambda.

Bucle for en Kotlin

El bucle for en Kotlin para iterar sobre colecciones de
elementos. Para recorrer estructuras de datos como
rangos, arreglos y strings.

Sintaxis del Bucle for

El bucle for en Kotlin se asemeja a las sentencias
foreach de otros lenguajes, donde se provee un iterador
(iterator()) para recorrer los elementos de datos
estructurados.

La sentencia se compone de una declaración de

variables, una expresión contenedora, compuesta por el
operador in y los datos estructurados (arreglos, listas,
etc.), y el cuerpo del bucle.
El patrón de arquitectura MVVM (Model-View-
ViewModel) es una variante moderna del patrón MVP y
se ha vuelto muy popular en el desarrollo de
aplicaciones Android. MVVM es especialmente útil
cuando se trabaja con arquitecturas basadas en
componentes como LiveData y ViewModel de Android.

Aquí te explico los componentes clave del patrón

MVVM:

1. Modelo (Model):
 Representa los datos y la lógica de negocio de
la aplicación, similar al patrón MVP.
  No conoce nada sobre la interfaz de usuario o
cómo se muestra la información.
2. Vista (View):
 Representa la interfaz de usuario de la
aplicación, al igual que en el patrón MVP.
 Es más pasiva y se centra en la presentación
de la información.
 En el contexto de Android, esto podría ser una
Activity, Fragment o un componente
personalizado.
3. ViewModel:
 Es el componente clave del patrón MVVM y
actúa como un intermediario entre el Modelo y
la Vista.
 Contiene la lógica de presentación y la lógica
de vista específica.
 Expone los datos y el estado de la Vista a
través de objetos observables (por ejemplo,
LiveData en Android).
 No debe contener referencias directas a la Vista
para evitar pérdida de memoria.

El flujo de trabajo en el patrón MVVM es el siguiente:

1. La Vista observa cambios en el ViewModel

mediante objetos observables.
2. El ViewModel obtiene datos y realiza
operaciones de negocio utilizando el Modelo.
3. El ViewModel actualiza los objetos observables
con los resultados obtenidos.
4. La Vista, al estar observando los objetos
observables, se actualiza automáticamente con
los nuevos datos.

Ventajas del patrón MVVM en Android:

  Separa de manera clara la lógica de
presentación y la lógica de negocio.
 Facilita la realización de pruebas unitarias, ya
que la lógica de presentación se encuentra en
el ViewModel, que es independiente de la Vista.
 Admite fácilmente el uso de LiveData y otros
componentes de arquitectura de Android para
manejar cambios en la interfaz de usuario de
manera eficiente.
 Mejora la mantenibilidad al reducir el
acoplamiento entre la Vista y el ViewModel.

En resumen, el patrón MVVM es una arquitectura

moderna y recomendada para el desarrollo de
aplicaciones Android, especialmente cuando se trabaja
con componentes de arquitectura de Android como
LiveData y ViewModel. Sin embargo, como en cualquier
patrón de arquitectura, es esencial comprender bien su
implementación y aplicarlo de manera adecuada a cada
proyecto.
El patrón MVP es una variante del patrón MVC (Model-
View-Controller) y está diseñado para mejorar la
separación de responsabilidades en una aplicación
Android. Su objetivo principal es dividir la lógica de
presentación de la interfaz de usuario (UI) de la lógica
de negocio y los datos, lo que facilita la mantenibilidad y
pruebas unitarias.

1. Modelo (Model):
 Representa los datos y la lógica de negocio de
la aplicación.
 Se encarga de acceder a bases de datos,
servicios web u otros orígenes de datos.
 No conoce nada sobre la interfaz de usuario o
cómo se muestra la información.
2. Vista (View):
 Representa la interfaz de usuario de la
aplicación.
 Es pasiva y se encarga principalmente de
mostrar información y responder a eventos del
usuario.
  No debe contener lógica de negocio y debe ser
lo más tonta posible.
3. Presentador (Presenter):
 Actúa como intermediario entre el Modelo y la
Vista.
 Recibe eventos de la Vista y realiza las
operaciones de negocio necesarias utilizando el
Modelo.
 Actualiza la Vista con los resultados del
Modelo.
 La Vista y el Presentador se comunican a
través de interfaces para una mayor
desacoplamiento.

El flujo de trabajo en el patrón MVP es el siguiente:

1. La Vista envía eventos (por ejemplo, clics de

botón) al Presentador.
2. El Presentador procesa esos eventos y realiza
las operaciones de negocio usando el Modelo.
3. El Presentador actualiza la Vista con los
resultados del Modelo.
4. La Vista muestra los datos actualizados en la
interfaz de usuario.

Ventajas del patrón MVP en Android:

 Separación clara de responsabilidades entre los

componentes.
 Facilita la realización de pruebas unitarias, ya
que la lógica de negocio se encuentra en el
Presentador, que se puede probar de forma
aislada.
  Mejora la mantenibilidad al evitar el
acoplamiento directo entre la interfaz de usuario
y la lógica de negocio.

Es importante tener en cuenta que existen diferentes

variaciones y enfoques del patrón MVP. Por ejemplo,
algunos utilizan interfaces para definir las interacciones
entre la Vista y el Presentador, mientras que otros
pueden utilizar bibliotecas como RxJava o LiveData
para manejar la comunicación entre estos
componentes.