Bueno les dejo una pequeña clase para para manejar nuestro MySQL que realiza por lo pronto tres metodos (o dos como quieran), la voy a ir mejorando pero para una conexión básica sirve perfecto…

Supondremos que el servidor de base de datos se encuentra activo y funcionando y que la base de datos ya fue creada. A continuación les dejo la tabla sobre la cual haremos la consulta.

Creacion de la tabla “pais”.

1
2
3
4
5

CREATE TABLE IF NOT EXISTS `pais` (
  `id` int(3) UNSIGNED NOT NULL,
  `nombre varchar(30) NOT NULL,
  PRIMARY KEY  (`id`)
);

La cargamos con algunos datos para hacer la consulta…

1
2
3
4
5
6
7
8
9
10
11

INSERT INTO `pais` (`id`, `nombre`) VALUES
(1, 'Afganistán'),
(2, 'Albania'),
(3, 'Alemania'),
(4, 'American Samoa'),
(5, 'Andorra'),
(6, 'Angola'),
(7, 'Anguila'),
(8, 'Antigua and Barbuda'),
(9, 'Antillas Holandesas'),
(10, 'Antártida');

Listo ya tenemos nuestra base de datos con paises…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

//Organizo estas clases en un paquete Controladores, si quieren obvien este paso...
package Controladores;
 
//Estas son clases de java que debemos importar que las usaremos mas adelante...
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
 
/**
 * 
 * @author Chuecko
 * @Site: http://www.zarpele.com.ar
 * @License: GPL
 * @Description: Conexión a base de datos MySQL
 *
 */
 
public class MySQL {
 
//Variable de tipo Connection...
Connection conexion = null;
 
//Datos de conexion
public String bd = "zarpele";
public String user = "user";
public String pass = "pass";
 //url no deben modificarlo, salvo que se conecten a una base de datos remota...
public String url = "jdbc:mysql://localhost/"+bd;
 
//Contructor...
public MySQL() throws InstantiationException, IllegalAccessException, ClassNotFoundException
{
 
   try {
      //Creando Instancia del driver
      java.lang.Class.forName("com.mysql.jdbc.Driver").newInstance();
      //Conectando con los datos de conexión
      this.conexion = DriverManager.getConnection(url,user,pass);
 
//      Datos del producto, version de mysql, etc. No es necesario por eso esta comentado...
//      DatabaseMetaData meta = (DatabaseMetaData) conexion.getMetaData();
//      System.out.println("El SGBD e s : ");
//      System.out.println(meta.getDatabaseProductName());
//      System.out.println(meta.getDatabaseProductVersion());
 
      System.out.println("Se ha conectado con exito!!!");
 
    } catch (SQLException ex) {
//   Aquí capturo la exepcion y muestos los mensajes y un error con el nombre de la base de datos
      System.out.println("Problemas al conectar con MySQL con base de datos :"+bd);
      System.out.println("SQLException : " + ex.getMessage());
      System.out.println("SQLState : " + ex.getSQLState());
      System.out.println("VendorError : " + ex.getErrorCode());
    }
 
}
 
//Pequeño método para realizar una consulta
public ResultSet consulta(String SQL) throws SQLException
{
//   Creamos un tipo Statement que maneja las consultas 
   Statement s = this.conexion.createStatement();
//   Retorno la consulta especifica...
    return  s.executeQuery (SQL);
 
}
 
//Cerramos la conexión previamente abierta...
public void cerrar() throws SQLException
{
this.conexion.close();
}
}

Listo esta clase nos ahorra muchas lineas de código cuando queramos traer datos desde la base de datos…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

 
//Importamos la clase anterior y las que usamos en esta clase Main
import Controladores.MySQL;
import java.sql.ResultSet;
import java.sql.SQLException;
 
/**
 * 
 * @author Chuecko
 * @Site: http://www.zarpele.com.ar
 * @License: GPL
 * @Description: Ejemplo de consulta MySQL
 *
 */
public class Main {
 
    public static void main(String[] args) throws InstantiationException, IllegalAccessException, ClassNotFoundException, SQLException {
 
//  Instanciamos la clase MySQL, que realiza la conexión 
    MySQL controladorDB=new MySQL();
 
//  Esta es la consulta en lenguaje SQL 
    String SQL=" SELECT * FROM pais";
 
//  Como ya vimos la consultas manejan un tipo ResultSet, le pasamos SQL y realizamos la consulta    
    ResultSet rs = controladorDB.consulta(SQL);
 
 
            // Se recorre el ResultSet, mostrando por pantalla los resultados.
            // Nótese que podemos usar el nombre de la column o un identificador empezando por 1
            while (rs.next())
            {
                System.out.println (rs.getInt ("id") + " " + rs.getString (2));
                System.out.println ("*******************");
            }
 
//  Cerramos la conexion
    controladorDB.cerrar();
 
}<pre>
 
}

Esto nos daría como resultado…

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

run:
Se ha conectado con exito!!!
1 Afganistán
*******************
2 Albania
*******************
3 Alemania
*******************
4 American Samoa
*******************
5 Andorra
*******************
6 Angola
*******************
7 Anguila
*******************
8 Antigua AND Barbuda
*******************
9 Antillas Holandesas
*******************
10 Antártida
GENERACIÓN CORRECTA (tiempo total: 1 segundo)

Y listo, a esta altura de hacer consultas con base de datos, se supone que están utilizando algún IDE, en mi caso en este momento uso NetBeans, que es mas fácil implementar las excepciones además de infinitas ventajas (ya es hora que sueltes el Notepad, Gedit, Kedit, etc…).
No se olviden de importar las bibliotecas necesarios en este caso Driver MySQL JDBC.
Cualquier sugerencia o critica solo comenten….
Si te fue útil también comentá…

Saludos…

La comunidad DragonJar a liberado el número 2 de su e-zine, que en esta ocación toca temas bastante interesantes como Blind SQL Injection, un tutorial de cómo crear un compilador para Java, administración de WordPress, entre otras.

La Herencia es el mecanismo por el que se crean nuevos objetos definidos en términos de objetos ya existentes. Por ejemplo, si se tiene la clase Ave, se puede crear la subclase Pato, que es una especialización de Ave.

1
2
3

 class Pato extends Ave {
        int numero_de_patas;
        }

La palabra clave extends se usa para generar una subclase (especialización) de un objeto. Una Pato es una subclase de Ave. Cualquier cosa que contenga la definición de Ave será copiada a la clase Pato, además, en Pato se pueden definir sus propios métodos y variables de instancia. Se dice que Pato deriva o hereda de Ave.

Además, se pueden sustituir los métodos proporcionados por la clase base. Utilizando nuestro anterior ejemplo de MiClase, aquí hay un ejemplo de una clase derivada sustituyendo a la función Suma_a_i():

1
2
3
4
5
6

 import MiClase;
    public class MiNuevaClase extends MiClase {
        public void Suma_a_i( int j ) {
            i = i + ( j/2 );
            }
        }

Ahora cuando se crea una instancia de MiNuevaClase, el valor de i también se inicializa a 10, pero la llamada al método Suma_a_i() produce un resultado diferente:

1
2
3

 MiNuevaClase mnc;
    mnc = new MiNuevaClase();
    mnc.Suma_a_i( 10 );

En Java no se puede hacer herencia múltiple. Por ejemplo, de la clase aparato con motor y de la clase animal no se puede derivar nada, sería como obtener el objeto toro mecánico a partir de una máquina motorizada (aparato con motor) y un toro (aminal). En realidad, lo que se pretende es copiar los métodos, es decir, pasar la funcionalidad del toro de verdad al toro mecánico, con lo cual no sería necesaria la herencia múltiple sino simplemente la compartición de funcionalidad que se encuentra implementada en Java a través de interfaces.

• Una Interfaz es una especificación para las operaciones externas
visibles de una clase, componente, o otra entidad (incluyendo
unidades globales como los paquetes), pero siempre sin
especificar la estructura interna

• Cada interfaz especifica a menudo sólo una parte limitada del
comportamiento de una clase real

• Una interfaz no tiene implementación

• Una Interfaz es formalmente equivalente a una clase abstracta sin
atributos y sin métodos, con sólo operaciones abstractas

• Un interfaz se puede representar de dos formas:
– Circulo unido por una línea a una clase con las operaciones de
interfaz al lado del círculo
– Rectángulo con la palabra reservada <> y la sección de
operaciones

• Una clase que usa las operaciones de una interfaz se une por
medio de una flecha de línea discontinua a los círculos o al
rectángulo de la interfaz

• También se puede utilizar la “relación Realiza” desde una clase a
una interfaz que soporta

Un interface es parecido a una clase abstracta en Java, pero con las siguientes diferencias:

1
2
3

       interface Figura{
    int area();
    }

1
2
3
4
5
6
7

      public class Cuadrado implements Figura {
    int lado;
    public Cuadrado (int ladoParametro) {
    lado = ladoParametro;
    }
 
    public int area(){ return lado*lado; }}

1
2
3
4
5
6

    public class PruebaInterfaz{
    public static void main(String args[]){
    Figura figura=new Cuadrado (5);
    //Podemos crear una referencia de interface(variable r) y que un objeto que pertenezca
    // a una clase que la implementa le sea asignada a la variable
    System.out.println(figura.area());}

Mas ejemplos en ingles
Fuente1
Fuente2
Fuente3

1.- Bajamos Eclipse

Lo primero que vamos a hacer es conseguir el Eclipse, es facil nos dirijimos a nuestro navegador web preferido y introducimos la siguiente direccion www.eclipse.org , alli en la parte download haremos click en la ultima opcion y eligiremos el sistema operativo donde lo querramos correr. El fichero de linux eclipse-SDK-3.3.2-linux-gtk.tar.gx
pesa aproximadamente 140.0 MB y ya viene pre compilado haci que no tendran problema al ejecutarlo

IMPORTANTE

El entorno de ejecución y desarrollo de Java

Java Development Kit (JDK)
Conjunto de programas y librerías que permiten
desarrollar, compilar y ejecutar programas Java
Java Runtime Environment (JRE)
Conjunto de programas y librerías que permiten solamente
ejecutar programas Java

Deberan tener instalada la maquina virtual de Java en este caso Java Development Kit para usar Eclipse lo mismo en
Windows…

Para instalarla en linux bajar JDK 6 ultima version desde la pagina de Sun.
Una vez bajado
Desde consola:

chmod +x jdk-6-linux-i586.bin
sudo ./jdk-6-linux-i586.bin

2.- Descomprimimos el Fichero

Bueno ya bajado el archivo eclipse-SDK-3.3.2-linux-gtk.tar.gz abrimos una consola y nos dirigimos al directorio donde se
aloja dicho archivo y

Desde consola:

zarpele@zarpele-desktop:~$ tar zxvf eclipse-SDK-3.3.2-linux-gtk.tar.gz

Ahora como veran se descomprimira todos los archivos en el directorio eclipse.

3.- Ejecutando Eclipse 3.3.2

Lo unico que debemos hacer es ejecutar el ejecutable nombrado eclipse.

Luego nos saldra una pantalla donde debemos indicarle al eclipse donde sera nuestro directorio donde alojemos nuestros trabajos en java (workspace), en mi caso los alojo en

/home/guido/Deskop/Guido-Linux/workspace

4. Creamos un Proyecto

New –> Project

Elejimos el tipo de Proyecto (Java Proyect)

Nombramos nuestro Proyecto (HolaMundo en mi caso)

5. Creamos una clase

Luego Creamos una clase a nuestro proyecto
New –> Class

Nos devuelve esto…

6.- Modificamos el codigo generado

/**
* La clase HolaMundo implementa una aplicacion que solo
* imprime “Hola Mundo by zarpele” en la salida estandar.
*/
public class HolaMundo {

/**
* @param args
*/
public static void main(String[] args) {
System.out.println(“Hola Mundo by zarpele”); //Imprime la cadena

}
}

7. Corremos la Aplicacion

Lo corremos
Run As –> Java Application

Pantalla intermedio que nos pregunta lo que queremos guardar tildamos Always save… y le damos ok

…Resultado…

Cualquier Duda o Sugerenci solo escriban
Sino ven bien solo hagan click en la imagen
Saludos…