Sintaxis Java#

Logo Java

Sintáxis básica de Java

Elementos básicos del lenguaje#

Instalación#

  • Instalación: Instalar el JDK de Java desde su página oficial.

  • Extensión de archivos: .java

Comentarios#

  • Comentarios de una sola línea:

1// comentario de una sola linea

  • Comentarios multilínea:

1/* Comentario
2multilinea
3en Java */

Entrada, salida estandar y concatenación#

Datos de entrada y salida a través de la consola y/o el navegador.

 1package com.mycompany.holamundo;
 2// para la entrada estandar hay que cargar la librería scanner:
 3import java.util.Scanner;
 4
 5
 6public class HolaMundo {
 7
 8    public static void main(String args[]){
 9
10        // Salida estandar
11        System.out.println("Entrada estandar");
12
13        System.out.println("Introduce tu nombre: ");
14        // entrada estandar:
15        Scanner scanner = new Scanner(System.in);
16        // guardamos el valor en una nueva variable (var es la versión mas moderna):
17        var nombre = scanner.nextLine();
18        // hay que usar la variable en java siempre:
19        System.out.println("Te llamas " + nombre);
20
21    }
22}

Estructura en Java#

  • Código java del archivo principal:

1package com.mycompany.holamundo;
2
3
4public class HolaMundo {
5
6    public static void main(String args[]){
7        System.out.println("Hola amigo desde java");
8    }
9}

Variables y tipos de datos#

  • Declaración, asignación y tipo:

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6
 7        // tipos primitivos:
 8        byte byteVar = 15; // valor máximo 127 (byte.MAX_VALUE . byte.MIN_VALUE)
 9        short shortVar = 100; // valor máximo 32767 (short.MAX_VALUE . short.MIN_VALUE)
10        int intVar = 25054; // valor máximo  2147483647 (Integer.MAX_VALUE . (Integer.MIN_VALUE)
11        long longVar = 1839744L; // usa L final, valor máximo 9223372036854775808 (long.MAX_VALUE . long.MIN_VALUE)
12
13        // tipos binario, octal y hexadecimal:
14        int numeroDecimal = 10;
15        int numeroOctal = 012; // añadir un 0 para que reconozca valor octal
16        int numeroHexadecimal = 0xA; // añadir 0x para reconocer un hexadecimal
17        int numeroBinario = 0b1010; // se añade 0b al inicio para reconocer binario
18
19        // tipos flotantes:
20        float floatVar = 10.73F; // tipo coma flotante (requiere F si no es double)
21        double doubleVar = 12.373; // tipo double
22
23        // tipos caracteres:
24        char charVar  = 'a'; // comillas simples un caracter
25        String stringVar = "Hola"; // comillas dobles para cadenas
26
27        // tipo booleano:
28        boolean boolVar = true; // o false
29
30        // tipo abierto (int, long, string):
31        var edad = 85; // si ponemos una L al final se convierte en long
32    }
33}

  • Constantes:

1static final DIAS_SEMANA = 7;

Operadores#

Operadores aritméticos#

  • Operaciones aritméticas:

1var suma = 10 + 20;
2var resta = 10 - 10;
3var multiplicar = 10 * 2;
4var division = 6 / 2;
5var resto = 10 % 3;

  • Incremento y decremento:

1// Incremento
2var dato = 10;
3dato++
4// decremento:
5dato--

  • Asignar operación:

1suma += 10 ;
2resta -= 10;
3multiplicar *= 10;
4division /= 6;
5resto %= 10;

Operadores relacionales#

Validación entre dos números.

  • Mayor que: >.

  • Menor que: <.

  • Mayor o igual que: >=.

  • Menor o igual que: <=.

  • Igual que: ==.

Operadores lógicos#

Expresiones de operaciones lógicas.

  • and: &&.

  • or: ||.

  • not: !.

Estructuras de control#

