APRENDE JAVA CON EJERCICIOS

Ejemplos y soluciones a los ejercicios del libro **"Aprende Java con Ejercicios"**.
<a href="https://leanpub.com/aprendejava">![Aprende Java con Ejercicios](title_page.png)</a>

Puedes descargar el libro mediante el siguiente enlace: http://leanpub.com/aprendejava

Apuntes - [Java]

Proyecto archivado. Nueva localización en apuntes-general.

---

Java es un lenguaje orientado a objetos. En la década de los 60 nació la programación estructurada impulsada por lenguajes como Pascal o C. Con el aumento de la complejidad de los programas se adoptó un nuevo enfoque como es la programación orientada a objetos o POO.

Desde un punto de vista general, un programa se puede organizar de dos formas: sobre su código (lo que sucede) y sobre sus datos (lo que se ve afectado). En la programación estructurada se organiza sobre el código pero en la programación orientada a objetos el programa se estructura alrededor de los datos, definiendo estos datos y las rutinas que permiten actuar sobre los mismos.

Para complementar los principios de la programación orientada a objetos, se aplican los conceptos de encapsulación, herencia y polimorfismo.

• La encapsulación es un mecanismo que combina el código con los datos que manipula, al tiempo que los protege de interferencias externas. La unidad básica de encapsulación es la clase. La clase define la forma de un objeto y especifica los datos y el código que actúa sobre ellos. Los objetos son instancias de una clase.

• El polimorfismo es la propiedad que permite a una interfaz acceder a una clase general de acciones. Este concepto suele expresarse como "una interfaz, múltiples métodos". El compilador en tiempo de ejecución será el encargado de seleccionar el método correcto a invocar.

• La herencia es el proceso mediante el cual un objeto puede adquirir las propiedades de otro. Gracias a la herencia un objeto solo tiene que definir los atributos que lo hacen único dentro de la clase y heredar los atributos generales.

