Mostrando entradas con la etiqueta programacion. Mostrar todas las entradas
Mostrando entradas con la etiqueta programacion. Mostrar todas las entradas

lunes, 26 de octubre de 2020

Arrays

Un array en java es un objeto que contiene de cero a más elementos de un mismo tipo, los elementos que contiene son almacenados en el array y se puede acceder a ellos mediante su numeración que comienza con el número 0.



Arrays unidimensionales y bidimensionales

Los arrays representan matrices, en el caso de los de una dimensión a aquellas matrices tipo columna o fila y los bidimensionales a cualquier matriz de "n" filas por "m" columnas.

En el lenguaje Java estas se pueden definir de la siguiente forma:

        
        //Arrays unidimensionales
        int[] vector; // vector[] es un array de valores tipo int
        
        //Arrays bidimensionales
        int[][] matriz; // matriz[][] es un array de valores tipo int[]
         

Como se aprecia, las matrices son arrays de arrays y para declarar cualquier array se debe colocar primero el tipo de dato que almacenarán sea primitivo o tipo objeto, luego dependiendo de la cantidad de dimensiones los corchetes [ ].



Operaciones con arrays

Para crear un array, se debe inicializar el mismo indicando la cantidad de elementos que contendrá o indicando los elementos que va contener de cualquiera de las siguientes maneras

        
        // Sin valores asignados
        byte[] notas = new byte[5]; 
        //Con valores
        String[] cursos = {"Física", "Cálculo", "Filosofía"};
         

Para ir asignando valores dentro del array se puede emplear estructuras repetitivas o manualmente indicando el nombre del array y entre corchetes la posición (conocida como index). Esta posición siempre comienza con cero y su máximo valor es el tamaño del array menos uno.

        
        //Asignación de valores
        notas[0]=20;
        notas[1]=12;
        notas[2]=10;
        notas[3]=15;
        notas[4]=6;
         

Para modificar un valor se realiza el mismo proceso que al asignar valores con el nuevo contenido.

        
        //Modificar un valor
        cursos[1] = "Matemática"; // Cambia 'Cálculo' por 'Matemática'
         

Para poder recorrer un array se pueden emplear estructuras repetitivas "for" con variables de tipo contador o sin estas conocidos en otros lenguajes como "foreach"

        
        //Imprimiendo en consola
        System.out.println("Contenido de notas[]");
        for (int i = 0; i < notas.length; i++) {
            System.out.println(notas[i]);
        }
        
        System.out.println("\nContenido de Cursos[]");
        for (String curso : cursos) {
            System.out.println(curso);
        }
         

Todos los arrays poseen un campo llamado "length" que devuelve el tamaño de este y puede ser empleado para diversas tareas como el límite del contador en una estructura "for", en el segundo caso al recorrer el array se emplea una variable del mismo tipo que el array con un identificador diferente al array, luego dos puntos y el nombre del array, ya no es necesario indicar dentro la posición como sí en el caso del array recorrido mediante una variable de tipo contador.

El programa completo sería:

package test;

public class Arrays {

    public static void main(String[] args) {
        //Creación e inicialización        
        // Sin valores asignados
        byte[] notas = new byte[5]; 
        //Con valores
        String[] cursos = {"Física", "Cálculo", "Filosofía"};
        
        //Asignación de valores
        notas[0]=20;
        notas[1]=12;
        notas[2]=10;
        notas[3]=15;
        notas[4]=6;
        
        //Modificar un valor
        cursos[1] = "Matemática"; // Cambia 'Cálculo' por 'Matemática'
        
        //Imprimiendo en consola
        System.out.println("Contenido de notas[]");
        for (int i = 0; i < notas.length; i++) {
            System.out.println(notas[i]);
        }
        
        System.out.println("\nContenido de cursos[]");
        for (String curso : cursos) {
            System.out.println(curso);
        }
    }
}

Se obtiene un resultado como el siguiente:

Contenido de notas[]
20
12
10
15
6

Contenido de cursos[]
Física
Matemática
Filosofía

martes, 20 de octubre de 2020

Estructuras repetitivas

Las estructuras repetitivas permiten ejecutar bloques de sentencias múltiples veces, aun si no conocemos el número de veces que debe repetirse el código. Se puede usar para ello una determinada condición, de manera que el bloque se detendrá cuando no se cumpla la condición.