Condicional if#

  • if sencillo:

 1package com.mycompany.holamundo;
 2
 3import java.util.Scanner;
 4
 5public class HolaMundo {
 6
 7    public static void main(String args[]){
 8        // se prepara la entrada:
 9        Scanner scanner = new Scanner(System.in);
10
11        // Se imprime un mensaje:
12        System.out.println("Introduce tu edad: ");
13        System.out.print(">>> ");
14
15        // recibimos la edad:
16        int edad = scanner.nextInt();
17
18        if(edad >= 18){
19            System.out.println("Eres un anciano");
20        }
21
22    }
23}

  • if / else:

 1package com.mycompany.holamundo;
 2
 3import java.util.Scanner;
 4
 5public class HolaMundo {
 6
 7    public static void main(String args[]){
 8        // se prepara la entrada:
 9        Scanner scanner = new Scanner(System.in);
10
11        // Se imprime un mensaje:
12        System.out.println("Introduce tu edad: ");
13        System.out.print(">>> ");
14
15        // recibimos la edad:
16        int edad = scanner.nextInt();
17
18        if(edad >= 18){
19            System.out.println("Eres un anciano");
20        }else{
21            System.out.println("Eres menor de edad");
22        }
23
24    }
25}

  • else-if:

 1package com.mycompany.holamundo;
 2
 3import java.util.Scanner;
 4
 5public class HolaMundo {
 6
 7    public static void main(String args[]){
 8        // se prepara la entrada:
 9        Scanner scanner = new Scanner(System.in);
10
11        // Se imprime un mensaje:
12        System.out.println("Introduce tu edad: ");
13        System.out.print(">>> ");
14
15        // recibimos la edad:
16        int edad = scanner.nextInt();
17
18        if(edad >= 65){
19            System.out.println("Eres un anciano");
20        }else if(edad >= 18){
21            System.out.println("Eres mayor de edad");
22        }else{
23            System.out.println("Eres menor de edad");
24        }
25
26    }
27}

  • Operador ternario:

 1package com.mycompany.holamundo;
 2
 3import java.util.Scanner;
 4
 5public class HolaMundo {
 6
 7    public static void main(String args[]){
 8        // se prepara la entrada:
 9        Scanner scanner = new Scanner(System.in);
10
11        // Se imprime un mensaje:
12        System.out.println("Introduce tu edad: ");
13        System.out.print(">>> ");
14
15        // recibimos la edad:
16        int edad = scanner.nextInt();
17
18        // realizar el ternario:
19        var resultado = edad >= 18 ? "Eres mayor de edad" : "Eres menor de edad";
20
21        System.out.println(resultado);
22
23    }
24}

Atención

Para utilizar el operador ternario solo se puede usar la expresión var para declarar el resultado.

Condicional Switch#

Estructura de un switch:

 1package com.mycompany.holamundo;
 2
 3import java.util.Scanner;
 4
 5public class HolaMundo {
 6
 7    public static void main(String args[]){
 8        // se prepara la entrada:
 9        Scanner scanner = new Scanner(System.in);
10
11        // Se imprime un mensaje:
12        System.out.println("Introduce una opción del 1 al 5: ");
13        System.out.print(">>> ");
14
15        // recibimos la opción:
16        String opcion = scanner.nextLine();
17
18        // switch:
19        switch(opcion){
20            case "1":
21                System.out.println("Elegiste la opción 1");
22                break;
23            case "2":
24                System.out.println("Elegiste la opción 2");
25                break;
26            case "3":
27                System.out.println("Elegiste la opción 3");
28                break;
29            case "4":
30                System.out.println("Elegiste la opción 4");
31                break;
32            case "5":
33                System.out.println("Elegiste la opción 5");
34                break;
35            default:
36                System.out.println("Opción no reconocida");
37        }
38    }
39}

Bucle for#

  • for básico:

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        for(var i = 0; i <= 10; i++){
 8            System.out.println("Iteración nº " + i);
 9        }
10    }
11}

  • foreach:

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String[] args) {
 6        // array numerico:
 7        int fechas[] = {1997, 2001, 2018, 2022};
 8
 9        // foreach en array:
10        for(int fecha: fechas){
11            System.out.println("- Fecha: " + fecha);
12        }
13    }
14
15}

Bucle while#

  • While sencillo:

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6        var contador = 0;
 7        while(contador < 10){
 8            System.out.println("Ejecución nº " + contador);
 9            contador++;
10        }
11    }
12}

  • do-while:

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6        var contador = 10;
 7        do{
 8            System.out.println("Ejecución nº " + contador);
 9            contador++;
10        }while(contador < 10);
11    }
12}

Detener secuenda de script#

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6        var contador = 0;
 7        while(contador < 10){
 8            System.out.println("Ejecución nº " + contador);
 9            contador++;
10            if(contador == 5){
11                break;
12            }
13        }
14    }
15}

Tipos de datos avanzados#

Arrays#

  • Declaración tradicional:

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.videoconsolas.Consola;
 4
 5public class HolaMundo {
 6
 7    public static void main(String args[]){
 8        // los arrays en java son de tipo object así que hay que construirlos:
 9        String consolas[] = new String[3]; // definimo por ejemplo 3 casillas.
10
11        // asignar valores usando indices (no es neceasrio usar todas las casillas:
12        consolas[0] = "Nintendo Switch";
13        consolas[1] = "Sega MegaDrive";
14        consolas[2] = "Super Nintendo";
15
16        // acceder a datos de un índice:
17        System.out.println(consolas[1]);
18
19        // se puede también crear arreglos de tipo objeto en base a una clase
20        Consola videoconsolas[] = new Consola[2];
21
22        // y creamos objetos:
23        videoconsolas[0] = new Consola("Nintendo", "Switch", 2017);
24        videoconsolas[1] = new Consola("Sega", "Dreamcast", 1998);
25        // acceder a métodos y atributos:
26        System.out.println(videoconsolas[1].getMarca());
27    }
28}

  • Recorrer array con bucle for:

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        String consolas[] = new String[3];
 8
 9        consolas[0] = "Nintendo Switch";
10        consolas[1] = "Sega MegaDrive";
11        consolas[2] = "Super Nintendo";
12
13        // recorrer elementos de un array:
14        for(int i = 0; i < consolas.length; i++){
15            System.out.println(consolas[i]);
16        }
17    }
18}

