Los errores en tiempo de ejecución (cuando se esta ejecutando el programa) se denominan excepciones, y

esto ocurre cuando se produce un error en alguna de las instrucciones de nuestro programa, como por
ejemplo cuando se hace una división entre cero, cuando un objeto es 'null' y no puede serlo, cuando no se
abre correctamente un fichero, etc. Cuando se produce una excepción se muestra en la pantalla un mensaje
de error y finaliza la ejecución del programa.

En Java (al igual que en otros lenguajes de programación), existen mucho tipos de excepciones y enumerar
cada uno de ellos sería casi una labor infinita. En lo referente a las excepciones hay que decir que se
aprenden a base experiencia, de encontrarte con ellas y de saber solucionarlas.

Cuando en Java se produce una excepción se crear un objeto de una determina clase (dependiendo del tipo
de error que se haya producido), que mantendrá la información sobre el error producido y nos proporcionará
los métodos necesarios para obtener dicha información. Estas clases tienen como clase padre la
clase Throwable, por tanto se mantiene una jerarquía en las excepciones. A continuación mostramos
algunas de las clases para que nos hagamos una idea de la jerarquía que siguen las excepciones, pero existen
muchísimas más excepciones que las que mostramos:
A continuación vamos a mostrar un ejemplo de como al hacer una división entre cero, se produce una
excepción. Veamos la siguiente imagen en el que podemos ver un fragmento de código y el resultado de la
ejecución del código:

Como vemos en nuestro programa tenemos 3 instrucciones. La primera debe de imprimir por pantalla el
mensaje "ANTES DE HACER LA DIVISIÓN", la segunda debe de hacer la división y la última debe de
imprimir por pantalla el mensaje "DESPUES DE HACER LA DIVISIÓN". La primera instrucción la
ejecuta perfectamente, pero al llegar a la segunda se produce una "ArithmeticException" (excepción de la
clase ArithmeticException) y se detiene la ejecución del programa ya que estamos dividiendo un número
entre '0'.

Java nos permite hacer un control de las excepciones para que nuestro programa no se pare inesperadamente
y aunque se produzca una excepción, nuestro programa siga su ejecución. Para ello tenemos la estructura
"try – catch – finally" que la mostramos a continuación:
Respecto a la estructura "try – catch – finally", se ha de decir que primero se ejecuta el bloque "try", si
se produce una excepción se ejecuta el bloque "catch" y por último el bloque "finally".

En esta estructura se puede omitir el bloque "catch" o el bloque "finally", pero no ambos.

Conociendo la estructura, podemos reescribir nuestro programa para que se ejecuten las tres instrucciones
aunque se produzca una excepción. Previamente debemos de saber cuál va a ser la clase de la excepción
que puede aparecer que sería la "ArithmeticException" para definirla en la parte del "catch". Nuestro
programa quedaría de la siguiente forma y se ejecutaría sin problema obteniendo también la información de
la excepción:

public class Principal

{
public static int numerador = 10;
public static int denominador =0;
public static float division;

public static void main (String[] args)

{
System.out.println("Antes de HACER LA DIVISIÓN");
try
{
division = numerador / denominador;
}
catch (ArithmeticException ex)
{
division = 6;// Si se produce la exepción doy valor de 0 a la variable division
System.out.println("Error " +ex.getMessage());
}
finally
{
System.out.println("División "+ division);

System.out.println("DESPPUES de HACER LA DIVISIÓN");

}
}

}
Como vemos capturamos la excepción en un objeto "ex" de la clase "ArithmeticException" y podemos
obtener el mensaje de error que nos da la excepción. Vemos también que el programa termina su ejecución
aunque se haya producido una excepción.

Dentro de una misma estructura podemos definir todas las excepciones que queramos. En el caso
anterior hemos definido solo la excepción "ArithmeticException"; pero por ejemplo, podemos definir
también la excepción "NullPointerException", por si nos viene un valor a 'null' al hacer la división:

public class Principal