Ejemplo práctico: al ingresar productos en una factura, el proceso se repite una y otra vez.

Estructura FOR

Se emplea cuando se conoce la cantidad de repeticiones o al recorrer un arreglo o vector.

for ( [tipo numérico] i = [valor inicial]; i <= [valor máximo]; [aumento o decremento] ) {
   //Sentencias que se van a repetir: "(valor máximo - valor inicial)" veces
}


for ( [tipo igual al arreglo] i in [variable tipo arreglo] ) {
   //Sentencias que se van a repetir tantas veces como elementos tenga
   //el arreglo
} 


Estructura WHILE y DO WHILE

Se emplea cuando el número de repeticiones no es conocido, pues depende de una condición. El punto a analizar es si se debe o no ejecutar la iteración por lo menos una vez.

while ( condición ) {
   //Sentencias que se van a repetir mientras condición sea verdadera
}

do {
   //Sentencias que se van a repetir por lo menos una vez y mientras condición sea verdadera
}while ( condición ); 


Ejemplo en código

El siguiente programa muestra todos los números pares entre dos valores ingresados por el usuario, validando que sean positivos y el segundo valor sea mayor que el primero

package test;

import java.util.Scanner;

public class Repetitivos {

    public static void main(String[] args) {
        Scanner scanner;
        int n1, n2;
        scanner = new Scanner(System.in);
        
        do {
            System.out.print("Ingrese un número positivo: ");
            n1 = scanner.nextInt();
        } while (n1 <= 0);

        do {
            System.out.print("Ingrese un número mayor que " + n1 + ": ");
            n2 = scanner.nextInt();
        } while (n2 <= n1);

        for (int i = n1; i <= n2; i++) {
            if (i % 2 == 0) {
                System.out.print(i + " ");
            }
        }
    }
}

Estructuras condicionales

Las estructuras condicionales permiten ejecutar bloques de sentencias de código para una determinada condición, si esta no se cumple se puede optar por no realizar nada o llevar a cabo otro bloque de sentencias, de manera que no pueden ejecutarse ambos bloques, solo uno de ellos.

Ejemplo práctico: al ingresar nuestra contraseña de una red social, si es incorrecta no podemos ingresar, pero si es correcta ingresamos a nuestra cuenta.


Condicional IF ELSE Condicional SWITCH CASE
if (condicion1) {
   //Sentencias si 
   //Condicion1 es verdad
}else if (condicion2) {
   //Sentencias si 
   //Condicion2 es verdad
}else {
   //Sentencias si condicion1 y
   //condicion2 no son verdad
}
switch (expresión) {
case x :
   //Sentencias si expresión es "x"
   break;
case y :
   //Sentencias si expresión es "y"
   break;
default:
   //Sentencias para otros casos
}


Operador ternario

Cuando tenemos una estructura condicional simple no anidada y sin "else if", lo más óptimo es utilizar un operador ternario, hay que tener en cuenta que no debe ser usado a diestra y siniestra, solo en casos donde exista un retorno de valor.

Condicional if-else Condicional con operador ternario
/*Codicional clásico*/
if (condicion) {
   //Sentencias si 
   //Condicion es verdad
}else {
   //Sentencias si condicion
   //no son verdad
}
/*Codicional clásico*/
[variable u otro] (condicion) ?
   //Sentencias si 
   //Condicion es verdad
:
   //Sentencias si condicion
   //no son verdad 
;  // cerrar la sentencia al final


Código de ejemplo

El siguiente código solicita la nota de un estudiante y de acuerdo a esta muestra un mensaje. Primero valida que la nota este en el rango de 0 a 20, luego si es 10 o menor muestra el mensaje "Desaprobado", si es 15 o menor muestra "Requiere recuperación" y en los demás muestra "Aprobado"

package test;

import java.util.Scanner;

public class Condicional {

    public static void main(String[] args) {
        Scanner scanner;
        byte nota;

        System.out.print("Ingrese la nota del estudiante: ");
        scanner = new Scanner(System.in);
        nota = scanner.nextByte();
        if (nota < 0 || nota > 20) {
            System.out.println("Nota inválida");
        } else if (nota <= 10) {
            System.out.println("Desaprobado");
        } else if (nota <= 15) {
            System.out.println("Requiere recuperación");
        } else {
            System.out.println("Aprobado");
        }
    }
}

