La historia de Java

Para conocer de dónde surgió Java, hemos de remontarnos al principio de Ios tiempos de la informática, cuando los dinosaurias -fortran, cobol y basic caminaban sobre la faz de la tiena. Aún no se habían inventado los microprocesadores -el i4004 fué un proyecto de InteI del año 71 , y, aunque se considere que fué el primer micrapracesador, se diseño para calculadoras, no para ordenadores, por lo que los equipos eran grandes, voluminosos y los costes de ejecución de los programas eran muy caros.


En aquel tiempo, una empresa -AT&T- _abajaba en un sistema revolucionario: MULTICS -MULTiplexed Iilformation and Computing System- fue un sistema operativo revolucionario para su tiempo. Quizás demasiado revoIucianarío, porque Jámas vio la luz. Se diseña para trabajar sobre un GE645, permitiendo compartición de la información entre varíos usuarios y una seguridad buena. Además, era interactivo -algo inovador para la época, ya que aún se empleaban tarjetas perforadas para programar los ordenadores-. Sin embarga, e1 desanol1o del proyecto era demasiado lento, y las necesidades de memona y de procesador excesivas para la época. Por ello, los laboratorios Bell abandonaron el proyecto.


Este sistema operativo había pasado a la histona como uno de tantos proyectos inconclusos de no ser por Ken Thompsom, uno de los programadores de la Bell. Ken diseñó un juego para la computadora GE llamada Space Travel. En dicha juego, el usuario debía conducir una nave espacial por el sistema solar. Parece bastante trivial, de no ser porque cada partida costaba 75 dólares -unas 1OOOO pesetas. Ante semejante coste, lo reescribió para una máquina más modesta, el PDP-1. Para ello contó con la ayuda de Denis Ritchie. Entre los dos tomaron el sistema operativo MULTICS -sobre el que corría el juego- y le recortaron todo lo que no era estrictamente necesario. También le adaptaron un sistema de archivos sencillo, que diseñaron entre Ken, Ritchie y Rudd Canaday. Aquello funcionaba, y a un coste muy inferior al de su hermano mayor. Jocósamente, un compañero de trabajo de Ken y Ritchie -Brian Kernighan- llamó UNICS al engendro.

Había nacido el UNIX

Mas, ¿qué tiene que ver todo esto con el lenguaje Java? Mucho. UNIX comenzó siendo programado en código máquina. Mas esto es una tarea despraporcionada para un programador. Por ella, cuando AT&T dio algunos fondos para comenzar a trabajar sobre un DEC PDP -1 Dennis Ritchie tomo el ensamblador del PDP- 11, lo mezcló con un lenguaje diseñado por Ken Thompsom para el desarrolIo primigenio del UNIX, el lenguaje B, lenguaje trenendamente parecida al C, y al que C le debe mucho; el cual provenía de un lenguaje bastante críptico, el BCPL de Martin Richars.

Había nacido el lenguaje C


C se covirtió pronto en un lenguaje muy popular. Un lenguaje diseñado por un grupo reducido especificamente para ayudarles a ellos mismos a programar un sistema operativo completo, el Unix. Por tanto un lenguaje que, a diferencia de otros lenguajes, no tenía como finalidad acercar la informática a usuarios no legos; ni fue un lenguaje diseńado en el escritorios de teóricos de la informática.

C está diseñado por programadores y para progamadores. Es el resultado último de la tarea de buscar un lenguaje cámodo para los expertos, y que permita sacar el máximo rendimiento de la máquina. C permite hacer lo que uno quiera, lo que da gran flexibilidad pero puede convertir la programación en una tarea diabolicamente compleja. De hecho, hay hasta cancursos de código ofuscado en C, donde gana el que hace el programa más dificil de entender.

Además, fue un lenguaje que se extendió con gran rapidez, por el éxito del sistema operativo UNTX. Al acompañar siempre a dicho
sistema operativo, su popularización contribuyó a que gran parte de las maquinas tuvieran un compilador de C instalado. La popularización del UNIX, con dichos compiladores instalados contribuyó al éxito del lenguaje. De hecho, las pocas bibliotecas estandares deI C coinciden con parte fundamental del API de UNIX, y la forma de gestión de memoria de un programa en C y de un proceso en UNIX es la misma, independientemente de sobre qué sistema operativo corra el programa.

Por último, su filosofía de creación es espléndida. C se diseñó para implementar un sistema o erativo. Por ello, se creá un lenguaje simple, potente, rápido y cercano a la maquina. Dichas razones hacen que hoy por hoy C sea el lenguaje más idóneo para la implementación de sistemas operativos y controladores. C es casi un ensamblador estandarizado, ya que, al ser producto de la mezcla de un lenguaje de alto nivel con un ensamblador una instrucción en C se corresponde a pacas instrucciones en código maquina - depende de si el procesador es RISC o CSIC, mas rara vez supera la media dacena de instrucciones en código máquina.

La llegada del golem: el C++

Sin embargo, "no todo el monte es orégano". En lo que le hace potente, C tiene su mayor debilidad: los punteros. C copió los punteros del ensamblador del PDP-11. Eso le da toda la potencia como lenguaje, mas tambien es fruto de problemas de depuración insalvables. Los programas en C eran lentos en desarrollar, y eran mastodontes de imposible depuracián. Era preciso buscar algo nuevo, algo que permitiera acortar el tiempo de desarrollo y el de depuración. '

Paralelamente, el mundo de la informática teórica había desarrollado un nuevo paradigma: la orientación a objetos. Una nueva forma de entender la pragramación, completamente revolucionaria, que acortaba el tiempo de desarrollo de las aplicaciones y su depuración a costa de incrementar un poco el tiempo previo de diseño.

Aquello era lo que necesitaba C


