Clase Object 

 
Todas las clases en Java heredan implícitamente de la clase Object. De esta forma, Object es la 
raíz de la jerarquía de herencia (de implementación) en Java. 
 
Object define un conjunto de métodos útiles, que pueden ser redefinidos en cada clase. En 
particular: 
• public boolean equals(Object o): Permite definir el criterio de igualdad utilizado para 
los objetos de una determinada clase (el operador == únicamente chequea la igualdad 
de referencias). En Object, equals se define directamente como la  identidad de 
referencias. 
• public String toString(): Permite decidir la representación externa de un objeto como 
una cadena. Por defecto es el valor de su referencia, etiquetada con el nombre de la 
clase. 
• public int hashCode() devuelve (con alta probabilidad) un valor distinto para cada 
objeto  
• protected Object clone() throws CloneNotSuportedException devuelve una copia 
binaria del objeto (incluyendo sus referencias)  
• public final Class getClass() devuelve el objeto del tipo Class que representa dicha clase 
durante la ejecución  
• protected void finalize() throws Throwable se usa para finalizar el objeto, es decir, se 
avisa al administrador de la memoria que ya no se usa dicho objeto, y se puede 
ejecutar código especial antes de que se libere la memoria. 
 
Clone 
 
Crea un objeto que es copia “superficial” del objeto actual independientemente de su tipo. 
• El tipo objeto a copiar debe haber declarado que es susceptible de copia 
implementando el interfaz vacío Clonable. 
• Es un método protegido de Object, por tanto para que pueda ser invocado desde otro 
paquete hay que redeclararlo como público y simplemente invocar a la clase base. 
Ejemplo: 
 
public class ClaseClonable {
// Otro código de la clase
public Object clone () throws CloneNotSupportedException{
return super.clone();
}
}