{
public static int numerador = 10;
public static Integer denominador = null;
public static float division;

public static void main(String[] args)

{

System.out.println("Antes de HACER LA DIVISIÓN");

try
{
division = numerador / denominador;

}
catch (ArithmeticException ex)
{
division = 0;// Si se produce la exepción doy valor de 0 a la variable division
System.out.println("Error " +ex.getMessage());
 }
catch (NullPointerException ex )
{
division = 1;
System.out.println("Error " +ex.getMessage());
}

finally
{
System.out.println("División "+ division);

System.out.println("DESPPUES de HACER LA DIVISIÓN");

}
}

En resumen, hemos puesto en esta entrada un ejemplo muy sencillo para controlar un par de excepciones
bastante obvias como la división entre '0' y un 'null', que perfectamente lo podríamos haber controlado con
una sentencia de control "if" mirando el contenido de los atributos, pero la finalidad de esta entrada era ver
como controlar las excepciones con la estructura "try – catch – finally", que si lo sabemos utilizar nuestro
programa deberá seguir funcionando aunque se produzcan excepciones. Decir también que es casi imposible
aprenderse todas las excepciones que hay en Java. De acuerdo a lo que se vaya aprendiendo en el
desarrollo en java.
 EJEMPLO 1:

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class EntradaJava

{
 public static void main(String[] args) throws IOException
{
//Notar que readLine() nos obliga a declarar IOException
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); //Ya tenemos
el "lector"

System.out.println("Por favor ingrese su nombre");//Se pide un dato al usuario

String nombre = br.readLine(); //Se lee el nombre con readLine() que retorna un String
con el dato

System.out.println("Bienvenido " + nombre + ". Por favor ingrese su edad");//Se pide

otro dato al usuario
String entrada = br.readLine(); //Se guarda la entrada (edad) en una variable

//Nótese que readLine siempre retorna String y la clase BufferedReader...

//no tiene un método para leer enteros, así que debemos convertirlo.

int edad = Integer.parseInt(entrada);//Se transforma la entrada anterior en un entero

//Si el usuario ingresó solo números funcionará bien, de lo contrario generará una
excepción

System.out.println("Gracias " + nombre + " en 10 años usted tendrá " + (edad + 10) + "
años."); //Operacion numerica con la edad
}
}
 EJEMPLO 2:

import java.util.Scanner;

public class EntradaJava2

{

public static void main(String[] args)

{
// TODO Auto-generated method stub
Scanner sc = new Scanner(System.in); //Se crea el lector

System.out.println("Por favor ingrese su nombre");//Se pide un dato al usuario

String nombre = sc.nextLine(); //Se lee el nombre con nextLine() que retorna un String
con el dato

System.out.println("Bienvenido " + nombre + ". Por favor ingrese su edad");//Se pide

otro dato al usuario

int edad = sc.nextInt(); //Se guarda la edad directamente con nextInt()

//Nótese que ya no hubo necesidad de usar parseInt() pues nextInt nos retorna un entero
derectamente

System.out.println("Gracias " + nombre + " en 10 años usted tendrá " + (edad + 10) + "
años."); //Operacion numerica con la edad
}

}
 EJEMPLO 1:

Definir una clase DiaAnyo que contenga los atributos mes y día, el método igual() y el método visualizar(). El mes se
registra como un valor entero (1, Enero; 2, Febrero; etc.). El día del mes se registra en la variable entera día. Escribir
un programa que compruebe si una fecha es la de su cumpleaños.

El método main() de la clase principal, crea un objeto DiaAnyo y llama al método igual() para determinar si coincide
la fecha del objeto con la fecha de su cumpleaños, que se ha leído del dispositivo de entrada
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class DiaAnyo

{

private int mes;

private int dia;
public DiaAnyo(int d, int m)
{
dia = d;
mes = m;
}
public boolean igual(DiaAnyo d)
{
if ((dia == d.dia) && (mes == d.mes))
return true;
else
return false;
}
// muestra en pantalla el mes y el día
public void visualizar()
{
System.out.println("mes = " + mes + " , dia = " + dia);
}

public static void main(String[] args) throws IOException

{
// TODO Auto-generated method stub
DiaAnyo hoy;
DiaAnyo cumpleanyos;
int d, m;
BufferedReader entrada = new BufferedReader(new InputStreamReader(System.in));

System.out.print("Introduzca fecha de hoy, dia: ");

d = Integer.parseInt(entrada.readLine());
System.out.print("Introduzca el número de mes: ");
m = Integer.parseInt(entrada.readLine());
hoy = new DiaAnyo(d,m);

System.out.print("Introduzca su fecha de nacimiento, dia: ");

d = Integer.parseInt(entrada.readLine());
System.out.print("Introduzca el número de mes: ");
m = Integer.parseInt(entrada.readLine());
cumpleanyos = new DiaAnyo(d,m);

System.out.print( " La fecha de hoy es ");

hoy.visualizar();
System.out.print( " Su fecha de nacimiento es ");
cumpleanyos.visualizar();
 if (hoy.igual(cumpleanyos))
System.out.println( "¡Feliz cumpleaños ! ");
else
System.out.println( "¡Feliz dia ! ");
}

}
Motor:
public class Motor
{
private int limitrpm;
private double currentrpm;
public int getLimitrpm()
{
return limitrpm;
}
public void setLimitrpm(int limitrpm)
{
this.limitrpm = limitrpm;
}
public double getCurrentrpm()
{
return currentrpm;
}

Vehículo:
public class vehiculo
{
private String brand;
private String model;
private int year;
private Motor engine;
public String getBrand() {
return brand;
}
public void setBrand(String brand) {
this.brand = brand;
}
public String getModel() {
return model;
}
public void setModel(String model) {
this.model = model;
}
public int getYear() {
return year;
}
public void setYear(int year) {
this.year = year;
}

public Motor getEngine() {

return engine;
 }
public void setEngine(Motor engine) {
this.engine = engine;
}
public void Acelerar (int rpm)
{
this.engine.VariarRpm(rpm,true);
}
public void Desacelerar(int rpm){
this.engine.VariarRpm(rpm,false);
}
public void Mostrar() {
System.out.println("Modelo del vehículo: " + this.model);
System.out.println("Marca del Vehículo: " + this.brand);
System.out.println("Año del Vehículo: " + this.year);
}
}

Main
public class Main
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
vehiculo v = new vehiculo ();
v.setBrand ("Ford");
v.setModel ("F-150");
v.setYear (1997);

Motor m = new Motor ();

m.setLimitrpm (500);
m.setCurrentrpm (0);
v.setEngine(m);

v.Mostrar();
System.out.println();

v.Acelerar(350);
System.out.println("Sus RPM son: " + m.getCurrentrpm());
v.getEngine().ControlarRPM();
m.Enfriamiento();
System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.Acelerar(860);
System.out.println("Sus RPM son: " + m.getCurrentrpm());
v.getEngine().ControlarRPM();
 m.Enfriamiento();
System.out.println("Sus RPM son: " + m.getCurrentrpm());

/*
v.Acelerar(-350);

System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.getEngine().ControlarRPM();
v.Acelerar(-700);

System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.getEngine().ControlarRPM();
v.Acelerar(860);

System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.getEngine().ControlarRPM();
v.Acelerar(175);

System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.getEngine().ControlarRPM();
v.Acelerar(450);

System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.getEngine().ControlarRPM();
v.Acelerar(900);

System.out.println("Sus RPM son: " + m.getCurrentrpm());

v.getEngine().ControlarRPM();

*/

}
package paquetes.carpetapaquetes.main;

Estudiante: package paquetes.carpetapaquetes.holamundo;

Novia: package paquetes.carpetapaquetes.holamundo;

Universidad:
package paquetes.carpetapaquetes.main;
import javax.swing.JOptionPane;

import paquetes.carpetapaquetes.holamundo.Estudiante;;

public class Universidad

{

public static void main(String[] args)

{

Estudiante objEstudiante = new Estudiante("Jose Luis Carrillo", 18, 1.75, "Anabel Lopez");
JOptionPane.showMessageDialog(null, "Nombre del Estudiante"+objEstudiante.getNombreEst()+"\n
Nombre de la Novia:"+objEstudiante.getObjNovia().getNomNovia());
}

}
Estudiante:
package paquetes.carpetapaquetes.holamundo;

public class Estudiante

{
//Atributos:
private String nombreEst;
private int edadEst;
private double estaturaEst;
private Novia objNovia;

public Estudiante(String nombreEst, int edadEst, double estaturaEst, String nomNovia) {

super();
this.nombreEst = nombreEst;
this.edadEst = edadEst;
this.estaturaEst = estaturaEst;
objNovia = new Novia(nomNovia);
}

public String getNombreEst() {

return nombreEst;
}

public void setNombreEst(String nombreEst) {

this.nombreEst = nombreEst;
}

public int getEdadEst() {

return edadEst;
}

public void setEdadEst(int edadEst) {

this.edadEst = edadEst;
}

public double getEstaturaEst() {

return estaturaEst;
}

public void setEstaturaEst(double estaturaEst) {

this.estaturaEst = estaturaEst;
}

public Novia getObjNovia() {

return objNovia;
}
}
Novia:
package paquetes.carpetapaquetes.holamundo;

public class Novia

{
//Atributos:
private String nomNovia;

public Novia(String nomNovia) {

this.nomNovia = nomNovia;
}

public String getNomNovia() {

return nomNovia;
}

public void setNomNovia(String nomNovia) {

this.nomNovia = nomNovia;
}

}
 EJEMPLO 1:

import java.util.Arrays;

public class EjemploArreglo

{
public static void main(String[] args)
{
// TODO Auto-generated method stub
int [ ] miArray1 = {2, -4, 3, -7};
for (int i=0; i<miArray1.length; i++) {
System.out.print ("miArray1[" + i +"]= " + miArray1[i]+"; ");}
System.out.println ("");
int [ ] otroArray = {2, -4, 3, -7};
for (int i=0; i<otroArray.length; i++) {
System.out.print ("otroArray[" + i +"]= " + otroArray[i]+"; ");}
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " +
Arrays.equals(miArray1, otroArray) );
otroArray = miArray1; //otroArray pasa a ser el mismo objeto que miArray1
for (int i=0; i<otroArray.length; i++) { System.out.print ("otroArray[" + i
+"]= " + otroArray[i]+"; "); }
System.out.println ("¿Son el mismo objeto? ... " + (miArray1==otroArray) );
System.out.println ("¿Tienen el mismo contenido (relación de igualdad)? ... " +
Arrays.equals(miArray1, otroArray) );

}
 EJEMPLO 2:
import java.util.Arrays;
public class PruebaApp
{
public static void main(String[] args)
{
// TODO Auto-generated method stub
int num[]={8, 10, 15, 20, 21, 25, 30, 32, 40, 41};

//Devuelve un 4
System.out.println("Metodo binarySearch: "+Arrays.binarySearch(num, 21));

//Copia el array num hasta la quinta posicion(este ultimo no incluido), devuelve un array
int num2[]=Arrays.copyOf(num, 4);

System.out.println("Metodo copyOf ");

//Lo recorremos para ver que lo realiza correctamente
muestraArray(num2);

//Copia el array num de la tercera hasta la octava posicion, devuelve un array

int num3[]=Arrays.copyOfRange(num, 2, 6);
System.out.println("Metodo copyOfRange");
muestraArray(num3);

//Compara si num1 y num2 no son iguales

System.out.println("Metodo equals: "+Arrays.equals(num, num2));

System.out.println("Metodo fill");
Arrays.fill(num3, 5);
muestraArray(num3);

System.out.println("Metodo toString");
System.out.println(Arrays.toString(num));
 }

public static void muestraArray(int num[])

{

for (int i=0;i<num.length;i++)

{
System.out.println(num[i]);
}

}
 EJEMPLO 1:

import java.util.Scanner;

Principal:
public class Principal
{
public static void main(String[] args)
{
Scanner leer = new Scanner(System.in);
//Arreglos Normales
String arreglo[] = new String[10];
int numero[] = new int[10];

// Arreglo de Objetos
Alumnos alumno[] = new Alumnos[2];
/*Lo que hariamos si fuese un tipo arreglo.
alumno[0].setMatricula(13);
alumno[0].setNombre("Milton Eduardo");
alumno[0].getMatricula();
alumno[0].getMatricula();
*/
String nombre ="";
int matricula = 0;
char grupo=' ';
int grado = 0;

for (int i=0; i<alumno.length; i++)

{
System.out.println("Ingresa tu nombre:");
nombre = leer.nextLine();
System.out.println("Ingresa tu matricula:");
matricula = leer.nextInt();
System.out.println("Ingresa tu grupo:");
//toma el primer caracter:
grupo = leer.next().charAt(0);
System.out.println("Ingresa tu grado:");
grado = leer.nextInt();
//Da un error Debemos encerar el buffer
leer.nextLine();

//PARA PASAR AL ARREGLO OBJETOS

alumno[i] = new Alumnos(nombre, matricula, grupo, grado);
 }

for (int i=0; i<alumno.length; i++)

{
System.out.println("ARREGLOS DE OBJETOS POSEE:");
System.out.println(alumno[i].getNombre()+" "+alumno[i].getMatricula()+
" "+alumno[i].getGrado()+""+alumno[i].getGrupo());
}
}

EJEMPLO 2:
package ArrayList;

public class UsoEmpleado

{
public static void main(String[] args)
{
// TODO Auto-generated method stub
Empleado A[] = new Empleado[3];
A[0]=new Empleado("Andres",23,2500);
A[1]=new Empleado("María",66,2000);
A[2]=new Empleado("Jóse",31,1500);

for(Empleado e: A)
{
System.out.println(e.dameDatos());
}
}

}
class Empleado
{
public String nombre;
int edad;
double salario;

public Empleado (String nombre, int edad, double salario)

{

this.nombre = nombre;
this.edad = edad;
this.salario = salario;
}

public String dameDatos()

{
return "El empleado se llama" + this.nombre + "Tiene" + this.edad + "años" + "Y un salario
de"+this.salario;
}

}
EJEMPLO 3:
Si deseo almacenar más de tres elementos: Redefino Empleado A[] = new Empleado[3];

Nota utilizamos el packete: import java.util.*;

package ArrayList;
import java.util.*;

public class UsoEmpleado

{
public static void main(String[] args)
{
// TODO Auto-generated method stub
/*Empleado A[] = new Empleado[3];
A[0]=new Empleado("Andres",23,2500);
A[1]=new Empleado("María",66,2000);
A[2]=new Empleado("Jóse",31,1500);
*/
//ArraList<TIPO DE DATO> NOMBRE <TIPO DE DATO A ALMACENAR>
ArrayList <Empleado> A=new ArrayList<Empleado>();
//METODO ADD AGREGAR ELEMENTOS:
A.add(new Empleado("Andres",23,2500));
A.add(new Empleado("María",66,2000));
A.add(new Empleado("Jóse",31,1500));
//AÑADIMOS OTRO Y SE VA AÑADIENDO DINÁMICAMENTE
A.add(new Empleado("Stefano",42,2000));
A.add(new Empleado("Andre",32,2000));
A.add(new Empleado("Pedro",32,2000));
A.add(new Empleado("Juan",22,2000));
A.add(new Empleado("Samuel",22,2000));
A.add(new Empleado("Eduardo",25,2000));
A.add(new Empleado("Felipe",55,2000));
A.add(new Empleado("Miguel",51,2000));
A.add(new Empleado("Martha",32,2000));
A.add(new Empleado("Angelica",12,2000));
A.add(new Empleado("Elizabeth",12,2000));
A.add(new Empleado("Josefina",12,2000));
A.add(new Empleado("Andromeda",12,2000));
A.add(new Empleado("Vanesa",11,2000));
A.add(new Empleado("Verónica",66,2000));
A.add(new Empleado("Sonia",64,2000));
A.add(new Empleado("Stefano",46,2000));

System.out.println(A.size());
for(Empleado e: A)
{
System.out.println(e.dameDatos());
}
}

class Empleado
{
public String nombre;
int edad;
 double salario;

public Empleado (String nombre, int edad, double salario)

{

this.nombre = nombre;
this.edad = edad;
this.salario = salario;
}

public String dameDatos()

{
return "El empleado se llama" + this.nombre + "Tiene" + this.edad + "años" +
"Y un salario de "+this.salario;
}
}
Ejemplo de código fuente en Java, para obtener la fecha, el día, el mes, el año, la hora,
el minuto y el segundo, actual del sistema.

Lo que haremos es mediante la clase Date, obtener la fecha actual del sistema, y después
mediante las clases DateFormat y SimpleDateFormat, formatearemos esas fechas y horas a nuestro
gusto (a formato español vamos).

Otra forma de obtener la fecha sería mediante la clase Calendar con la que obtendremos mediante
los métodos que trae, el desglosamiento de esa fecha en: el día, el mes, el año, las horas, los
minutos y los segundos. En este caso, tengo que puntualizar que cuando se consigue el mes
mediante el método Calendar.MONTH, hay que sumarle +1 mes, ya que este método comienza a contar
con índice = 0 y por tanto nos devolvería Enero = 0 y Diciembre = 11

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;

public class FechaHora {

public static void main(String[] args)

{
//Fecha actual en formato completo:
//Wed Nov 15 11:40:27 COT 2017
Date fechaActual = new Date();
System.out.println(fechaActual);
System.out.println("---------------------------------------------");

//Formateando la fecha:
DateFormat formatoHora = new SimpleDateFormat("HH:mm:ss");
DateFormat formatoFecha = new SimpleDateFormat("dd/MM/yyyy");
System.out.println("Son las: "+formatoHora.format(fechaActual)+" de fecha:
"+formatoFecha.format(fechaActual));

//Fecha actual desglosada:

Calendar fecha = Calendar.getInstance();
int año = fecha.get(Calendar.YEAR);
int mes = fecha.get(Calendar.MONTH) + 1;
int dia = fecha.get(Calendar.DAY_OF_MONTH);
int hora = fecha.get(Calendar.HOUR_OF_DAY);
int minuto = fecha.get(Calendar.MINUTE);
int segundo = fecha.get(Calendar.SECOND);
 System.out.println("Fecha Actual: "+ dia + "/" + (mes) + "/" + año);
System.out.printf("Hora Actual: %02d:%02d:%02d %n", hora, minuto, segundo);
System.out.println("-------------Fecha desglosada----------------");
System.out.println("El año es: "+ año);
System.out.println("El mes es: "+ mes);
System.out.println("El día es: "+ dia);
System.out.printf("La hora es: %02d %n", hora);
System.out.printf("El minuto es: %02d %n", minuto);
System.out.printf("El segundo es: %02d %n", segundo);
}