En 1979 BJarne Stroustrup numenta en 10 las palabras claves del C, y conserva la sintaxis antigua, pero dota al lenguaje de unn nueva sematica, basada en el paradigma orientado a objetos. El l983 lo bautiza. Ha nacida el C++. con una sintaxis semejante a la del C, mas con una semántica nueva: la ojentación a objetos.

El nacimiento de este nuevo lenguaje supuso una nueva revolución. Era un compromiso razonable entre la velocidad y la comodidad de uso. Si bien no consiguió desbancar al C en el campo de las aplicaciones que necesitaban más rendimiento -sistemas operativos y controladores de dispositivos, básicamente, se canvirtió en el lenguaje por antonomasia.

C++ es un lenguaje especial. Prograamado como si se programara en C, los programas son más complejos y dificiles de entender que los equivalentes en C. Mas cuando se emplea toda la potencia del paradigma orientado a objetos, y se sigue una metodologia cuidadosamente, se desarrollan aplicaciones de gran tamaño con una facilidad impresionante.

Además de todo esto nacieron nuevos conceptos de rogramación. Primero, las herramientas de desarrollo rápido de apliaciones. Después, las herramientas de pramación Visual. Ahora hacer grandes programas con un buen interfaz con el usuario era una tarea facil.

Y al fin llego la revolución

C++ tenía muchas ventajas. Pero tambien muchos inconvenientes. Había hecho muchas concesiones al C.por lo que su sintaxis aún era oscura; un programa en C está más cerca de un texto alquímico que de la lista de la compra. Además, si en C la compatibilidad entre compiladores era pequeña, en C++ era nula. Las bibliotecas estandar de clases se retrasó mucho, y cuando estuvo madura, ya se habia popularizado el lenguaje.

Si el C era un lenguaje hermítico, solo para expertos, el C++ era más cerrado todavía. Además de necesitar dominar la programación tradicional, necesitaba conacer la programación orientada a objetos.

Finales de las años 80. James Gosling estuvo trabajando antes que en el Java en un editor de SG llamada "Imagination" usando C++ y, bajo su desesperación, observó que el programa se le iba de las manos. No pudo acabarlo.

Año 1990. Patrick Naughtan estaba completamente harto de su trabajo. Su función era simple, "sólamente" mantener la compatibilidad entre los distintos API que empletaban los compiladores de C++ de su empresa. Fue a hablar can el director de Sun, Scott McNealy, que se iba a dejar la empresa por la NeXT. Mas el director de Sun no estaba dispuesto a perder una persona tan valiosa, y le pidio que escribiera una lista can todo lo que creía que debía cambiar en su trabajo.

La lista, además de muy fuerte se hizo muy popular. Hasta que cayó en las manos de Billy Joy. Billy Joy habia sido el responsable de una parte muy importante de las mejoras del BSD -UNI de Berkley- sobre el SV de T&T y después había sido Unix su tema en la tesis

doctoral, y, al abandonar la universidad, creó una nueva versión de Unix basada en la BSD, la Sun OS. Era, pues, el fundadar de Sun y, además, uno de los "gurús" de la informática. Billy Joy estaba completamente de acuerdo con sus quejas, que iba a ser transferido, si estaba dispuesto a continuar en la empresa, a un equipo nuevo y distinto.

El equipo estaría integrado por James Gosling, Patric Naughton, Chris Warth, Ed Frank y Mike Sheridan. Más

tarde se sumarian el mismo Billy Joy, A1thur van Hoff, Jonathan Payne, Frank Yellin y Tim Lindholm.

Proyecto Secreto GREEN PROJECT

Corria el año 1991. El objetivo estaba claro, viendo los protagonistas de la historia. Un lenguaje cómodo de programar, potente, de propósito general, robusto, fiable. Un lenguaje diseñado tanto para hacer un sistema de gestión enorme como para programar un horno microondas. Independiente del ordenador, independiente de la tecnalogía. Estaba naciendo una revolución. Estaba naciendo Java.

Siendo todos programadores experimentados, muchos de ellos provenientes del mundo del UNIX y hasta gurus dentro de él, teniendo las manos libres el trabajo fue espectacular. Tomaran el lenguaje C++, que era lo mejor que había en el momento, y comenzaron a trabajar

con él. Primero quitaran todo aquello que no servía, que era fuente de errores, o que daba problemas de progración. Después quitaron lo opaco o difícil de comprender, dejando un lenguaje minimalista, con toda la potencia expresiva del C++, pero con mucha más claridad.

Habiendo acabado esto, cambiaron las palabras claves que no les agradaban, y comenzaron a incluir lo último en tecnologías. Recolección de basura, orientación a objetos fuerte, tipo Smalltalk, polimorfismo dinámico nexible, multihebra nativa, soparte nativo de red, seguridad en red, fueron algunas de las cosas que incluyeron. No satisfechos todavía, incluyeron aquellos tipos que el C y el C++ estaban pidiendo desde hace mucho tiempo como los booleanos, formalizaron el tamaño y el método de representación de las vȧnables, adaptaron los caracteres al farmato Unicode que, a diferencin del ASCII, permite representar una gran cantidad de lenguas y alfabetos.

Después de la expejencia del API de C caótico y el de C++ más caótico todavía, si esto es posible, crearon un API estructurada en una jerarquía de clases estándar, conocida y bien documentada. Además, incluyeron herramientas para la generación automática de documentación, y muchas cosas más. Era, definitivamente, el lenguaje del futuro.

El lenguaje estaba listo. Faltaba el nombre. El empleado para el desarrollo interno había sido Oak; mas este nombre era poco comercial y, al parecer, ya estaba registrado. Por ello, tras una lluvia de ideas, alguien dijo "Java", y con ese nombre se quedó, en

recuerdo de los cientos de tazas de café que los programadores hemos tenida que tomar delante del monitor, por la noche, depurando cientos de líneas de código en la carrera por tener el programa listo antes de la fecha de entrega.

