martes, 15 de abril de 2008

PRESENTADO POR STIVEN HERNANDEZ

CONEXION JAVA-MYSQL

QUE ES MYSQL:
MySQL es un sistema de administración de bases de datos (Database Management System, DBMS) para bases de datos relacionales. Así, MySQL no es más que una aplicación que permite gestionar archivos llamados de bases de datos o , lo que es lo mismo.[1]

Instalamos MYSQL:



Luego de finalizar la configuración se procede a la configuración de MySql:





Configuramos el servidor como maquina de desarrollo:

En la vista de de configuración de desarrollo se configura el numero de usuarios:










En este paso definimos el password del administrador “root” del SGBD MySQL:




Ventana de proceso de que toda la configuración esta bien:


Instalamos el cliente SQLYog para MySQL, este cliente permite interactuar con MySQL ya que dispone de ventanas graficas, ademas existe diferentes clientes los cuales podemos elegir libremente.






Conexión entre netbeans y MySQL.Para ello primero ingresamos al netbeans, una vez dentro, elegimos la opción SERVICES, luegoDatabases>Drivers, luego clic derecho en este, para luego clic en NEW DRIVER..., se muestra la ventanasiguiente en el cual debemos darle la ruta de nuestro driver.


Una vez terminada la instalación, podemos hacer ya la prueba de conexión a MySQL mediante el cliente, previamente instalado, para ello ingresamos al programa cliente, y ejecutamos ó creamos una nueva conexión al MySQL, para ello ingresamos los datos necesarios, el password de ROOT creada durante la instalación del MySQL. y Si la conexión fue exitosa, se debe mostrar las bases de datos y todo lo demás, que existe dentro del MySQL.
El siguiente paso será crear una base de datos, y por lo menos crear un par de tablas dentro, esto nos servirá para las pruebas de conexión desde java, posteriormente.


primeramente ingresamos al netbeans, una vez dentro, elegimos la opción SERVICES, luego
Databases>Drivers, luego clic derecho en este, para luego clic en NEW DRIVER..., se muestra la ventanasiguiente en el cual debemos darle la ruta de nuestro driver.



Una vez registrado el driver, ya podemos hacer la conexión con MySQL. Para ello hacemos clic derecho sobre el driver de MySQL registrado, y luego clic en CONNECT USING..., luego se muestra una ventana, en el cual debemos ingresar los datos de nuestra base de datos creada anteriormente. Un ejemplo de conexión de muestra en la
siguiente ventana.



Si la conexión fue exitosa se debe mostrar la ventana de confirmación, con el mensaje de CONNECTION ESTABLISHED. De lo contrario se debe revisar que los datos ingresados sean los correctos. Un aspecto que me pareció súper genial, al margen la conexión, era la posibilidad de poder interactuar de forma directa con la base de datos de MySQL, desde netbeans, sin la necesidad de un cliente especial para ello, para lo cual simplemente es necesario logearse con una cuenta de usuario, como por ejemplo el ROOT, y ya podemos estar adentro, viendo, creando, eliminando y insertando datos, como se muestra en la ventana siguiente.



Si somos mas curiosos, podemos ver mas opciones que nos permiten interactuar con nuestra base de datos.
Bueno, hemos terminado la primera parte de la conexión directa, desde netbeans al MySQL, y hemos visto y utilizado las herramientas que nos facilitan el uso y manejo de la base de datos desde el IDE. Ahora nos toca hacer aplicaciones reales, específicamente para la web, para ello es necesario realizar algunas configuraciones adicionales.
Primeramente, como lógico, debemos crear un proyecto web, dentro de netbeans, para luego agregarle el driver de conexión entre java y MySQL (Connector/J driver), esto en forma de librería, este paso se irán especificando en los siguientes pasos.
Primeramente creamos la librería con el driver, para ello vamos al menú TOOLS>LIBRARIES, luego dentro de la ventana hacemos clic en NEW LIBRARY..., y luego colocamos Library Name = MySQL y Library Type=Class Libraries, luego una vez creado la librería, elegimos este, y le agregamos el *.jar.

