Curso Java SE & POO

Introducción a Java SE
¿Qué es Java?
Java es un lenguaje de programación orientado a objetos de alto nivel, creado en 1991 por
James Goslim mientras trabajaba en Sun Microsystems, este lenguaje fue creado para ser
multiplataforma y poder funcionar en diferentes sistemas operativos mediante una máquina
virtual que se instala en cada equipo, este lenguaje fue comprado por Oracle en el año de
2009 pero personas o comunidades Open source le dan mantenimiento a Java haciendolo
mas accesible a todas las personas.

Java sigue la filosofía de Write Once, Run Anywhere (WORA) gracias a su máquina virtual,
también todo lo que aprendas en Java SE lo podrás aplicar también con Java EE.

Java tiene dos categorías:

● Standard Edition - Para construir aplicaciones de escritorio o consola.
● Enterprise Edition - Para que las empresas trabajen aplicaciones web de última
generación.

Versiones de Java y JDK

El JDK o Java Development Kit se compone de los siguientes elementos:

● Java Runtime Environment (JRE): La máquina virtual de Java, lo que nos permite
que al escribir el mismo código funcione igual en todos los dispositivos y sistemas
operativos.
● Compilador de Java: El encargado de traducir nuestro código en Java a un lenguaje
que puede entender e interpretar nuestra máquina virtual.
● APIs de desarrollo: Una base de código lista para ayudarnos a desarrollar.

Las APIs de desarrollo con Java han evolucionado con el tiempo, por lo que existen
diferentes versiones de java que puedes utilizar. La versión que más elevó la popularidad y
las ofertas de trabajo con Java fue Java SE 6.

En Java SE 9 anunciaron que las actualizaciones ocurrirían cada 6 meses, pero las
versiones LTS (Long Time Support) tendrán mantenimiento por 3 años, así que las
actualizaciones son necesarias, pero no urgentes.

En este curso vamos a trabajar con la versión Java SE 11 LTS, la primera versión de Java
con licencia. Solo podremos usarlo gratis cuando trabajamos en ambientes de desarrollo y
testing. De otra forma, debemos pagar 2.5 USD al mes por usuario de escritorio y 25 USD
por procesador para aplicaciones de servidor.

Afortunadamente, OpenJDK es una versión gratis y open source de usar Java SE Platform
Edition.
Esta es una imagen donde se representa toda la arquitectura y entorno de Java.

Herramientas más usadas de Java

Java 8 (LTS) es la versión más usada de Java hasta inicios del 2019, pero solo tendrá
soporte hasta diciembre del 2020, luego de esta fecha tendremos que pagar una licencia
para continuar con su soporte.

Java 10 introdujo algunos cambios en la forma de declarar variables, así que en este curso
vamos a trabajar con las versiones 8 y 11 de Java.

La herramienta más usada para construir proyectos web con Java es Maven, pero también
existen otras alternativas como Gradle. También existen frameworks como Spring para
trabajar con Java EE y ORMs como Hibernate para trabajar con bases de datos.

Los IDEs son entornos de desarrollo integrados, herramientas (aplicaciones, seguramente

de escritorio) que nos ayudan a escribir nuestro código con editores, compiladores,
depuradores y constructores de interfaces gráficas, todo en un mismo lugar.

El IDE recomendado por Oracle es NetBeans, pero también están Eclipse e IntelliJ IDEA,
este último es el que más fuerza ha tomado gracias a Kotlin. Las tres herramientas son
gratuitas, pero IntelliJ IDEA también tiene una versión de pago.

¿Por qué Java es multiplataforma?

El lenguaje Java es a la vez compilado e interpretado. Con el compilador se convierte el
código fuente que reside en archivos cuya extensión es .java, a un conjunto de
instrucciones que recibe el nombre de bytecodes que se guardan en un archivo cuya
extensión es .class. Estas instrucciones son independientes del tipo de ordenador. El
intérprete ejecuta cada una de estas instrucciones en un ordenador específico (Windows,
Macintosh, etc). Solamente es necesario, por tanto, compilar una vez el programa, pero se
interpreta cada vez que se ejecuta en un ordenador.
Cada intérprete de Java es una implementación de la máquina virtual Java (JVM).

