Devolver objetos desde métodos.

Código Java:

//Devolver objetos desde métodos.
package pasoobjeto;

class ObjectFactory {
   public CreatedClass getNewObject() {
      return new CreatedClass();
   }
}

class CreatedClass {
   public String tag = "Esta es la etiqueta de datos";
}

public class PasoObjeto {
   public static void main(String[] args) {
      ObjectFactory of = new ObjectFactory();
      CreatedClass cc = of.getNewObject();
      System.out.println(cc.tag);
   }
}


Resultado:

run:
Esta es la etiqueta de datos
BUILD SUCCESSFUL (total time: 0 seconds)

Uso de la palabra clave this.

Codigo:

//Usar la palabra clave this.
package javaapplication60;

class Data{
private String data_string;
Data (String s){
data_string = s;
}

public String getData(){
return data_string;
}

public void printData(){
printer p = new printer();
p.print(this);
}
}

class printer{
void print(Data d){
System.out.println(d.getData());
}
}

public class JavaApplication60 {
public static void main(String[] args){
(new Data("Hola")).printData();
}
}


Resultado:

run:
Hola
BUILD SUCCESSFUL (total time: 0 seconds)
·

Interfaces para herencia múltiple (estructura básica).

Codigo:

//Interfaces para herencia múltiple (estructura básica).
//Uso de las claves: interface e implement.

package main;

interface b{
//codigo
}

interface c{
//codigo
}

class a implements b, c {
//codigo
}

public class Main {
public static void main(String[] args) {
a obj = new a();
}
}
·

Clase interna anónima.

Código Java (ClaseInternaAnonima.java):

package claseinternaanonima;

class a {
    a() {
        (new b() {
            public void print() {
                System.out.println("Hola");
            }
        }).print();
    }
}

class b {}

public class ClaseInternaAnonima {
    public static void main(String[] args) {
        a obj = new a();
    }
}


Resultado:

run:
Hola
BUILD SUCCESSFUL (total time: 0 seconds)

Determinar la clase de un objeto: getClass.

Codigo:

//Determinar la clase de un objeto: getClass.
package clasedelobjeto;

class a{
public void print(){
System.out.println("Aqui esta a...");
}
}

class b extends a{
public void print(){
System.out.println("Aqui esta b...");
}
}

class c extends a{
public void print(){
System.out.println("Aqui esta c...");
}
}

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

a primera = new a(); //objeto de la clase base a
b segunda = new b(); //objeto de la subclase b
c tercera = new c(); //objeto de la subclase c

a ref_a;

ref_a = primera;
System.out.println("La clase ref_a es: "+ref_a.getClass());
ref_a.print();

ref_a = segunda;
System.out.println("La clase ref_a es: "+ref_a.getClass());
ref_a.print();

ref_a = tercera;
System.out.println("La clase ref_a es: "+ref_a.getClass());
ref_a.print();

}
}


Resultado:

run:
La clase ref_a es: class clasedelobjeto.a
Aqui esta a...
La clase ref_a es: class clasedelobjeto.b
Aqui esta b...
La clase ref_a es: class clasedelobjeto.c
Aqui esta c...
BUILD SUCCESSFUL (total time: 1 second)
·

Crear una clase abstracta: abstract.

Codigo:

package claseabstracta;

abstract class a{
abstract String getData();
public void print(){
System.out.println(getData());
}
}

class b extends a{
String getData(){
return "Hola";
}
}

public class JavaApplication69 {
public static void main(String[] args) {
b b1 = new b();
b1.print();
}
}


Resultado:

run:
Hola
BUILD SUCCESSFUL (total time: 0 seconds)
·

Acceso a los miembros sobreescritos: uso de super.

Codigo:

//Acceso a los miembros sobreescritos
package usarsuper;

class animal{
public void breathe(){
System.out.println("Respirar");
}
}

class pez extends animal{
public void breathe(){
System.out.println("Burbujear");
}
public void newbreathe(){
breathe(); //coge el breathe de la subclase "pez"
super.breathe(); //coge el breathe de la clase base "animal"
}
}

public class JavaApplication68 {
public static void main(String[] args) {
System.out.println("Crear un animal...");
animal a = new animal();
a.breathe();
System.out.println("Crear pez...");
pez p = new pez();
p.newbreathe();
}
}


Resultado:

run:
Crear un animal...
Respirar
Crear pez...
Burbujear
Respirar
BUILD SUCCESSFUL (total time: 0 seconds)
·

