VARIABLES Y TIPOS

TipoDescripciónValor mínimo a máximo
byte Entero con signo -128 a 127
short Entero con signo -32768 a 32767
int Entero con signo -2147483648 a 2147483647
long Entero con signo -922117036854775808 a 922117036854775807
float Real de simple precisión +-3.40282347e+38 a +-1.40239846e-45
double Real de doble precisión +-1.79769313486231570e+308 a +-4.94065645841246544e-324
char Caracteres Unicode \u0000 a \uFFFF
boolean Verdadero o falso true o false

String (usado igual que un tipo aunque sea una clase): String cadena = "En un lugar de la mancha de cuyo lugar no quiero...";

CONSTANTES

final (delante del nombre del tipo)

OPERADORES

+, -, ++, --, >, >=, <, <=, =, !=, +=, -=, *=, /=, %= !, &&, ||

LEER DESDE PANTALLA (Clase Scanner)

import java.util.Scanner; Scanner reader = new Scanner(System.in); int altura = reader.nextInt(); // Lectura de entero

CASTING

intValue = (int) floatValue;

ESTRUCTURAS DE SELECCIÓN

if (condición) { sentencias } if (condición) { sentencias } else { sentencias }
edad >= 18 ? chicoMayor : chicoMenor
switch (expresión) { case valor1: sentencias; break; case valor2: case valor3: sentencias; break; default: sentencias; break;
while (condición) { sentencias }
do { sentencias } while (condición);
for (inicialización; condición; actualización) { sentencias }

STATIC

Static: aplicado a atributos y métodos son llamados "de clase" (atributo de clase o método de clase). Se carga desde el principio en memoria.

public class Profesor { static int numProfesores = 0; static void incrementeNumProfesores() { numProfesores++; } static void imprimeTotalProfesores() { System.out.println("Número total de profesores " + numProfesores); public static void main(String args[]) { Profesor.incrementaNumProfesores(); Profesor.imprimeTotalProfesores(); } }

PROCEDIMIENTOS

static void dameValor(int arg1, int arg2) { sentencias }

FUNCIONES

static int devuelveNumero(int arg1, int arg2) { sentencias return result; }

CONTROL DE ACCESO A PROCEDIMIENTOS/FUNCIONES

  • Acceso privado: private solo desde la misma clase
  • Acceso de paquete: No se escribe nada. Acceso libre a clases del mismo paquete.
  • Acceso protegido: protected solo desde la misma clase, las que la extienden (herencia) o del mismo paquete
  • Acceso público: public todas las clases pueden utilizar los elementos de dicha clase.

CLASES

Para que la clase que se está escribiendo pertenezca a un paquete, hace falta que la primera sentencia sea como la siguiente:

package nombrePaquete;

Para importar una clase de un paquete, hay que hacer esto:

import nombrePaquete.clase;

ARRAYS

Declaración:

int[] nombreArray; int nombreArray[];

Creación:

int[] nombreArray = new int[30]; int nombreArray[] = new int[90];

Inicialización:

double[] arrayDecimales = {1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7, 8.8}; String[] meses = { "Enero", "Febrero", "Marzo", "Abril", "Mayo", "Junio", "Julio", "Agosto", "Septiembre", "Octubre", "Noviembre", "Diciembre"};

Acceso:

System.out.println("El primer año es " + meses[0]);

Longitud:

System.out.println("El array meses tiene " + meses.length + " elementos.");

ARRAYS N-DIMENSIONALES

Declaración

int[][] tablero;

Creación

tablero = new int[5][5]; int[][][] pirámide = new int[5][5][5];

Acceso a valores

tablero[4][4] = 30;

Longitud

tablero.length --> 5 tablero[0].length --> 5

Arrays no rectangulares

int[][] tablero = new int[5][]; tablero[0] = new int[2]; tablero[1] = new int[3]; tablero[2] = new int[4]; tablero[3] = new int[5];

PROGRAMACIÓN O.O.

  • Encapsulación - Control de acceso a nuestras clases. Ocultación de estado.
  • Herencia - una clase hereda de otra (extends).
  • Polimorfismo - Uso general de clases que pertenecen a una misma jerarquía.
  • VISIBILIDAD

    [public] class NombreClase { // Métodos y atributos }

    public - visible por cualquier clase.

    si no se pone - visible desde el paquete.

    CARACTERÍSTICAS DE LAS CLASES

    • Herencia de variables y métodos
    • No existe herencia múltiple
    • En un fichero no puede haber más de una clase pública. LA CLASE PÚBLICA DEBE TENER EL MISMO NOMBRE QUE EL FICHERO.
    • this hace referencia a la misma clase.

    ESTRUCTURA DE UNA CLASE

    public class NombreClase { // Atributos // Métodos public static void main (String[] args) { // Main es el punto de entrada a la clase. } }

    El método main suele aparecer solo en la clase pública, como punto de acceso a nuestro programa.

    REFERENCIAS AL MISMO OBJETO

    Coche CocheA; // Vale null Coche CocheB; // Vale null CocheA = CocheB; // Ahora apuntan al mismo objeto.

    CLASE DE EJEMPLO

    class Coche { private String modelo; private String matricula; private String color; public String dameModelo {...} public void ponModelo (String nuevoModelo) {...} }

    THIS

    this.modelo = "Audi Quattro";

    SOBRECARGA DE MÉTODOS

    Métodos con el mismo nombre

    public void ponModelo ( String nuevoModelo) { this.modelo = nuevoModelo; } public void ponModelo ( String nuevoModelo, String nuevoColor) {this.modelo = nuevoModelo; this.color = nuevoColor;}

    CONSTRUCTOR

    class Coche { // Atributos String modelo; String matricula; String color; Coche (String nuevo_modelo, String nueva_matricula, String nuevo_color) { this.modelo = nuevo_modelo; this.matricula = nueva_matricula; this.color = nuevo_color; } Coche (String nuevo_modelo) { this.modelo = nuevo_modelo; } }

    CONSTRUCTOR THIS()

    Dentro de un constructor se puede llamar a this() como constructor en la primera línea.

    class Coche { // Atributos String modelo; String matricula; String color; Coche (String nuevo_modelo, String nueva_matricula) { this.modelo = nuevo_modelo; this.matricula = nueva_matricula; } Coche (String nuevo_modelo, String nueva_matricula, String nuevo_color) { this(nuevo_modelo,nueva_matricula); // <===== VER ESTO. SOLO EN LA PRIMERA LÍNEA this.color = nuevo_color; } }

    ATRIBUTOS STATIC

    Son atributos de clase. Un solo valor por clase.

    MÉTODOS STATIC

    Son métodos de clase. Se les puede llamar sin instanciar la clase. Los métodos de clase sirven para acceder a atributos de clase.

    INICIALIZAR ATRIBUTOS STATIC

    class Coche { static int numCoches; static { <==== VER ESTO; ASÍ SE INICIALIZA numCoches numCoches = 0; } }

    ACCESO A CLASES

    • PRIVADO - private
    • ACCESO DE PAQUETE
    • PROTEGIDO - protected
    • PÚBLICO - public

    CLASES ESTÁNDAR.

    Clases Estándar

    COMPOSICIÓN

    Consiste en usar una clase que agrupa objetos de otras clases mediante Arrays.

    public class Concesionario { public static void main(String[] args) { Coche coches[] = new Coche[10]; Coche motos[] = new Moto[10]; } }

    HERENCIA

    public class Vehículo { .... } public class Coche extends Vehículo { .... }

    La clase derivada puede acceder a todos los atributos y métodos de la superclase, salvo que sean definidos como privados.

    LA CLASE OBJECT

    Toda clase deriva de otra. Si una clase no extiende explícitamente a otra, deriva de java.lang.Object, la raíz de toda jerarquía de clases de Java.

    SUPER

    Se puede usar la palabra "super" para llamar al constructor de la superclase. Por ejemplo: super(arg1,arg2);

    NOTA: super debe ser la primer sentencia.

    COMPATIBILIDAD ENTRE SUPERCLASE Y CLASE DERIVADA

    Compatibilidad ascendente: un objeto de la superclase puede contener un objeto de clase derivada:

    Persona unaPersona; Alumno alumnoHarry = new Alumno("Harry", "Potter", 19, "Android"); unaPersona = alumnoHarry; Persona otraPersona = new Alumno("Harry", "Potter", 19, "Android");

    Compatibilidad descendente:

    Persona otraPersona = new Alumno("Harry", "Potter", 19, "Android"); Alumno harry = (Alumno) otraPersona;

    Comprobación de clase: instanceof

    Persona otraPersona = new Alumno("Harry", "Potter", 19, "Android"); if (otraPersona instanceof Alumno) { Alumno harry = (Alumno)otraPersona; }

    REDEFINIR MÉTODOS EN LA CLASE DERIVADA (SOBRECARGA)

    Al redefinir en la clase derivada, podemos asignar un nivel de acceso más público pero no menos.

    Derecho Superclase Derecho Clase Derivada ====================================================== privado privado, protected, de paquete, público de paquete de paquete, protected, público protected protected, público público público

    EL MODIFICADOR FINAL

    • Delante de una clase: no se puede heredar
    • Delante de una variable: no se puede cambiar (constante)
    • Delante de un método: no se puede sobrecargar
    • Delante de un parámetro de un método: el método no puede cambiar su valor.

    POLIMORFISMO

    Una referencia a una clase es capaz de servir de referencia a cualquiera de sus clases derivadas.

    class A { } class B extends A { void d() {} } class C { public static void main(String[] args) { A a = new A(); B b = (B) a; b.d(); } }

    CLASES Y MÉTODOS ABSTRACTOS

    Sirve para crear interfaces indefinidas. Se usa abstract.

    public abstract class NombreDeLaClase { ... }
    • Un método abstracto debe tener abstract delante (está sin definir)
    • Un método abstracto debe ser definido en las clases derivadas o bien definida como abstracta otra vez.
    • Un método abstracto solo se puede definir en una clase abstracta.
    • Una clase abstract puede puede tener métodos que no son abstract.

    INTERFACES

    • Conjunto de declaraciones de métodos (sin definir)
    • interface InstrumentoMusical { void tocar(); void afinar(); String tipoInstrumento(); }
    • Se pueden definir constantes:
      • public final static
      • inicializadas en la declaración
    • No es necesario poner public, ni se pueden cambiar sus derechos de acceso.
    • Las clases que implementan la interfaz tiene que definir los métodos de la interface.
    class InstrumentoViento extends Object implements InstrumentoMusical { void tocar() { . . . }; void afinar() { . . .}; String tipoInstrumento() {} } class Guitarra extends InstrumentoViento { String tipoInstrumento() { return "Guitarra"; } }

    Una clase que implementa una interfaz puede ser derivada de otra.

    EXCEPCIONES

    public class ExcepcionGetCurso extends Exception{ private static final long serialVersionUID = 2640934169135364818L; public ExcepcionGetCurso(String mensaje){ super(mensaje); } }
    try { idCurso = modeloCurso.getIdPorNombre(db, contenCurso); } catch (ExcepcionGetCurso e) { // Si no existe el curso, lo insertamos. idCurso = modeloCurso.insertar(db, contenCurso); } finally{ //Código de finally }

    El método tradicional es con valores de error, pero el programador termina ignorando este valor.

    Las excepciones utilizan objetos. Cuando ocurre una excepción, se crea un objeto que representa la excepción. El objeto es "lanzado" para buscar una manjador de la excepción:

    • Si se trata de un error, la aplicación no debería proveer un manejador.
    • En otro caso, se busca un manejador que pueda buscar una solución. En caso contrario, la máquina virtual finaliza la aplicación. Java proporciona una jerarquía de clases que representan diferentes tipos de excepciones, con origen en java.lang.Throwable.

    Cuando Java no provee una excepción adecuada para el problema que quiero chequear, tengo que fabricarme mi propia clase de excepción. Esta clase hereda de Exception.

    NOTA: La clase exception tiene varios constructores, uno de ellos toma como argumento una cadena de texto con el mensaje del problema.

    public class ExcepcionFormatoNoValido extends Exception { private String formatoEsperado; private String formatoExistente; public ExcepcionFormatoNoValido(String formatoEsperado, String formatoExistente) { this.formatoEsperado = formatoEsperado; this.formatoExistente = formatoExistente; } public String getFormatoEsperado() { return formatoEsperado; } public String getFormatoEsperado() { return formatoExistente; } }

    LANZAR EXCEPCIONES

    // Ejemplo 1 public static void convert(String srcName, String dstName) throws ExcepcionFormatoNoValido { if (srcName == null) throw new NullPointerException(srcName + " is null"); if (dstName == null) throw new NullPointerException(dstName + " is null"); //NullPointerException es un error y por eso no aparece //en la cláusula throws del método convert. String expectedFormat = "RM"; String existingFormat = "WAVE"; throw new ExcepcionFormatoNoValido(expectedFormat,existingFormat); }
    // Ejemplo 2. public static double sqrt(double x) { if (x < 0) throw new IllegalArgumentException(x + " is negative"); }

    MANEJAR EXCEPCIONES

    La intención de manejar excepciones está en usar try/catch.

    public static void main(String[] args) { if (args.length != 2) { System.err.println("usage: java Converter srcfile dstfile"); return; } try { Media.convert(args[0], args[1]); } catch (ExcepcionFormatoNoValido efnv) { System.out.println("Imposible convertir " + args[0] + " a " + args[1]); System.out.println("Esperando que " + args[0] + " sea del format " + efnv.getFormatoEsperado()); } catch (FileNotFoundException fnfe) { } catch (IOException ioe) { } }

    CLÁUSULA FINALLY

    FileInputStream fis = null; try { fis = new FileInputStream(args[0]); FileOutputStream fos = null; try { fos = new FileOutputStream(args[1]); int b; // I chose b instead of byte because byte is a reserved //word. while ((b = fis.read()) != -1) fos.write(b); } catch (FileNotFoundException fnfe) { String msg = args[1] + " could not be created, possibly because " + "it might be a directory"; System.err.println(msg); } catch (IOException ioe) { String msg = args[0] + " could not be read, or " + args[1] + " could not be written"; System.err.println(msg); } finally { if (fos != null) try { fos.close(); } catch (IOException ioe) { System.err.println("unable to close " + args[1]); } } } catch (FileNotFoundException fnfe) { String msg = args[0] + " could not be found or might be a directory"; System.err.println(msg); } finally { if (fis != null) try { fis.close(); } catch (IOException ioe) { System.err.println("unable to close " + args[0]); } }

    En resumen:

    • Hace falta una clase para la excepción. Por ejemplo, MiExcepcion
    • Hace falta una función que lanza la excepción. Por ejemplo, funcionQueLanza().
    • Hace falta una función que hace un try/catch.

    En el ejemplo siguiente hay:

    • una clase de excepción, llamada MiExcepcion.
    • una función que lanza la excepción, llamada lanzador.
    • una función (main) que hace try/catch.
    // MiExcepcion.java package excepciones; public class MiExcepcion extends Exception { public MiExcepcion(String msg) { super(msg); } } ------------------------------- // Prueba.java package prueba; import excepciones.*; public class Prueba { public static void lanzador (int i) throws MiExcepcion { if (i < 0) { throw new MiExcepcion("El número es menor de 0"); } } public static void main(String[] args) { // TODO Auto-generated method stub System.out.println("Empezamos."); int numero = -2; try { lanzador(numero); } catch (MiExcepcion me) { System.out.println("Excepción capturada: " + me.getMessage()); } } }

    COLECCIONES

    import java.util.ArrayList; import java.util.List; List<String> ls = new ArrayList<String>();

    ITERADORES

    // Declaración el ArrayList ArrayList<String> nombreArrayList = new ArrayList<String>(); // Añadimos 10 Elementos en el ArrayList for (int i=1; i<=10; i++){ nombreArrayList.add("Elemento "+i); } // Añadimos un nuevo elemento al ArrayList en la posición 2 nombreArrayList.add(2, "Elemento 3"); // Declaramos el Iterador e imprimimos los Elementos del ArrayList Iterator<String> nombreIterator = nombreArrayList.iterator(); while(nombreIterator.hasNext()){ String elemento = nombreIterator.next(); System.out.print(elemento+" / "); }