Matrices o arrays multidimensional#

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6        // las matrices cuentan con múltiples dimensiones [fila][columna]:
 7        String consolas[][] = new String[3][2];
 8
 9        consolas[0][0] = "Nintendo Switch";
10        consolas[0][1] = "2017";
11        consolas[1][0] = "Sega MegaDrive";
12        consolas[1][1] = "1989";
13        consolas[2][0] = "Super Nintendo";
14        consolas[2][1] = "1992";
15
16        // recorrer elementos de un array anidando for:
17        for(int i = 0; i < consolas.length; i++){
18            for(int j = 0; j < consolas[i].length; j++){
19                System.out.print(consolas[i][j] + " ");
20            }
21            System.out.println("");
22        }
23    }
24}

Colecciones#

Las colecciones son similares a objetos literales, diccionarios y otros terminos en otros lenguajes de programación. Estas colecciones tienen tres tipos de formatos List, Set y Map, pero cada uno tiene sus limitaciones.

 1package com.mycompany.holamundo;
 2
 3// se importa del paquete util las arraylist y las list:
 4import java.util.*; // o todos con *
 5
 6public class HolaMundo {
 7
 8    public static void main(String[] args) {
 9
10        // creamos una lista con la clase list:
11        List consolas = new ArrayList();
12
13        // añadir elementos:
14        consolas.add("Nintendo switch");
15        consolas.add("Nintendo switch");
16        consolas.add("Nintendo DS");
17
18        // recorrer lista:
19        for(Object consola: consolas){
20            System.out.println(consola);
21        }
22
23        // Hacemols lo mismo con los sets:
24        Set videoconsolas = new HashSet();
25
26        // añadir elementos:
27        videoconsolas.add("Nintendo switch");
28        videoconsolas.add("Nintendo switch");
29        videoconsolas.add("Nintendo DS");
30
31        // al recorrer lista vemos que ha ordenado elementos y que no añade el elemento repetido:
32        for(Object consola: videoconsolas){
33            System.out.println(consola);
34        }
35
36        // Los mapas usan clave-valor:
37        Map vConsolas = new HashMap();
38
39        // añadir elemento con su clave y su valor:
40        vConsolas.put("marca", "Nintendo");
41        vConsolas.put("Modelo", "Switch");
42        vConsolas.put("Lanzamiento", 2017);
43
44        // para imprimir las claves usamos el metodo keySet:
45        System.out.println(vConsolas.keySet());
46        // para imprimir los valores usamos values:
47        System.out.println(vConsolas.values());
48
49        // recorrer elementos (solo se pueden recorrer claves o valores:
50        for(Object key: vConsolas.keySet()){
51            System.out.print("- " + key);
52        }
53    }
54
55}

Control de errores#

Crear excepciones#

  • Se crea una nueva clase en el proyecto en un paquete nuevo para controlar los errores:

 1package com.mycompany.errors;
 2
 3// la clase para crear el error hereda del padre Exception:
 4public class EdadException extends Exception {
 5    // se crea un constructor que recibirá un mensaje de error:
 6    public EdadException(String mensaje){
 7        // al constructor padre se le pasa el mensaje:
 8        super(mensaje);
 9    }
10}

  • Ahora se utiliza la excepción en una clase:

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.errors.EdadException;
 4
 5public class HolaMundo {
 6    // al método utilizado se le debe añadir los throws de la excepción creada:
 7    public static void main(String[] args) throws EdadException {
 8    int edad = -10;
 9
10    // si la edad es menor a 0:
11    if(edad < 0){
12        // se lanzará nuestra excepción:
13        throw new EdadException("La edad no puede ser un valor negativo");
14    }
15    }
16
17}

Esto lanzará un mensaje de error con la excepción que mostrará el mensaje que hemos creado.

Controlar excepción#

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.errors.EdadException;
 4
 5public class HolaMundo {
 6    // al método utilizado se le debe añadir los throws de la excepción creada:
 7    public static void main(String[] args) {
 8    int edad = -10;
 9
10    // controlamos la excepción con try catch:
11    try{
12        // si la edad es menor a 0:
13            if(edad < 0){
14                // se lanzará nuestra excepción:
15                throw new EdadException("La edad no puede ser un valor negativo");
16            }
17    }catch(EdadException error){ // evitamos así que finalice la ejecución abruptamente
18        // se puede recuperar el mensaje de error:
19        System.out.println(error.getMessage());
20        // se puede recuperar la traza de error:
21        error.printStackTrace();
22    }
23
24    System.out.println("Ya no se interrumpe la ejecución");
25
26
27    }
28
29}

Programación modular#

El tipo de paradigma que usa Java es usualmente Programación orientada a objeto, de modo que utiliza métodos en lugar de funciones.

Programación orientada a objetos#

Los elementos de una clase se definen con ámbito public, private y protected. Adicionalmente se puede agregar el modificador static para poder acceder a los atributos y métodos sin crear un objeto.

Clases y objetos#