• Si los miembros de una clase son otros objetos que necesiten “copia profunda” habrá 
que añadir el código necesario. 
o  Llamada a los métodos clone() de cada uno de los objetos implicados para 
crear una copia 
• Reglas generales 
o Implementar el interfaz Cloneable si se desea que la clase se pueda copiar 
o No utilizar constructores en la implementación de clone() si no llamadas a los 
métodos clone() de los otros objetos a copiar. 
o Puede existir problemas en el tipo de objeto creado 
• Cuidado todas las subclases de una clase Clonable también son susceptibles de ser 
clonadas. 
o Deben reescribir el método clone() 
 
 
public class Alumno {
String nombre;
String apellidos;
public Alumno(String nombre, String apellidos){
this.nombre= nombre;
this.apellidos= apellidos;
}
public boolean equals(Alumno al){
if (apellidos.equals(al.apellidos))
return true;
else
return false;
}
public String toString(){
return nombre + " " + apellidos + " ";
}
public static void main(String args[]) {
Alumno alum = new Alumno("Julian", "Fernandez");
Class tipoObjeto = alum.getClass();
System.out.println("nombre de la clase: " +
tipoObjeto.getName());
Alumno alum2 = alum;
alum2.apellidos = "Rodriguez";

System.out.println("son el mismo objeto?:"+ (alum==alum2));

alum2 = new Alumno("Antonio", "Rodriguez");
System.out.println("son iguales los objetos?:"+
alum.equals(alum2));

Alumno alum3;
try {
alum3 = (Alumno)alum.clone();
alum.nombre="Fran";
alum3.nombre="Moises";
System.out.println("objetos: "+ alum + alum3);
}catch (CloneNotSupportedException e){
System.out.println("no tiene implementada la
clonacion");
}
}
} 
 
Manejo de excepciones 
 
Introducción 
 
¿Qué es el Manejo de Excepciones? 
 
El manejo de excepciones es un mecanismo de java, que permite definir acciones a realizar en 
caso  de  producirse  una  situaciones  anomala  (excepción)  producida  durante  la  ejecución  del 
programa. 
 
La  acción  a  realizar  suele  consistir  en  una  acción  correctiva,  o  la  generación  de  un  informe 
acerca del error producido. 
 
¿Cómo se implementa? 
  
Para la gestión de excepciones incorpora en sus bibliotecas la capacidad de detectar y notificar 
errores. 
Cuando un error es detectado se siguen estas acciones: 
 
1. Se interrumpe la ejecución del código en curso. 
2. Se  crea  un  objeto  excepción  que  contiene  información  del  problema.  Esta  acción  es 
conocida  como  "lanzar  una  excepción".  Existe  un  mecanismo  estandar  de  gestión  de 
error 
3. Si hay un manejador de excepciones en el contexto actual le transfiere el control. En 
caso contrario, pasa la referencia del objeto excepción al contexto anterior en la pila 
de llamadas. 
4. Si no hay ningún manejador capaz de gestionar la excepción, el hilo que la generó es 
terminado. 
 
Por ejemplo, si intentamos leer un fichero inexistente usando la clase FileReader del lenguaje 
Java, la implementación de la propia clase detectará el problema, y lanzará una excepción de 
tipo FileNotFoundException. 
 
Implementación en Java 
 
La captura de excepciones se implementa en el lenguaje Java con el bloque try/catch/finally. 
 
try {
// código sospechoso de producir excepciones
} catch(Exception e){
// registra el error y/o relanza la excepción
} finally {
// libera recursos
}
 
La excepción a capturar puede ser cualquier subclase de Throwable. 
El  código  del  finally  se  ejecutará  siempre.  Una  excepción  en  el  try,  o  en  el  bloque  catch  no 
impedirán su ejecución. 
Si  el  bloque  finally  lanza  una  excepción,  quedarán  descartadas  excepciones  anteriores.  Es 
decir, una excepción en el finally oculta excepciones anteriores. 
 
Throwable 
 
Throwable es la superclase de todos los objetos excepción:  
java.lang.Object 
    java.lang.Throwable 
        java.lang.Exception 
            java.lang.RuntimeException 
 
Según su superclase, hay dos tipos de excepciones:  
 
Checked: el programa no compila si no existe un manejador de excepciones. Son las subclases 
de Exception que no son subclases de RuntimeException.  
Unchecked: su captura no es obligatoria. Son las subclases de RuntimeException. 
 
Throwable (String): Constructor que asigna un mensaje al objeto. 
 
En el constructor de Throwable se puede especificar:  
Un mensaje indicando el motivo de la excepción.  
Una referencia a otro objeto Throwable asociado (solo desde 1.4). Esto permite indicar que la 
causa de esta excepción fue otra. 
 
Throwable()  
Throwable(String message)  
Throwable(Throwable cause)  // 1.4 
Throwable(String message, Throwable cause)  // 1.4 
 
El  método  getStackTrace()  devuelve  un  array  de  elementos  StackTraceElement,  que 
representan  cada  uno  (excepto  el  primero  en  la  pila)  una  llamada  a  un  método.  Cuando 
ejecutamos Throwable.printStacktrace() obtenemos una representación como cadena de estos 
objetos. 
 
Métodos 
 
 
Cuando una excepción no se procesa hasta el final, el programa se interrumpe y se ejecuta 
printStackTrace(). 
 
Método  Descripción 
getMessage ()  Devuelve el mensaje del Objeto. 
toString()  Devuelve  un  String  incluyendo  la  clase  del  objeto  más  el 
mensaje. 
printStackTrace()  Escribe la traza de ejecución en el standard error. 
getStackTrace ()  Obtiene la información que imprime printStackTrace. 
 
 
Declarar excepciones 
 
La palabra reservada throws permite a un método declarar las listas de excepciones (nombres 
de las clases de excepción separados por comas) que pueden lanzar. Esto tiene dos utilidades:  
 
1.‐ Dar información a los usuarios de la clase que proporciona este método sobre las 
cosas anormales que puede hacer el método. 
 
2.‐Escribir un método que lance una o más excepciones que no sean atrapadas por el 
propio método, sino por los métodos que lo llamen. 
 
Crear y lanzar excepciones 
 
En  Java  podemos  crear  nuestras  propias  excepciones.  Todos  los  tipos  de  excepción  se 
corresponden  con  una  clase  derivada  de  Throwable,  clase  raíz  de  la  jerarquía  de  clases  de 
excepciones  de  Java.  El  paquete  java.lang  proporciona  dos  subclases  de  Throwable  que 
agrupan las excepciones que se pueden lanzar, como consecuencia de los errores que pueden 
ocurrir en un programa, en dos clases: Error y Exception. Los errores que ocurren en la mayoría 
de  los  programas  se  corresponden  con  excepciones  de  alguna  de  las  subclases  de 
ExceptionError  reservada  para  el  tratamiento  de  los  errores  que  se  puedan  producir  en  la 
máquina virtual de Java. 
 
Ejemplo: 
 
 
public class ValorNoValido extends Exception{
public ValorNoValido(){}
public ValorNoValido(String mensaje){
super(mensaje);
}
} 
 

Estamos  utilizando  la  clase  anterior  para  crear  una  excepción  para  un  error  no  valido,  la 
superclase  es  Exception  e  implementa  dos  constructores,  uno  sin  parámetros  y  otro  con  un 
parámetro de tipo String. El parámetro de tipo String es el mensaje que devolverá el método 
getMessage heredado  de  la  clase  Throwable  a  través  de  Exception.  Para  ello  el  constructor 
ValorNoValido  debe  invocar  al  constructor  de  la  superclase  y  pasar  como  argumento  dicha 
cadena, la cual será almacenada como un miembro de datos de la clase Throwable.

Ejemplo de aplicación  

public class MiClase {

public void n(int x) throws ValorNoValido{
if(x==0)
throw new ValorNoValido("Error: valor cero");
}
}

Lanzar una excepción equivale a crear un objeto de ese tipo de excepción. En este ejemplo lo 
que  provoca  el  error  es  que  el  parámetro x  del  método  n  de  MiClase  es  0,  en  este  caso  el
método n lanza una excepción de la clase ValorNoValido creando un objeto de esta clase. Para 
crear (new) ese objeto se invoca al constructor ValorNoValido pasando como argumento, en 
este caso, la cadena "Error:valor cero";

public class Prueba {

public static void main(String[] args) {
MiClase mc = new MiClase();
try {
mc.n(0);
} catch (ValorNoValido e) {
e.printStackTrace();
}
}
}

Si un método n lanza una excepción debe declararlo, para que los usuarios de MiClase, que es 
quien proporciona el método n, estén informados sobre las cosas anormales que puede hacer 
dicho método. 

public class MiClase {

public void n(int x) throws ValorNoValido{
if(x==0)
throw new ValorNoValido("Error: valor cero");
 }
}

Otra alternativa es que el propio método que lanza la excepción la atrape como se muestra en 
el siguiente ejemplo:  

public class MiClase {

public void n(int x){
try {
if(x==0)
throw new ValorNoValido("Error: valor cero");
} catch (ValorNoValido e) {
e.printStackTrace();
}
}
} 

Escribir un método que lance una o más excepciones y él mismo las atrape es anticiparse a las 
necesidades que pueda tener el usuario de la clase que proporciona ese método, en cuanto al 
tratamiento de la excepción se refiere. 

Ejemplo
public class PruebaExcepcion{
public static void main(String [] args){
int [] a ={0,1,2,3,4,5};
try{
for (int i=0;i<6;i++){
System.out.println(“a[“+i+”]es “+a[i]);
}
}catch(excepcion e) {
System.out.println(“Excepcion: “ +e);
}
System.out.println(“Código que se puede ejecutar”);
}
}
 
Clase System 
 
La clase System permite acceder a los recursos del sistema independientes de la plataforma. 
Se declara como final, por lo que no es posible obtener subclases de ella. También declara sus 
métodos y variables como static (estático). De esta forma se consigue que esté disponible sin 
instanciarla.  
 
Los métodos de la clase System admiten varias aplicaciones. Una característica importante es 
la posibilidad de obtener la hora actual del sistema mediante el método currentTimeMillis.  
También pueden recuperarse y modificarse recursos del sistema mediante los métodos Get y  
Set  Properties.  El  aspecto  más  útil  de  la  clase  System  son  las  variables  que  declara.  Estas 
variables se emplean para interactuar con el sistema. Entre ellas, se encuentran in, out, err. 
 
• in representa el flujo de entrada estándar del sistema. 
• out representa el flujo de salida estándar.  
• err es el flujo de errores estándar. 
 