Cálculo letra del DNI.

Codigo:

package dni1;
import java.util.Scanner;
public class Dni1 {
public static void main(String[] args) {
String letras = "TRWAGMYFPDXBNJZSQVHLCKE";
System.out.println("Introduce DNI sin letra: ");
Scanner leer = new Scanner(System.in);
int dni = Integer.parseInt(leer.next());
int index = dni - (Math.abs(dni/23)*23);
System.out.println("Su letra de DNI es: "+ letras.charAt(index));
}
}

Resultado:

run:
Introduce DNI sin letra:
12345678
Su letra de DNI es: Z
BUILD SUCCESSFUL (total time: 4 seconds)
·

Gestión multiniveles de constructores.

Codigo:

//Gestion Multiniveles de Constructores
package jerarquia2;

class a{
a(){ System.out.println("a"); }
}

class b extends a{
b(){ System.out.println("b"); }
}

class c extends b{
c(){ System.out.println("c"); }
}

class d extends c{
d(){ System.out.println("d"); }
}

//Principal
public class Jerarquia2 {
public static void main(String[] args) {

System.out.println("1- objeto: ");
d objeto = new d();

System.out.println("2- objeto2: ");
b objeto2 = new b();

}
}


Resultado:

run:
1- objeto:
a
b
c
d
2- objeto2:
a
b
BUILD SUCCESSFUL (total time: 1 second)

Multiniveles de herencia. (subclases de subclases).

Codigo:

//Multiniveles de herencia. (subclases de subclases)
package jerarquia;

//nivel 1 (base)
class papel{
public void start(){
System.out.println("Coger tipo puntero...");
}
}

//nivel 2 (pincel)
class pincel extends papel{
public void usarpincel(){
System.out.println("Usar pincel...");
}
}

//nivel 2 (brocha)
class brocha extends papel{
public void usarbrocha(){
System.out.println("Usar brocha...");
}
}

//nivel 3 (escribir con pincel)
class escribir extends pincel{
public void escritura(){
System.out.println("Escribiendo...");
}
}

//nivel 3 (dibujar con pincel)
class dibujar extends pincel{
public void dibujo(){
System.out.println("Dibujando...");
}
}

//nivel 3 (pintar con brocha)
class pintar extends brocha{
public void pinta(){
System.out.println("Pintando...");
}
}

//nivel 3 (colorear con brocha)
class colorear extends brocha{
public void colorea(){
System.out.println("Coloreando...");
}
}

//Principal
public class Jerarquia {
public static void main(String[] args) {

System.out.println("1- ");
escribir e = new escribir();
e.start();
e.usarpincel();
e.escritura();

System.out.println("2- ");
dibujar d = new dibujar();
d.start();
d.usarpincel();
d.dibujo();

System.out.println("3- ");
pintar p = new pintar();
p.start();
p.usarbrocha();
p.pinta();

System.out.println("4- ");
colorear c = new colorear();
c.start();
c.usarbrocha();
c.colorea();
}
}


Resultado:

run:
1-
Coger tipo puntero...
Usar pincel...
Escribiendo...
2-
Coger tipo puntero...
Usar pincel...
Dibujando...
3-
Coger tipo puntero...
Usar brocha...
Pintando...
4-
Coger tipo puntero...
Usar brocha...
Coloreando...
BUILD SUCCESSFUL (total time: 0 seconds)

Crear una subclase usando la herencia.

Código (EjemploSubClase.java):

package ejemplosubclase;

// Clase base
class Vehiculo {
    // Método
    public void arrancar() {
        System.out.println("Arrancar");
    }
}

// Subclase de la clase base
class Coche extends Vehiculo {
    // Método
    public void conducir() {
        System.out.println("Conducir");
    }
}

public class EjemploSubClase {
    public static void main(String[] args) {
        System.out.println("Crear coche...");
        Coche c = new Coche();
        c.arrancar();
        c.conducir();
    }
}


Resultado:

run:
Crear coche...
Arrancar
Conducir
BUILD SUCCESSFUL (total time: 0 seconds)

Math.random: Generar números aleatorios.

Codigo:
package aleatorio1;
public class Aleatorio1 {
public static void main(String[] args) {
int numAleatorio = (int) Math.floor(Math.random()*1000+1);
System.out.println("Nº aleatorio 0-1000: " + numAleatorio);
}
}