En un IDE como NetBeans se hace click derecho en Source packages y en la opción New class.

  • Estructura clase:

 1// se genera la ruta al paquete si lo hemos seleccionado:
 2package com.mycompany.holamundo;
 3
 4// se crea el nombre de la clase:
 5public class Consola {
 6    // atributos:
 7    String marca;
 8    String modelo;
 9    int lanzamiento;
10
11    // metodos:
12    public void info(){
13        System.out.println("La consola " + marca + " " + modelo + " fue lanzada en " + lanzamiento);
14    }
15}

  • Métodos:

 1package com.mycompany.holamundo;
 2
 3public class Consola {
 4    String marca;
 5    String modelo;
 6    int lanzamiento;
 7
 8    // metodo que no retorna nada o void:
 9    public void info(){
10        System.out.println("La consola " + marca + " " + modelo + " fue lanzada en " + lanzamiento);
11    }
12
13    // método que retorna un valor:
14    public String nombre(){
15        return marca + " " + modelo;
16    }
17
18    // metodo que recibe parámetros:
19    public String propietario(String nombre){
20        return "La consola " + marca + " " + modelo + " es de " + nombre;
21    }
22}

  • Operador spread:

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6        // cargar distintos elementos en la función:
 7        listaConsolas("Nintendo Switch", "PS4", "Xbox One");
 8    }
 9
10    // cargar el operador spread el cual creará un array de strings:
11    public static void listaConsolas(String... consolas){
12        for(var i = 0; i < consolas.length; i++){
13            System.out.println("- " + consolas[i]);
14        }
15    }
16}

  • Creación de objeto en clase principal:

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        // crear objeto:
 8        Consola nsw = new Consola();
 9
10        // asignar datos:
11        nsw.marca = "Nintendo";
12        nsw.modelo = "Switch";
13        nsw.lanzamiento = 2017;
14
15        // Ejecutar método:
16        nsw.info();
17
18        // pasar parámetros:
19        String propietario = nsw.propietario("Guillermo");
20
21        System.out.println(propietario);
22    }
23}

  • Constructores en clases:

 1package com.mycompany.holamundo;
 2
 3public class Consola {
 4    // lo normal es tener encapsulado los atributos como este caso:
 5    private String marca;
 6    private String modelo;
 7    private int lanzamiento;
 8
 9    // método constructor lleva exactamente el mismo nombre que la clase:
10    public Consola(String marca, String modelo, int lanzamiento){
11        // cargar valores proporcionados al objeto en el constructor:
12        this.marca = marca;
13        this.modelo = modelo;
14        this.lanzamiento = lanzamiento;
15
16        // mensaje de prueba:
17        System.out.println("Se ha creado el objeto consola");
18    }
19
20    public void info(){
21        System.out.println("La consola " + marca + " " + modelo + " fue lanzada en " + lanzamiento);
22    }
23
24    public String nombre(){
25        return marca + " " + modelo;
26    }
27
28    public String propietario(String nombre){
29        return "La consola " + marca + " " + modelo + " es de " + nombre;
30    }
31}

Atención

Se pueden crear mas de un constructor según la necesidad, por ejemplo si queremos tener valores default creamos un constructor vacío con los valores que queramos y otro para añadir valores personalizados como el caso anterior.

  • Constructores en objetos:

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        // crear objeto y añadir datos al constructor:
 8        Consola nsw = new Consola("Nintendo", "Switch", 2017);
 9
10
11        nsw.info();
12
13        String propietario = nsw.propietario("Guillermo");
14
15        System.out.println(propietario);
16    }
17}

  • Sobrecarga de constructores:

 1package com.mycompany.holamundo;
 2
 3public class Consola {
 4    public String marca;
 5    public String modelo;
 6    public int lanzamiento;
 7
 8    // constructor padre:
 9    private Consola(){
10        System.out.println("Se ha creado el objeto consola");
11    }
12
13    // constructor hijo:
14    public Consola(String marca, String modelo, int lanzamiento){
15        // requiere la función reservada this:
16        this();
17        this.marca = marca;
18        this.modelo = modelo;
19        this.lanzamiento = lanzamiento;
20    }
21
22    public String getMarca(){
23        return this.marca;
24    }
25
26    public void setMarca(String marca){
27        this.marca = marca;
28    }
29
30    public void info(){
31        System.out.println("La consola " + marca + " " + modelo + " fue lanzada en " + lanzamiento);
32    }
33
34    public String nombre(){
35        return marca + " " + modelo;
36    }
37
38    public String propietario(String nombre){
39        return "La consola " + marca + " " + modelo + " es de " + nombre;
40    }
41
42}

Atención

