Primeros pasos en Java

Hola Skilly

Vamos a ver todas las partes de un programa .java.

El siguiente código imprime la frase "Hola Skilly" en la consola.

public class HolaMundo {
    public static void main(String[] args) {
        // Esto es un comentario. El programa comienza ejecutando el método 'main'.
        
        // La siguiente línea imprime "Hola Skilly" en la consola.
        System.out.println("Hola Skilly");
    }
}

public class HolaMundo: Esta línea define una clase llamada "HolaMundo". En Java, cada programa comienza con al menos una clase. El nombre de la clase debe coincidir con el nombre del archivo Java que contiene el código fuente.
{: Esto marca el comienzo del cuerpo de la clase.
public static void main(String[] args) {: Aquí definimos un método llamado "main". El método "main" es el punto de entrada de un programa Java. Debe tener exactamente esta firma y estructura para que Java lo reconozca como punto de entrada. Los detalles de los argumentos (String[] args) se explicarán más adelante en programas más complejos. De momento basta con saber que "siempre se escribe lo mismo".
// Esto es un comentario.: Los comentarios comienzan con // y se ignoran durante la ejecución. Te ayudan a poner apuntes en tu código.
System.out.println("Hola Skilly");: Esta línea imprime el mensaje "Hola Skilly" en la consola. System.out se refiere a la consola y println es un método que imprime una línea de texto en la consola. "Hola Skilly" es el mensaje que se imprimirá.
}: Esto marca el final del cuerpo del método "main"
}: Esto marca el final del cuerpo de la clase.

⚠️ ADVERTENCIA Todas las líneas de Java tienen que terminar en ; para indicar que acaba la instrucción

En definitiva, ésta sería la estructura básica de cualquier archivo java:

public class NombreArchivo {
    public static void main(String[] args) {
        // Aquí va el código de tu programa, es decir, qué quiero que haga.
        // Podremos poner tantas acciones o líneas de código como queramos.     
        
    }
}

Tipos de datos

En Java, los tipos de datos se utilizan para definir el tipo de valor que una variable puede contener. Los tipos de datos se dividen en dos categorías principales: tipos de datos primitivos y tipos de datos de objeto.

Tipo de Dato	Descripción	Ejemplo
`int`	Número entero	`int edad = 30;`
`double`	Número de punto flotante	`double salario = 1500.50;`
`boolean`	Valor verdadero o falso	`boolean esMayor = true;`
`char`	Carácter individual	`char letra = 'A';`
`String`	Cadena de caracteres	`String nombre = "Juan";`
`long`	Número entero largo	`long poblacion = 7000000000L;`
`float`	Número de punto flotante (precisión reducida)	`float altura = 1.75f;`
`byte`	Entero de 8 bits	`byte codigo = 65;`
`short`	Entero corto de 16 bits	`short cantidad = 1000;`
`BigDecimal`	Número decimal de alta precisión	`BigDecimal precio = new BigDecimal("19.99");`
`BigInteger`	Entero de alta precisión	`BigInteger cantidad = new BigInteger("1000000000000");`
`Date`	Fecha y hora	`Date fecha = new Date();`

⚠️ IMPORTANTE Prestar atención a cómo se escribe el valor. Ya que hay tipos de datos que se escriben tal cual (como los números) y tipos de datos que han de escribirse entre comillas (como el texto).

Variables

Las variables se utilizan para almacenar valores en la memoria durante la ejecución de un programa. Deben declararse con un tipo de dato y un nombre, siempre siguiendo la sintaxis tipo variable = valor:

int edad = 25;
double salario = 1500.50;
String nombre = "Ana";

Se podría decir que las variables con "cajas" que guardan información, para luego poder usarlas. En el código de arriba estaríamos creando:

Una variable de tipo entero llamada edad que guarda el valor 25.
Una variable de tipo decimal llamada salario que guarda el valor 1500.50.
Una variable de tipo texto llamada nombre que guarda el valor "Ana".

Scope de las variables

El alcance de una variable se refiere a la parte del programa en la que la variable es visible y puede utilizarse. En Java, las variables pueden tener alcance local o alcance de clase.

variables de clase: se escriben antes del public static void main.
variables locales: se escriben dentro del public static void main.

public class EjemploScope {
    // Variable de clase
    static int variableClase = 10;
    
    public static void main(String[] args) {
        // Variable local
        int variableLocal = 5;
        
        System.out.println(variableClase); // Acceso a la variable de clase
        System.out.println(variableLocal); // Acceso a la variable local
        
        // ...
    }
}

Operadores

Los operadores son símbolos que nos permiten realizar operaciones con datos y variables.

Por ejemplo:

int edad = 25; // Declara la variable edad
int nuevaEdad = edad + 1; // Declara la variables nuevaEdad como la edad + 1

En este caso, + es un operador que permite sumar dos valores.

Java dispone de diferentes tipos de operadores:

Operadores aritméticos
Operadores de asignación
Operadores de comparación
Operadores lógicos
Operadores de incremento y decremento
Operador ternario
Operadores de bits

1. Operadores aritméticos

Los operadores aritméticos se utilizan para realizar operaciones matemáticas.

Operador	Operación	Ejemplo
`+`	Suma	`5 + 3`
`-`	Resta	`5 - 3`
`*`	Multiplicación	`5 * 3`
`/`	División	`10 / 2`
`%`	Módulo (resto)	`10 % 3`

Suma

int a = 10;
int b = 5;

int resultado = a + b;

System.out.println(resultado);

Resultado:

Resta

int resultado = 10 - 3;

System.out.println(resultado);

Resultado:

Multiplicación

int resultado = 4 * 5;

System.out.println(resultado);

Resultado:

División

int resultado = 10 / 2;

System.out.println(resultado);

Resultado:

Importante: cuando trabajamos con int, la división también devuelve un int.

Por ejemplo:

int resultado = 7 / 2;

System.out.println(resultado);

El resultado será:

No será 3.5, porque los dos operandos son enteros.

Si queremos obtener decimales podemos utilizar double:

double resultado = 7.0 / 2;

System.out.println(resultado);

Resultado:

3.5

2. El operador módulo `%`

El operador % devuelve el resto de una división.

Por ejemplo:

int resultado = 10 % 3;

System.out.println(resultado);

El resultado es:

Porque:

10 / 3 = 3

y sobra:

¿Para qué sirve %?

Una de sus aplicaciones más habituales es comprobar si un número es par.

Un número es par si al dividirlo entre 2 el resto es 0.

numero % 2 == 0 // significa que el número es par

3. Operador `+` con Strings

El operador + también se puede utilizar para concatenar textos.

String nombre = "Maria";

System.out.println("Hola " + nombre);

Resultado:

Hola Maria

También podemos combinar texto y números:

int edad = 25;

System.out.println("Tengo " + edad + " años");

Resultado:

Tengo 25 años

Atención con el orden

Java evalúa las operaciones de izquierda a derecha.

Por ejemplo:

System.out.println("Resultado: " + 5 + 3);

El resultado será:

Resultado: 53

¿Por qué?

Primero se hace:

"Resultado: " + 5

y obtenemos:

"Resultado: 5"

Después:

"Resultado: 5" + 3

Por tanto:

"Resultado: 53"

Si queremos sumar primero los números debemos utilizar paréntesis:

System.out.println("Resultado: " + (5 + 3));

Resultado:

Resultado: 8

4. Operadores de asignación

El operador de asignación básico es:

Sirve para asignar un valor a una variable.

int edad = 25;

Aquí estamos guardando 25 dentro de la variable edad.

Java también proporciona operadores que combinan una operación aritmética con una asignación.

Operador	Equivale a
`=`	`a = valor`
`+=`	`a = a + valor`
`-=`	`a = a - valor`
`*=`	`a = a * valor`
`/=`	`a = a / valor`
`%=`	`a = a % valor`

Por ejemplo:

int numero = 10;

numero += 5;

Es equivalente a:

numero = numero + 5;

Ahora numero vale:

Otro ejemplo:

int numero = 10;

numero -= 3;

Es equivalente a:

numero = numero - 3;

Resultado:

También podemos utilizar:

numero *= 2;

que equivale a:

numero = numero * 2;

5. Operadores de comparación

Los operadores de comparación permiten comparar dos valores.

El resultado de una comparación siempre es un boolean:

true

false

Los principales operadores son:

Operador	Significado
`==`	Igual a
`!=`	Distinto de
`>`	Mayor que
`<`	Menor que
`>=`	Mayor o igual que
`<=`	Menor o igual que

Igual `==`

int edad = 18;

System.out.println(edad == 18);

Resultado:

true

Distinto `!=`

int edad = 18;

System.out.println(edad != 20);

Resultado:

true

Mayor `>`

int edad = 25;

System.out.println(edad > 18);

Resultado:

true

Menor `<`

int edad = 15;

System.out.println(edad < 18);

Resultado:

true

6. Diferencia entre `=` y `==`

Esta es una de las cosas más importantes que debemos recordar.

= sirve para asignar un valor.

int edad = 20;

Estamos diciendo:

Guarda el valor 20 en edad.

== sirve para comparar.

edad == 20

Estamos preguntando:

¿El valor de edad es igual a 20?

Por ejemplo:

int edad = 20;

System.out.println(edad == 20);

7. Operadores lógicos

Los operadores lógicos permiten combinar varias condiciones.

Los principales son:

Operador	Nombre	Significado
`&&`	AND	Y
`		`	OR	O
`!`	NOT	Negación

7.1. Operador AND `&&`

La expresión:

condicion1 && condicion2

es verdadera únicamente cuando las dos condiciones son verdaderas.