Resultado:
run:
Nº aleatorio 0-1000: 577
BUILD SUCCESSFUL (total time: 0 seconds)

Applets 1: Ejecución de una aplicación desde un navegador Web.

Usando el Ide Netbeans 7.1.
1- Creamos nuevo proyecto de tipo "Java Aplication", con nombre "Applet1".
2- Eliminamos el "Applet1.java" y añadimos un "JApplet Form...".
3- En "Source Packages" añadimos un "HTML File..." con nombre "index1".
4- La estructura de nuestro proyecto debe quedar algo parecido a esto:


5- Nos dirigimos al "JApplet1.java" pestaña "Design" y añadimos botones, labels etc... tal y como muestra la siguiente captura:


// Codigo generado automaticamente por Netbeans:
package applet1;
public class JApplet1 extends javax.swing.JApplet {
public void init() {
try {
java.awt.EventQueue.invokeAndWait(new Runnable() {
public void run() {
initComponents();
}
});
} catch (Exception ex) {;}
}
@SuppressWarnings("unchecked")
private void initComponents(){...}
// Variables declaration - do not modify
private javax.swing.JButton jButton1;
private javax.swing.JComboBox jComboBox1;
private javax.swing.JLabel jLabel1;
private javax.swing.JList jList1;
private javax.swing.JProgressBar jProgressBar1;
private javax.swing.JScrollPane jScrollPane1;
private javax.swing.JScrollPane jScrollPane2;
private javax.swing.JTextArea jTextArea1;
// End of variables declaration
}

6- Nos dirigimos al "index1.html" y añadimos la siguiente etiqueta:


7- Observamos el codigo index1.html tal y como quedaria:


8- Para ver el resultado desde Netbeans pulsamos Shift + F6
9- Y para ver el resultado desde un navegador web, primero buscamos el archivo "index1.html". En nuestro caso Netbeans nos lo ha ubicado en:
D:\MIS DOCUMENTOS\NetBeansProjects\Applet1\build\classes\index1.html


10- Finalmente le damos a index1.html para ver el resultado final:

Expresiones Regulares II: Ejemplo práctico. Búsqueda de patrones dentro de un texto.

Codigo:

package expresion_regular;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

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

try {

BufferedReader teclado;
teclado = new BufferedReader (new InputStreamReader(System.in));

String texto = "Cuando utilice cart@uchos.es de impresión que no "
+ "de email@mail.tk, es que algunas características impresión de "
+ "los datos del ej. http://blogspot.com volumen restante, estén "
+ "disponibles por 192.168.1.1 usar suministro que no sea de api.";

System.out.println("Inserta expresion regular: ");
String ex_regular = teclado.readLine();

Pattern pat=Pattern.compile(ex_regular);
Matcher mat=pat.matcher(texto);

while(mat.find()){
String aux = mat.group();
System.out.println("Encontrado: " + aux);
}

} catch (IOException ex) {}

}
}


Resultado 1:
run:
Inserta expresion regular:
[0-9]+ (aquí ponemos manualmente la Expresión Regular deseada)
Encontrado: 192
Encontrado: 168
Encontrado: 1
Encontrado: 1
BUILD SUCCESSFUL (total time: 16 seconds)

Resultado 2:
run:
Inserta expresion regular:
\b(?:\d{1,3}\.){3}\d{1,3}\b
Encontrado: 192.168.1.1
BUILD SUCCESSFUL (total time: 2 seconds)

Resultado 3
run:
Inserta expresion regular:
((\w-)+(\.\w+)?)+@\w+\.\w+
Encontrado: cart@uchos.es
Encontrado: email@mail.tk
BUILD SUCCESSFUL (total time: 3 seconds)

Expresiones Regulares I: Tabla de referencia.

Las Expresiones Regulares son un mecanismo muy potente para realizar búsquedas o manipulaciones de cadenas dentro de un texto. Normalmente utilizadas para validación de formularios.

Tabla de referencia para la generación de estas expresiones:

*Caracteres:
x ................... Carácter
x\\ ................. Carácter de barra invertida
\0n ................. Carácter con valor octal 0n (0 <= n <= 7)
\0nn ................ Carácter con valor octal 0nn (0 <= n <= 7)
\0mnn ............... Carácter con valor octal 0mnn (0 <= m <= 3, 0 <= n <= 7)
\xhh ................ Carácter con valor hexadecimal 0xhh
\uhhhh .............. Carácter con valor hexadecimal 0xhhhh
\t .................. Carácter de tabulación ('\u0009')
\n .................. Carácter salto de línea('\u000A')
\r .................. Carácter de retorno de carro ('\u000D')
\f .................. Carácter de avance ('\u000C')
\a .................. Carácter de alerta ('\u0007')
\e .................. Carácter de escape ('\u001B')
\cx ................. Carácter de control correspondiente a x