El siguiente código solicita un número entre 1 y 7 devolviendo el día correspondiente iniciando la semana en el lunes

package test;

import java.util.Scanner;

public class Tipos {

    public static void main(String[] args) {
        Scanner scanner;
        byte dia;

        System.out.print("Ingrese un número del 1 al 7: ");
        scanner = new Scanner(System.in);
        dia = scanner.nextByte();
        switch (dia){
            case 1: System.out.println("LUNES");break;
            case 2: System.out.println("MARTES");break;
            case 3: System.out.println("MIERCOLES");break;
            case 4: System.out.println("JUEVES");break;
            case 5: System.out.println("VIERNES");break;
            case 6: System.out.println("SABADO");break;
            case 7: System.out.println("DOMINGO");break;
            default: System.out.println("Valor inválido");break;
        }    
    }
}

Tipos de datos

Datos primitivos

Java admite ocho tipos de datos básicos conocidos como tipos primitivos. Además, admite clases y matrices como tipos de datos compuestos o tipos de referencia.

Los tipos primitivos son:

  • boolean
  • byte
  • short
  • int
  • float
  • double
  • long
  • char

En la siguiente tabla se aprecia las características de estos

Tipo Contenido Rango Tamaño
byte Valor numérico entero -128 a 127 8 bits
short Valor numérico entero –32768 a 32767 16 bits
int Valor numérico entero –2147483648 a 2147483647 32 bits
long Valor numérico entero –9223372036854775808 a 9223372036854775807 64 bits
float Valor numérico con decimales ±1.4E–45 a ±3.4028235E+38 32 bits
double Valor numérico con decimales ±4.9E–324 a ±1.7976931348623157E+308 64 bits
boolean Valor lógico "false" y "true" 1 bit
char Caracter UNICODE \u0000 - \uFFFF 16 bits

Podemos ver en el siguiente código como crear variables de estos tipos y asignarles un contenido.

package test;

public class Tipos {

    public static void main(String[] args) {
        /*DECLARANDO VARIABLES*/

        //Variable lógica
        boolean log;
        
        //Variables enteras
        byte ent1;
        short ent2;
        int ent3;
        long ent4;
        
        //Variables con decimal
        float dec1;
        double dec2;
        
        //Variable caracter
        char caracter;
        
        /*ASIGNANDO VALORES*/
        log = true;
        ent1 = -100;
        ent2 = 4000;
        ent3 = -120000;
        ent4 = 490000000;
        dec1 = 1e7f;
        dec2 = 3.14d;
        caracter = '\u0026';
        
        /*MOSTRANDO EL CONTENIDO*/
        System.out.print("log = ");
        System.out.println(log);
        System.out.print("ent1 = ");
        System.out.println(ent1);
        System.out.print("ent2 = ");
        System.out.println(ent2);
        System.out.print("ent3 = ");
        System.out.println(ent3);
        System.out.print("ent4 = ");
        System.out.println(ent4);
        System.out.print("dec1 = ");
        System.out.println(dec1);
        System.out.print("dec2 = ");
        System.out.println(dec2);
        System.out.print("caracter = ");
        System.out.println(caracter);
    }    
}

Podemos ver en el siguiente código como crear variables de estos tipos y asignarles un contenido.

log = true
ent1 = -100
ent2 = 4000
ent3 = -120000
ent4 = 490000000
dec1 = 1.0E7
dec2 = 3.14
caracter = &

viernes, 1 de mayo de 2020

Polimorfismo

Dentro de las características del paradigma de la programación orientada a objetos una de ellas es el polimorfismo.

Dentro de JAVA esta característica permite que un objeto interactúe de forma diferente en relación de los parámetros con los que un método es invocado o mediante especialización de un método que es heredado, de ahí la estrecha relación entre el polimorfismo y la herencia.


Polimorfismo por parámetros

Se produce cuando existen funciones con el mismo identificador en una misma clase donde se diferencian por la cantidad y/o nombre de parámetros

package entidades;

public class Calculadora{
 
 public Calculadora(){
  //Constructor
 }
 
 public Double procesar(Double a){
  return a*2;
 }
 
 public Double procesar(Double a, Double b){
  return a*b;
 }
 