Cambiar de versiones Java

Si cuentas con varias versiones de Java instaladas en tu ordenador y deseas hacer un
cambio de versión para poder trabajar con una en específico solamente se tiene que
cambiar los valores de las variables de entorno:

JShell
Sabías que Java tiene una herramienta interactiva en dónde puedes ir probando segmentos
de código en vez de realizar todo el proceso de creación de un programa en Java. Escribir,
compilar y correr.

Su nombre es jshell y está disponible desde la versión 9 de Java.

Para acceder a ella solamente desde consola se escribe el comando:
"jshell"

Sintaxis de Java
Variables y tipos de datos
Consideraremos que las variables son entidades elementales muy similares a contenedores
al que se le deposita o asigna un valor: un número, un carácter, un valor verdadero o falso,
mientras que los objetos son entidades complejas que pueden estar formadas por la
agrupación de muchas variables y métodos estos tipos de datos lo abordaremos más
adelante cuando veamos POO. Pero ambas cosas ocupan lo mismo: un espacio de
memoria (que puede ser más o menos grande).

public class Class2Variables {

public static void main(String[] args) {
//Declarando variables
int numero = 10;
char letra = "a";
boolean feliz = true;
}
}

⚠️ Nota:
- Desde la versión de Java10 se implementó un tipo de dato
genérico que se puede usar para todo tipo de variables.
- var saludo = "Hola mundo"; var dinero = 10.5;
Tipos primitivos
Los tipos de datos primitivos que Java utiliza como se observa en la imagen anterior, son los
tipos de datos simples que al declararlos no es necesaria una invocación y estos carecen de
métodos.
char letra = 'a';
int numero = 123;
boolean enojado = false;

Estos tipos de datos se utilizan para guardar cifras y se dividen en dos categorías
"enteros" y "decimales", estos tipos de datos tienen la característica de que tienen un
límite de almacenamiento, si el valor que se le asigna sobrepasa el límite ocasionará un
desbordamiento y el código fuente marcara errores, por eso es muy importante elegir el tipo
de dato que se utiliza y analizar si el valor incrementará con el tiempo.

Enteros
En Java, se pueden utilizar los siguientes tipos de datos numéricos para números enteros:
1. byte : ocupa 1 byte de memoria.
2. short: ocupa 2 bytes de memoria.
3. int : ocupa 4 bytes de memoria
4. long : ocupa 8 bytes de memoria.

⚠️ Nota:
- Para diferenciar un int de un long es necesario poner una ‘L’
al final del número de tipo long.
- long numLong = 1234L;

Decimales
Para datos numéricos con punto decimal o flotante existen dos opciones: float y double.
1. float : ocupa 4 bytes de memoria y no tiene tanta precisión como double.
2. double: ocupa 8 bytes de memoria y tiene más precisión qué float.
 ⚠️ Nota:
- Para hacer la distinción entre estos, es necesario poner una ‘F’ al
final del número flotante.
- float numf = 1234F;

Carácter
Para datos de tipo texto o más bien caracteres el único tipo de dato primitivo que podemos
utilizar es el char y solo podrá contener un carácter en su valor.

1. char : ocupa 2 bytes de memoria y es de rango unicode.

⚠️ Nota:
- El valor de este dato siempre debe declararse con comillas
simples.
- char letra = 'a';

Lógicos
Para utilizar datos lógicos y poder representar decisiones se utiliza el tipo de dato boolean
donde su valor puede ser: false y true.

Constantes
Estas son simplemente variables como cualquier otra, estas tienen su espacio en memoria y
se acceden a ellas de la misma manera, pero lo que las diferencia de una normal es que su
valor no se puede actualizar o están hechas para que sus valores no varien. Un caso muy
común es el del número PI que es un valor que nunca cambia y por eso se suele declarar
como una variable constante. "final" es la palabra reservada que va a diferenciar a las
constantes en Java esta va antes de el tipo de dato de la variable.
 ⚠️ Nota:
- Por convención al nombrar constantes siempre será en
mayúsculas para identificar rápidamente el tipo.
- final int HORASDIA = 24;

public class ClassConstantes{

public static void main(String[] args) {
final double PI = 3.1416;
}
//Nota: Si la constante está fuera del método main se debe incluir la
palabra static
final static double PI = 3.1416;
}

Convención de nombres en Java

Todos los identificadores ya sean variables, constantes, clases…
necesitan cumplir ciertas reglas sintácticas para poder funcionar perfectamente:
● No utilizar ninguna palabra reservada por el lenguaje de programación (vistas en la
parte de arriba).
● Key Sensitive: distingue entre mayúsculas y minúsculas.
● Empezar siempre por una letra, símbolo de dólar "$" o barra baja "_".
● Una vez empezamos la variable con letra , símbolo de dólar "$" barra baja "_",
podemos añadirle todo lo anterior además de números. Ejemplo: "a2$".
● Se desaconseja todo uso de espacios: usar espacios es una mala práctica en Java
debido a que en las clases funciona pero en las variables no. Por ello mejor no
usarlos y así nos evitaremos futuros problemas.
● Los identificadores no tienen límite de longitud: es decir, no tienen caracteres
máximos.
● Por tanto, los identificados son la manera que tenemos de poder declarar identificar
por ejemplo, una variable de forma única. Por esto, no es posible definir dos
variables (o métodos o funciones o clases) con el mismo nombre (identificador).

public class Class4ConvencionNombres {

public static void main(String[] args) {
//Sensitivo a mayúsculas y minúsculas
int celphone = 6677984;
int celPhone = 3333333;
System.out.println(celphone);
System.out.println(celPhone);
//Formas buenas alternativas de declarar nombres de variables
String $nombrePais = "España";
String _nombrePais = "México";
 }
}

Técnicas de Naming
Upper Camel Case y Lower Camel Case
Upper Camel Case se le llama así a la técnica de que la primera letra del nombre o
identificador de una variable inicie con MAYÚSCULAS. Normalmente usado en clases.
Caso contrario, Lower Camel Case es para MINÚSCULAS. Se usa en variables y nombre
de métodos.
class Class4ConvencionNombres //UpperCamelCase (Clases)
String nombrePais = "España"; //LowerCamelCase (Variables)
public static void main(String[] args) //LowerCamelCase (Métodos)

Operadores aritméticos

Asignación
Los operadores de asignación son muy útiles al momento de querer dar un valor a una
variable o reasignar un valor, como se puede apreciar en la siguiente tabla hay
abreviaciones para poder agilizar el tiempo de desarrollo pero es importante comprender lo
que cada operador realiza internamente.