Java no ha sido nunca un lenguaje para crear "monicacos" en paginas WWW de internet. Es un lenguaje anterior al nacimiento de la WWW en el CERN. Sin embargo, su especial arquitectura y su completa biblioteca de clases gráficas -applets- lo hacen excepcional para la tarea de la programación de páginas WWW. Por lo que después del nacimiento de la WWW se le incluyeron características para adaptarlo a este medio.

Hoy en día, Sun ha dotado a JDK, su compilador de Java, de una licencia similar a la de GPL, lo que petmite decir que ahora es software libre. Las restricciones que tiene Java estan relacionadas con que siga siendo un estándar a pesar del intento desesperado de determinadas compañías para que deje de serlo y que siga siendo libre. Además, ha establecido conversaciones con ANSI para hacer un estándar oficial, ha obligado a todo el que desarrolle un compilador Java a que sea compatible con Java y está convirtiendo las potentísimas pero indocumentadas sun.* en Java.*, documentadas y campletamente estándares.

El futuro

Billy Joy, uno de los visianarios de BSD, el visionario de Sun, tuvo pronto una nueva idea: ¿Y un sistema operativo basado en Java? Es el JavaOS, sistema operativo microkernel y en red, que promete revolucionar el mundo de la informatica, al permitir que todas las aplicaciones corran sobre todas las máquinas.Un sistema operativo para hacer electrodomésticos inteligentes, bombillas que avisen cuando se queman, televisores que naveguen por Internet; el de los anillas Java, que permiten encender y apagar luces, abrir y cerrar cerraduras; o el de robots Java. Es decir, Java intenta convertirse en toda una tecnología unificada, que nos permita programar cualquier máquina con el compilador de cualquier fabricante, y que además presente al usuario el mismo interfaz final.

Java solo tiene un detractor. Microsoft vió en ese campo un filón de aro, y está diseńando una versión de windows que permita todo eso. Además de eso, el lenguaJe Java supone un disparo bajo su linea de flotación. Hasta hora, la posición de Microsoft era cómoda; los programadores programaban para Windows porque todo el mundo tenía windows, y todo el mundo tenía Windows porque los

programadores programaban para Windows. Eso tuvo como consecuencia la practica desaparición de toda competencia, quedando sólo dos competidores: un Macintosh marginal, mantenido artificialmente por Microsfot para evitar que se apliquen leyes antimonopolio la ultima inyección importante de capital a Apple vino de la mano de la misma Microsoft, que tiene suficiente capital en Apple como para controlar la empresa, y el suficentemente poco como para que no se el apliquen leyes de monopolio, y un UNIX, con fama de excesivamenete dificil y compIejo de manejar, con un mercado reducido y en pugna con el Windows NT.

Al ser la aplicación completamente independiente de la plataforma, el día que se popularicen aplicaciones escritas en Java será el fin de facto del monopolio de Microsoft. Las usuarios escogerán el sistema operativo que mejor se adapte a sus maquinas, no teniendo que esctar consientemente sometidos a la carrera de comprar material informático cada vez mas potente para correr sistemas operativos cada vez más lentos que son precisos para correr nuevas versiones de aplicaciones que sólo funcionan sobre estos nuevos sistemas.

Por ello, Microsoft contraataca afreciendo compiladores que dicen que son compatibles con Java pero no lo son batalla que aún está en los tribunales, creando formatos de empaquetado el CAB que, además de no aportar nada nuevo el ZIP realiza las mismas funciones mejor no permite interconectividad con todos los demás sistemas operativos, máquinas virtuales y navegadores. ¿Podrá Java romper el monopolio de Microsoft? ¿Podrá Microsoft romper el estandar Java y la compatibilidad? Va a comenzar la batalla entre los dos colosos: Microsoft lider del mercado y Sun empresa historica del sector.

Java, además, ya dispone de una implementación de GNU, el GUAVAC. Eso significa software libre que, independientemente de la politica empresarial de Sun, el lenguaje va a estar ai disponible. Con la existencia de compiladores libres siempre estaremos tranquilos, ya que no pasaremos de estar casados con una empresa a estar casados con otra sino que podremos programar tranquilamente, de forma independiente de las corrientes del mercado.

David Santos

Instalar JDK

Para la instalación del JDK lo descargamos desde aqui

Para instalar el JDK solo copie el archivo a /opt y ejecute con
./jdk-6u26-linux-i586.bin

Para la configurar siga los siguientes pasos
$ update-alternatives --install /usr/bin/java java /opt/jdk1.6.0_26/jre/bin/java 120

8.- Ahora para seleccionar la version java a instalar usamos el comando
$ update-alternatives --config java

que nos mostrara todas las versiones de java que tenemos instaladas, ahora solo tecleamos el numero que
contiene la version que hemos instalado osea /usr/java/jre1.6.0_17/bin/java y listo

9.- Y al final
$ update-alternatives --set java /opt/jdk1.6.0_26/jre/bin/

se puede verificar la version instalada actualmente de java con el comando
$ java -version

para los que aun usan Windows podrán instalarlo de la siguiente manera :
1. Descargar JDK desde el enlace que esta arriba
2. Doble clic en el instalador jdk-6u26-windows-i586.exe
3. Seguir los siguientes pasos

Instalar NetBeans

Para la instalación del Netbeans lo descargaremos de aqui  Netbeans

Entrada de datos

import java.io.IOException;
import java.io.BufferedReader;
import java.io.InputStreamReader;

public class Consola {
    public static void main(String [] args) throws IOException
    {
        InputStreamReader fluj = new InputStreamReader(System.in);
        BufferedReader teclado = new BufferedReader(fluj);
     
        System.out.println("ingrese un numero: ");
        String num = teclado.readLine();
        int n = Integer.parseInt(num);
        System.out.println("usted ingresó: "+n);
    }

}

Variables

Variable cadena

public class Consola {
    public static void main(String[] args) {
        String cadena="esta es mi variable";
        System.out.println(cadena);
    }
}


Variable entera