Ahora, una vez creado la librería con el *.jar dentro, luego este debe ser agregado al proyecto, específicamente dentro de la carpeta LIBRARIES, para ello vamos dentro de la opción Projects>webapplication4>libraries, hacemos clic derecho sobre el ultimo, y luego clic en ADD LIBRARY..., después dentro de la ventana, elegimos la librería MySQL que acabamos de crear. webapplication4 es el nombre de mi proyecto.




Si usted ha agregado correctamente entonces la ruta del Connector/J del *.jar de JDBC en su ambiente de CLASSPATH se mantiene fijo.
Tip: Cuando usted hace los cambios a cualquiera de sus variables de ambiente (como CLASSPATH), cierre y re-abre cualquier orden abierto las ventanas puntuales para que ellos se refresquen su ambiente de valores no actualizados.
Ya tenemos configurado las variables de ambiente de forma correcta, el siguiente paso es crear nuestro script java, el cual accederá a la base de datos.
Nosotros crearemos un programa de Java simple que intentará conectar a nuestro servidor de base de datos MySQL usando el driver Connector/J de JDBC. Cree un nuevo archivo de *.java.

CODIGO:

mport java.io.*;
import java.net.*;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
import javax.naming.*;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class listahr extends HttpServlet
{
private static final String CONTENT_TYPE = "text/html;charset=UTF-8";
Connection conn;
ResultSet resultado;
Statement sentencia;
String login = "root";
String password = "secreto";
String bd = "mysql";
String url = "jdbc:mysql://localhost:3306/"+bd;
public void registrar() throws SQLException, Exception, NamingException
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
}
public void conectar() throws SQLException,Exception
{
conn = DriverManager.getConnection(url,login,password);
}
public void consultar() throws SQLException,Exception
{
sentencia = null;
resultado = null;
sentencia = conn.createStatement();
resultado = sentencia.executeQuery("select * from departamento");
}
public void init(ServletConfig config) throws ServletException
{
super.init(config);
}
public void resultado(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
response.setContentType(CONTENT_TYPE);
PrintWriter out = response.getWriter();
out.println("

Servlet de conexion a BD..." + request.getContextPath () + "

");
try
{ registrar();
try
{ conectar();
if (conn != null)
{ out.println("Conexión a base de datos " + url + " ... Ok");
conn.close();
}
}
catch(Exception e)
{
out.println("Error en la conexion a BD " + url + e.getMessage());
}
}
catch(Exception e)
{
out.println("Error en el registro del driver " + url + e.getMessage());
}
out.close();
}
public String getServletInfo()
{
return "Short description";
}
public void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
resultado(request, response);
}
public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
IOException
{
resultado(request, response);
}
}[2]

[1]http://www.esepestudio.com/articulo/desarrollo-web/bases-de-datos-mysql/Que-es-MySQL.htm
[2]http://www.latindevelopers.com/forum/viewtopic.4857.html.

CONEXION ORACLE-JAVA

QUE ES ORACLE:
básicamente una herramienta cliente/servidor para la gestión de Bases de Datos. Es un producto vendido a nivel mundial, aunque la gran potencia que tiene y su elevado precio hace que sólo se vea en empresas muy grandes y multinacionales, por norma general. En el desarrollo de páginas web pasa lo mismo: como es un sistema muy caro no está tan extendido como otras bases de datos, por ejemplo, Access, MySQL, SQL Server, etc.[1]

CONEXION:

Para poder conectar a Java con ORACLE lo primero que necesitamos es la implementación de JDBC para ORACLE. Esta implementación se encuentra en el archivo Classes12.jar que podemos encontrar en el siguiente directorio del servidor de Oracle.

%ORACLE_HOME%\jdbc\lib

ORACLE_HOME es una variable de entorno que se crea durante la instalación del servidor ORACLE, y que indica donde está instalado fisicamente ORACLE dentro del sistema de archivos, normalmente C:\oracle\ora92 para servidores Windows y ORACLE 9i. Esta .misma nomenclatura se aplica al hablar de la instalación cliente

Debemos configurar correctamente nuestra variable CLASSPATH para incluir en ella el archivo Classes12.jar.