 public Double procesar(Double a, Double b, Double c){
  return a+b+c;
 } 
}


Polimorfismo por inclusión

Se produce mediante el uso de interfaces, de forma que las clases especializadas desconocen la implementación de las funciones entre ellas.

package entidades;

public abstract class AbstractCalculadora{ 
 public Double procesar(); 
}


package entidades;

public class Calculadora extends AbstractCalculadora{ 
 private Double a;
 private Double b;
 private Double c;
 
 public Calculadora(Double a, Double b, Double c){
  this.a=a;
  this.b=b;
  this.c=c;  
 }
 
 @Override
 public Double procesar(){
  return a+b+c;
 }
}


Fuentes:

  • Flanagan, D. (2002). JAVA IN A NUTSHELL Desktop Quick Reference (4a ed.). England: Pearson Education.


Clases y métodos abstractos

Método abstracto

Java nos permite definir un método sin implementarlo declarando el método con el modificador abstracto. Un método abstracto no tiene cuerpo; simplemente tiene una definición de firma seguida de un punto y coma.

// Ejemplo de método abstracto
public abstract String saludo();


Clase abstracta

Una clase abstracta es aquella cuya implementación es incompleta y no puede ser instanciada. Cualquier clase con uno o más métodos abstractos debe declararse abstracta.

// Ejemplo de clase abstracta

public abstract class SerVivo{
   //Atributos

   //Métodos

}


Consideraciones

  • Cualquier clase con un método abstracto se abstrae automáticamente y debe declararse como tal.
  • La clase abstracta no puede ser instanciada.
  • Una subclase de una clase abstracta se puede instanciar solo si invoca a cada uno de los métodos abstractos de su superclase y proporciona una implementación para todos ellos. Dicha clase a menudo se denomina subclase concreta, para enfatizar el hecho de que no es abstracta.
  • Si una subclase de una clase abstracta no implementa todos los métodos abstractos que hereda, esa subclase es en sí misma abstracta.
  • Los métodos estáticos, privados y finales no pueden ser abstractos, ya que estos tipos de métodos no pueden ser anulados por una subclase. Del mismo modo, una clase final no puede contener ningún método abstracto.
  • Una clase puede declararse abstracta incluso si en realidad no tiene ningún método abstracto. Declarar dicho resumen de clase indica que la implementación está de alguna manera incompleta y está destinada a servir como una superclase para una o más subclases que completarán la implementación. Tal clase no puede ser instanciada.


Ejemplo en código

Se creó dos clases, una abstracta llamada "Figura" y otra común llamada "Cuadrado", la primera tiene dos métodos abstractos y es la superclase de la segunda, esto implica que los dos métodos se deben implementar en la clase hija o subclase.
package entidades;

public abstract class Figura {
 
 public abstract Double area();
 public abstract Double perimetro();

}


package entidades;

public class Cuadrado extends Figura{
 private Double lado;
 
 public Cuadrado(Double lado) {
  super();
  this.lado = lado;
 }

 @Override
 public Double area() {
  return Math.pow(lado, 2);
 }

 @Override
 public Double perimetro() {  
  return 4*lado;
 }

 public Double getLado() {
  return lado;
 }

 public void setLado(Double lado) {
  this.lado = lado;
 } 
 
}

package test;

import entidades.Cuadrado;

public class Ejecutor {
 public static void main(String[] args) {
  Cuadrado cuadrado = new Cuadrado(3d);
  System.out.println("Medida del lado: " + cuadrado.getLado().toString());
  System.out.println("Área: " + cuadrado.area().toString());
  System.out.println("Perímetro: " + cuadrado.perimetro().toString());
 }
}

Salida:

Medida del lado: 3.0
Área: 9.0
Perímetro: 12.0

Esquema del proyecto:



Fuentes:

  • Flanagan, D. (2002). JAVA IN A NUTSHELL Desktop Quick Reference (4a ed.). England: Pearson Education.


domingo, 13 de octubre de 2019

Pruebas simples a un DAO

Estructura

Crear un paquete de pruebas que llamaremos "test", dentro un "Java Main Class" que se llamará "TestDaoInquilinos "


Código

Probamos cada una de las funciones de la clase DAO, en este caso del "DaoInquilinos" (clic aquí para ver el código del DAO)