public class Consola {
    public static void main(String[] args) {
       int entero=5;
        System.out.println(entero);
    }
}

Variable flotante

public class Consola {
    public static void main(String[] args) {
       float flotante=9999.33292f;
        System.out.println(flotante);
    }
}


Variable booleana

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

        boolean booleano=false;
        if(booleano==true)   {
            System.out.print("Esto es verdadero");
        } else {
            System.out.print("Esto es falso");
        }
     
    }
}

Variable fecha

import java.util.Date;
import java.text.SimpleDateFormat;
import java.text.DateFormat;
public class Consola {
    public static void main(String[] args) {

DateFormat dateFormat = new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
Date fecha = new Date();

System.out.println(dateFormat.format(fecha));
     
    }
}

Variable array

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

        String[] array=new String[4];
        array[0]="bob";
        array[1]="riche";
        array[2]="jacky";
        array[3]="rosy";
        System.out.println(array[1]);      
    }
}

Métodos de la clase String

+
Concatenación (unión de hilera).También permite
concatenar una hilera con un dato numérico o booleano.
EJEMPLO
String cadena = "Universidad " + " Técnica";


int length( ) 
Retorna la cantidad de caracteres que tiene la String
EJEMPLO
String cadena = “Universidad Técnica”;
int a = cadena.length();


String replace (char viejoChar, char nuevoChar)
Remplaza en la hilera que invoca el método, el viejoChar por el nuevoChar. Se utiliza para reemplazar caracteres
EJEMPLO
String hilera, cadena = "mamá";
hilera = cadena.replace(‘m’,’p’ );



String replaceAll (String viejaString, String nuevaString)
Remplaza en la hilera que invoca al método la vieja String por la nueva String. Se utiliza para reemplazar subhileras
EJEMPLO
String cadena = "José Soto";
cadena = cadena.replaceAll("Soto","Solís" );


String toLowerCase() 
Convierte todos los caracteres de la hilera a minúscula. Solo para hileras, no funciona para char.
EJEMPLO
String cadena = "JAVA";

String toUpperCase() 
Convierte todos los caracteres de la hilera a mayúscula. Solo para hileras, no funciona para char.
EJEMPLO
String cadena = "java";
cadena = cadena.toUpperCase();


