5. Sintaxis de Java

5.1. Imprimir texto - concatenación

  • System.out.println("Hola Mundo"); (crea nuevas líneas)
  • System.out.print("Hola Mundo");
  • System.out.print("Hola " + variable);
  • s1.concat(s2)

5.2. Variables

  • Para definir una variable hay que indicar de qué tipo es (un número entero o decimal, texto, etc.). Dentro de cada tipo, existen distintos tipos básicos o primitivos, cada uno ocupa una cantidad de memoria distinta (cuántos más valores admita, más ocupará):
  • Números enteros:
    • byte: número desde -128 a 127 (8-bit).
    • short: desde -32.768 a 32.767 (16-bit).
    • int: desde -2^31 a 2^32-1 (32-bit).
    • long: desde -2^63 a 2^64-1 (64-bit).
  • Números decimales:
    • float: (32-bit).
    • double: (64-bit).
  • Valores booleanos (sólo admiten dos valores, verdadero o falso):
    boolean
  • Caracteres:
    • char: carácter Unicode desde ‘uoooo’ (0) a ‘uffff’ (65.535) (16-bit).
  • Se admite el tipo no primitivo String (cadena de texto) a través de la clase “java.lang.String”.

5.3. Arrays

  • Definición:
    • int[] num = new int[10]; (array de 10 valores)
    • String[] str = {“Hola”, “Mundo”};
    • int[][] num2 = {{3,4,2},{5,7,8}};
  • Asignar valores:
    • num[2] = 40;
    • num2[1][2] = 8;
  • Averiguar longitud:
    • num.length;

5.4. Listas

  • ArrayList
    • Similares a los arrays, pero sin tamaño fijo.
      import java.util.ArrayList;
      …
      ArrayList<String> lista = new ArrayList<String>(10);
    • Añadir elemento: lista.add(18);
    • Quitar elemento: lista.remove(<índice>);
    • Sustituir un elemento: lista.set(<<índice>>, 14);
    • Obtener un elemento de la lista: lista.get(<<índice>>);
  • LinkedList
    • Similares a los ArrayList, pero no se les puede indicar un tamaño al definirlos.
      import java.util.LinkedList;
      …
      LinkedList<Integer> lista2 = new LinkedList<Integer>();
  • HashMap
    • Listas de pares clave-valor:
      import java.util.HashMap;
      …
      HashMap<Integer, String> lista3 = new HashMap<Integer, String>();
    • Añadir un elemento: lista3.put(1, “Javier”);
    • Obtener un elemento de la lista: lista3.get(<<clave>>);
  • Collections
    • Es una clase que permite ordenar listas (ArrayList, LinkedList), entre otras opciones (no requiere crear objeto):
    • import java.util.Collections;
    • Collections.sort(lista);
    • Collections.max(lista); (se debe asignar a una variable)
    • Collections.min(lista); (se debe asignar a una variable)
    • Collections.reverse(lista);
    • Collections.shuffle(lista); (revuelve aleatoriamente los elementos)

5.5. Clases

  • Todo el código que se escriba debe ir dentro de una clase. Existen unas clases que vienen por defecto y que permiten, por ejemplo, el uso del tipo “String” nombrado anteriormente. Cada archivo de código debe incluir una clase con el mismo nombre de dicho archivo. Se pueden crear clases siguiendo este formato:
    class MiClase{
    …
    }
  • Clase Rectangle:
    • Crea objetos con unas coordenadas "x" e "y" y un ancho y alto:
    • Rectangle r = new Rectangle(0, 0, 100, 50);

5.6. Condicionales y bucles

  • Condicionales
    if(x == 7){
    …
    }else if(...){
    …
    }else{
    …
    }
  • Bucles
    for (int x = 0; x < 100; x++){
    …
    }
    while (x < 100){
    …
    x++;
    }
    • (“Bucle mejorado”, para arrays)
      for (int x: arr){
      System.out.println(x);
      }
  • ‘break’ y ‘continue’

5.7. Excepciones (errores)

  • Definición
    • Las excepciones son problemas que ocurren durante la ejecución o compilación del programa. Un buen programador preve la aparición de excepciones en el programa “capturándolas”, es decir, indicando en el código esa posibilidad de que aparezcan.
  • Manejo de excepciones
    • Existen varios tipos de excepciones, algunas aparecen al compilar el programa y otras al ejecutarlo:
    • IndexOutOfBoundsException (se intenta acceder a un índice de un array que no existe)
    • FileNotFoundException (el archivo al que se quiere acceder no existe)
    • ArithmeticException (errores matemáticos, como dividir por cero)
    • IllegalArgumentException (error creado por el programador cuando se quiere restringir los argumentos que puede tener una función)
    • Exception (error genérico, engloba a todos)
    • Bloque try/catch
      try{
      código a ejecutar;
      }catch (Exception e){
      código a ejecutar si hay un error con el anterior código;
      }
    • Pueden incluirse varios “catch” con distintas excepciones, ordenadas de la más expecífica a la más general.
    • "finally": se ejecuta haya o no error:
      try{
      ...
      }catch(){
      ...
      }finally{
      ...
      }
    • “throws” y “throw new”
      int funcion() throws ArithmeticException{
      if(código){
      throw new ArithmeticException(“Error”);
      }else{
      …
      }

5.8. Propiedades y métodos

  • Un método se define así:
    modificadores nombreMetodo(parametros){…}
  • Para que un método se ejecute, hay que llamarlo: nombreMetodo(argumentos);
  • Un método puede retornar un valor:
    public int metodo(int x){
    return x*x;
    }
  • Si el método no retorna ningún valor, se debe usar el tipo “void” al definirlo:
    public void metodo(){
    System.out.println(“Hola”);
    }

5.9. Objetos

  • Se puede entender una clase como una plantilla que podemos utilizar tantas veces como queramos creando “instancias” de ella. Estas instancias se llaman “objetos”, y se inician así:
    MiClase nombre_variable = new MiClase(); //opción 1
    System.out.println(nombre_variable.propiedad);
    int numero = new MiClase().propiedad; //opción 2
    System.out.println(numero);

5.10. Prefijos (modificadores)

  • Al definir una clase, una variable o una función se pueden añadir diversos prefijos según el comportamiento que deseamos que tenga:
  • Prefijos de acceso:
    • public: si queremos que el elemento sea accesible fuera del paquete al que pertenece, incluiremos el prefijo “public” (la clase principal del proyecto debe tener este prefijo, lo que permite que se pueda ejecutar el programa).
    • private: impide que el elemento sea accesible fuera de su clase.
    • protected:
    • sin prefijo de acceso: el elemento es accesible dentro de su paquete.
  • static: hace que la función o variable sea accesible sin iniciar una instancia de su clase (es decir, sin crear un nuevo objeto).

5.11. Trabajo con archivos

  • Clase File:
    import java.io.File;
    …
    File archivo = new File(“C:\archivo.txt”);
    archivo.exists(); //devuelve “true” o “false”
    Scanner sc = new Scanner(archivo); //para leer el archivo, hay que incluirlo dentro de un try/catch con el error “FileNotFoundException” ya que el archivo puede no existir
    while (sc.hasNext()){
    System.out.println(sc.next());
    }
    sc.close();
  • Clase Formatter:
    import java.util.Formatter;
    …
    Formatter f = new Formatter(“C:\nuevo.txt”); (crea un archivo, utilizar try/catch con un error genérico “Exception”)
    f.format(“%s %s”, “Hola”, “Mundo/r/n”);
    f.close();