Oracle proporciona los siguientes drivers en su implementacion JDBC:

  • JDBC Thin Driver: No requiere de la instalación cliente de ORACLE. Ideal para Applets.
  • JDBC OCI :API nativa de ORACLE, para aplicaciones J2EE.
  • JDBC KPRB driver: (default connection) para Java Stored Procedures y Database JSP's.

Todos los drivers soportan la misma sintaxis y funcionalidad, por lo que nuestro código variará únicamente en la forma de crear la conexion.

  1. l driver JDBC Thin se conecta y comunica con ORACLE a nivel de sockets. Proporciona su propia versión del protocolo Net8 (SQL*Net) sobre TCP/IP, por lo que no es necesario que exista una instalación de la parte cliente de ORACLE. Dado que este driver es código 100% Java es completamente independiente de la plataforma de ejecución, y como implementa su propia versión del protocolo es ideal para aplicaciones que se ejecutan sobre un navegador Web (applets) .
  2. El driver JDBC OCI usa el API ORACLE OCI (Oracle Call Interface) para interactuar con ORACLE, por lo que es necesaria la instalación y configuración de la parte cliente de ORACLE. El driver OCI trabaja con SQL*Net o Net8, por lo que tamdebemos haber creado un alias en el archivo TNS names
    (%ORACLE_HOME%\network\ADMIN).
  3. El driver JDBC OCI permite realizar llamadas a ORACLE OCI directamente desde Java proporcionando
    un alto grado de compatibilidad con una versión específica de ORACLE utilizando métodos nativos, pero específicos de la plataforma.
  4. Por último el driver ORACLE JDBC KPRB es utilizado para escribir en Java procedimientos almacenados, funciones, triggers ... Ofrece acceso a la conexion activa por lo que no es necesario crear ninguna conexión adicional.
  5. El driver JDBC KPRB de ORACLE permite obtener un handle de la conexion actual del contexto a través del método OracleDriver.defaultConenction(). Como hemos dicho, se utiliza para procedimientos almacenados, triggers .... Para ejecutar un procedimiento almacenado debemos estar conectados a ORACLE a través de una herramienta cliente como SQL*Plus., lo que hacemos con defaultConenction() es acceder a está conexion.
  6. Es necesario crear un "wrapper" para poder ejecutar el programa desde PL/SQL o SQL.
  7. Una vez hecho esto, podemos ejecutar la función como si se tratase de una función PL/SQL.
[2]
[1]http://www.desarrolloweb.com/articulos/840.php.
[2]http://www.devjoker.com/contenidos/Articulos/132/Como-conectar-a-ORACLE-con-Java.aspx

CONEXION ACCESS-JAVA

QUE ES ACCESS:
Podemos definir Access como una herramienta para la administración de bases de
datos relacionales.
En su forma más simple, una base de datos es una colección de datos
relacionados a un tema particular, una lista de datos. Cuando se efectúa una lista
de direcciones, nombres, productos, se está generando una base de datos. De
hecho, no es necesario usar un programa de bases de datos para crear una: se
podría estar haciendo una lista como la que acabamos de mencionar usando
Excel, Word o (incluso) el Bloc de notas.[1]

CREAR UN NUEVO DATA SOURCE NAME:

Para realizar la conexión a una base de datos ODBC necesitaremos crear un perfil DSN desde el panel de control y posteriormente accederemos a la base de datos a partir del nombre del perfil. En el perfil DSN lo que se hace es indicar el driver a utilizar, así como el archivo o archivos del origen de datos. Estos son los pasos a llevar a cabo para configurar un perfil DSN.

1.- Iremos a Panel de Control. Ello se hace desde Inicio->Configuración o desde MiPC.

2.- Ahora hacemos doble-click en el icono de Fuentes de datos ODBC (32 bits).

3.- En nuestra pantalla aparecerá ahora la pestaña DSN usuario seleccionada. Para crear un nuevo perfil haremos click en Agregar...

4.- A continuación se nos pide que ingresemos el controlador que vamos a usar en el nuevo perfil. En nuestro caso será Microsoft Access Driver (*.mdb).

5.- Una vez aquí sólo nos queda dar un nombre al origen de datos y especificar el archivo .mdb de origen. Tras aceptar la ventana ya tenemos creado un perfil con lo que ya podemos comenzar a programar.