boolean equals(String str): 
Compara la hilera que invoca al método con la del parámetro. Si son iguales retorna true y si nó, retorna false. Es sensitivo a mayúsculas y minúsculas.
EJEMPLO
String cadena1 = "alajuela", cadena2 = "Alajuela";
if (cadena1.equals(cadena2)){
out.println("Son iguales");
else
out.println("Son diferentes");


boolean equalsIgnoreCase (String str) 
Compara la hilera que invoca al método con la del parámetro. Si son iguales retorna true y si nó, retorna false. No es sensitivo a mayúsculas y minúsculas.
EJEMPLO
String cadena1 = "alajuela";
String cadena2 = "Alajuela";
if (cadena1.equalsIgnoreCase(cadena2)){
out.println("Son iguales");
else
out.println("Son diferentes");


int compareTo(String str1)
Compara 2 cadenas y retorna un valor numérico.:
Cero (o): si ambas cadenas son iguales
Un número < 0 si la primera hilera es menor a la segunda.
Un número > 0 si la primera hilera es mayor a la segunda.
EJEMPLO
String cad1="1234";
String cad2="1334";
valor=cad1.compareTo(cad2);
if(valor==0)
out.println("Son iguales";
else
if (valor<0)
out.println("cad1 menor cad2";
else
out.println("cad1 mayor cad2";


String trim()
Elimina espacios en blanco al principio y al final de la cadena. No elimina los espacios situados entre las palabras.
EJEMPLO
String cadena = " Programación 1 ";
cadena = cadena.trim();


String substring(int indiceInicial, int indiceFinal) 
Retorna el segmento de la String entre la posición ‘indiceInicial’ inclusive hasta una posición anterior a ‘indiceFinal’.
EJEMPLO
String cadena = "Desarrollo Orientado a Objetos";
out.println(cadena.substring(11,20));

char charAt (int indice)

Devuelve el carácter que ocupa la posición indicada por el índice. 

EJEMPLO 

String cadena = "Polimorfismo"; 

out.println(cadena.charAt(4)); 

bolean isLetter(char caracter)) 
Retorna un verdadero si el carácter del parámetro es una letra
EJEMPLO
char caracter;
if (Character.isLetter(caracter))
out.println(caracter +" es una letra");



bolean isDigit(char caracter)) 
Retorna un verdadero si el carácter del parámetro es un dígito
EJEMPLO
char caracter;
if (Character.isDigit(caracter))
out.println(caracter +" es un dígito");

bolean isUpperCase(char caracter) 
Retorna un verdadero si el carácter del parámetro es una letra mayúscula
EJEMPLO
char caracter;
if (Character.isUpperCase(caracter))
out.println(caracter +" es una letra mayúscula");

boolean isLowerCase(char caracter) 
Retorna un verdadero si el carácter del parámetro es una letra minúscula
EJEMPLO
char caracter;
if (Character.isLowerCase(caracter))
out.println(caracter +" es una letra minúscula");

La clase java.lang.Math

La clase java.lang.Math es una clase utilitaria cuyos métodos (todos estáticos) nos permiten realizar algunos cálculos matemáticos comunes.

Antiguamente Math implementaba cada uno de sus métodos, pero hoy en día hace uso de la clase java.lang.StrictMath para llevar adelante sus tareas, llegando al punto que prácticamente es lo mismo llamar a un método de Math como uno de StrictMath.

StrictMath utiliza librerías nativas (escritas en C) para realizar sus cálculos, asegurando entre otras cosas una mejor performance con números flotantes y repetibilidad de los resultados (si se llama un método con los mismos parámetros obtenemos exactamente el mismo resultado, bit a bit). Concretamente hace uso de la librería fdlibm (Freely Distributable Math Library) version 5.3 que es parte del proyecto netlib.



Constantes Matemáticas
Math tiene una referencia a las dos constantes más utilizadas en matemática con una precisión de 15 decimales (suficiente para la mayoría de los mortales). Si ejecutamos:

out.println("e = " + Math.E);
out.println("pi = " + Math.PI);


Conversiones Grados a Radianes, y viseversa
Tenemos dos métodos que realizan la tarea por nosotros

double angGrados = 45; //grados
double angRadianes = Math.toRadians(angGrados);
out.println("Deg a Rad: " + angGrados + "º = " + angRadianes + " rad");
angGrados = Math.toDegrees(angRadianes);
out.println("Rad a Deg: " + angRadianes + " rad = " + angGrados + "º");


Funciones Trigonométricas
Las funciones trigonométricas aceptan y devuelven los ángulos en radianes por lo que siempre hay que convertir desde/hacia grados.

Por ejemplo si ejecutamos:


double valor = 0;

double angulo = 45; //grados
double anguloRadianes = Math.toRadians(angulo);

valor = Math.cos(anguloRadianes);
out.println("Coseno de " + angulo + "º = " + valor);

valor = Math.sin(anguloRadianes);
out.println("Seno de " + angulo + "º = " + valor);

valor = Math.tan(anguloRadianes);
out.println("Tangente de " + angulo + "º = " + valor);

valor = 0.707;

anguloRadianes = Math.acos(valor);
angulo = Math.toDegrees(anguloRadianes);
out.println("Arco Coseno de " + valor + " = " + angulo + "º");

anguloRadianes = Math.asin(valor);
angulo = Math.toDegrees(anguloRadianes);
out.println("Arco Seno de " + valor + " = " + angulo + "º");

anguloRadianes = Math.atan(valor);
angulo = Math.toDegrees(anguloRadianes);
out.println("Arco Tangente de " + valor + " = " + angulo + "º");


Funciones Hiperbólicas

Las funciones hiperbólicas están disponibles a partir de la versión 1.5 Aún no existe implementaciones para las funciones inversas (acosh, asinh y atanh)

Del siguiente ejemplo:


double valor = 0;
double x = 1.0;
 valor = Math.cosh(x);
out.println("Coseno Hiperbolico de " + x + " = " + valor);
valor = Math.sinh(x);
out.println("Seno Hiperbolico de " + x + " = " + valor);
valor = Math.tanh(x);
out.println("Tangente Hiperbolica de " + x + " = " + valor);

Conversiones

De cadena a numérico

public class Consola {
    public static void main(String [] args)
    {      
        String cadena ="5";
        int numero = Integer.parseInt(cadena);

        System.out.println(numero);
    }
}


De cadena a float

public class Consola {
    public static void main(String [] args)
    {
        String cadena ="5.5";
        float numero= Float.parseFloat(cadena);

        System.out.println(numero);
    }
}

De numerico a cadena

public class Consola {
    public static void main(String [] args)
    {
        int numero = 500;
        String cadena = String.valueOf(numero);

        System.out.println(cadena);
    }
}

Estructura de control

a.) La sentencia if - else

La sentencia if-else de Java dota a los programas de la habilidad de ejecutar distintos conjuntos de sentencias según algún criterio.

La sintaxis de la sentencia if-else es:


if ( condición )
  Bloque de código a ejecutar si la condición es cierta
else
  Bloque de código a ejecutar si la condición es falsa


La parte del else es opcional, y un bloque de código puede ser simplemente la sentencia vacía ; para representar que en ese caso no se ha de ejecutar nada.

Supongamos que un programa debe realizar diferentes acciones dependiendo de si el usuario oprime el botón aceptar o el botón cancelar en una ventana de dialogo. Nuestro programa puede realizar esto usando la sentencia if - else:


public class Consola {
    public static void main(String [] args)
    {
        boolean respuesta=true;
        if (respuesta == true) {
          System.out.println( "Su peticion esta siendo atendida" );
        } else {
          System.out.println( "Cancelando accion" );
        }
    }
}


Se pueden anidar expresiones if-else, para poder implementar aquellos casos con múltiples acciones. Esto es lo que se suele denominar como sentencias else if.

Por ejemplo, supongamos que se desea escribir un programa que clasifique según el contenido de una variable valor, asigne una letra a una variable clasificacion: A para un valor del 100-91, B de 90-81, C para 80-71 y F si no es ninguno de los anteriores:

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

       int valor=80;
       char clasificacion;
       if (valor > 90)
          {clasificacion='A';}
       else
          if (valor > 80)
            {clasificacion='B';}
          else
            if (valor > 70)
              {clasificacion='C';}
            else
              {clasificacion='F';}
       System.out.println(clasificacion);

    }
}


Se pueden escribir los if en las mismas líneas que los else, pero desde este tutorial se insta a utilizar la forma indentada (como se ha podido ver en el ejemplo), pues es más clara para el lector.

Este sistema de programación (else if) no es demasiado recomendable, y por ello el lenguaje Java incluye la sentencia switch, que veremos a continuación, para dirigir el flujo de control de variables con múltiples valores.


b.) La sentencia switch

Mediante la sentencia switch se puede seleccionar entre varias sentencias según el valor de cierta expresión.

La forma general de switch es la siguiente:

switch ( expresionMultivalor ) {
  case valor1 : conjuntoDeSentencias; break;
  case valor2 : conjuntoDeSentencias; break;
  case valor3: conjuntoDeSentencias; break;
  default: conjuntoDeSentencias; break;
}


La sentencia switch evalúa la expresiónMultivalor y ejecuta el conjuntoDeSentencias que aparece junto a la cláusula case cuyo valor corresponda con el de la expresiónMultivalor.

Cada sentencia case debe ser única y el valor que evalúa debe ser del mismo tipo que el devuelto por la expresiónMultivalor de la sentencia switch.