 Los flujos se tratan en la siguiente sección dedicada al paquete de E/S. 
 
Paquete I/O (E/S) 
 
El paquete java.io permite leer y escribir datos en distintos dispositivos. Las clases contenidas 
en él pueden dividirse en: 
 
• clases InputStream (flujo de entrada). 
• clases OutputStream (flujo de salida). 
• clases File (archivo). 
• clase StreamTokenizer. 
 
Clase Scanner 
 
 La clase Scanner permite crear objetos capaces de leer información desde una fuente de datos 
que puede ser un archivo, una cadena de caracteres, el teclado, etc. Los objetos de esta clase, 
serán  los  que  utilizaremos  para  pedir  los  datos  que  se  requieran  para  dar  solución  a  un 
problema. 
 
Lectura de teclado 
Scanner kbd= new Scanner (System.in); 
 
Lectura desde un fichero (¡de texto!) 
Scanner kbd= new Scanner (new File (“MiFichero”)) 
 
 
1. Creación del objeto. 
//Creación de un objeto Scanner 
Scanner myScanner = new Scanner(System.in); 
 
 
2. Una vez que se ha construido el objeto ya se tiene lo requerido para capturar la
información, las siguientes dos líneas de código solicitan al usuario el ingreso de la
información y captura el valor digitado en una variable de tipo entera.

//La siguiente línea muestra un mensaje por pantalla 
System.out.print("Digite un número entero"); 
int número = myScanner.nextInt(); 
 
3. Si quiere mostrar por pantalla el valor de la variable número para verificar que en
realidad fue capturado por Scanner, puede escribir lo siguiente:
System.out.println(numero); 
 
 
Finalmente, así como fue posible capturar un dato de tipo int con el servicio nextInt() también 
existen  otros  servicios  apropiados  dependiendo  del  tipo  de  dato  al  que  corresponda  la 
información que se va a capturar: 
 
Para el tipo byte: nextByte() 
Para el tipo short nextShort() 
Para el tipo float: nextFloat() 
Para el tipo double: nextDouble() 
Para el tipo long: nextLong() 
Para el tipo String: nextLine() y next()