CARGAR EL DRIVE:

Lo primero es hacer una llamada al Driver JDBC-ODBC para cargarlo. Eso se consigue con las siguientes líneas de código:

try{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); }
catch(Exception e){ System.out.println("No se ha podido cargar el Driver JDBC-ODBC"); }

Con esto ya tenemos cargado el Driver. Ahora básicamente trabajaremos con tres objetos. Estos objetos son: Connection, Statement y ResultSet. El objeto Connection se obtiene al realizar la conexión a la base de datos. El objeto Statement se crea a partir del anterior y nos permite ejecutar SQL para hacer consultas o modificaciones en la base de datos. En caso de hacer una consulta (SELECT ... FROM ...) se nos devolverá un objeto que representa los datos que deseamos consultar; este objeto es un objeto ResultSet (Hoja de resultados).

EL OBJETO DE CONEXION:

Debemos realizar la conexión a nuestro origen de datos. Para ello debemos crear un objeto Connection de la siguiente forma:

Connection con = DriverManager.getConnection("jdbc:odbc:Nombre_Perfil_DSN", "Nombre_Usuario", "Contraseña");

Los dos últimos parámetros pueden ser cadenas vacías "" a no ser que la base de datos las requiera. Con esto ya hemos realizado una conexión a nuestra base de datos. Pero esto todavía no es suficiente. Ahora vamos a crear un objeto Statement con el que podremos ejecutar y hacer consultas SQL. Si hasta ahora todo ha sido rutinario a partir de ahora vamos a poder crear código más adaptado a las necesidades de nuestro programa.

[2]


[1]http://faa.unse.edu.ar/alumnos/document/Acc2K_1.pdf
[2]http://www.gamarod.com.ar/articulos/como_conectar_java_y_access.asp

CONEXION SQL SERVER-JAVA

SQL Server : es un potente motor de bases de datos de alto rendimiento capaz de soportar millones de registros por tabla con un interface intuitivo y con herramientas de desarrollo integradas como Visual Studio 6.0 o .NET, además incorpora un modelo de objetos totalmente programable (SQL-DMO) con el que podemos desarrollar cualquier aplicación que manipule componentes de SQL Server, es decir, hacer aplicación para crear bases de datos, tablas, DTS, backups, etc., todo lo que se puede hacer desde el administrador del SQL Server y podemos hacerlo no solo en Visual C++ sino también en Visual Basic, ASP y por supuesto en .NET.[1]

Para establecer una conexión a una base de datos con la clase DriverManager, debe registrar primero el controlador como en el ejemplo siguiente:

Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");

Una vez cargado el controlador, puede establecer una conexión con una URL de conexión:

String connectionUrl = "jdbc:sqlserver://localhost:1433;" +

"databaseName=AdventureWorks;user=MyUserName;password=*****;";

Connection con = DriverManager.getConnection(connectionUrl); [2]

Este es bloque para la conexion:

// cargar el controlador JDBCODBC
try { Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
} catch (Exception e) {
System.out.println("Fallo en carga del controlador JDBC/ODBC");
}
// obtener la conexion
try {
Connection con = DriverManager.getConnection(
"jdbc:odbc:cursopoo",
"alumno",
"alumnopoo");
} catch (Exception e) {
System.err.println("problemas para conectar a "+URL);
}

[2]




[1]http://www.netveloper.com/contenido2.aspx?IDC=64_0.
[3]http://www.tamps.cinvestav.mx/~ilopez/poo/poo-XIII.pdf.

CONEXION JAVA -POSTGRES

PostgreSQL :es un Sistema de Gestión de Bases de Datos Objeto-Relacionales (ORDBMS) que ha sido desarrollado de varias formas desde 1977. Comenzó como un proyecto denominado Ingres en la Universidad Berkeley de California. Ingres fue más tarde desarrollado comercialmente por la Relational Technologies/Ingres Corporation.

En 1986 otro equipo dirigido por Michael Stonebraker de Berkeley continuó el desarrollo del código de Ingres para crear un sistema de bases de datos objeto-relacionales llamado Postgres. En 1996, debido a un nuevo esfuerzo de código abierto y a la incrementada funcionalidad del software, Postgres fue renombrado a PostgreSQL, tras un breve periplo como Postgres95. El proyecto PostgreSQL sigue actualmente un activo proceso de desarrollo a nivel mundial gracias a un equipo de desarrolladores y contribuidores de código abierto.