Las sentencias break que aparecen tras cada conjuntoDeSentencias provocan que el control salga del switch y continúe con la siguiente instrucción al switch. Las sentencias break son necesarias porque sin ellas se ejecutarían secuencialmente las sentencias case siguientes. Existen ciertas situaciones en las que se desea ejecutar secuencialmente algunas o todas las sentencias case, para lo que habrá que eliminar algunos break.

Finalmente, se puede usar la sentencia default para manejar los valores que no son explícitamente contemplados por alguna de las sentencias case. Su uso es altamente recomendado.

Por ejemplo, supongamos un programa con una variable entera meses cuyo valor indica el mes actual, y se desea imprimir el nombre del mes en que estemos. Se puede utilizar la sentencia switch para realizar esta operación:

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

       int meses=10;

        switch (meses){
          case 1: System.out.println( "Enero" ); break;
          case 2: System.out.println( "Febrero" ); break;
          case 3: System.out.println( "Marzo" ); break;
          case 4: System.out.println( "Abril" ); break;
          case 5: System.out.println( "Mayo" ); break;
          case 6: System.out.println( "Junio" ); break;
          case 7: System.out.println( "Julio" ); break;
          case 8: System.out.println( "Agosto" ); break;
          case 9: System.out.println( "Septiembre" ); break;
          case 10: System.out.println( "Octubre" ); break;
          case 11: System.out.println( "Noviembre" ); break;
          case 12: System.out.println( "Diciembre" ); break;
          default: System.out.println( "Mes no valido" ); break;
        }
     
    }
}



Por supuesto, se puede implementar esta estructura como una sentencia if else if:

int meses;
if ( meses == 1 ) {
  System.out.println( "Enero" );
} else
  if ( meses == 2 ) {
    System.out.println( "Febrero" );
  }
  // Y así para los demás meses


El decidir si usar la sentencia if o switch depende del criterio de cada caso. Se puede decidir cuál usar basándonos en la legibilidad, aunque se recomienda utilizar switch para sentencias con más de tres o cuatro posibilidades.

c.) Bucle while

El bucle while es el bucle básico de iteración. Sirve para realizar una acción sucesivamente mientras se cumpla una determinada condición.

La forma general del bucle while es la siguiente:

while ( expresiónBooleana ) {
  sentencias;
};


Las sentencias se ejecutan mientras la expresiónBooleana tenga un valor de verdadero.

Se utiliza, por ejemplo para estar en un bucle del que no hay que salir hasta que no se cumpla una determinada condición. Por ejemplo, multiplicar un número por 2 hasta que sea mayor que 100:

public class Consola {
    public static void main(String [] args)
    {
        int i = 1;
        while ( i <= 100 ) {
            i = i * 2;
            System.out.println(i);
        }
    }
}

Con él se podrían eliminar los bucles do-while y for por ser extensiones de éste, pero que se incluyen en el lenguaje para facilitar la programación.


d.) Bucle do-while

El bucle do-while es similar al bucle while, pero en el bucle while la expresión se evalúa al principio del bucle y en el bucle do-while la evaluación se realiza al final.

La forma general del bucle do-while es la siguiente:

do {
  sentencias;
} while ( expresiónBooleana );

La sentencia do-while es el constructor de bucles menos utilizado en la programación, pero tiene sus usos, cuando el bucle deba ser ejecutado por lo menos una vez.

Por ejemplo, cuando se lee información de un archivo, se sabe que siempre se debe leer por lo menos un carácter:

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

        int c;
        c=5;
        do {
          System.out.println(c);
          c--;
        } while(c>0);

    }
}

e.) Bucle for

Mediante la sentencia for se resume un bucle do-while con una iniciación previa. Es muy común que en los bucles while y do-while se inicien las variables de control de número de pasadas por el bucle, inmediatamente antes de comenzar los bucles. Por eso el bucle for está tan extendido.

La forma general de la sentencia for es la siguiente:

for ( iniciación ; terminación ; incremento )
  sentencias;

La iniciación es una sentencia que se ejecuta una vez antes de entrar en el bucle.

La terminación es una expresión que determina cuándo se debe terminar el bucle. Esta expresión se evalúa al final de cada iteración del bucle. Cuando la expresión se evalúa a falso, el bucle termina.

El incremento es una expresión que es invocada en cada iteración del bucle. En realidad puede ser una acción cualquiera, aunque se suele utilizar para incrementar una variable contador:

for ( i = 0 ; i < 10 ; i++ )

Algunos (o todos) estos componentes pueden omitirse, pero los puntos y coma siempre deben aparecer (aunque sea sin nada entre sí).

Se debe utilizar el bucle for cuando se conozcan las restricciones del bucle (su instrucción de iniciación, criterio de terminación e instrucción de incremento).

Por ejemplo, los bucles for son utilizados comúnmente para iterar sobre los elementos de una matriz, o los caracteres de una cadena:

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

        for ( int i = 0; i < 5 ; i++){
            System.out.println(i);
        }

    }
}

Excepciones

Vamos a hablar un poco sobre las Excepciones en Java, que son?, de donde vienen? y como evitarlas entre, otras....... debemos tener presente que siempre estamos propensos a encontrarnos con errores o Excepciones cuando estamos desarrollando, por eso de la importancia de conocerlas y saber como tratarlas....

Básicamente una excepcion es un Objeto descendiente de la clase java.lang.Object, podemos pensar en ellas como una condición excepcional en nuestro sistema el cual altera la correcta ejecución del mismo, las excepciones nos indican que hay algo anómalo,  inconsistente o simplemente un Error, lo cual impide que el sistema se ejecute como debería de ser...

Tal vez se preguntaran si ¿pero Anómalo, inconsistente o Error no es básicamente lo mismo?...... podría ser, pero en este enfoque no necesariamene lo es, ya que lo que vamos a conocer como una excepcion no siempre es un error (hablando como excepcion en general, ya que en java una Exception es muy diferente a un Error), muchas veces necesitaremos trabajar con excepciones controladas para indicar alguna inconsistencia en nuestro sistema que podría provocar errores.......