Probando el listado de registros

DaoInquilinos daoInquilinos = new DaoInquilinosImpl();
List<Inquilinos> list = daoInquilinos.inquilinosSel();
if (list != null) {
 try {
  list.forEach((t) -> {
   System.out.println(t.getIdinquilinos().toString() + " "
    + t.getDni() + " "
    + t.getNombres() + " "
    + t.getPaterno() + " "
    + t.getMaterno() + " "
    + t.getTelefono() + " "
    + t.getCorreo() + " "
    + t.getDeuda().toString() + " "
    + t.getFecha_ingreso().toString());
  });
 } catch (Exception e) {
  System.out.println(daoInquilinos.getMessage());
  System.out.println(e.getMessage());
 }
} else {
 System.out.println("Lista vacía");
}


Probando el obtener un registro por su código

DaoInquilinos daoInquilinos = new DaoInquilinosImpl();
Inquilinos inquilino = daoInquilinos.inquilinosGet(1);
if (inquilino != null) {
 try {
  System.out.println(inquilino.getIdinquilinos().toString() + " "
    + inquilino.getDni() + " "
    + inquilino.getNombres() + " "
    + inquilino.getPaterno() + " "
    + inquilino.getMaterno() + " "
    + inquilino.getTelefono() + " "
    + inquilino.getCorreo() + " "
    + inquilino.getDeuda().toString() + " "
    + inquilino.getFecha_ingreso().toString());
 } catch (Exception e) {
  System.out.println(daoInquilinos.getMessage());
  System.out.println(e.getMessage());
 }
} else {
 System.out.println("Usuario no encontrado");
}


Probando el insertar un nuevo registro

DaoInquilinos daoInquilinos = new DaoInquilinosImpl();
Inquilinos inquilino = new Inquilinos();
inquilino.setDni("71005052");
inquilino.setNombres("ROBERT");
inquilino.setPaterno("JONES");
inquilino.setMaterno("SMITH");
inquilino.setTelefono("997777822");
inquilino.setCorreo("robert@mail.com");
inquilino.setDeuda(0d);
inquilino.setFecha_ingreso(LocalDate.parse("2010-12-18"));
try {
 daoInquilinos.inquilinosIns(inquilino);
} catch (Exception e) {
 System.out.println(daoInquilinos.getMessage());
 System.out.println(e.getMessage());
}


Probando la actualización de un registro ingresando su código

DaoInquilinos daoInquilinos = new DaoInquilinosImpl();
Inquilinos inquilino = new Inquilinos();
inquilino.setIdinquilinos(5);
inquilino.setDni("79905052");
inquilino.setNombres("PAUL");
inquilino.setPaterno("WAYNE");
inquilino.setMaterno("DIAZ");
inquilino.setTelefono("998484822");
inquilino.setCorreo("paul@mail.com");
inquilino.setDeuda(0d);
inquilino.setFecha_ingreso(LocalDate.parse("2012-12-28"));
try {
 daoInquilinos.inquilinosUpd(inquilino);
} catch (Exception e) {
 System.out.println(daoInquilinos.getMessage());
 System.out.println(e.getMessage());
}


Probando la eliminación de un registro por su código

DaoInquilinos daoInquilinos = new DaoInquilinosImpl();
List<Integer> del = new ArrayList<>();
del.add(4);
del.add(3);
try {
 daoInquilinos.inquilinosDel(del);
} catch (Exception e) {
 System.out.println(daoInquilinos.getMessage());
 System.out.println(e.getMessage());
}


Clase de pruebas

Crear un paquete de pruebas que llamaremos "test", dentro un "Java Main Class" que se llamará "TestDaoInquilinos" donde implementaremos todo el código anterior en un solo archivo para probar todas las funcionalidades en un solo archivo

package test;

import dao.DaoInquilinos;
import dao.impl.DaoInquilinosImpl;
import dto.Inquilinos;
import java.text.ParseException;
import java.time.LocalDate;
import java.util.List;
import java.util.ArrayList;
import java.util.Scanner;

public class TestDaoInquilinos {