Por ejemplo:

int edad = 25;

System.out.println(edad >= 18 && edad <= 30);

Tenemos dos condiciones:

edad >= 18

edad <= 30

Las dos deben cumplirse.

Tabla de verdad

Condición A	Condición B	`A && B`
`true`	`true`	`true`
`true`	`false`	`false`
`false`	`true`	`false`
`false`	`false`	`false`

7.2. Operador OR `||`

El operador || significa O.

La expresión será verdadera cuando al menos una de las condiciones sea verdadera.

int edad = 15;

System.out.println(edad < 18 || edad > 65);

Tabla de verdad

| Condición A | Condición B | A || B | |---|---|---| | true | true | true | | true | false | true | | false | true | true | | false | false | false |

7.3. Operador NOT `!`

El operador ! sirve para negar una condición.

Si tenemos:

boolean activo = true;

Podemos hacer:

System.out.println(!activo);

Resultado:

false

Porque:

!true → false

!false → true

8. Operadores de incremento y decremento

Java permite aumentar o disminuir una variable en una unidad utilizando:

++

--

Incremento `++`

int numero = 5;

numero++;

System.out.println(numero);

Resultado:

Es equivalente a:

numero = numero + 1;

Decremento `--`

int numero = 5;

numero--;

System.out.println(numero);

Resultado:

Es equivalente a:

numero = numero - 1;

9. Operador ternario

El operador ternario permite escribir una condición de forma compacta.

Su estructura es:

condicion ? valorSiVerdadero : valorSiFalso

Por ejemplo:

int edad = 20;

String resultado = edad >= 18 ? "Mayor de edad" : "Menor de edad";

System.out.println(resultado);

Resultado:

Mayor de edad

El operador ternario es especialmente útil cuando tenemos una condición sencilla.

10. Precedencia de operadores

Cuando tenemos varias operaciones en una misma expresión, Java debe decidir en qué orden realizarlas.

Por ejemplo:

int resultado = 2 + 3 * 4;

El resultado es:

No es 20.

Primero se realiza la multiplicación:

3 * 4 = 12

y después:

2 + 12 = 14

Una forma sencilla de recordar el orden general es:

Paréntesis
Incrementos y decrementos
Multiplicaciones, divisiones y módulo
Sumas y restas
Comparaciones
Operadores lógicos
Asignaciones

Cuando tengamos dudas, podemos utilizar paréntesis.

Por ejemplo:

int resultado = (2 + 3) * 4;

Ahora el resultado es:

11. Operadores con variables

Los operadores se utilizan constantemente con variables.

Por ejemplo:

int precio = 20;
int cantidad = 3;

int total = precio * cantidad;

System.out.println(total);

Resultado:

Podemos combinar varias operaciones:

double precio = 100;
double descuento = 20;

double precioFinal = precio - (precio * descuento / 100);

System.out.println(precioFinal);

Resultado:

80.0

Resumen de operadores

Operadores aritméticos

+    suma
-    resta
*    multiplicación
/    división
%    resto

Operadores de asignación

=    asignación
+=   suma y asignación
-=   resta y asignación
*=   multiplicación y asignación
/=   división y asignación
%=   módulo y asignación

Operadores de comparación

==   igual
!=   diferente
>    mayor
<    menor
>=   mayor o igual
<=   menor o igual

Operadores lógicos

&&   AND
||   OR
!    NOT

Incremento y decremento

++   incrementar en 1
--   disminuir en 1

Operador ternario

?:

Hola Skilly​

Tipos de datos​

Variables​

Scope de las variables​

Operadores​

1. Operadores aritméticos​

Suma​

Resta​

Multiplicación​

División​

2. El operador módulo %​

3. Operador + con Strings​

4. Operadores de asignación​

5. Operadores de comparación​

Igual ==​

Distinto !=​

Mayor >​

Menor <​

6. Diferencia entre = y ==​

7. Operadores lógicos​

7.1. Operador AND &&​

7.2. Operador OR ||​

7.3. Operador NOT !​

8. Operadores de incremento y decremento​

Incremento ++​

Decremento --​

9. Operador ternario​

10. Precedencia de operadores​

11. Operadores con variables​

Resumen de operadores​

Hola Skilly

Tipos de datos

Variables

Scope de las variables

Operadores

1. Operadores aritméticos

Suma

Resta

Multiplicación

División

2. El operador módulo `%`

3. Operador `+` con Strings

4. Operadores de asignación

5. Operadores de comparación

Igual `==`

Distinto `!=`

Mayor `>`

Menor `<`

6. Diferencia entre `=` y `==`

7. Operadores lógicos

7.1. Operador AND `&&`

7.2. Operador OR `||`

7.3. Operador NOT `!`

8. Operadores de incremento y decremento

Incremento `++`

Decremento `--`

9. Operador ternario

10. Precedencia de operadores

11. Operadores con variables

Resumen de operadores