*Grupo de caracteres:
[abc] ............... "a", "b", o "c" (clase simple)
[^abc] .............. Cualquier carácter excepto "a", "b", o "c" (negación)
[a-zA-Z] ............ de "a" a "z" o de "A" a "Z" (rango)
[a-d[m-p]] .......... "a" a "d", o "m" a "p" través de: [a-DM-p] (unión)
[a-z&&[def]] ........ "D", "E" o "F" (intersección)
[a-z&&[^bc]] ........ "a" a "z", con excepción de "b" y "c": [ad-z] (resta)

*Grupo de caracteres ya predefinidos:
\d .................. Caracteres numéricos [0-9]
\D .................. Cualquier caracter no numérico: [^0-9]
\s .................. Espacio en blanco: [\t\n\x0B\f\r]
\S .................. Cualquier caracter menos espacio: [^\s]
\w .................. Caracteres alfanumericos: [a-zA-Z_0-9]
\W .................. Caracteres no-alfanumericos: [^\w]

*Comparadores de límites:
^ ................... Principio de línea
$ ................... Final de línea
\b .................. Límite de palabra
\B .................. Límite de no-palabra
\A .................. Comienzo de la entrada
\G .................. Final del limite anterior
\z .................. Final de la entrada

*Greedy quantifiers:
X? .................. Una vez o cero
X* .................. Cero o más veces
X+ .................. Una o más veces
X{n} ................ Exactamente n veces
X{n,} ............... Mínimo de n veces
X{n,m} .............. Mínimo de n veces pero con un máximo de m veces

*Reluctant quantifiers:
X?? ................. Una vez o cero
X*? ................. Cero o más veces
X+? ................. Una o más veces
X{n}? ............... Exactamente n veces
X{n,}? .............. Mínimo de n veces
X{n,m}? ............. Mínimo de n veces pero con un máximo de m veces

*Possessive quantifiers:
X?+ ................. Una vez o cero
X*+ ................. Cero o más veces
X++ ................. Una o más veces
X{n}+ ............... Exactamente n veces
X{n,}+ .............. Mínimo de n veces
X{n,m}+ ............. Mínimo de n veces pero con un máximo de m veces

*Operadores lógicos:
XY .................. "X" seguida por "Y"
XIY ................. Ya sea "X" o "Y"
(X) ................. "X" como un grupo de captura

*Referencias anteriores:
\n .................. Cualquiera que sea el grupo enésimo coincidente

*Quotation:
\ ................... Ninguno, pero cita el siguiente carácter
\Q .................. Ninguno, pero cita a todos los caracteres hasta \E
\E .................. Ninguno, pero termina citando iniciado por \Q

*Construcciones especiales (sin captura):
(?:X) ............... X como un grupo sin captura
(?idmsux-idmsux) .... Ninguna, pero con indicadores de coincidencia ON-OFF
(?idmsux-idmsux:X) .. Como grupo sin captura con los indicadores ON-OFF
(?=X) ............... Vía de ancho cero positivo preanálisis
(?!X) ............... Vía de ancho cero anticipado negativo
(?<=X) .............. Vía ancho cero "lookbehind" positivo
(?>X) ............... Como independiente, no captura el grupo

Para puesta en práctica de ese tipo de estas expresiones muy recomendamble entrar en http://www.gskinner.com/RegExr/

Lectura desde teclado: Scanner

Codigo:

package leer_teclado;
import java.util.Scanner;

public class Leer_teclado {
public static void main(String[] args) {
System.out.println("Escribe tu nombre: ");
Scanner leer = new Scanner(System.in);
String nombre = leer.next();
System.out.println("Hola " + nombre);
}
}


Resultado:

run:
Escribe tu nombre:
Juan (aquí ponemos manualmente un nombre y pulsamos enter)
Hola Juan
BUILD SUCCESSFUL (total time: 7 seconds)

Hacer un "ping" a una máquina remota.

package jping;

import java.io.IOException;
import java.net.InetAddress;