A modo de ejemplo, podemos encontrarnos con el famoso NullPointerException el cual nos indica que un objeto se encuentra vació, pero esto no es un error ya que nosotros podemos trabajar con objetos null, entonces veamoslo como si la excepcion nos dijera "Es un objeto nulo y no se puede efectuar el proceso", mientras que hay errores como NoClassDefFoundError el cual nos indica que la maquina virtual de Java (JVM) no puede encontrar una clase que necesita, debido a por ejemplo que no encuentra un .class, esto si se maneja como un error en java


La importancia de Prever!!!

Cuando se esta programando debemos tener claro que nuestro código no es perfecto, así tengamos mucha experiencia en desarrollo siempre esta la posibilidad de que algo falle, sea por nuestro código o por otros factores, por eso de la importancia de contemplar todo desde antes, posibles fallos o lo que pueda afectar el sistema.

Veamos un ejemplo Simple:

public class Consola {
    public static void main(String [] args)
    {
        int dividendo=4;
        int divisor=2;
        int resultado=dividendo/divisor;
        System.out.println(resultado);
    }
}

el main teóricamente esta bien, claro, a simple vista si tenemos : dividendo = 4 y divisor = 2 pues el resultado es 2 ......básico....... pero y si el divisor es 0? pues con ese caso puntual el resultado seria el siguiente.


Vemos que nos indican que se produjo una ArithmeticException debido a una división por cero, además se muestra cual fue la traza del error pasando por el método main hasta el metodoDividir().


La anterior es una Excepcion simple, algo que se supone no debería pasar, es obvio, no se puede dividir por cero, o ¿no?.........pues no, en programación no podemos asumir ni pensar así, ya que muchas veces nos olvidamos de las cosas obvias y las pasamos por alto, el problema es que eso tan obvio puede detener toda la ejecución del programa.


Trabajando con try - catch - finally

con los bloques Try - Catch podemos capturar y procesar una posible excepcion, evitando que el sistema se detenga sin necesidad cuando el motivo de esto puede ser corregido facilmente, la estructura básica es la siguiente.

try {
  //Bloque de código que vamos a procesar
} catch(excepcion) {
  //Tratamiento que se le da a la posible excepción
} finally {
  //Bloque de código que se ejecutará despues del try o del catch
}


Apliquemos esto a nuestro ejemplo anterior...

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

        int dividendo=4;
        int divisor=2;
        int resultado=0;
        try {
            resultado=dividendo/divisor;
        }catch (Exception e) {
            System.out.println("Se intentó dividir por cero");
        } finally{
            System.out.println(resultado);  
        }
     
    }

}

Como vimos aplicamos la estructura de los bloques y de esta manera nos aseguramos que la excepción anterior fue controlada evitando que el sistema se detenga, en el catch podemos hacer el proceso que consideremos conveniente, ya sea solo informar del error o solicitar nuevos parámetros de entrada.


Algunas Consideraciones.

Veamos un poco mas lo que debemos tener en cuenta cuando usamos estos bloques:

try : Aquí vamos a escribir todo el bloque de código que posiblemente llegue a lanzar unas excepción la cual queremos manejar, aquí va tanto el código como llamados a métodos que puedan arrojar la excepción.

En este bloque solo se detectara la primera excepcion lanzada, hay que tener en cuenta que por cada try se debe especificar un catch y/o un finally.

catch : en caso de que en el try se encuentre alguna excepción, se ingresara automaticamente al bloque catch donde se encontrara el código o proceso que queremos realizar para controlar la excepción.

Se pueden especificar cualquier cantidad de catch de ser necesario, estos deben ser ubicados después del try y antes del finally (en caso de que este ultimo se especifique),  cada catch que se ponga debe manejar una excepcion diferente (no se puede repetir) y el orden de estos depende de la jerarquía de herencia que se tenga, ingresando al primer catch que pueda suplir la necesidad a corregir, por ejemplo.

try {
      //Sentencias con posibles errores;
    } catch(InterruptedException e){
      //manejo de la exepcion
    } catch(IOException e){
   //manejo de la exepcion
    } catch(Exception e){
   //manejo de la exepcion
    }

Si se genera una excepción en el try, se valida a cual de los 3 catch se ingresa, dependiendo si InterruptedException puede controlarlo se ingresa a esa, sino entonces a IOException o si no a la superClase que seria Exception (ver la jerarquía de herencia anterior).

En el ejemplo que del metodoDividir() trabajamos directamente con Exception e, de esta forma nos aseguramos que capture cualquier excepción, sin embargo se recomienda usar la jerarquía en los catch para poderle dar un mejor manejo.

finally : Este bloque es opcional, lo podremos si queremos ejecutar otro proceso después del try o el catch, es decir, siempre se ejecutara sin importar que se encuentre o no una excepción, a menos que exista un return en alguno de los bloques anteriores.

Hilos

A veces necesitamos que nuestro programa Java realice varias cosas simultáneamente. Otras veces tiene que realizar una tarea muy pesada, por ejemplo, consultar en el listín telefónico todos los nombres de chica que tengan la letra n, que tarda mucho y no deseamos que todo se quede parado mientras se realiza dicha tarea. Para conseguir que Java haga varias cosas a la vez o que el programa no se quede parado mientras realiza una tarea compleja, tenemos los hilos (Threads).

Crear un Hilo

Crear un hilo en java es una tarea muy sencilla. Basta heredar de la clase Thread y definir el método run(). Luego se instancia esta

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

        Runnable miRunnable = new Runnable() {
            public void run() {
                //----------------------------------------
                for(int i=0;i<=10;i++){
                    System.out.println(i);
                    try {
                        Thread.sleep (1000);
                    } catch (Exception e) { }
                }
                //----------------------------------------
            }          
        };
        Thread hilo = new Thread(miRunnable);
        hilo.start();

    }
}