Java llama a todos los constructores a la hora de crear objetos

  • Get y Set (clase):

 1package com.mycompany.holamundo;
 2
 3public class Consola {
 4    // los atributos son privados y no se puede acceder a ellos fuera de la clase:
 5    private String marca;
 6    private String modelo;
 7    private int lanzamiento;
 8
 9    public Consola(String marca, String modelo, int lanzamiento){
10        this.marca = marca;
11        this.modelo = modelo;
12        this.lanzamiento = lanzamiento;
13
14        System.out.println("Se ha creado el objeto consola");
15    }
16
17    // para ello usamos los getters y setters:
18    public String getMarca(){
19        // el get retorna el atributo:
20        return this.marca;
21    }
22
23    public void setMarca(String marca){
24        // modificar el atributo externamente:
25        this.marca = marca;
26    }
27
28    // se hace lo mismo con el resto de atributos que vayan a usarse externamente
29
30}

Atención

Si el atributo con el que trabajamos es booleano se cambia el get por is es decir isReal() que retorna True o False.

  • Get y Set (objeto):

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        Consola nsw = new Consola("Nintendo", "Switch", 2017);
 8
 9        // modificar la marca:
10        nsw.setMarca("Sega");
11
12        // ver la marca (el único valor que podemos cargar:
13        System.out.println(nsw.getMarca());
14    }
15}

  • Información encapsulada con toString (clase):

 1package com.mycompany.holamundo;
 2
 3public class Consola {
 4    private String marca;
 5    private String modelo;
 6    private int lanzamiento;
 7
 8    public Consola(String marca, String modelo, int lanzamiento){
 9        this.marca = marca;
10        this.modelo = modelo;
11        this.lanzamiento = lanzamiento;
12
13        System.out.println("Se ha creado el objeto consola");
14    }
15
16    public String getMarca(){
17        return this.marca;
18    }
19
20    public void setMarca(String marca){
21        this.marca = marca;
22    }
23
24    // toString hace referencia informativa con que atributos cuenta la clase:
25    @Override // al existir el método toString de la clase raiz object se anota la sobrecarga
26    public String toString(){
27        return "Consola(" + "marca=" + this.marca + ", modelo=" + this.modelo + ", lanzamiento=" + this.lanzamiento + ")";
28    }
29
30}

  • Información encapsulada con toString (objeto):

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        Consola nsw = new Consola("Nintendo", "Switch", 2017);
 8
 9        // uso del método toString:
10        System.out.println(nsw.toString());
11    }
12}

  • Ámbito estático:

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5    // en la clase principal no se puede acceder a atributos a menos que sean estaticos:
 6    public static String nombre = "Guillermo";
 7
 8    public static void main(String args[]){
 9
10        hola();
11
12        nombre = "Pepe";
13    }
14    // pasa lo mismo con los métodos:
15    public static void hola(){
16        System.out.println("Hola colega");
17    }
18}

  • Herencia (clase padre Consola):

 1package com.mycompany.holamundo;
 2
 3// tenemos la clase Padre:
 4public class Consola {
 5    private String marca;
 6    public String modelo;
 7    public int lanzamiento;
 8
 9    public Consola(String marca, String modelo, int lanzamiento){
10        this.marca = marca;
11        this.modelo = modelo;
12        this.lanzamiento = lanzamiento;
13
14        System.out.println("Se ha creado el objeto consola");
15    }
16
17    public String getMarca(){
18        return this.marca;
19    }
20
21    public void setMarca(String marca){
22        this.marca = marca;
23    }
24
25    public void info(){
26        System.out.println("La consola " + marca + " " + modelo + " fue lanzada en " + lanzamiento);
27    }
28
29    public String nombre(){
30        return marca + " " + modelo;
31    }
32
33    public String propietario(String nombre){
34        return "La consola " + marca + " " + modelo + " es de " + nombre;
35    }
36
37    @Override
38    public String toString(){
39        return "Consola(" + "marca=" + this.marca + ", modelo=" + this.modelo + ", lanzamiento=" + this.lanzamiento + ")";
40    }
41
42}

Atención

Si agregamos el modificador final en la declaración de la clase public final class Consola no se podrá heredar de esta. En caso de utilizarlo en atributos o métodos funciona como una constante, una vez declarado ya no se podrá sobrecargar.

  • Herencia (Clase hija ConsolaPortatil):

 1package com.mycompany.holamundo;
 2
 3// La clase consola portatil heredará atributos y métodos de consola:
 4public class ConsolaPortatil extends Consola{
 5    // atributos de esta clase:
 6    private String TipoBaterias;
 7
 8    // el constructor lleva la palabra super para usar los atributos del padre:
 9    public ConsolaPortatil(String marca, String modelo, int lanzamiento, String TipoBaterias){
10        // pasamos los atributos correspondientes al padre:
11        super(marca, modelo, lanzamiento);
12
13        // cargamos los atributos del hijo:
14        this.TipoBaterias = TipoBaterias;
15    }
16
17    // creamos sus getter y setters:
18    public String getTipoBaterias(){
19        return this.TipoBaterias;
20    }
21
22    public void setTipoBaterias(String TipoBaterias){
23        this.TipoBaterias = TipoBaterias;
24    }
25
26    // y también podemos crear métodos propios además de usar los del padre:
27    public void bateria(){
28        System.out.println("El tipo de batería que usa " + this.getMarca() + " " + this.modelo + " es de tipo: " + this.TipoBaterias);
29    }
30
31    // También se sobreescriben los métodos del padre si es necesario:
32    @Override
33    public void info(){
34        System.out.println("La consola " + this.getMarca() + " " + this.modelo + " fue lanzada en " + this.lanzamiento + " y su tipo de bateria es: " + this.TipoBaterias);
35    }
36}

  • Herencia (Objeto):

 1package com.mycompany.holamundo;
 2
 3
 4public class HolaMundo {
 5
 6    public static void main(String args[]){
 7        // el objeto se crea tal y como el original:
 8        ConsolaPortatil nsw = new ConsolaPortatil("Nintendo", "Switch", 2017, "Batería Lipo");
 9
10        // se pueden usar los métodos del hijo:
11        nsw.bateria();
12
13        // y los del padre:
14        System.out.println(nsw.nombre());
15
16        // y también vemos como reacciona al usar un método sobrecargado del padre:
17        nsw.info();
18    }
19}

  • Saber a que clase apunta el objeto (instanceof):

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.videoconsolas.Consola;
 4
 5public class HolaMundo {
 6
 7    public static void main(String[] args) {
 8        // crear objeto:
 9        Consola nsw = new Consola("Nintendo", "Switch", 2017);
10
11        // averiguar si el objeto es parte de la clase correspondiente:
12        if(nsw instanceof Consola){
13            System.out.println("nsw es objeto de la clase Consola");
14        }
15    }
16
17}