public class JPing {
public static void main(String[] args) {
InetAddress ping;
String ip = "192.168.1.10"; // Ip de la máquina remota
try {
ping = InetAddress.getByName(ip);
if(ping.isReachable(5000)){
System.out.println(ip+" - responde!");
}else {
System.out.println(ip+" - no responde!");
}
} catch (IOException ex) { System.out.println(ex); }
}
}

Resultado:

run:
192.168.1.10 - responde!
BUILD SUCCESSFUL (total time: 4 seconds)

Comunicación entre procesos en diferentes máquinas de una red (Sockets)

Para ello necesitamos 2 codigos, uno con funcion servidor y otro de cliente.
Primero entramos en la IDE de Netbeans, creamos dos nuevos proyectos de tipo "Java aplication". Uno lo llamaremos "socket_servidor" y el otro "socket_cliente".


* Codigo servidor:

package socket_servidor;

import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Socket_servidor {
static final int PUERTO = 5000;
public Socket_servidor( ) {
try {
ServerSocket skServidor = new ServerSocket(PUERTO);
System.out.println("Esperando cliente..." );
Socket skCliente = skServidor.accept();
System.out.println("Recibido cliente y mandando saludo");
OutputStream aux = skCliente.getOutputStream();
DataOutputStream flujo = new DataOutputStream( aux );
flujo.writeUTF( "Saludos");
skCliente.close();
} catch( Exception e ) { System.out.println(e); }
}
public static void main(String[] args) {
new Socket_servidor();
}
}


* Codigo cliente:

package socket_cliente;

import java.io.DataInputStream;
import java.io.InputStream;
import java.net.Socket;

public class Socket_cliente {
static final String HOST = "localhost";
static final int PUERTO = 5000;
public Socket_cliente( ) {
try {
Socket skCliente = new Socket( HOST , PUERTO );
InputStream aux = skCliente.getInputStream();
DataInputStream flujo = new DataInputStream( aux );
System.out.println( "Servidor dice: " + flujo.readUTF() );
skCliente.close();
} catch( Exception e ) { System.out.println(e); }
}
public static void main(String[] args) {
new Socket_cliente();
}
}


- Resultado en pantalla del servidor:

run:
Esperando cliente...
Recibido cliente y mandando saludo
BUILD SUCCESSFUL (total time: 8 seconds)

Nota: Hasta que no se ejecute el codigo de cliente permanecerá en estado de "Esperando cliente..."


- Resultado en pantalla del cliente:

run:
Servidor dice: Saludos
BUILD SUCCESSFUL (total time: 0 seconds)

Nota 1: Debemos arrancar primero el codigo "socket_servidor" antes que el "socket cliente".
Nota 2: Asegurarse de usar puertos por encima de 1024. En nuestro caso utilizamos el puerto 5000.
Nota 3: Si tenemos puesto el proceso del servidor en otro PC dentro una misma red local, solo tenemos que modificar en el codigo del cliente la variable String HOST = "localhost" por la IP del servidor.
Ej:
String HOST = "192.168.0.100"; // IP donde este arrancado la aplicación "socket_servidor"

Ejecución de comandos MySql en codigo java.

Se crea una tabla llamada contactos. Seguidamente se agregan datos (registros), luego se hace una consulta y muestra el resultado en consola. Finalmente elimina la tabla y cierra la base de datos.

Codigo:

package mysql1;
import java.sql.*;
public class MySQL1 {
static String bd = "mi_base";
static String login = "root";
static String password = "";
static String url = "jdbc:mysql://localhost:3306/"+bd;
public static void main(String[] args) throws Exception {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,password);
if (conn != null) {
System.out.println("-Abierta base de datos " + url + " - Ok");

// Crear tabla contacto
Statement st = conn.createStatement();//Permite comandos SQL
st.executeUpdate( "CREATE TABLE contacto ("
+ "id INT AUTO_INCREMENT, "
+ "PRIMARY KEY(id), "
+ "nombre VARCHAR(20), "
+ "apellidos VARCHAR(20), "
+ "telefono VARCHAR(20))" );
System.out.println("-Creada tabla (contacto) - Ok");

// Insertar datos a la tabla
String nombres[]={"Juan","Maria","Antonio"};
String apellidos[]={"Sanchez","Jimenez","Moreno"};
String telefonos[]={"918971234","918984621","935741254"};
for (int i=0;i < nombres.length;i++) {
st.executeUpdate("INSERT INTO contacto ("
+ "nombre, "
+ "apellidos, "
+ "telefono) "
+ "VALUES ("
+ "'"+nombres[i]+
"','"+apellidos[i]+
"','"+telefonos[i]+
"' )");
}
System.out.println("-Añadir registros a la tabla - Ok");

// Consulta de datos
System.out.println("-Consultar registros:");
ResultSet rs = st.executeQuery ("select * from contacto");
while (rs.next()) {
System.out.println (
rs.getString (1) + " " +
rs.getString (2) + " " +
rs.getString (3) + " " +
rs.getString (4)
);
}

// Borrar tabla
st.executeUpdate("DROP TABLE contacto");
System.out.println("-Borrar tabla contacto - Ok");

conn.close();// Cerrar base de datos
System.out.println("-Cerrar base de datos " + url + " - Ok");
}
} catch(SQLException ex) { System.out.println(ex); }
}
}