Listo. Hemos creado una clase hilo que hereda de Thread y con un método run(). En el método run() pondremos el código que queremos que se ejecute en un hilo separado. Luego instanciamos el hilo con un new hilo() y lo arrancamos con hilo.start(). El System.out que hay detrás se ejecutará inmediatamente después del start(), haya terminado o no el código del hilo.

Imprimir en Java

Se trata de un programa que recibe un String en un campo de texto y lo imprime al pulsar el botón IMPRIMIR.

/********************************************************************
* El siguiente programa es un ejemplo bastante sencillo de *
* impresión con JAVA. *
********************************************************************/
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;


/********************************************************************
* La siguiente clase llamada "Impresora", es la encargada de   *
* establecer la fuente con que se va a imprimir, de obtener el *
* trabajo de impresion, la página. En esta clase hay un método *
* llamado imprimir, el cual recibe una cadena y la imprime. *
********************************************************************/
class Impresora
{
    Font fuente = new Font("Dialog", Font.PLAIN, 10);
PrintJob pj;
Graphics pagina;


/********************************************************************
* A continuación el constructor de la clase. Aquí lo único que *
* hago es tomar un objeto de impresion. *
********************************************************************/
Impresora()
{
pj = Toolkit.getDefaultToolkit().getPrintJob(new Frame(), "SCAT", null);
}

/********************************************************************
* A continuación el método "imprimir(String)", el encargado de *
* colocar en el objeto gráfico la cadena que se le pasa como *
* parámetro y se imprime. *
********************************************************************/
    public void imprimir(String Cadena)
{
//LO COLOCO EN UN try/catch PORQUE PUEDEN CANCELAR LA IMPRESION
try
{
pagina = pj.getGraphics();
pagina.setFont(fuente);
pagina.setColor(Color.black);

pagina.drawString(Cadena, 60, 60);

pagina.dispose();
pj.end();
}catch(Exception e)
{
System.out.println("LA IMPRESION HA SIDO CANCELADA...");
}
}//FIN DEL PROCEDIMIENTO imprimir(String...)


}//FIN DE LA CLASE Impresora



//A CONTINUACION LA CLASE PRINCIPAL
public class Programa extends JFrame
{
String cadena;
JTextField campo;
JButton imprimir;
JLabel info;
Impresora imp;
JPanel principal = new JPanel(new BorderLayout());
JPanel etiq = new JPanel(new FlowLayout());
JPanel dos = new JPanel(new FlowLayout());

//CONSTRUCTOR DE LA CLASE
Programa()
{
super("Muestra Simple de Impresión en JAVA...");

info = new JLabel("ESCRIBA ALGO EN EL CAMPO Y HAGA CLIC EN IMPRIMIR...");
cadena = new String();
campo = new JTextField(30);
imprimir = new JButton("IMPRIMIR");

dos.add(campo);
dos.add(imprimir);
etiq.add(info);

campo.setToolTipText("ESCRIBA ALGO AQUÍ...");
imprimir.setToolTipText("CLIC AQUI PARA IMPRIMIR...");

principal.add(etiq, BorderLayout.NORTH);
principal.add(dos, BorderLayout.CENTER);

getContentPane().add(principal);

//AJUSTO EL TAMAÑO DE LA VENTANA AL MINIMO
pack();
//NO PERMITO QUE PUEDAN CAMBIAR EL TAMAÑO DE LA VENTANA
this.setResizable(false);

//AHORA LA CENTRARÉ EN LA PANTALLA
Dimension pantalla, cuadro;
pantalla = Toolkit.getDefaultToolkit().getScreenSize();
cuadro = this.getSize();

this.setLocation(((pantalla.width - cuadro.width)/2),
 (pantalla.height - cuadro.height)/2);


//LE AGREGAMOS EL EVENTO AL BOTON "imprimir"

imprimir.addActionListener(new ActionListener()
{
public void actionPerformed(ActionEvent evt)
{
cadena = "";
cadena = String.valueOf(campo.getText());
if (!cadena.equals(""))
{
imp = new Impresora();
imp.imprimir(cadena);
}
else System.out.println("NO SE IMPRIME NADA EN BLANCO...");

campo.requestFocus();
campo.select(0, cadena.length());
}
});
 

 
}//FIN DEL CONSTRUCTOR

public static void main(String jm[])
{
Programa p = new Programa();
p.show();

p.addWindowListener(new WindowAdapter()
{
public void windowClosing(WindowEvent evt)
{
System.exit(0);
}
});
}//FIN DEL MAIN



}//FIN DE LA CLASE PRINCIPAL

Esperar un tiempo en java

Normalmente se hacen todas las sentencias seguidas, pero a veces se necesita congelar el tiempo.

Pero como se hace para esperar un tiempo en una aplicación en Java antes de lanzar la siguiente sentencia…

Sencillo, imagina que quieres esperar 10 segundos entre una sentencia y otra. Para conseguirlo deberemos hacer lo siguiente:

Sentencia 1

try {
Thread.sleep (10000);
} catch (Exception e) {
// Mensaje en caso de que falle
}

Sentencia 2

Sencillo, ¿no?

El tiempo que se le pasa tiene que ser en milisegundos. También se puede crear un método Java que nos haga esto.

public void esperar (int segundos) {
try {
Thread.sleep (segundos*1000);
} catch (Exception e) {
// Mensaje en caso de que falle
}
}

Y ya tendremos un método Java al que le pasaremos los segundos a esperar.

JBLAS

JBLAS son un conjunto de librerías JavaBeans, que nos permite trabajar con base de datos (MySQL y PostgreSQL), su forma de trabajo es muy similar a la que trabajábamos con Visual FoxPro o Visual Basic, de esta manera programar conexiones y actualización de datos se hace muy fácil, las librerías aun están en versión beta, y las liberare muy pronto, espero comentarios y si desean usarlas solo pídanlas