    public static void main(String[] args) throws ParseException {
        Scanner scanner;
        DaoInquilinos daoInquilinos = new DaoInquilinosImpl();
        Inquilinos inquilino;
        Integer opt;
        do {
            scanner = new Scanner(System.in);
            inicio();
            opt = scanner.nextInt();
            switch (opt) {
                case 1:
                    List<inquilinos> list = daoInquilinos.inquilinosSel();
                    if (list != null) {
                        try {
                            list.forEach((t) -> {
                                System.out.println(t.getIdinquilinos().toString() + " "
                                        + t.getDni() + " "
                                        + t.getNombres() + " "
                                        + t.getPaterno() + " "
                                        + t.getMaterno() + " "
                                        + t.getTelefono() + " "
                                        + t.getCorreo() + " "
                                        + t.getDeuda().toString() + " "
                                        + t.getFecha_ingreso().toString());
                            });
                        } catch (Exception e) {
                            System.out.println(daoInquilinos.getMessage());
                            System.out.println(e.getMessage());
                        }
                    } else {
                        System.out.println("Lista vacía");
                    }
                    break;
                case 2:
                    inquilino = daoInquilinos.inquilinosGet(1);
                    if (inquilino != null) {
                        try {
                            System.out.println(inquilino.getIdinquilinos().toString() + " "
                                    + inquilino.getDni() + " "
                                    + inquilino.getNombres() + " "
                                    + inquilino.getPaterno() + " "
                                    + inquilino.getMaterno() + " "
                                    + inquilino.getTelefono() + " "
                                    + inquilino.getCorreo() + " "
                                    + inquilino.getDeuda().toString() + " "
                                    + inquilino.getFecha_ingreso().toString());
                        } catch (Exception e) {
                            System.out.println(daoInquilinos.getMessage());
                            System.out.println(e.getMessage());
                        }
                    } else {
                        System.out.println("Usuario no encontrado");
                    }
                    break;
                case 3:
                    inquilino = new Inquilinos();
                    inquilino.setDni("71005052");
                    inquilino.setNombres("ROBERT");
                    inquilino.setPaterno("JONES");
                    inquilino.setMaterno("SMITH");
                    inquilino.setTelefono("997777822");
                    inquilino.setCorreo("robert@mail.com");
                    inquilino.setDeuda(0d);
                    inquilino.setFecha_ingreso(LocalDate.parse("2010-12-18"));
                    try {
                        daoInquilinos.inquilinosIns(inquilino);
                    } catch (Exception e) {
                        System.out.println(daoInquilinos.getMessage());
                        System.out.println(e.getMessage());
                    }
                    break;
                case 4:
                    inquilino = new Inquilinos();
                    inquilino.setIdinquilinos(5);
                    inquilino.setDni("79905052");
                    inquilino.setNombres("PAUL");
                    inquilino.setPaterno("WAYNE");
                    inquilino.setMaterno("DIAZ");
                    inquilino.setTelefono("998484822");
                    inquilino.setCorreo("paul@mail.com");
                    inquilino.setDeuda(0d);
                    inquilino.setFecha_ingreso(LocalDate.parse("2012-12-28"));
                    try {
                        daoInquilinos.inquilinosUpd(inquilino);
                    } catch (Exception e) {
                        System.out.println(daoInquilinos.getMessage());
                        System.out.println(e.getMessage());
                    }
                    break;
                case 5:
                    List<integer> del = new ArrayList<>();
                    del.add(4);
                    del.add(3);

                    try {
                        daoInquilinos.inquilinosDel(del);
                    } catch (Exception e) {
                        System.out.println(daoInquilinos.getMessage());
                        System.out.println(e.getMessage());
                    }
                    break;
                case 6:
                    System.out.println("Adios");
                    break;
                default:
                    System.out.println("Opción incorrecta");
            }
        } while (opt != 6);
    }

    private static void inicio() {
        System.out.println("--------Claves de las prueba-----");
        System.out.println("1: Lista de usuarios UsuariosSel");
        System.out.println("2: Obtener usuario UsuariosGet");
        System.out.println("3: Insertar usuario UsuariosUpd");
        System.out.println("4: Actualizar usuario UsuariosIns");
        System.out.println("5: Eliminar usuario UsuariosDel");
        System.out.println("6: Salir");
        System.out.println("-----------------------------------");
        System.out.print("\nIngrese la clave: ");
    }
}

Conectar MySql o MariaBD con Java (NetBeans)