Paquetes#

Crear paquetes#

  1. Se puede crear un paquete en NetBeans haciendo click derecho en Source Packages y en New.. Java Package.

  2. A continuación lo llamamos con el nombre de un dominio pero inverso: com.mysitio.nombrepaquete en este caso lo llamaremos: com.mycompany.videoconsolas

  3. En este paquete podemos crear clases como Consola y ConsolaPortatil

Importar paquetes#

En cualquier archivo Java podemos importar una clase de un paquete como videoconsolas:

 1package com.mycompany.holamundo;
 2// se importa la clase del paquete que queremos usar:
 3import com.mycompany.videoconsolas.Consola; // si escribimos com.mycompany.videoconsolas.* va a cargar todos los nombres de clases si existe mas de uno.
 4
 5
 6public class HolaMundo {
 7
 8    public static void main(String args[]){
 9        Consola nsw = new Consola("Nintendo", "Switch", 2017);
10
11        nsw.info();
12
13    }
14}

Enumeradores o enums#

Los enumeradores se utilizan para listar una serie de elementos constantes como los días de la semana.

Enumerador básico#

Los enumeradores más básicos utilizan atributos como constantes y se suelen utilizar para validar elementos con estructuras switch. Se crea una nueva clase java y se escribe lo siguiente:

 1package com.mycompany.holamundo;
 2
 3// crear el enum:
 4public enum Generaciones {
 5    PRIMERA,
 6    SEGUNDA,
 7    TERCERA,
 8    CUARTA,
 9    QUINTA,
10    SEXTA,
11    SEPTIMA,
12    OCTAVA,
13    NOVENA
14}

  • Si se imprime alguno de los valores estos mostrarán el nombre de la constante:

1package com.mycompany.holamundo;
2
3public class HolaMundo {
4
5    public static void main(String args[]){
6        System.out.println(Generaciones.PRIMERA);
7    }
8
9}

Enumeradores avanzados#

Estos enumeradores contienen atributos más complejos como objetos y métodos para manejar dichos atributos:

 1package com.mycompany.holamundo;
 2
 3// crear el enum:
 4public enum Generaciones {
 5    PRIMERA("Magnavox Oddysey"),
 6    SEGUNDA("Atari 2600"),
 7    TERCERA("NES"),
 8    CUARTA("Sega Megadrive"),
 9    QUINTA("PlayStation"),
10    SEXTA("Sega Dreamcast"),
11    SEPTIMA("Nintendo Wii"),
12    OCTAVA("Nintendo Switch"),
13    NOVENA("PS5");
14
15    // se genera un atributo para agregar elementos a cada atributo constante:
16    private final String consolas; // este atributo será constante.
17
18    // se llama al constructor y se inicializa las consolas:
19    private Generaciones(String consolas){
20        this.consolas = consolas;
21    }
22
23    // se carga un método para poder acceder a los elementos de cada objeto constante.
24    public String getConsolas(){
25        return this.consolas;
26    }
27}

  • Ejemplos de uso de enumeradores:

 1package com.mycompany.holamundo;
 2
 3public class HolaMundo {
 4
 5    public static void main(String args[]){
 6        // Acceder a un elemento de un enumerador:
 7        System.out.println(Generaciones.QUINTA.getConsolas());
 8
 9        // recorrer los elementos de cada enumerador utilizando el metodo values:
10        for(Generaciones g: Generaciones.values()){
11            System.out.println(g + " GENERACIÓN: " + g.getConsolas());
12        }
13    }
14
15}

  • Clase abstracta:

 1package com.mycompany.videoconsolas;
 2
 3// para crear una clase abstracta se añade el manejador abstract:
 4public abstract class Sistema { // no se pueden crear objetos de esta clase
 5    // atributos que heredarán los hijos:
 6    protected String marca;
 7    protected String modelo;
 8    protected int lanzamiento;
 9
10    // constructor por defecto para heredar:
11    protected Sistema(String marca, String modelo, int lanzamiento){
12        this.marca = marca;
13        this.modelo = modelo;
14        this.lanzamiento = lanzamiento;
15    }
16
17    // métodos abstractos disponibles (no tendrán nada definido):
18    public abstract void info();
19}

  • Clase que hereda de clase abstracta:

 1package com.mycompany.videoconsolas;
 2
 3public class Consola extends Sistema{
 4
 5    // se define el constructor:
 6    public Consola(String marca, String modelo, int lanzamiento){
 7        // se invoca al constructor abstracto y se le pasan los valores:
 8        super(marca, modelo, lanzamiento);
 9
10        System.out.println("Se ha creado el objeto consola, ejemplo de datos:");
11        System.out.println("Marca: " + this.marca);
12        System.out.println("Modelo: " + this.modelo);
13        System.out.println("Lanzamiento: " + this.lanzamiento);
14    }
15
16    // se añade el contenido del método abstracto:
17    public void info(){
18        System.out.println("La consola " + this.marca + " " + this.modelo + " fue lanzada en " + this.lanzamiento);
19    }
20
21}

  • Objeto que se crea:

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.videoconsolas.Consola;
 4
 5public class HolaMundo {
 6
 7    public static void main(String[] args) {
 8    Consola nsw = new Consola("Nintendo", "Switch", 2017);
 9
10    nsw.info();
11    }
12
13}