PostgreSQL está ampliamente considerado como el sistema de bases de datos de código abierto más avanzado del mundo. Posee muchas características (las cuales serán discutidas en detalle en la sección denominada ``Juego de Características de PostgreSQL'') que tradicionalmente sólo se podían ver en productos comerciales de alto calibre.[1]




Primero, es necesario descargarse el JDBC Driver para PostgreSQL. Este se encuentra en la página http://jdbc.postgresql.org/index.html Obviamente, será necesario contar con nuestra Base de Datos funcionando para realizar las consultas necesarias.

Posteriormente hay que determinar la manera de agregar este Driver a nuestro proyecto. NetBeans ofrece una manera mas que sencilla.

Conociendo la ubicación de nuestro Driver y con el proyecto abierto, en el Panel de Proyectos, ubicamos en el Árbol de Proyecto la opción Libraries, clic Derecho en ella y seleccionamos Add JAR / Folder..., de esta manera estaremos
agregando ej .JAR del Driver que descargamos. Esto nos crea en nuestro proyecto una carpeta llamada "dist" y en ella otra de nombre "lib" donde esta nuestro Driver.

Ahora, teniendo lo necesario, podemos probar nuestra conexión con PostgreSQL y realizar lo que nos concierne, Altas, Bajas y Modificaciones a nuestras tablas.

Para empezar, debemos de importar lo siguiente:

import java.sql.*;

Cabe mencionar que hay una gran diferencia entre Select y Update, Insert o Delete, ya que no se aplican de igual manera. A continuación muestro el proceso para realizar un Select (en idioma geek, vamos a selectear)

public class Main{
public static void main(String[] args){

/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitariamos estar registrados en ella y contar con su IP*/
String url = "jdbc:postgresql://localhost/moo";

try{

//Acceso al Driver
Class.forName("org.postgresql.Driver");

//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");

//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();

/*Un ResultSet es como en .NET un DataSet, un arreglo temporal donde se almacenará el resultado de la consulta SQL*/
ResultSet rs;

//Una variable String para almacenar la sentencia SQL
String query = "select id as ID from moo.usuarios";

//En el ResultSet guardamos el resultado de ejecutar la consulta
rs = stmt.executeQuery(query);

//En un ciclo while recorremos cada fila del resultado de nuestro Select
while ( rs.next()){

/*Aqui practicamente podemos hacer lo que deseemos con el resultado, en mi caso solo lo mande a imprimir*/
System.out.println(rs.getString("ID") + "\t" + rs.getString("ID"));
}

//Cerramos la conexión
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){

//Por si ocurre un error
System.out.println(e.getMessage());
e.printStackTrace();
}
}
}

Para realizar todo aquello diferente a un Select, utilzaremos lo siguiente:

/*Variable para almacenar la URL de conexión a nuestra Base de Datos, si esta estuviera en otra máquina, necesitariamos estar registrados en ella y contar con su IP*/
String url = "jdbc:postgresql://localhost/moo";

try{

//Acceso al Driver
Class.forName("org.postgresql.Driver");

//La conexión con los parámetros necesarios
Connection con = DriverManager.getConnection( url,"postgres","postgres");

//Abrimos la conexión y la iniciamos
Statement stmt = con.createStatement();

//Una variable String para almacenar la sentencia SQL
String query = "update moo.usuarios set nombre = 'Mauricio' where id = '1'";

//Ejecutamos la consulta SQL
stmt.executeQuery(query);

//Cerramos la conexión
stmt.execute("END");
stmt.close();
con.close();
}
catch( Exception e ){

//Por si ocurre un error
System.out.println(e.getMessage());
e.printStackTrace();
}

Es muy importante tener en cuenta que si este método lo utilizas en una función para hacerla llamar cuando lo necesites, y quieras enviarle tanto argumentos como retornar resultados, en la función de Select las líneas siguientes NO deben de estar presentes:

stmt.execute("END");
stmt.close();