Se necesita lo siguiente:
  • NetBeans IDE 8.2 o superior.
  • Tener instalado el JDK versión 8 o superior.
  • Tener Instalado MySql versión  5.7.24 o superior, en caso de MariaBD la versión 10.3.12 o superior

El servidor de bases de datos

En este caso debemos tener conocimiento del URL de la base de datos, el puerto que emplea (3306 para MySql y 3307 para MariaBD), el usuario y contraseña.

Creamos una clase llamada "ConectaBD" dentro del paquete "biblioteca" y definimos 4 constantes:
  • URL: que contiene la dirección del servidor de base de datos, en este caso "jdbc:mysql".
  • DRIVER: dirección del driver de conexión de bases de datos, en este caso el driver de MySQL.
  • USER: el usuario, en este caso usamos root.
  • PASS: la constraseña, en este caso está vacía.
El código sería:

package biblioteca;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;


public class ConectaBD {
    private final String URL = "jdbc:mysql://localhost:3306/blog";
    private final String DRIVER = "com.mysql.jdbc.Driver";
    private final String USER = "root";
    private final String PASS = "";
    
    public Connection conexionDB() throws SQLException{
    Connection c = null;
        try {
            Class.forName(DRIVER).newInstance();
            c = DriverManager.getConnection(URL, USER, PASS);
        } catch (ClassNotFoundException | 
                 IllegalAccessException | 
                 InstantiationException | 
                 SQLException e) {
            throw new SQLException(e.getMessage());
        }
    
    return c;
    }
}


Se emplea las clases: "Connection", "DriverManager" y "SQLException".

domingo, 22 de septiembre de 2013

Conectar Oracle con Eclipse

Programas o Software requerido

Para realizar la conexión necesitamos tener los siguientes programas:

Ahora debemos conocer al usuario SYS de nuestra base de datos para ella haremos los siguientes pasos:

Paso 1 - Acceder:

Si tienen windows 7 busquen en inicio Run SQL Command Line o en caso contrario ingresen al CMD o linea de comando y escriban sqlplus /nolog, en cualquiera de los dos casos en la pantalla de comando se mostrará lo siguiente:

Microsoft Windows [Versión 6.1.7601]   
Copyright (c) 2009 Microsoft Corporation. Reservados todos los derechos.

C:\Users\PC>sqlplus /nolog
SQL*Plus: Release 11.2.0.2.0 Production on Dom Sep 22 23:44:35 2013
Copyright (c) 1982, 2010, Oracle.  All rights reserved.

SQL>

Paso 2 - Conectarse:

Luego deberá identificarse como usuario sysdba, para ellos ingresar lo siguiente:

SQL*Plus: Release 11.2.0.2.0 Production on Dom Sep 22 23:55:12 2013
Copyright (c) 1982, 2010, Oracle.  All rights reserved.
SQL> conn system/jhon as sysdba
Connected.
SQL> show user
USER is "SYS"

Paso 3 - Crear una base de datos:

Ahora creamos nuestra base de datos a conectar con Eclipse (Les dejo de ejemplo una base de datos que cree para una tienda de ventas)

DECLARE
 N INT;
 COMMAND VARCHAR2(200);
BEGIN
 COMMAND := 'DROP USER TIENDA CASCADE';
 SELECT COUNT(*) INTO N
 FROM DBA_USERS
 WHERE USERNAME = 'TIENDA';
 IF ( N = 1 ) THEN
  EXECUTE IMMEDIATE COMMAND;
 END IF;
END;
/

CREATE USER TIENDA IDENTIFIED BY CLAVE;
GRANT CONNECT, RESOURCE TO TIENDA;

-- =============================================
-- CONECTARSE A LA APLICACIÓN
-- =============================================

CONNECT TIENDA/CLAVE

-- -----------------------------------------------------
-- Tabla Empleado
-- -----------------------------------------------------

CREATE  TABLE empleado (
  empl_DNI  INT NOT NULL ,
  empl_Paterno  VARCHAR(45) NOT NULL ,
  empl_Nombre  VARCHAR(45) NOT NULL ,
  empl_Materno  VARCHAR(45) NOT NULL ,
  empl_email  VARCHAR(25) NULL ,
  empl_telefono  VARCHAR(16) NULL ,
  empl_Direccion  VARCHAR(65) NOT NULL ,
  empl_usuario  VARCHAR(12) NOT NULL ,
  empl_clave  VARCHAR(10) NOT NULL 
);