Bloques de código#

Los bloques de códigos son bloques anónimos que se ejecutan antes que cualquier otro elemento en una clase. Además los bloques static anonimos se ejecutan incluso antes que los bloques anónimos.

 1package com.mycompany.videoconsolas;
 2
 3public class Consola {
 4    public String marca;
 5    public String modelo;
 6    // en un bloque estatico solo pueden cargarse elementos estaticos:
 7    public static int lanzamiento;
 8
 9    // bloque de inicialización de código:
10    {
11        marca = "Desconocida";
12        modelo = "Desconocido";
13    }
14
15    // bloque de inicialización de código estatico:
16    static{
17        // valor inicial de lanzamiento:
18        lanzamiento = 1970;
19    }
20
21    private Consola(){
22        System.out.println("Se ha creado el objeto consola, ejemplo de datos:");
23        // en el constructor podemos mostrar los atributos inicializados:
24        System.out.println("Marca: " + this.marca);
25        System.out.println("Modelo: " + this.modelo);
26        System.out.println("Lanzamiento: " + this.lanzamiento);
27    }
28
29    public Consola(String marca, String modelo, int lanzamiento){
30        this();
31        this.marca = marca;
32        this.modelo = modelo;
33        this.lanzamiento = lanzamiento;
34        // Probamos ahora con el constructor hijo a ver los datos:
35        System.out.println("Datos añadidos al objeto:");
36        System.out.println("Marca: " + this.marca);
37        System.out.println("Modelo: " + this.modelo);
38        System.out.println("Lanzamiento: " + this.lanzamiento);
39    }
40
41    public void info(){
42        System.out.println("La consola " + marca + " " + modelo + " fue lanzada en " + lanzamiento);
43    }
44
45    public String nombre(){
46        return marca + " " + modelo;
47    }
48
49    public String propietario(String nombre){
50        return "La consola " + marca + " " + modelo + " es de " + nombre;
51    }
52
53}

Interfaces#

Las interfaces son similares a las clases abstractas, se usan para implementar contenido adicional a diferentes clases. También son muy útiles para hacer herencia múltiple.

  • Crear una interfaz en netbeans haciendo clic derecho en Source Packages, luego en new y luego elegimos Java Interface:

 1package com.mycompany.videoconsolas;
 2
 3// la interfaz es similar a la clase:
 4public interface Soporte {
 5    // Los atributos en interfaces deben ser constantes y estáticos:
 6    public static final String SOPORTE = "ROM";
 7
 8    // Los métodos de una interface son siempre públicos y abstractos:
 9    public abstract void verSoporte();
10}

  • Implementar en clase:

 1package com.mycompany.videoconsolas;
 2
 3// se implementa la interfaz, no importa si la clase es padre o hija:
 4public class Consola extends Sistema implements Soporte{
 5
 6    public Consola(String marca, String modelo, int lanzamiento){
 7        super(marca, modelo, lanzamiento);
 8
 9        System.out.println("Se ha creado el objeto consola, ejemplo de datos:");
10        System.out.println("Marca: " + this.marca);
11        System.out.println("Modelo: " + this.modelo);
12        System.out.println("Lanzamiento: " + this.lanzamiento);
13    }
14
15    public void info(){
16        System.out.println("La consola " + this.marca + " " + this.modelo + " fue lanzada en " + this.lanzamiento);
17    }
18
19    @Override
20    public void verSoporte() {
21        System.out.println("El formato de los archivos es " + SOPORTE);
22    }
23
24}

  • Crear objeto:

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.videoconsolas.Consola;
 4
 5public class HolaMundo {
 6
 7    public static void main(String[] args) {
 8    Consola nsw = new Consola("Nintendo", "Switch", 2017);
 9
10    nsw.info();
11
12    nsw.verSoporte();
13    // se pueden usar también las constantes de la interfaz desde el objeto:
14    System.out.println(nsw.SOPORTE);
15    }
16
17}