Resultado:

run:
-Abierta base de datos jdbc:mysql://localhost:3306/mi_base - Ok
-Creada tabla (contacto) - Ok
-Añadir registros a la tabla - Ok
-Consultar registros:
1 Juan Sanchez 918971234
2 Maria Jimenez 918984621
3 Antonio Moreno 935741254
-Borrar tabla contacto - Ok
-Cerrar base de datos jdbc:mysql://localhost:3306/mi_base - Ok
BUILD SUCCESSFUL (total time: 1 second)

Nota: Para ejecutar comandos MySql desde codigo java hemos utilizado la sentencia executeUpdate y para consultas se utiliza executeQuery.

Comandos básicos de MySQL desde consola.

Entramos en consola del sistema. Y nos dirigimos en el siguiente directorio:
C:\Archivos de programa\MySQL\MySQL Server 5.5\bin
Y arrancamos el usuario "root" con la siguiente instrucción:

mysql -u root -p

Una vez dentro del menú "MySQL monitor" ya podemos empezar a gestionar nuestras bases de datos con las siguientes instrucciones basicas:

SHOW databases; --> Muestra listado de todas las bases de datos

CREATE database agenda; --> Crea una nueva base de datos llamada "agenda"

USE agenda; --> Seleccionamos la base de datos "agenda"

CREATE table contacto (nombre varchar(20), edad int); --> Crea una tabla llamada "contacto" con los campos nombre y edad

DESCRIBE contacto; --> Describe la estructura de los campos de la tabla "contacto"

INSERT INTO contacto VALUES ('Fulano', 20); --> Añade un registro a la tabla

SELECT * FROM contacto; --> Muestra todos datos de la tabla contacto

DROP table contacto; --> Borra la tabla "contacto"

DROP database agenda; --> Borra la base de datos "agenda" junto con todas las tablas que contenga


- Ejemplo práctico de utilización de dichos comandos:

C:\Archivos de programa\MySQL\MySQL Server 5.5\bin> mysql -u root -p
Enter password: ******

Welcome to the MySQL monitor. Commands end with ; or \g.
Your MySQL connection id is 40
Server version: 5.5.17 MySQL Community Server (GPL)

Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.

Oracle is a registered trademark of Oracle Corporation and/or its
affiliates. Other names may be trademarks of their respective
owners.

Type 'help;' or '\h' for help. Type '\c' to clear the current input statement.

mysql> show databases;
+--------------------+
| Database...........|
+--------------------+
| information_schema |
| mysql..............|
| performance_schema |
+--------------------+
3 rows in set (0.00 sec)

mysql> create database agenda;
Query OK, 1 row affected (0.00 sec)

mysql> show databases;
+--------------------+
| Database...........|
+--------------------+
| information_schema |
| agenda.............|
| mysql..............|
| performance_schema |
+--------------------+
4 rows in set (0.00 sec)

mysql> use agenda;
Database changed

mysql> create table contacto (nombre varchar(20), edad int);
Query OK, 0 rows affected (0.06 sec)

mysql> describe contacto;
+--------+-------------+------+-----+---------+-------+
| Field .| Type........| Null | Key | Default | Extra |
+--------+-------------+------+-----+---------+-------+
| nombre | varchar(20) | YES .|.....| NULL....|.......|
| edad...| int(11).....| YES .|.....| NULL....|.......|
+--------+-------------+------+-----+---------+-------+
2 rows in set (0.00 sec)

mysql> insert into contacto values ('Fulano', 20);
Query OK, 1 row affected (0.01 sec)