public class Class3ActualizandoVariables {

public static void main(String[] args) {
int salario = 200;
//bono 200
salario += 200;
System.out.println(salario);
//50 descuento
salario -= 50;
System.out.println(salario);
 //2 horas extra 30 cu
//comida 45
salario += (30*2) - 45;
System.out.println(salario);
//Actualizando Cadenas de texto
String nombre = "Diego Zazueta ";
nombre += "Aguirre";
System.out.println(nombre);
}

Incremento y decremento
Estos son sumamente útiles para definir valores que van incrementando su valor o por lo
contrario reduciendo su valor.

Este tipo de operadores se dividen en dos tipos: con prefijo y postfijo.

Prefijo: Primero se realiza el aumento o decremento y después de acceder al valor de la

variable.
Postfijo: Primero se accede al valor de la variable y por último se realiza el aumento o
decremento.
public class Class5IncrementDecrement {
public static void main(String[] args) {
int lives = 5;
lives = lives -1;
System.out.println(lives); //4
//postfijo
lives--;
System.out.println(lives); //3
lives++;
System.out.println(lives); //4
//prefija
int gift = 100 + ++lives;
 System.out.println(gift); //105
System.out.println(lives); //5
}
}

Clases nativas útiles de Java

Math
Math es un api o conjunto de funciones o constantes nativas de Java que nos ofrece una
gran cantidad de ecuaciones matemáticas., a continuación se muestran unas cuantas
funcionalidades básicas del objeto math.

Scanner
La clase Scanner permite a los usuarios contestar algunas preguntas para que nuestro
programa actúe de una forma u otra. Para usarla solo debemos importar la clase Scanner
de las APIs de desarrollo de Java:
import java.util.Scanner;

int response = 0;

Scanner sc = new Scanner(System.in);

response = Integer.valueOf(sc.nextLine());
Casteo de variables
El casting o casteo es un procedimiento para transformar una variable primitiva de un tipo a
otro. También se utiliza para transformar un objeto de una clase a otra clase siempre y
cuando haya una relación de herencia entre ambas.

En la programación hay situaciones en las que se necesita cambiar el tipo de dato esto
dependiendo de nuestra necesidad, podemos realizar castings por:
Estimación : Se utiliza cuando no nos importa la cantidad de decimales que tiene un
número, sino que se busca representar la parte entera del número.
Exactitud : Se hace uso de esta para realizar un alcance más preciso posible del número.

Dentro del casteo se distinguen dos clases:

Casting implícito: Aquí no se necesita escribir código. Ocurre cuando se lleva a cabo una
conversión ancha, es decir, cuando se coloca un valor pequeño en un contenedor grande,
estos casos no son susceptibles a pérdida de datos.
int num1 = 100;
long num2 = num1; // un int cabe en un long
Casting explícito: Aquí si es necesario escribir código. Ocurre cuando se realiza una
conversión estrecha, es decir, cuando se coloca un valor grande en un contenedor pequeño,
son susceptibles a pérdida de datos.
double d = 86.45;
int i = (int) d; //86 convertimos un decimal a entero

Archivos JAR
Los ficheros Jar (Java Archives) permiten recopilar en un sólo fichero varios ficheros .class,
reuniendolos en un formato comprimido para que ocupen menos espacio. Es por tanto, algo
similar a un fichero .zip (de hecho están basados en ficheros .zip) para luego ser ejecutados
por la máquina virtual (JVM).
La particularidad de los ficheros .jar es que no necesitan ser descomprimidos para ser
usados, es decir que el intérprete de Java es capaz de ejecutar los archivos comprimidos en
un archivo jar directamente.

Para poder correr estos archivos .jar es necesario que la máquina virtual instalada en el
equipo sea igual o mayor a la versión usada para compilarse el .jar.

Sentencias

If / else
Los condicionales son la forma en que las computadoras toman decisiones, evaluarán si la
condición para ejecutar una parte del código se cumple. Si el resultado de la operación es
verdadero ejecutarán esta parte del código, en caso de que no, seguirán con las siguientes
instrucciones.

La forma de programar condicionales es usando la sentencia IF (hay más, pero las veremos
más adelante) de la siguiente manera:
if (condición) {
// instrucciones
}

En el siguiente ejemplo vamos a guardar algunas instrucciones dentro del condicional IF,
Java solo ejecutará esta parte del código si se cumple la condición, en este caso, que la
variable Bluetooth Enabled sea igual a true:
if (isBluetoothEnabled) {
fileSended++;
System.out.println("Archivo enviado");
}

Si la condición no es válida podemos conectar otra condición de default llamada else

if (condición) {
// instrucciones
} else {
// entra aca si no se cumple la condición principal
}

Ámbito o Scope de las variables

Las variables globales: Se definen antes de entrar a una función o proceso y que como su
nombre indica pueden ser llamadas a procesos en cualquier lugar ya que fueron
previamente declaradas. (USO PÚBLICO PODRÍA DECIRSE)
int numero = 5; // variable global se usa en todos lados
if (condición){
int numero2 = 10;
 // esta variable sólo existe en este bloque
}

Las variables locales: Son las que se definen para un proceso en específico en un función
específica y solo van a ser reconocidas para esa función o proceso, es decir que si
intentamos hacer la llamada a una variable local en otra función que no sea la de origen no
la reconocerá como declarada.(USO PRIVATIZADO).

Operadores lógicos y expresiones booleanas

Las condicionales no solo pueden evaluar variables booleanas, también pueden evaluar si
el resultado de una operación es verdadero o falso.

Por ejemplo:
boolean condicionA = true; // verdadero
boolean condicionB = false; // falso

boolean condicionC = 2 + 2 == 4; // verdadero

boolean condicionD = 2 + 2 == 5; // falso

boolean condicionE = "Pepito" == "Pepito"; // verdadero

boolean condicionF = "Pepito" == "Pepe"; // falso

Para esto debemos usar los operadores lógicos:

Operadores de equidad:

Igualdad: ==
Desigualdad: !=
Operadores Relacionales:

Menor que: <

Mayor que: >
Menor o igual que: <=
Mayor o igual que: >=
Operadores lógicos:

&&: AND (evaluar si dos o más condiciones son verdaderas).

||: OR (evaluar si al menos una de las condiciones es verdadera).
!: NOT (evaluar que la condición NO sea verdadera).
Recuerda que además de las sentencias IF y ELSE, también podemos usar ELSE IF. Esta
la usamos cuando queremos evaluar alguna condición diferente a la condición del IF pero
no exactamente al revés.

if (noHayInternet) {
System.out.println("No hay Internet");
} else if (hayInternetPeroMuyPoquito) {
System.out.println("Tienes muy poquito Internet");
} else if (hayBuenInternetPeroNoEsSuficiente) {
System.out.println("Casi casi, falta solo un poquito más");
} else {
System.out.println("¡Tienes suficiente Internet!");
}
Switch
La sentencia Switch nos ayuda a tomar decisiones con base en una o más condiciones,
pero funciona un poco diferente:

Switch hasta Java 11:

switch (profe) {
case "Anahí":
System.out.println("¡Profesora de Java!");
break;
case "Oscar":
System.out.println("¡Profesor de React.js!");
break;
case "JuanDC":
System.out.println("Oye niño, ¿qué haces aquí?");
break;
default:
System.out.println("¡Un nuevo profe!");
break;
}
Switch desde Java 12:
switch (edad) {
case 1 -> System.out.println("¡Tienes 1 año!");
 case 20 -> System.out.println("Tienes 20 años!");
default -> System.out.println("Tu edad no es 1 ni 20");
}

la sentencia SWITCH solo admite los tipos de datos:

● byte y Byte
● short y Short
● int y Integer
● char y Character
● String
● enum
No admite:
● boolean y Boolean
● long y Long
● float y Float
● double y Double

Sentencias if ternario
Los operadores ternarios son otra forma de evaluar condiciones, así como los condicionales
IF y ELSE`:
// Operador Ternario:
isTurnOnLight = (isTurnOnLight) ? false : true;

// IF y ELSE:
if (isTurnOnLight) {
isTurnOnLight = false;
} else {
isTurnOnLight = true;
}
Funciones

Las funciones nos ayudan a ejecutar código que dependiendo de las opciones que le
enviemos, transformará y devolverá un cierto resultado. Gracias a las funciones podemos
organizar, modularizar, reutilizar y evitar repeticiones en nuestro código.

Todas nuestras funciones deben tener un nombre. Opcionalmente, pueden recibir

argumentos y devolver un resultado. También debemos especificar el tipo de dato de
nuestros argumentos y el resultado final de nuestra función.

Por ejemplo:
public int suma(int a, int b) {
return a + b;
}
Si nuestra función NO devuelve ningún tipo de dato podemos usar la palabra reservada
void.

Para utilizar nuestras funciones solo debemos asignar el resultado de la función y sus
parámetros a una variable con el mismo tipo de dato de la función:
int c = suma(5, 7);

Java Docs
Los Javadocs son una herramienta usada por muchas otras herramientas y aplicaciones
porque nos ayuda a documentar todo nuestro código usando comentarios. Además, nos
permite visualizar la documentación en formato HTML.

Tipos de comentarios
// Comentarios de una sola línea

/* Comentario
* en múltiples
* líneas */

/**
* Comentario para Java Docs
* */

Vamos a documentar la función convertToDolar. Recuerda que esta función devuelve un

número double y recibe dos argumentos: quantity (de tipo double) y currency (de tipo
String):

/**
* Descripción: función que permite convertir divisas a dólares
*
* @param quantity cantidad de dinero
* @param currency tipo de moneda
*/
public static double converToDolar(double quantity, String currency)
{
switch (currency) {
case "MXN":
quantity *= 0.052;
break;
case "COP":
quantity *= 0.0031;
break;
default:
break;
}
return quantity;
}
Bucles
Los bucles (ciclos) nos ayudan a ejecutar una parte de nuestro código una cantidad de
veces hasta que se cumpla alguna condición y podamos continuar con la ejecución de
nuestro código.

Los ciclos evaluarán si la condición se cumple y cuando deje de hacerlo no ejecutarán más
el código del ciclo. Las instrucciones son las encargadas de que esta condición cambie de
verdadero a falso. De otra forma, si las instrucciones nunca cambian la condición, el ciclo no
se detendrá nunca, lo que conocemos como un ciclo infinito.
While / do while
do {
// instrucciones
} while (condición);

El ciclo do while ejecuta primero la operación para posteriormente realizar la validación.

El ciclo while ejecuta primero la evaluación para posteriormente ejecutar la operación.

while (condición){
// instrucciones
}

For
El Ciclo For también nos ayuda a ejecutar una parte de nuestro código las veces que sean
necesarias para que se cumpla una condición. De hecho, el ciclo FOR nos da muchas
ayudas para lograr este resultado de la forma más fácil posible:
// Estructura:
for (inicialización; condición; incremento o decremento;) {
// Instrucciones
}

// En este ejemplo el mensaje de printSOS se

// ejecutará 10 veces:
for (int i = 1; i <= 10; i++) {
printSOS();
}
Bucle For: una estructura repetitiva para ejecutar un mismo segmento de código una
cantidad de veces deseada; debes de saber su valor de inicialización, su condición y su
incremento.
Ciclo Foreach: nos ayuda a recorrer los elementos de un arreglo, pero no tenemos control
sobre el índice.

Controladores de flujo
Break
En Java esta sentencia la verás en dos situaciones específicamente:

1. En un Switch: en esta situación break hace que el flujo del switch no continúe
ejecutándose a la siguiente comparación, esto con el objetivo de que solo se cumpla
una sola condición:
switch (colorModeSelected){
case "Light":
System.out.println("Seleccionaste Light Mode");
break;
case "Night": //Ambar
System.out.println("Seleccionaste Night Mode");
break;
case "Blue Dark":
System.out.println("Seleccionaste Blue Dark Mode");
break;
 }
2. Para salir de un bucle: Como acabamos de ver un break es capaz de detener el flujo
en el código, en este caso detendremos el ciclo como tal terminándolo y haciendo
que saltemos a la siguiente instrucción después del ciclo.
3. for (int i = 1; i <= 10; i++) {
4. printSOS();
5. break;
6. }

Continue
Continue en cierto modo también nos va a servir para detener un ciclo pero en lugar de
terminarlo como en el caso de break, este volverá directo a la condición.

Return
Aunque en algunos lenguajes esta sentencia sirve como un tipo goto, dónde se rompe el
flujo del programa la mejor forma de usarlo en Java es en Funciones, cuando lo usamos
aquí siempre viene acompañado de un valor, el cuál indica el dato que se estará
devolviendo en la función.

Arrays / Arraylist
Array => Tamaño definido
ArrayList => Tamaño dinámico

Los arreglos o arrays son objetos en los que podemos guardar más de una variable, una
lista de elementos. Los arrays son de una sola dimensión, pero si guardamos arrays dentro
de otros arrays podemos obtener arrays multidimensionales.

Los arrays se definen en código de las siguientes maneras:

// 1. Definir el nombre de la variable y el tipo de datos
// que va a contener, cualquiera de las siguientes dos
// opciones es válida:
TipoDato[] nombreVariable;
TipoDato nombreVariable[];

// 2. Definir el tamaño del array, la cantidad de elementos

// que podemos guardar en el array:
TipoDato[] nombreVariable = new TipoDato[capacidad];

// Array de dos dimensiones:

TipoDato[][] cities = new String[númeroFilas][númeroColumnas];

Ya que los arrays pueden guardar múltiples elementos, la convención es escribir los
nombres de las variables en plural.

El arraylist es un tipo de array que no se necesita especificar su longitud pues esta es

dinámica y se irá expandiendo o reduciendo la necesidad de la app.
Hay que tener en cuenta el rendimiento, los array son asignados a una zona de memoria de
acceso más rápido ya que el tamaño es fijo, mientras que el arraylist es enviado a una zona
de acceso más lento por su naturaleza dinámica. Esa es la razón de ser de uno y otro, de
no ser así, no tendría sentido mantener los dos. Si bien suele usar siempre los arraylist, no
está de más tener en cuenta esta diferencia para los array. En un programa de escritorio no
es problema la diferencia de rendimiento pero en un programa de servidor donde tenga que
manejar millones de transacciones, se nota mucho.

ejemplo de un ArrayList:
public class ArraysTest {
public static void main(String[] args) {
List<String> Days = new ArrayList<>();
Days.add("Monday");
Days.add("Tuesday");

Days.forEach((n) -> System.out.println(n));

}
}

Índices
Los índices son variables simples que nos ayudan a identificar las posiciones en un arreglo.
Estas variables siempre guardan números, comienzan en 0 e incrementan de abajo a arriba
y de izquierda a derecha a medida que guardamos más elementos en nuestros arrays.

Para guardar un valor en alguna posición de nuestro array solo debemos usar el índice de la
siguiente forma:
nombreVariable[indice] = valor;

Para identificar la posición de un arreglo o índice es necesario hacer el cálculo de n-1 ya

que los índices de los arreglos inician en 0.

Multidimensionales
Una propiedad de los arrays o colecciones es que se pueden anidar dependiendo de la
necesidad
//Array multidimensional
String[][] cities = new String[4][2]; // 4*2 = 8
/*
* pais | ciudad
* Mexico | CDMX
* Mexico | GDL
* Col | Bogota
* Col | Medellin
*/

cities[0][0] = 'Colombia';
cities[0][1] = 'Medellin';
 cities[1][0] = 'Colombia';
cities[1][1] = 'Bogota';
cities[2][0] = 'Mexico';
cities[2][1] = 'GDL';
cities[3][0] = 'Mexico';
cities[3][1] = 'CDMX';

String[][][][] animals = new String[2][3][2][2];

animals[1][0][0][1] = "Monkey";
System.out.println(animals[1][0][0][1]);

Java SE con POO

Notas recomendadas
Curso POO

Como vimos en el los temas anteriores java es un lenguaje muy potente y versátil pero aún
no hemos entrado en lo que realmente java sale a relucir y es en el trabajo con la
programación orientada a objetos.

En esta ocasión nos abstendremos de entrar demasiado a los conceptos básicos de POO
por que ya existe un documento en donde explica a detalle las columnas que componen la
programación orientada a objetos.

Sintaxis de Java
Variables y tipos de datos

Tipos objetos
Estos tipos de datos comúnmente llamados wrappers son utilizados en java porque ya traen
una lista de métodos definidos que nos agilizan el trabajo en un problema concreto y
necesitan una invocación para poder declararlos.
Ejemplo de declaración de algunos wrappers:
String palabra= "Hola";
Integer num = 1234;
num.toString(); //Método del tipo de dato Integer