Tipos Genéricos#

Los tipos genéricos definen el el tipo de dato que tendrán todos sus atributos que se va a utilizar en un objeto de una clase.

  • Clase con genéricos:

 1package com.mycompany.videoconsolas;
 2
 3// Se define el comportamiento que recibirá osea que el objeto tendrá un objeto genérico:
 4public class Consola<T>{
 5    // los atributos tendrán el tipo genérico:
 6    T marca;
 7    T modelo;
 8    T lanzamiento;
 9
10    // el constructor definirá el tipo que va a recibir:
11    public Consola(T marca, T modelo, T lanzamiento){
12        this.marca = marca;
13        this.modelo = modelo;
14        this.lanzamiento = lanzamiento;
15
16        System.out.println("Se ha creado el objeto consola, ejemplo de datos:");
17        System.out.println("Marca: " + this.marca);
18        System.out.println("Modelo: " + this.modelo);
19        System.out.println("Lanzamiento: " + this.lanzamiento);
20    }
21
22    public void info(){
23        System.out.println("La consola " + this.marca + " " + this.modelo + " fue lanzada en " + this.lanzamiento);
24    }
25
26}

  • Ahora se crea el objeto:

 1package com.mycompany.holamundo;
 2
 3import com.mycompany.videoconsolas.Consola;
 4
 5public class HolaMundo {
 6
 7    public static void main(String[] args) {
 8    // al crear el objeto se le pasa el tipo string y ya se encargará de hacer casting si es posible a todos:
 9        Consola<String> nsw = new Consola("Nintendo", "Switch", 2017);
10    }
11
12}

Atención

El tipo generico T no acepta tipos primitivos, es decir que solo acepta tipos object como String o Integer (no int)

Nota

Se puede ver este tipo de implementación en colecciones tipo List, Set y Map que son de tipo objetos.

Manejo de archivos#

Crear un archivo#

 1package com.mycompany.holamundo;
 2
 3// se importa java.io:
 4import java.io.*;
 5
 6public class HolaMundo {
 7
 8    public static void main(String[] args) {
 9    // se define la ruta y el nombre del archivo:
10    String nombreArchivo = "c:\\prueba\\prueba.txt";
11
12    // se crea un nuevo objeto de tipo file:
13    File archivo = new File(nombreArchivo);
14    // se usa un try catch para evitar errores en la lectura:
15    try{
16        // se crea un objeto para imprimir el archivo:
17            PrintWriter salida = new PrintWriter(archivo);
18            // cerramos la salida:
19            salida.close();
20
21    }catch(FileNotFoundException error){
22        error.printStackTrace(System.out);
23    }
24
25    }
26}

Escribir en un archivo#

 1package com.mycompany.holamundo;
 2
 3import java.io.*;
 4
 5public class HolaMundo {
 6
 7    public static void main(String[] args) {
 8    String nombreArchivo = "c:\\prueba\\prueba.txt";
 9
10    File archivo = new File(nombreArchivo);
11    try{
12            PrintWriter salida = new PrintWriter(archivo);
13            // escribir en el archivo:
14            String contenido = "Esto es contenido de prueba";
15            // enviar el contenido a la salida:
16            salida.println(contenido);
17            salida.println();
18            String fin = "Fin de escritura";
19            salida.println(fin);
20            // para guardar cambios se debe cerrar el archivo:
21            salida.close();
22            System.out.println("Se ha escrito el contenido con éxito");
23
24    }catch(FileNotFoundException error){
25        error.printStackTrace(System.out);
26    }
27
28    }
29}

Leer información de archivo#

 1package com.mycompany.holamundo;
 2
 3import java.io.*;
 4
 5public class HolaMundo {
 6
 7    public static void main(String[] args) {
 8    String nombreArchivo = "c:\\prueba\\prueba.txt";
 9
10    // el buffer exige un try catch:
11    try{
12            // se crea un buffer para leer el archivo y dentro se le pasa un lector de archivo:
13            BufferedReader entrada = new BufferedReader(new FileReader(nombreArchivo));
14
15            // guardar en string el contenido del archivo (requiere controla su escepción:
16            String lectura = entrada.readLine();
17            // recorrer todas las líneas del archivo hasta que sea el resultado nulo:
18            while(lectura != null){
19                // imprimir línea:
20                System.out.println(lectura);
21                // salto de línea:
22                lectura = entrada.readLine();
23            }
24            // cerrar archivo:
25            entrada.close();
26    }catch(FileNotFoundException error){
27        error.printStackTrace(System.out);
28    }catch(IOException error){
29        error.printStackTrace(System.out);
30    }
31
32    }
33}