mysql> select * from contacto;
+--------+------+
| nombre | edad |
+--------+------+
| Fulano |...20 |
+--------+------+
1 row in set (0.00 sec)

mysql> drop table contacto;
Query OK, 0 rows affected (0.05 sec)

mysql> show tables;
Empty set (0.00 sec)

mysql> drop database agenda;
Query OK, 0 rows affected (0.00 sec)

mysql> show databases;
+--------------------+
| Database...........|
+--------------------+
| information_schema |
| mysql .............|
| performance_schema |
+--------------------+
3 rows in set (0.00 sec)

mysql> exit;
Bye

C:\Archivos de programa\MySQL\MySQL Server 5.5\bin>

Creación de una base de datos MySQL y comprobación de conexión

* Creación base de datos "mi_base":
Para empezar necesitaremos tener instalado el gestor de base de datos MySQL (la instalación por defecto, nos lo deja ya todo preparado).

1- Entramos a consola de comandos Inicio - Ejecutar - cmd [enter]

2- Nos dirigimos en el directorio:
C:\Archivos de programa\MySQL\MySQL Server 5.5\bin

3- Ejecutamos la orden:

mysql -u root -p

e introducimos la contraseña que nos pide

4- Procedemos a crear la tabla "mi_base" con la instrucción:

CREATE DATABASE mi_base;

5- Mostramos un listado de las bases de datos disponibles y vemos que se nos ha creado la nuestra (mi_base)

SHOW DATABASES;

5- Finalmente activamos nuestra base de datos con la instrucción:

USE mi_base;



Ya tenemos creada nuestra base de datos, ahora nos hace falta hacer la conexión desde codigo java. Para ello entramos al Netbeans IDE le damos a New Project y a Java Application al que llamaremos "mysql1".

* Codigo MySQL.java:

package mysql1;
import java.sql.*;
public class MySQL1 {
static String bd = "mi_base"; //Nombre de nuestra base de datos
static String login = "root"; //Nombre usuario que nos sale por defecto
static String password = "pass"; //contraseña del servidor del MySQL
static String url = "jdbc:mysql://localhost:3306/"+bd;
public static void main(String[] args) throws Exception {
Connection conn = null;
try {
Class.forName("com.mysql.jdbc.Driver").newInstance();
conn = DriverManager.getConnection(url,login,password);
if (conn != null) {
System.out.println("Conexión a base de datos "+url+" ... Ok");
conn.close();
}
} catch(SQLException ex) {
System.out.println("Error al conectarse con la base de datos "+url);
}
}
}

* Resultado:

run:
Conexión a base de datos jdbc:mysql://localhost:3306/mi_base ... Ok
BUILD SUCCESSFUL (total time: 2 seconds)

Conectar Java con MySQL.

Para empezar, debemos tener instalado el IDE NetBeans y el MySQL Connector Java que lo descargamos desde la URL:
http://dev.mysql.com/downloads/connector/j/


Se descomprime el archivo y se guarda en una carpeta que llamaremos C:\ConectorJ

Abrimos el Netbeans y procederemos de la siguiente manera:

1- Primero crearemos un proyecto normal (Java application).

2- Abrimos el manejador de bibliotecas. Menu Tools - Libraries - (Library Manager)



3- Nos aparece el cuadro Libray Manager y le damos al botón New Library. Nos aparece un cuadro que debemos rellenarlo tal y como se muestra en la figura de acontinuación y le damos Ok.



4- Ahora debemos agregar unos detalles a la biblioteca. Asegurando que la nueva biblioteca creada "MySQL" este seleccionada (izquierda).

5- Seleccionamos la pestaña Class Path y damos clic en el botón Add JAR/Folder...



6- Se abre un dialogo llamado Browse JAR/Folder que permite seleccionar archivos. Buscamos en la carpeta "C:\ConectorJ\mysql-connector-java-5.1.18\" el archivo "mysql-connector-java-5.1.18-bin.jar" descargado anteriormente, lo seleccionamos y damos click en el boton Add JAR/Folder

7- Aparecerá en la sección Class Path el archivo que acabamos de agregar, damos clic en Ok del cuadro de dialogo Library Manager. Y aqui termina la primera parte del proceso.

8- Ahora debemos agregar la librería al proyecto. Dentro del explorador del proyecto debemos seleccionar la carpeta Libraries. Dar click derecho para mostrar el menu contextual.



