Fundamentos de Java: Tipos de Datos, POO, Excepciones y E/S para Principiantes

Fundamentos de Java

COMPILADOR 80%, INTÉRPRETE 20%. Java compila el código fuente a bytecode, que se ejecuta en la JVM (Java Virtual Machine). El SDK incluye la JVM, las clases y el compilador; el JRE incluye la JVM y las clases necesarias para ejecutar programas.

Modificador final

• final en un dato: es invariable, una vez asignado no puede cambiar.
• final en un parámetro: es de solo lectura.
• final en un método: no puede reescribirse en las clases derivadas.
• final en una clase: no puede heredarse de ella.

Java utiliza UNICODE, por lo que puede representar caracteres como la ó de camión.

Bucle for-each

int[] n = {a, b};
for (int i : n)
    System.out.println(i); // a \n b

Paquetes e importación

Un paquete contiene clases. Se importan con:

import clase;
import paq.*;
import static paq.cla.*;

Clase Math

Los métodos estáticos de Math incluyen max, min, ceil, floor, round, pow y random (double). Las constantes final disponibles son E y PI.

Fechas

Las clases Date, Calendar y el método getInstance() se utilizan sin new.

Tipos de datos básicos

• int: 32 bits
• long: 64 bits
• short: 16 bits
• byte: 8 bits
• float: 32 bits
• double: 64 bits
• char: 16 bits

Para forzar un int a long se usa el sufijo L. Los números reales son double por defecto; para float se usa el sufijo f, por ejemplo float pi = 3.14f;.

Tipos envoltorio y referencias

Los tipos envoltorio (como Integer) son objetos y se manejan por referencia, mientras que los tipos básicos se manejan por valor.

Arrays

tipo[] a;
a = new int[tam];
a.length;

int[][] tb;
tb = new int[2][];
tb[0] = new int[3];
tb[1] = new int[4];

Entrada de datos por teclado

public class Tecl {
    public static char LeC() {
        char c;
        try {
            c = LeS().charAt(0);
        } catch (Exception e) {
            c = 0;
        }
        return c;
    }

    public static String LeS() {
        BufferedReader b = new BufferedReader(new InputStreamReader(System.in));
        String s;
        try {
            s = b.readLine();
        } catch (Exception e) {
            s = "";
        }
        return s;
    }
}

Los métodos que pueden lanzar excepciones de E/S se declaran con throws IOException.

Flujos de entrada y salida

Los objetos System.in, System.out y System.err están en java.io.*. Para texto se usan Reader y Writer; para datos binarios, InputStream y OutputStream.

Scanner s = new Scanner(System.in); // java.util.*

Manejo de ficheros

Para ficheros binarios se usan FileInputStream y FileOutputStream; para ficheros de texto, FileReader y FileWriter.

public class File_tex {
    public static void main(String[] args) throws IOException {
        BufferedReader t = new BufferedReader(new FileReader(args[0]));
        File f = new File(ruta);
        Scanner s = new Scanner(f);
    }
}

Arrays de objetos

Clase[] obj;
obj = new Clase[N];      // reserva de memoria para el array
obj[i] = new Clase();    // reserva de memoria para cada objeto

for (i = 0; i < N; i++) ...

Herencia

public class Deriv extends Base {
    public Deriv() {
        super(...);         // llama al constructor de Base
    }
    void metodo() {
        super.metodo();     // reescribir
    }
}

La sobrecarga de métodos permite usar el mismo nombre con distintos parámetros, como ocurre con += en String.

Clases abstractas

Si una clase tiene un método sin código, la clase debe declararse abstract. Una clase que no crea métodos también puede ser abstracta.

Interfaces

Las interfaces contienen funciones abstractas, public, static y final.

interface Nom {
    static final tipo v = ...;
    tipo metodo();
}

class Der implements Nom {
    public tipo metodo() {
        // implementación obligatoria
    }
}

Enumeraciones

Los tipos enum no se instancian con new.

enum N { PERRO, FLAUTA }

private static N var;
var = N.FLAUTA;

for (N v : N.values())
    System.out.println(v);

Expresiones regulares

private Pattern d;
d = Pattern.compile("[A-z]*");
Matcher coincidencia = d.matcher(String);

Colecciones

ArrayList v = new ArrayList();
v.add(x);

Hashtable h = new Hashtable();
h.put(key, obj);

Interfaces gráficas: AWT y Swing

Los componentes gráficos incluyen JFrame, JPanel, JButton, JComboBox, JTextField y JLabel. El constructor suele invocar initComponents(), que en los editores visuales se genera automáticamente.