Y en la parte de Update, Insert o Delete, solo la siguiente línea:

stmt.execute("END");[2]



[1]http://www.sobl.org/traducciones/practical-postgres/node12.html
[2]http://www.mygnet.net/articulos/java/conectado_postgresql_con_java.1162


MANEJO DE EXCEPCIONES EN JAVA

QUE ES UNA EXCEPCIÓN EN JAVA:

Es un evento que ocurre durante la ejecución del programa y detiene el flujo normal de la secuencia de instrucciones de esos programas; en otras palabras, una excepción es una condición anormal que surge en una secuencia de código durante su ejecución.

Las excepciones en java están destinadas para detección y corrección de errores, Si hay un error, la aplicación no debería morirse y generar un core (meollo) o un crash en DOS. Se debería lanzar un throw (arrojar, derribar, echar) una excepción que a su vez debería capturarse en un catch (captura) y resolver la situación de error, o bien poder ser tratada finally (finalmente) por un gestor por defecto. La gestión de excepciones en Java proporciona un mecanismo poderoso para controlar programas que tengan muchas características dinámicas durante su ejecución.[1]

MANEJO DE EXCEPCIONES:

El manejo de excepciones es una estructura de control de los lenguajes de programación diseñada para manejar condiciones anormales que pueden ser tratadas por el mismo programa que se desarrolla.[2]

Por ejemplo, un programa puede admitir cierto número de errores en el formato de los datos y continuar su proceso para producir el mejor resultado posible en lugar de producir una salida aparatosa llena de mensajes de error probablemente incomprensibles para el usuario. Muchas veces la acción asociada a una excepción es simplemente producir un mensaje informativo y terminar, otras veces, es sólo indicación de la necesidad de un cambio en la estrategia de resolución del problema

A continuación se muestra como se utiliza las excepciones, a partir de la versión iterativa de HolaIte.java (“Tomado del Libro JAVA 2 Manual de Usuario y Tutorial- pag. 180”)

import java.awt.*;

import java.applet.Applet.*;

public class HolaIte extends Applet{

private int i = 0;

private String Saludos[]={

“Hola Mundo!”;

“HOLA Mundo!”;

“HOLA MUNDO!”;

};

public void paint( Graphics g ) {
    try {
        g.drawString( Saludos[i],25,25 );
        } catch( ArrayIndexOutOfBoundsException e ) {
            g.drawString( "Saludos desbordado",25,25 );
        } catch( Exception e ) {
            // Cualquier otra excepción
            System.out.println( e.toString() );  
        } finally {
            System.out.println( "Esto se imprime siempre!" );
        }
    i++;
    }[1]

CAPTURA DE EXCEPCIONES:

Las excepciones lanzadas por un método que pueda hacerlo deben recogerse en un bloque try/catch o try/ finally.

TRY:

Es el bloque de código donde se prevé que se genere una excepción. Es como decir “intenta estas sentencias y mira a ver si se produce una excepción”, seguido ir seguido al menos por un catch o una cláusula finally.

CATCH:

Es el código que se ejecuta cuando se produce la excepción. Es como decir “controlo cualquier excepción que coincida con mi argumento”). No hay código alguno que entre en bloque try y un bloque catch, ni entre bloques catch.

FINALLY:

Es el bloque de código que se ejecuta siempre, haya o no haya excepciones, existe controversia en su utilidad. Este bloque finally puede ser util cuando no hay ninguna excepción. Es un trozo de código que se ejecuta independientemente de lo que haga el bloque try.

THROW:

Se utiliza para lanzar explícitamente una excepción. En primer lugar se debe obtener una descripción de un objeto Throwable (throw ObjetoThrowable), bien mediante una cláusula catch o bien creándolo mediante el operador new.

THROWS:

Si un método es capaz de provocar una excepción que no maneja el mismo, debería especificar este comportamiento para que los métodos que lo llamen puedan colocar protecciones frente a una excepción. La palabra clave Throws se utiliza para identificar la lista posible de excepciones que un método puede lanzar.[1]

[1]] JAVA 2 Manual del Usuario y Tutoríal.

[2]http://es.wikipedia.org/wiki/Manejo_de_excepciones