9- Seleccionar opción Add Library

10- Seleccionar de la lista, la biblioteca recién creada con el nombre "MySQL".

11- Debe aparecer como una nueva entrada dentro de la carpeta Libraries, tal y como muestra la siguiente imagen:



Y listo.

Instalación de un gestor de base de datos (MySQL)

Para empezar a trabajar con la base de datos, vamos a necesitar un sistema de gestion de base de datos relacional. Utilizaremos el sistema MySQL por su potencia y por ser software libre.

Primero descargamos el MySQL Installer desde la URL:
http://www.mysql.com/downloads/installer/


Y ejecutamos el instalador mysql-installer-5.5.17.0.msi.
Para evitar problemas y/o malos entendidos instalamos todas las opciones que nos vienen por defecto:

Developer Default - Next> - Next> - Execute - Next> - Developer Machine - Next> En esta pantalla en el apartado Security Settings introducimos nuestra contraseña que utilizaremos para entrar en nuestra futura base de datos.

Next> - Next> - Finish

Y ya tenemos la instalación de MySQL terminada.

Instalación de Netbeans 7.0 para programar en Java SE.

NetBeans es el entorno de desarrollo que utilizaremos para la programación Java. Pasos a seguir para su puesta en marcha:

1º Descargamos e instalamos JAVA desde la URL http://java.com/es/

2º Descargamos e instalamos Java Platform (JDK) desde la URL http://www.oracle.com/technetwork/java/javase/downloads/jdk-7u1-download-513651.html

3º Descargamos e instalamos NetBeans IDE de Java SE desde la URL http://netbeans.org/downloads/index.htmDurante la instalación dejamos todas las opciones por defecto.

Operar con números muy grandes (BigInteger)

Codigo: (Archivo: NumerosGrandes.java)

package numerosgrandes;
import java.math.BigInteger;
public class NumerosGrandes {
public static void main(String[] args) {
BigInteger fact = factorial(30);
System.out.println ("Factorial de 30 es: " + fact);
}

public static BigInteger factorial(int n) {
BigInteger f = new BigInteger("1");
for(int i=1;i<=n;i++) f = f.multiply(new BigInteger(i + ""));
return f;
}

}

Resultado:

Factorial de 30 es: 265252859812191058636308480000000

Mostrar otra ventana (JDialog) al pulsar botón.

Usando Netbeans7.0 se agregan en el nuevo proyecto dos ventanas. La ventana principal tipo jFrame con un boton dentro y la ventana secundaria de tipo jDialog.

Ventana principal (JFrame):
package dosventanas;
public class ventanaPrincipal extends javax.swing.JFrame {
public ventanaPrincipal() {
initComponents();
}
@SuppressWarnings("unchecked")
+ Generated Code //Aqui va codigo generado por Netbeans (ventana y boton).

private void BotonMostrarJDialog1ActionPerformed(java.awt.event.ActionEvent evt) {
new ventana2(this, true).setVisible(true);
}

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {
new ventanaPrincipal().setVisible(true);
}
});
}
// Variables declaration - do not modify
private javax.swing.JButton BotonMostrarJDialog1;
// End of variables declaration
}

Ventana secundaria (JDialog):
package dosventanas;
public class ventana2 extends javax.swing.JDialog {
public ventana2(java.awt.Frame parent, boolean modal) {
super(parent, modal);
initComponents();
}

@SuppressWarnings("unchecked")
+ Generated code //Aqui va codigo generado por Netbeans (ventana2)

public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {

public void run() {
ventana2 dialog = new ventana2(new javax.swing.JFrame(), true);
dialog.addWindowListener(new java.awt.event.WindowAdapter() {

public void windowClosing(java.awt.event.WindowEvent e) {
System.exit(0);
}
});
dialog.setVisible(true);
}
});
}
// Variables declaration - do not modify
// End of variables declaration
}

Resultado:
Nota1: En este ejemplo la ventana principal queda inhabilitada hasta que no se cierre la ventana secundaria (jDialog). Las ventanas de tipo jDialog tienen la pecurialidad de que al abrirse bloquean el resto (por seguridad).

Nota2: En netbeans7.0 (por defecto) no aparece en la lista el paquete "jDialog Form". Para ello, clic con botón izquierdo sobre icono paquete del proyecto y en el menu que aparece seguir el siguiente camino:
- New - Other - Swing GUI FORMS - jDialog form. [Next] -