Sintaxis básica

  * Compilar código Java: `$ javac filename.java`
  * Ejecutar código: `$ java filename`
  * Start a graphical console to monitor and manage Java applications: `jconsole`

  [Tools and Commands Reference](https://docs.oracle.com/en/java/javase/11/tools/tools-and-command-reference.html)

---

// Comentarios de una sóla línea

/*
Comentarios multilínea
*/

/**
* Comentarios JavaDoc lucen así. Suelen describir la clase o varios atributos de una clase.
*/

 // Todos los programas importan automáticamente el paquete 'java.lang' que define la clase 'System'
// Importa la clase 'ArrayList' dentro del paquete 'java.util'
import java.util.ArrayList;
// Importa todas las clases dentro del paquete 'java.security'
import java.security.*;

// Para Java un archivo es una unidad de compilación. Pueden contener una o varias clases.
// Por convención, el nombre de la clase principal (declarada como public) debe coincidir con el nombre del archivo que contiene el programa.
public class Sample {

    // Un programa debe tener un método 'main' como punto de entrada
    public static void main (String[] args) {
        // Usa 'System.out.println' para imprimir líneas
        System.out.println("¡Hola mundo!");
        System.out.println(
            " Integer (int): " + 10 +
            " Double (double): " + 3.14 +
            " Boolean (boolean): " + true);

        // Para imprimir sin el salto de línea, usa 'System.out.print'
        System.out.print("Hola ");
        System.out.print("Mundo");
    }
}

Tipos & Variables

Java es "case sensitive" lo que significa que Java distingue entre mayúsculas y minúsculas.

En Java se declara una variable usando <tipo> <nombre>. Es necesario declarar la variable antes de poder hacer referencia a ella. A partir de que se declaran se pueden utilizar, y no antes. Por lo general, debe asignar un valor a una variable antes de poder usarla aunque en determinados casos Java puede inicializar el valor de las variables, como por ejemplo en variables de instancia.

// [Tipos primitivos]
// ------------------
// [Byte] - Entero complemento a dos con signo de 8-bit (-128 <= byte <= 127)
byte fooByte = 100;

// [Short] - Entero complemento a dos con signo de 16-bit (-32,768 <= short <= 32,767)
short fooShort = 10000;

// [Integer] - Entero complemento a dos con signo de 32-bit (-2,147,483,648 <= int <= 2,147,483,647)
int fooInt = 1;

// [Long] - Entero complemento a dos con signo de 64-bit (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
long fooLong = 100000L;
// 'L' es usado para denotar que el valor de esta variable es del tipo Long; cualquier cosa sin ella es tratado como un entero por defecto.

// Nota: Java no tiene tipos sin signo

// [Float] - Número de coma flotante IEEE 754 de precisión simple de 32-bit
float fooFloat = 234.5f;
// 'f 'es usado para denotar que el valor de esta variable es del tipo float; de otra manera es tratado como un double.

// [Double] - Número de coma flotante IEEE 754 de precisión doble de 64-bit
double fooDouble = 123.4;

// [Boolean] - true & false
boolean fooBoolean = true;
boolean barBoolean = false;

// [Char] - Un simple carácter unicode de 16-bit.
/* Como char es un tipo sin signo de 16 bits, se pueden realizar operaciones aritméticas. Las constantes de carácter se incluyen entre comillas simples. */
char fooChar = 'A';
fooChar++; // now fooChar == 'B'

En Java, un literal es un valor fijo representado en formato legible para los humanos. Por ejemplo, el número 100 es un literal. Los literales también suelen denominarse constantes. De forma predeterminada, los literales enteros son de tipo int y los literales de coma flotante son de tipo double. Los literales de carácter se incluyen entre comillas simples. Java también admite los literales de cadena. Una cadena es un conjunto de caracteres includos entre comillas dobles.

int a = 100;
long b = 100L;
double c = 100.5;
float d = 100.5f;
String str = "Literal de cadena";

int hexadecimal = 0xFF; // Formato hexadecimal que corresponde a 255 en decimal
int octal = 011; // Formato octal que corresponde a 9 en decimal

Secuencias de escape de caracteres:

• \ - Comilla simple
• \" - Comilla doble
• \\ - Barra invertida
• \r - Retorno de carro
• \n - Nueva línea
• \f - Salto de formulario
• \t - Tabulación horizontal
• \b - Retroceso
• \ddd - Constante octal (donde 'ddd' es una constante octal)
• \uxxxx - Constante hexadecimal (donde 'xxxx' es una constante hexadecimal)

Desde JDK 7 se pueden emplear guiones bajos para mejorar la legibilidad de literales enteros o flotantes:

int x = 123_456_789;
int z = 123_456_789.5;

Se usa la palabra clave final para hacer inmutable las variables. Por convención el nombre de la variable se declara en mayúsculas:

final int HORAS_QUE_TRABAJO_POR_SEMANA = 9001;

Notación abreviada para declarar (e inicializar) múltiples variables:

int x, y, z;
int i1 = 1, i2 = 2;
int a = b = c = 100; // el símbolo '=' retorna el valor de su derecha y por tanto lo podemos usar para de esta forma.

En Java, un identificador es un nombre asignado a un método, variable u otro elemento definido por el usuario. Pueden tener uno o varios caracteres de longitud.

Los nombres de variable pueden empezar por cualquier letra, guión bajo o $. El siguiente carácter puede ser cualquier letra, dígito, guión bajo o $. Por lo tanto no pueden empezar con un dígito ni emplear palabras clave de Java.

Un bloque de código es un grupo de dos o más instrucciones definidas entre llaves ({}). Tras crear un bloque de código se convierte en una unidad lógica que se puede usar como si fuera una instrucción independiente.

Un bloque de código define un ámbito. Las variables definidas en un ámbito o bloque de código no son accesibles fuera de ese ámbito. Cada vez que se accede a un bloque las variables contenidas en ese bloque se inicializan y cuando el bloque finaliza se destruyen. Una variable está disponible a partir de su definición. Por lo tanto si se define una variable al final de un bloque no se podrá utilizar (y tampoco tiene sentido).

Los bloques se pueden anidar, de forma que un bloque de código es contenido por otro bloque de código. Desde el bloque interior se pueden acceder a las variables definidas en el bloque exterior pero el exterior no puede acceder a las variables definidas en el bloque interior.

Operadores

// La aritmética es directa
System.out.println("1 + 2 = " + (1 + 2)); // => 3
System.out.println("2 - 1 = " + (2 - 1)); // => 1
System.out.println("2 * 1 = " + (2 * 1)); // => 2
System.out.println("1 / 2 = " + (1 / 2)); // => 0 (0.5 truncado)

// Módulo
System.out.println("11%3 = " + (11 % 3)); // => 2

// Operadores de comparación
System.out.println("3 == 2 " + (3 == 2)); // => false
System.out.println("3 != 2 " + (3 != 2)); // => true
System.out.println("3 > 2 " + (3 > 2)); // => true
System.out.println("3 < 2 " + (3 < 2)); // => false
System.out.println("2 <= 2 " + (2 <= 2)); // => true
System.out.println("2 >= 2 " + (2 >= 2)); // => true

// Asignaciones abreviadas
int x += 10; // x = x + 10;
int x -= 10; // x = x - 10;
int x *= 10; // x = x * 10;
int x /= 10; // x = x / 10;
int x %= 10; // x = x % 10;
boolean bool &= true; // bool = bool & true;
boolean bool |= true; // bool = bool | true;
boolean bool ^= true; // bool = bool ^ true;

// Incrementos y decrementos
int y, x = 10;
y = x++; // y = 10. Primero se asigna el valor y luego se aumenta
y = ++x; // y = 11. Primero se aumenta y luego se asigna
y = x--; // y = 10. Primero se asigna el valor y luego se resta
y = --x; // y = 9. Primero se resta y luego se asigna

Operadores lógicos

| A | B | A|B | A&B | A^B | !A | | :-------: | :-------: | :------: | :-------: | :-------: | :-------: | | False | False | False | False | False | True | | True | False | True | False | True | False | | False | True | True | False | True | True | | True | True | True | True | False | False |

Los operadores lógicos AND y OR pueden funcionar en modo cortocircuito (&&) y (||). En este modo se evalúa el primer operando y si fuera necesario, se evaluaría el segundo.

Cadenas

String fooString = "¡Mi String está aquí!";

// \n es un carácter escapado que inicia una nueva línea
String barString = "¿Imprimiendo en una nueva linea?\n¡Ningun problema!";

// \t es un carácter escapado que añade un carácter tab
String bazString = "¿Quieres añadir un 'tab'?\t¡Ningun problema!";

Conversión de tipos numéricos primitivos en cadenas y viceversa:

Integer.parseInt("123"); // retorna una versión entera de "123"
String.valueOf(123); // retorna una version string de 123

Control de flujo

/*
if (expr booleana) {
    bloque de intrucciones;
} else if (expr booleana) {
    bloque instrucciones;
} else {
    intrucciones en caso de que ninguna condición anterior se cumpla;
} */


/*
while(expr booleana) {
    bloque de instrucciones;
    contador++;  // actualizar la variable usada para evaluar la condición
} */

/*
do {
    bloque de intrucciones
    contador++; // actualizar la variable usada para evaluar la condición
}while(expr booleana);
*/

/*
for(<declaración_de_inicio>; <condicional>; <paso>) {
    bloque de instrucciones;
} */

En Java, el cuerpo asociado a un bucle for o de otro tipo puede estar vacío ya que una instrucción vacía es sintácticamente válida. Puede ser útil en algunos casos:

int sum = 0;
for(int i = 1; i<= 5; sum += i++); // Se usa el bucle for para incrementar la variable sum

En JDK 5 se añadió los bucles for-each que permiten iterar por matrices, clases del p