Sin embargo, entre versión y versión se aplican ciertas mejoras y/o correcciones. Por ejemplo: JDK1.1 incorporó la tecnología
JavaBeans. Basicamente esta tecnología describe un
bean como un objeto con sus
atributos y
métodos de acceso (accesors methods):
setters y
getters, y convirtió a todos los componentes gráficos en beans.
En JDK1.1 los componentes gráficos (botones, combos, areas de texto, etc) se convirieron en JavaBeans y se agregaron los métodos de acceso para sus atributos. Por ejemplo: para el atributo
size de los componentes gráficos se agregaron los métodos
getSize y
setSize para asignar un nuevo tamaño al componente. El viejo método que haciá esto se llamaba
resize y quedó obsoleto o
deprecated. Esto implica que si intentamos compilar un programa que aplique el método
resize sobre un componente el compilador va a mostrar un
warning indicando que ese método quedó obsoleto e invitándonos a consultar la documentación para conocer las causas y cual es el método por el cual lo tenemos que reemplazar.
La imagen permite ver como
Eclipse (la herramienta que vamos a utilizar) nos indica que estamos utilizando un método
deprecated.
A partir de
JDK1.2 se aplicó un cambio de nomemclatura, se comenzó a hablar de
Java 2 y se crearon dos distribuciones:
- J2SE – "Java 2 Standard Edition"
- J2EE – "Java 2 Enterprise Edition"
es el lenguaje de programación propiamente dicho: compilador, librerías básicas (que incluyen las clases
String,
Object,
System, etc) y herramientas de desarrollo como el debugger, un documentador, etc.
J2EE son “extensiones para el desarrollo de aplicaciones empresariales”. Esto lo veremos un poco más adelante pero podemos ir adelantando que incluye (por ejemplo) la tecnología Java desarrollar aplicaciones WEB:
Servlets,
JSP, etc.
Comparando Java con C y C++Algunas diferenciasSi comparamos Java con C o C++ veremos que Java es mucho más simple. Por ejemplo: en C o C++ los strings son arrays de caracteres con un último caracter ‘\0’ (barra cero). En Java tenemos la clase
String que permite manejar cadenas de caracteres a “alto nivel” como en los otros lenguajes.
String s1 = “Hola, ”;
String s2 = “que tal...???”;
String s3 = s1 + s2;
Respecto de los booleans, en C y C++ se manejan con valores numéricos enteros. Una variable
int con valor 0 (cero) representa
false y con valor distinto de cero representa
true. En Java existe el tipo
boolean.
boolean b1 = true;
// asigno true a b1boolean b2 = !b1;
// asigno la negacion de b1 a b2boolean b3 = "esto es una cadena".length()<=0;
En
b3 estamos asignando el resultado lógico de la proposición:
“esto es una cadena”.length()<=0
“esto es una cadena” es un
literal String; es un String por lo tanto es un objeto y como tal tiene métodos. En este caso aplicamos el método
length que retorna la longitud del String y la comparamos con cero para asignar
true o
false según sea el resultado.
Otro punto importante que diferencia a Java de C y C++ es la liberación de memoria. En C alocamos memoria y cuando no la necesitamos más la tenemos que liberar.
char *s = “Esto es una cadena”;
free(s);
s = “Esta es otra cadena”:
En Java no es necesario liberar la memoria que vamos a desreferenciar porque existe el
Garbage Collector (o recolector de residuos) que se ocupa de liberar la memoria a medida que queda desreferenciada.
String s = “Esto es una cadena”;
s = “Esto es otra cadena”;
Respecto de C++, en Java no existe herencia múltiple. Todas las clases heredan de la clase base
Object (como en Smalltalk). Tampoco existen los destructores ni la sobrecarga de operadores.
Algunas SimilitudesLos tipos de datos primitivos son idénticos:
short,
int,
long,
float,
double,
char. Java además agrega:
byte y
boolean.
Las sentencias para codificar las estructuras de control:
while,
do while,
for,
if y
switch son las mismas.
Los operadores lógicos y binarios son los mismos también.
Veamos algunas comparaciones:
HolaMundo.c 1:
2:#include <stdio.h>
3:
4:int main()
5:{
6: /* imprime en stdout */
7: printf("Hola Mundo C");
8:}
9:
HolaMundo.java 1:
2:public class HolaMundo
3:{
4: public static void main(String args[])
5: {
6: /* imprime en stdout */
7: System.out.println("Hola Mundo Java");
8: }
9:}
10:
En Java cualquier programa (incluso un simple "Hola Mundo") debe ser una clase ya que es un lenguaje fuertemente orientado a objetos.
El "printf" de Java es el
System.out.println. La función
main debe ser pública y estática (temas que veremos en el capítulo de objetos). Los comentarios, llaves y "punto y coma" son idénticos a C (también se puede comentar con "//" como en C++).
Numeros.c 1:
2:#include <stdio.h>
3:
4:int main(int argc, char **argv)
5:{
6: int i,n;
7: if( argc<2 )
8: {
9: printf("Debe pasar el argumento");
10: return 0;
11: }
12:
13: n=atoi(argv[1]);
14: for( i=0; i<n; i++ )
15: {
16: printf("%d\n",i);
17: }
18: return 0;
19:}
20:
Numeros.java 1:
2:import java.lang.*;
3:
4:public class Numeros
5:{
6: public static void main(String args[])
7: {
8: int i,n;
9:
10: if( args.length<1 )
11: {
12: System.out.println("Debe pasar el argumento");
13: return;
14: }
15:
16: n = Integer.parseInt(args[0] );
17: for( i=0; i<n; i++ )
18: {
19: System.out.println(i);
20: }
21: }
22:}
23:
En este ejemplo vemos que el
for y el
if son los mismos que en C. El "atoi" (función de para convertir cadenas en valores enteros) en Java es el
Integer.parseInt.
J2EE (o JEE) – “Java Enterprise Edition”J2EE es una extensión de Java para facilitar el desarrollo de
aplicaciones empresariales entendiendo “Aplicación Empresarial” como una aplicación marcada por un importante nivel de
requerimientos no funcionales.
Por ejemplo, si hablamos de una aplicación de "home banking", un requerimiento funcional podría ser: “dado el número de una cuenta mostrar todos sus movimientos” pero el requerimiento funcional puede acotarse con un requerimiento no funcional diciendo “además, la pantalla que muestra los movimientos debe emitirse en menos de 3 segundos”.
De lo anterior se desprende que las aplicaciones enterprise deben tener buena respuesta, buena performance y demás habilidades que (en conjunto) se comocen como atributos de una arquitectura.
- Disponibilidad
- Escalabilidad
- Confiabilidad
- Seguridad
Es decir: una aplicación empresarial siempre debe estar disponible para su acceso, debe soportar incrementos de carga (sin que esto implique un costo demasiado elevado), debe ser segura, etc.
Para cumplir con todos estos requisitos las aplicaciones enterprise corren sobre un
entorno operativo compuesto por diferentes
servidores como ser: servidores de bases de datos, servidores de mensajería, servidores de nombres y directorios, de transacciones, etc.
J2EE provee
APIs para que desde nuestros programas Java podamos interactuar con los servicios disponibles en un entorno de cómputo empresarial.
El gráfico muestra como una aplicación accede a los servicios empresariales (entorno operativo) a través de las diferentes APIs provistas por J2EE.
Además, por medio de la tecnología de
interfaces y fábricas de instancias (
factory method) J2EE permite que los programas Java accedan a los servidores que componen el entorno operativo sin que el programador tenga que preocuparse por la marca o fabricante del producto.
El fabricante del producto (Oracle por ejemplo) debe proveer un driver a través del cual se pueda establecer la conexión con su (en este caso) base de datos. El driver se sitúa en el medio, entre la base de datos y un conjunto de métodos definidos por las APIs J2EE en diferentes interfaces de forma tal que nuestro programa accede a los servicios del driver solo a través de los métodos definidos estas APIs. Esto permite que tan solo cambiando el driver nuestro programa pueda conectarse a otra base de datos sin tener que hacer ningún otro cambio.
También son parte de J2EE las APIs para generar contenido web dinamicamente. Servlets y JSP.
.
