configuración y conexion de mysql en java

http://javarocks.wordpress.com/2010/09/08/installing-and-configuring-javamysqlmysqlj-connector-in-windows/
ese es el link de otra forma de conectar y configurar la conexion de mysql mediante java.
enjoy the tuto
http://dev.mysql.com/downloads/connector/j/5.0.html#downloads en este enlace esta la descarga del conector.
y ahi mismo encontrarán la documentación de como instalarlo.
http://www.daniweb.com/software-development/java/threads/327483
por si fuera poco aqui esta mas explicado todavia

EJemplo de conexion a mysql desde java

/*
 * PruebaMySQL.java
 *
 * Programa de prueba para conexión a una base de datos de MySQL.
 * Presupone que el servidor de base de datos está arrancado, disponible,
 * en el puerto por defecto.
 * El usuario y password de conexión con la base de datos debe cambiarse.
 * En la base de datos se supone que hay una base de datos llamada prueba y que
 * tiene una tabla persona con tres campos, de esta manera:
 * mysql> create database prueba;
 * mysql> use prueba;
 * mysql> create table persona (id smallint auto_increment, nombre varchar(60), 
 *      nacimiento date, primary key(id)); 
 */

package chuidiang.ejemplos.base_datos;

import java.sql.*;

/**
 * Clase de prueba de conexión con una base de datos MySQL
 */
public class PruebaMySQL {
    
    /** 
     * Crea una instancia de la clase MySQL y realiza todo el código 
     * de conexión, consulta y muestra de resultados.
     */
    public PruebaMySQL() 
    {
        // Se mete todo en un try por los posibles errores de MySQL
        try
        {
            // Se registra el Driver de MySQL
            DriverManager.registerDriver(new org.gjt.mm.mysql.Driver());
            
            // Se obtiene una conexión con la base de datos. Hay que
            // cambiar el usuario "root" y la clave "la_clave" por las
            // adecuadas a la base de datos que estemos usando.
            Connection conexion = DriverManager.getConnection (
                "jdbc:mysql://localhost/prueba","root", "la_clave");
            
            // Se crea un Statement, para realizar la consulta
            Statement s = conexion.createStatement();
            
            // Se realiza la consulta. Los resultados se guardan en el 
            // ResultSet rs
            ResultSet rs = s.executeQuery ("select * from persona");
            
            // Se recorre el ResultSet, mostrando por pantalla los resultados.
            while (rs.next())
            {
                System.out.println (rs.getInt ("Id") + " " + rs.getString (2)+ 
                    " " + rs.getDate(3));
            }
            
            // Se cierra la conexión con la base de datos.
            conexion.close();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
    }
    
    /**
     * Método principal, instancia una clase PruebaMySQL
     *
     * @param args the command line arguments
     */
    public static void main(String[] args) 
    {
        new PruebaMySQL();
    }
    
}

Ejemplo de uso de Jradio

import javax.swing.*;
import javax.swing.event.*;
public class Formulario extends JFrame implements ChangeListener{
    private JRadioButton radio1,radio2,radio3;
    private ButtonGroup bg;
    public Formulario() {
        setLayout(null);
        bg=new ButtonGroup();
        radio1=new JRadioButton("640*480");
        radio1.setBounds(10,20,100,30);
        radio1.addChangeListener(this);
        add(radio1);
        bg.add(radio1);
        radio2=new JRadioButton("800*600");
        radio2.setBounds(10,70,100,30);
        radio2.addChangeListener(this);        
        add(radio2);
        bg.add(radio2);
        radio3=new JRadioButton("1024*768");
        radio3.setBounds(10,120,100,30);
        radio3.addChangeListener(this);        
        add(radio3);
        bg.add(radio3);        
    }
    
    public void stateChanged(ChangeEvent e) {
        if (radio1.isSelected()) {
            setSize(640,480);
        }
        if (radio2.isSelected()) {
            setSize(800,600);
        }
        if (radio3.isSelected()) {
            setSize(1024,768);
        }        
    }