ALTER TABLE empleado
 ADD CONSTRAINT PK_empleado
 PRIMARY KEY (empl_DNI);
 
ALTER TABLE empleado
 ADD CONSTRAINT U_empleado
 UNIQUE (empl_usuario);

Este código crea el usuario TIENDA identificado con CLAVE, luego inicia sesión con este usuario y crea la tabla.

Paso 4 - Proyecto en Eclipse:

Ahora procedemos a Eclipse donde creamos un nuevo proyecto, colocamos el nombre del proyecto como queramos llamarlo. Luego continuamos y vamos a la pestaña Libraries (Bibliotecas) y dentro de ella agregamos una nueva (Add Library).

Despliega una nueva ventana y elegimos la opción Connectivity Driver Definition,lo más seguro es que su lista este vacía así que al lado hay un icono con la descripción New Driver Definition, la elegimos y damos un clic.

En una nueva ventana escogemos Oracle dentro de la opción Vendor Filter. Aparecerán muchas opciones con "Oracle Thin Driver", seleccionar el que corresponde a la versión de nuestra BD. En mi caso System version será 11.

Ahora la biblioteca esta configurada, pero no el archivo jar necesario, entonces se debe seleccionar la biblioteca Oracle Thin Driver y dar clic a la opción Add External JARs y luego seleccionar el archivo JAR correspondiente, en mi caso el ojdbc14, y aceptar.

Dentro del proyecto se observa las bibliotecas del Jdk y de Oracle

Paso 5 - Clase de conexión y prueba:

Creo un paquete de nombre accesoBD y dentro de el la Clase AccesoBD la cual tendrá la siguiente codificación:
package accesoBD;

import java.sql.Connection;
import java.sql.DriverManager;

public class AccesoBD {
 public static Connection getConnection() throws Exception{
 Connection cn;
 Class.forName("oracle.jdbc.OracleDriver").newInstance();
 String url = "jdbc:oracle:thin:@localhost:1521:XE";
 cn = DriverManager.getConnection(url, "TIENDA", "CLAVE");
 return cn;
 }
}

  • Bien ahora que son cada una de estas cosas, hay que recalcar que los valores que varían generalmente y nos interesan son:
   oracle.jdbc.OracleDriver
   jdbc:oracle:thin:@localhost:1521:XE
   url, "TIENDA", "CLAVE"
  • El primero hace referencia al driver de oracle, si utilizáramos otra base de datos usaríamos otro driver
  • El segundo al URL de nuestra base de datos generalmente la obtendrán con la siguiente fórmula jdbc:oracle:thin:@[HOST][:PORT]:SID todos estos datos son proporcionados por oracle durante la instalación y en caso deseen conocerlos pueden utilizar la herramienta SqlDeveloper o la perspectiva de Base de datos de Eclipse o Netbeans para encontrar el URL.
  • Bueno el tercero llama a nuestra URL, luego coloca el nombre de USER y a continuación la clave por la cual se identifica.
  • Ahora probemos si tenemos una conexión exitosa o no creando una clase Prueba. java dentro de un paquete al que yo llamaré test

package services;

import java.sql.Connection;
import java.sql.PreparedStatement;

import javax.swing.JOptionPane;

import accesoBD.AccesoBD;

public class PruebaBD {

 public static void main(String[] args) {
  Connection cn = null;
  try {
   cn = AccesoBD.getConnection();
   cn.setAutoCommit(false);
   String query = "INSERT INTO EMPLEADO VALUES "
     + "('Empl1', 'Coronel', 'Castillo',"
     + " 'Gustavo', 'GCoronel', '123456')";
   PreparedStatement pstm = cn.prepareStatement(query);
   pstm.executeUpdate();
   cn.commit();
   JOptionPane.showMessageDialog(null,
   "Conexion correcta \n Empleado agregado", null,
   JOptionPane.INFORMATION_MESSAGE);

  } catch (Exception e) {
   JOptionPane.showMessageDialog(null, "ERROR", null,
   JOptionPane.INFORMATION_MESSAGE);
   try {
    cn.rollback();
   } catch (Exception e1) {
   }
  }
 }
}