    public static void main(String[] ar) {
        Formulario formulario1=new Formulario();
        formulario1.setBounds(0,0,350,230);
        formulario1.setVisible(true);
    }  
}

Como cambiar el orden en el que bootea grub

Hoy dejare constancia de como cambiar el orden de como bootea (arranca) grub, en este caso específico colocaremos que arranque de manera predeterminada con la particición donde tenemos instalado windows.
bueno lo primero que debemos hacer es abrir la terminal y ejecutar el siguiente comando
sudo gedit /boot/grub/menu.lst 
en este archivo encontraremos una sintaxis parecida a esta:

# menu.lst - See: grub(8), info grub, update-grub(8)
#            grub-install(8), grub-floppy(8),
#            grub-md5-crypt, /usr/share/doc/grub
#            and /usr/share/doc/grub-doc/.

## default num
# Set the default entry to the entry number NUM. Numbering starts from 0, and
# the entry number 0 is the default if the command is not used.
#
# You can specify 'saved' instead of a number. In this case, the default entry
# is the entry saved with the command 'savedefault'.
# WARNING: If you are using dmraid do not use 'savedefault' or your
# array will desync and will not let you boot your system.
default        0

## timeout sec
# Set a timeout, in SEC seconds, before automatically booting the default entry
# (normally the first entry defined).
timeout        10

## hiddenmenu
# Hides the menu by default (press ESC to see the menu)
#hiddenmenu

# Pretty colours
#color cyan/blue white/blue

## password ['--md5'] passwd
# If used in the first section of a menu file, disable all interactive editing
# control (menu entry editor and command-line)  and entries protected by the
# command 'lock'
# e.g. password topsecret
#      password --md5 $1$gLhU0/$aW78kHK1QfV3P2b2znUoe/
# password topsecret

#
# examples
#
# title        Windows 95/98/NT/2000
# root        (hd0,0)
# makeactive
# chainloader    +1
#
# title        Linux
# root        (hd0,1)
# kernel    /vmlinuz root=/dev/hda2 ro
#

#
# Put static boot stanzas before and/or after AUTOMAGIC KERNEL LIST

### BEGIN AUTOMAGIC KERNELS LIST
## lines between the AUTOMAGIC KERNELS LIST markers will be modified
## by the debian update-grub script except for the default options below

## DO NOT UNCOMMENT THEM, Just edit them to your needs

## ## Start Default Options ##
## default kernel options
## default kernel options for automagic boot options
## If you want special options for specific kernels use kopt_x_y_z
## where x.y.z is kernel version. Minor versions can be omitted.
## e.g. kopt=root=/dev/hda1 ro
##      kopt_2_6_8=root=/dev/hdc1 ro
##      kopt_2_6_8_2_686=root=/dev/hdc2 ro
# kopt=root=UUID=242c29c3-01fa-47ab-a4c3-9991029c9ae2 ro

## Setup crashdump menu entries
## e.g. crashdump=1
# crashdump=0

## default grub root device
## e.g. groot=(hd0,0)
# groot=(hd0,2)

## should update-grub create alternative automagic boot options
## e.g. alternative=true
##      alternative=false
# alternative=true

## should update-grub lock alternative automagic boot options
## e.g. lockalternative=true
##      lockalternative=false
# lockalternative=false

## additional options to use with the default boot option, but not with the
## alternatives
## e.g. defoptions=vga=791 resume=/dev/hda5
# defoptions=quiet splash

## should update-grub lock old automagic boot options
## e.g. lockold=false
##      lockold=true
# lockold=false

## Xen hypervisor options to use with the default Xen boot option
# xenhopt=

## Xen Linux kernel options to use with the default Xen boot option
# xenkopt=console=tty0

## altoption boot targets option
## multiple altoptions lines are allowed
## e.g. altoptions=(extra menu suffix) extra boot options
##      altoptions=(recovery) single
# altoptions=(recovery mode) single

## controls how many kernels should be put into the menu.lst
## only counts the first occurence of a kernel, not the
## alternative kernel options
## e.g. howmany=all
##      howmany=7
# howmany=all

## should update-grub create memtest86 boot option
## e.g. memtest86=true
##      memtest86=false
# memtest86=true

## should update-grub adjust the value of the default booted system
## can be true or false
# updatedefaultentry=false

## should update-grub add savedefault to the default options
## can be true or false
# savedefault=false

## ## End Default Options ##

title        Ubuntu 7.10, kernel 2.6.22-14-generic
root        (hd0,2)
kernel        /boot/vmlinuz-2.6.22-14-generic root=UUID=242c29c3-01fa-47ab-a4c3-9991029c9ae2 ro quiet splash
initrd        /boot/initrd.img-2.6.22-14-generic
quiet

title        Ubuntu 7.10, kernel 2.6.22-14-generic (recovery mode)
root        (hd0,2)
kernel        /boot/vmlinuz-2.6.22-14-generic root=UUID=242c29c3-01fa-47ab-a4c3-9991029c9ae2 ro single
initrd        /boot/initrd.img-2.6.22-14-generic

title        Ubuntu 7.10, memtest86+
root        (hd0,2)
kernel        /boot/memtest86+.bin
quiet

### END DEBIAN AUTOMAGIC KERNELS LIST

# This is a divider, added to separate the menu items below from the Debian
# ones.
title        Other operating systems:
root

# This entry automatically added by the Debian installer for a non-linux OS
# on /dev/sda1
title        Windows Vista/Longhorn (loader)
root        (hd0,0)
savedefault
makeactive
chainloader    +1

# This entry automatically added by the Debian installer for a non-linux OS
# on /dev/sda2
title        Windows Vista/Longhorn (loader)
root        (hd0,1)
savedefault
makeactive
chainloader    +1

en la que deberemos cambiar a default de 0 al numero que deseamos que arranque, para saber veamos lo siguiente:

cada sistema operativo deja su huella colocando las siguientes lineas:

# This entry automatically added by the Debian installer for a non-linux OS
# on /dev/sda2
title  

por lo que solo debemos contar hasta el sistema que deseamos arrancar desde un principio y cambiar el numero en default por el numero de la cuenta que realizamos.

Ejercicio 1 ActionEvent

Descarga aqui

Url libros

http://tinyurl.com/librosbipc

Ciencia Libre, Noticias Actuales.

Horario de Clases En la Tarde.

Variables

Las variables son valores modificables, es decir, son nombres que representan un valor de cierto tipo y el valor asociado al nombre se puede variar. Por ejemplo, si digo que X es una variable de tipo entero y después digo que tiene valor 10, escribiendo la expresión 5 + X es como si escribiera la expresión 5 + 10. De todas formas creo que todos vosotros tenéis familiaridad con las variables porque son lo principal de cada lenguaje de programación. Dicho esto, vamos a ver como Java trata las variables. En primer lugar, antes de utilizarla, una variable se tiene que escribir. En Java la escritura de una variable está compuesta por tres partes: modificadores, tipo e indentificadores. Los modificadores son una opción y son los que establecen el acceso a las variables, es decir, a los public particulares y protegidos que vimos en el capítulo anterior. Éstos se llaman modificadores de acceso y los hay estáticos, sincronizados y finales. No es importante ponerlos en órden, aunque sí es importante utilizar siempre el mismo órden para que sea legible el código. Estátic también lo vimos: nos permite escribir atributos y métodos constantes que se pueden invocar incluso antes de que un objeto se escriba. Final, en cambio, quiere decir que, cuando se utiliza un valor, éste se puede unir sólo una vez a un campo porque es también una constante. El modificador sincronizado lo dejaremos de lado: basta con indicar que sirve para decir que a un método, en el caso de una multiprogramación (con los thread), se puede acceder a través de una exclusión múltiple, es decir, un thread a la vez. Los identificadores pueden ser uno o más, están separados por una coma y son nombres que tienen variables. Por ejemplo, la escritura de X en el ejemplo anterior se convertirá en: ent X; pero, también puedo escribir más de uno. Por ejemplo, la siguiente escritura se considera válida: ent X,Y,Z; doble W=3.12; Como son atributos de las clases tienen que escribirse dentro de los mismos; escribirlos fuera de ellos se considera un error. Como se puede ver en el ejemplo, también es posible inicializar una variable en el momento en el que la creamos: símplemente hay que añadir, después del nombre, el signo igual y el valor que toma. Después de la escritura de la variable y su inicialización, el identificador de la variable, en cualquier lugar que se haya escrito, se entiende como su valor actual, excepto si le damos un nuevo valor. Por ejemplo, si escribo X = 10 me refiero a la variable X y no a su valor, y con el signo igual 10 me refiero a que el nuevo valor de la variable es 10. Si después escribo: X = X+1; con la X a la izquierda del signo igual me refiero a que la variable se llama X, mientras que con la X a la derecha me refiero al valor actual de la variable X. La expresión X+1, entonces, en este caso será 10 + 1 y entonces 11, es decir por X = X + 1, he dicho X = 11; Provad este pequeño programa que hace unos calculos: class p { ent X,Y,Z; double W = 3.12; public double A = 15; static int B = 101; private final int C = 2; protected static boolean D = true; public p() { X= 10 ; Y= X ; Z= X + Y ; System.out.println ("Al\'principio tengo: X="+X+", Y="+Y+", Z="+Z); X= X + 1 ; Y= Z - X; System.out.println ("Hago las operaciones: \nX= X + 1 ;\nY= Z - X;\ned resultado:"); System.out.println ("X="+X+", Y="+Y+", Z="+Z); } } class decl { public static void main(String[] a) { p Prueba=new p(); } } Como sabéis, visto que decl es la clase que incluye el main, tendréis que editar el programa en un archivo que se llama decl.java; después, ponedlo en marcha y a ver lo que ocurre. Hay también otros atributos para mostrar el uso de los modificadores. En el ejemplo vemos que yo creé una clase p y le puse el objeto Prueba, llamando al constructor. Hice esto porque las variables son atributos y, por eso, si no son estáticos, son atributos de un objeto. Tuve que crear un objeto para poder trabajar con sus variables. Hay que acostumbrarse a programar desde esta perspectiva porque los programas Java son todos así. Como el main del programa TIENE que declararse static (y tiene que tener una cadena como parámetro), éste se pone en marcha en ausencia del objeto y, por eso, algunas variables no son estáticas. Si hubiera querido crear solo una clase, hubiese tenido que escribir algo parecido a: class decl2 { int X,Y,Z; // Main public static void main(String [] a) { decl2 Prueba=new decl2(); } // Constructor public decl2() { X= 10 ; Y= X ; Z= X + Y ; System.out.println ("Al\'inicio tengo: X="+X+", Y="+Y+", Z="+Z); X= X + 1 ; Y= Z - X; System.out.println ("Hago las operaciones: \nX= X + 1 ;\nY= Z - X;\ned resultado:"); System.out.println ("X="+X+", Y="+Y+", Z="+Z); } } En este segundo ejemplo, editado y redactado en decl2.java, no se entiende bien cuándo vemos decl2 como clase y cuándo como objeto. Realmente el main está en la clase y en él se crea el objeto. Por tanto se invoca el constructor y dentro de él razonamos en términos de objeto creado. De todas formas, es posible y veréis que el programa funciona también en este caso. Algún día, cuando tengáis más familiaridad con el lenguaje, podréis hacerlo vosostros también. De momento no os lo aconsejo porque es fundamental, llegados a este punto, distinguir bien entre clases y objeto, y esto se consigue fácilmente con mucha experiencia. Los identificadores Java tienen que empezar por una letra (o con _ o $) seguida por una secuencia larga de caracteres y cifras elegidas a vuestro antojo. Las cifras, codificadas en Unicode, son mucho más numerosas que las letras y que las cifras ASCII utilizadas por otros lenguajes. Lo siento, pero no tengo un mapa completo de los caracteres unicode que dejaros, pero puedo deciros que están incluidos los caracteres griegos, cirílicos, árabes, etc. Ahora vamos a ver cómo escribir e inicializar un array. La escritura se hace poniéndo un par de corchetes después del tipo: ent [] vectorDeEnteros; Los array en Java son casi objetos, sólo que no pueden extenderse para añadirles nuevos métodos. Lo que acabamos de citar es una referencia a un array que, sin embargo, rl lenguaje no ha asignado. Si quiero inicializar el array elemento por elemento, como se hace con los demás lenguajes, tengo que escribir las dimensiones: ent [] vectorDeEnteros = nuevo ent[100]; A partir de ahora puedo empezar a poner los elementos en el vector, en las posiciones de 0 a 99. Si salgo de estos números, el aparato nos dará unmensaje de excepción del tipo out of range. Cuando creo, puedo además inicializar un array, basta con escribir: ent [] vectorDeEnteros = { 1,2,3,10,100,555,0, ….otros valores…}; Además puedo crear unos vectores cuyos elementos son ellos mismos vectores, etc. Esto se consigue de esta forma: double[] [] matrizIdentidadDeÓrden3 = { { 1.0 , 0.0 , 0.0 } , { 0.0 , 1.0 , 0.0 } , { 0.0 , 0.0 , 1.0 } }; El siguiente programa utiliza los array y lo editaremos en un archivo que se llama vect.java: clase vect { static ent NOMBRE = 0; static ent APELLIDOS = 1; static ent PATODÓNALD=0; static ent GILBERTO=1; static ent JORGITO=2; static ent JAIMITO=3; static ent JUANITO=4; static ent GUS=5; static ent COMISARIO=6; static ent RATÓN=7; static ent SUPER PATO=8; static ent PLUTO=9; static ent ABUELA=10; static ent GILITO=11; static Cadena personajes[][] = { {"Paolino","Pato Donald"}, {"Pietro","Gilberto"}, {"Jorgito","No especificado"}, {"Jaimito","No especificado"}, {"Juanito","No especificado"}, {"Ciccio","De Abuela Donald"}, {"No especificado","Comisario"}, {"No especificado","Ratón Micky"}, {"Tribilín","No especificado"}, {"Pluto","No especificado"}, {"No especificado","Daisy"}, {"No especificado","Gilito"}, }; public static void main(String [] a) { ent PersonajeTmp; ent Número=1; System.out.println ("Unos personajes de Walt Disney"); PersonajeTmp=PATODÓNALD; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=GILBERTO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=JORGITO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=JAIMITO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=JUANITO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=GUS; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=COMISARIO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=PLUTO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=TRIBILÍN; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=GILITO; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); Número=Número+1; PersonajeTmp=RATÓN; System.out.println("Número:"+Número+"\tNombre:"+personajes[PersonajeTmp][NOMBRE]+" Apellidos:"+personajes[PersonajeTmp][APELLIDOS]); System.out.println("HiCe los cálculos "+Número+" personajes, y eran muchos más"); // Éste sí es un programa realmente inútil. El autor. } } Un pequeño comentario sobre el programa. Os habéis dado cuanta de que en el main se establecen unas variables (es posible hacerlo): normalmente se usan sin redactarlas como static porque las variables del main, o de una función, por lo general, no son atributos y, por eso, no están relacionados con el objeto o con la clase, sino sólamente con la función en la que se escriben. En estas definiciones no están incluidos los modificadores porque estos se asocian a las clases. Llegados a este punto nos queda por ver los tipos compuestos que se pueden fácilmente identificar ahora con las clases. Por ejemplo, si queréis definir el tipo compuesto Complejos, escribiremos: clase Complejos { private double ParteReal; private double ParteImaginaria; Complejos (double Re, double Im) { ParteReal=Re; ParteImaginaria=Im; } // ahora estableceremos todos nuestros obvios métodos en el nuevo tipo double démeParteReal() { return ParteReal; }; double démeParteImaginaria() { return ParteImaginaria; }; double calculaMódulo() { return (java.lang.Math.sqrt((ParteImaginaria*ParteImaginaria)+ (ParteReal*ParteReal))); }; } Para probar, podéis escribir los siguiente(pruebaComplejos.java): clase pruebaComplejos { public static void main (Cadena[] arg) { Complejos N=nuevo Complejos(3.0,1.1); double Re=N.démeParteReal(); double Im=N.démeParteImaginaria(); double mod=N.calculaMódulo(); System.out.println("Número complejo:"+Re+"+i"+Im+" tiene "+mod); } }

Tipos primitivos de Java y valores

Llamamos tipos primitivos de un lenguaje cuando hablamos de tipos de datos ya definidos en el lenguaje y de los que se puede partir para la construcción de expresiones o tipos de compuestos.
Los tipos son muy importantes en todos estos lenguajes de programación y son fundamentales en Java que es un lenguaje que se basa mucho en los tipos. El concepto de tipo es muy natural: si veo un número, por ejemplo, 15.4 puedo decir en seguida el conjunto de números al que pertenece, en este caso al conjunto de los números reales.
Si veo una operación 4 / 5 puedo decir:

4 es de entero entero 5 es de tipo entero y / es una función de dos enteros y que me devuelve un número real. Se escribe así:

/ : ent x ent à float

Entonces, puedo decir que toda la expresión 4/5 es de tipo entero.

Lo que acabamos de hacer es, más o menos, una inferencia de tipos que es una práctica muy utilizada en informática. Para explicarla toda se necesitaría, como con los modelos por objetos, un curso entero.
Los problemas no surgen con estas expresiones, que se llaman cerradas, que no tienen variables, sino con las que tienen variables. Cada lenguaje emplea una técnica suya: algunas usan los tipos para las expresiones, otras establecen el tipo partiendo del contexto de la expresión y da un tipo en secuencia incluso por cada una de las expresiones, y los que, como Java, obligan a declarar todos los tipos de todas las variables desde el principio. Los tipos primitivos de Java son los mismos de los demás lenguajes de programación, sólo que difieren un poco en los valores y son.

boolean
es decir, valores que pueden ser verdaderos o falsos

char los caracteres son de 16 bit y están codificados en Unicode 1.1.5; en los demás lenguajes son ASCII solamente de 8 bit.

byte
enteros de 8 bit con signo, es decir, número entre menos (dos a la séptima) y dos a la octava.

short
enteros de 16 bit con signo.

int
enteros de 32 bit con signo.

long
enteros de 64 bit con signo.

float
reales de 32 bit con coma móvil (IEEE 754-1985).

double
reales de 32 bit con coma móvil (IEEE 754-1985).

Obviamente, a partir de éstos es posible definir nuevos tipos de datos que se llaman compuestos. Por ejemplo, una cadena es un vector de caracteres y es un tipo compuesto.
Como vimos el la lección precedente, en el paquete java.lang están los contenedores para estos tipos de base, es decir, que si escribo ent, me refiero a un número entero, mientras que si escribo Enteger me refiero a las clases enteros.

Si uso las clases, tendré también una serie de atributos y métodos útiles para trabajar con ellos. Por ejemplo, en alguans se definen las constantes MIN_VALUE y MAX_VALUE (Mínimo y máximo valor), en las clases Float y Double encontraremos las constantes NEGATIVE_INFINITY y POSITIVE_INFINITY, NaN para indicar un valor que no es válido y el método isNan() para controlar si un valor es válido. Por ejemplo, se puede utilizar después de una división para controlar que no se haya hecho una división por cero que resultaría catastrófica. Todo esto no existe en los demás lenguajes de programación.
Ahora vamos a ver los literales de cada tipo de Java, es decir los valores constantes que cada tipo puede tener.

El único literal para referirnos a los objetos es null, se puede utilizar cada vez que nos esperamos una referencia a un objeto, null es un objeto que no se ha creado y no es válido: no es de ningún tipo.

Los literales booleani son verdaderos y falsos e indican, respectivamente, el valor cero y el valor falso.

Los literales enteros son cadenas de cifras octales, decimales o exadecimales. El inicio de la constante sirve para escribir la base del número: un cero inicial indica base ocho, 0x o 0X indica base 16 y nada indica los decimales. Por ejemplo, el número 15 en base diez puede representarse como:

15 como decimal
017 como octal
0xf o 0XF como esadecimal.

Las constantes enteras que terminan por l o L se consideran long. Es mejor que terminen por L porque l se confunde fácilmente con la unidad (no se equivoca el compilador, pero sí nosostros que leemos los programas) y si no acaban por una letra se consideran como ent. Si un leteral ent se escribe como un short o como un byte, éste se porta como si lo fuera.

Los literales con coma móvil se escriben como números decimales, con un punto opcional seguido, posiblemente, por un exponente que empieza por e, según la práctica corriente para indicar mantisa-exponente. El número puede llevar detrás una f (F) o una d (D) para indicar que es, con precisión, simple o doble, para default es doble.

35, 35. , 3.5y1, .35y2 representan el mismo número.

El cero puede ser positivo o negativo, si los comparamos obtenemos la equivalencia. Sin embargo, es útil en los cálculos, pensemos en 1d/0d y 1d/-0d.
No es posible conceder una constante doble a una float aunque esté en la serie. Si queremos hacer esta operación, hay que hacer un cambio que se llama casting que analizaremos a continuación.

Los caracteres se ponen entre comilla como, por ejemplo, '2', y los caracteres especiales están representados por unas secuencias, llamadas secuencias de escape. Son:

\n newline, a parte

\t tab

\b backspace, borra a la izquierda

\r return, representa el carácter especial ENVIO

\f form feed

\\ es el carácter backslash

\' comilla

\" comillas

\ddd es un char que emplea el valor octal (d son cifras octales, por ejemplo \329, tienen que ser de tres o menos cifras y menores de \377), se puede dar también la representación exadecimal, siempre de cuatro cifras. Aquí ponemos en orden los caracteres citados antes con su número exadecimal: \u000A, \u0009, \u0008, \u000D, \u000C, \u005C, \u0027 y \u0022.

Las cadenas se escriben entre comillas, como por ejemplo "Pietro" y todas las secuencias de escape válidas se pueden introducir en una larga cadena, creando cosas interesantes como, por ejemplo:

System.out.println("\tNombre:\tPietro\n\tApellido:\tCastellucci" );

dará este resultado:Nombre: Pietro
Apellido: Castellucci

Manteniendo de Hardware .

Clase Mantenimiento de Computadoras.