2. INTRODUCCION
La sociedad en virtud al vanguardismo que vive actualmente
tecnológicamente hablando, ha creado un sin fin de lenguajes de programación
que contribuyen y ayudan a los usuarios en este mundo actual, global y
computacional en que vivimos. Así todo lo que vemos en el computador como
aplicaciones, ventanas de información y hasta el navegador web está
desarrollado por programación. Se han creado lenguajes como C++, phyton,
visual Basic, php, java, entre otros.
Java se creó como parte de un proyecto de investigación para el
desarrollo de software avanzado para una amplia variedad de dispositivos de
red y sistemas embebidos. La meta era diseñar una plataforma operativa
sencilla, fiable, portable, distribuida y de tiempo real. Cuando se inició el
proyecto, C++ era el lenguaje del momento. Pero a lo largo del tiempo, las
dificultades encontradas con C++ crecieron hasta el punto en que se pensó que
los problemas podrían resolverse mejor creando una plataforma de lenguaje
completamente nueva. Se extrajeron decisiones de diseño y arquitectura de
una amplia variedad de lenguajes como Eiffel, SmallTalk, Objetive C y
Cedar/Mesa. El resultado es un lenguaje que se ha mostrado ideal para
desarrollar aplicaciones de usuario final seguras, distribuidas y basadas en red
en un amplio rango de entornos desde los dispositivos de red embebidos hasta
los sistemas de sobremesa e Internet.
Internet ha ayudado considerablemente a «catapultar» a Java al cenit del
mundo de la programación de computadoras. Y Java. A su vez, ha tenido un
profundo impacto en Internet. La razón es muy simple: Java extiende el
universo de los objetos que se mueven libremente en el ciberespacio que forma
la red Internet. En una red existen dos grandes categorías de objetos que se
transmiten entre las computadoras conectadas (el servidor y la computadora
personal): información pasiva y dinámica, programas activos. Un ejemplo fácil
de datos pasivos son los correos electrónicos que usted recibe en su
computadora o una página web que se baja de la red. Incluso si descarga un
programa, está recibiendo datos pasivos hasta tanto no ejecute dicho
programa. Sin embargo, existen otros tipos de objetos que se transmiten por la
red: programas dinámicos autoejecutables que son agentes activos en la
computadora.
3. Flujo de dato:
Es la representación de una fuente desde la cual se reciben datos o un
destino hacia cual se envían datos.
Java – Flujos de datos – Entrada y Salida estándar
La entrada y salida estándar son flujos de datos que actúan como canales
de comunicación permitiendo la interacción entre un programa y su entorno en
el sistema. En Java podemos tener acceso a estos flujos de datos desde la
clasejava.lang.System.
http://darkbyteblog.wordpress.com/2011/03/08/java-flujos-de-datos-entrada-y-salida-
estandar/
Salida estándar:
La salida estándar está asociada por defecto a la terminal del sistema, es
decir que el resultado de los datos enviados a la salida se observa en pantalla
a menos que su destino sea modificado. Existen dos salidas con diferentes
propositos, una es la propiamente denominada salida estándar la cual se utiliza
para la salida regular de datos, y la otra es la salida estándar de errores la cual
se utiliza para la salida de errores.
http://lenguajesprogramar.blogspot.com/
Re-definir la salida estándar:
Para mostrar como re-definir la salida estándar pondremos en practica el
ejemplo mencionado anteriormente sobre modificar el destino de out y err hacia
dos archivos diferentes.
Una forma de modificar las salidas es utilizando los métodos estáticos void
setOut(PrintStream out) y void setErr(PrintStream err) de la propia
clase System. Necesitamos abrir flujos de datos hacia los nuevos destinos de
cada salida, para cada una se envuelve un objeto FileOutputStream(File
file) con un objeto PrintStream(OutputStream out).
4. Ejemplo:
System.setOut(new PrintStream(new
FileOutputStream("salida_normal.txt")));
System.setErr(new PrintStream(new
FileOutputStream("salida_error.txt")));
System.out.println("Esta es la salida estandar normal");
System.err.println("Esta es la salida estandar de errores");
throw new RuntimeException("Error Fatal");
http://darkbyteblog.wordpress.com/2011/03/08/java-flujos-de-datos-entrada-y-salida-
estandar/
Flujos estándares:
Los flujos estándar de entrada y salida siempre están abiertos mientras se
ejecuta el programa, listo para proporcionar datos (entrada) o para mostrar
datos (salida).
Acceso al flujo estándar en java:
System.in
System.out
http://prezi.com/sr6cgnwebcks/flujos-en-java/
System.in :
Instancia de la clase InputStream el cual es un flujo de datos de entrada
Métodos:
Read(): permite leer un byte de la entrada como entero.
Skip(int n): ignora n bytes de la entrada
Available: número de bytes disponibles para leer en la entrada
System.out:
Instancia de la clase PrintStream el cual esun flujo de datos de salida
Métodos:
Print()
Println(): Permiten escribir en pantalla un flujo de bytes.
http://prezi.com/sr6cgnwebcks/flujos-en-java/
5. Flujos a archivos:
Leer y escribir un archivo de texto en java no es muy complicado en
resumen es un proceso muy similar a leer y escribir texto escrito del teclado
Lectura de archivos:
Muchas de las operaciones realizadas con archivos en un programa tienen que
ver con la lectura de archivos de texto
Para recuperar cadenas de caracteres de un archivo, el paquete java.io
proporciona dos clases:
FileReader
BufferedReader
FileReader:
FileReader para poder recuperar información de un archivo de texto, es
necesario primeramente crear un objeto FileReader asociado al mismo. Un
objeto FileReader representa un fichero de texto “abierto” para lectura de datos.
Este objeto es capaz de adaptar la información recuperada del fichero a las
características de una aplicación Java; transformando los bytes almacenados
en el mismo en caracteres Unicode.
http://prezi.com/sr6cgnwebcks/flujos-en-java/
BufferedReader:
Este objeto se apoya en FileReader para poder leer el archivo, solo que en
esta ocasión lo realiza línea a línea del archivo.
http://prezi.com/sr6cgnwebcks/flujos-en-java/
Escritura de archivos:
La manera en que un programa almacena información de manera común es
con la creación de archivos.
Para escribir cadenas de caracteres de un archivo, el paquete java.io
proporciona dos clases:
FileWriter
PrintWriter
6. FileWriter:
La manera en que se puede tener acceso al flujo de escritura de archivos en
Java es con la clase FileWrites, la cual crea un flujo hacia el archivo deseado
de tal manera que si existe es creado, y desde el constructor podemos
especificar si el flujo de datos será agregado al final del archivo o el archivo
será creado nuevamente.
http://prezi.com/sr6cgnwebcks/flujos-en-java/
PrintWriter:
PrintWriter una de las maneras de poder tener mejor flujo de datos, en
cuestión de caracteres es utilizando la clase PrintWriter del API de java el cual
ofrece métodos para poder manipular mejor el flujo de datos.
http://prezi.com/sr6cgnwebcks/flujos-en-java/
Serialización en Java
Para que un programa java pueda convertir un objeto en un montón
de bytes y pueda luego recuperarlo, el objeto necesita ser Serializable. Al poder
convertir el objeto a bytes, ese objeto se puede enviar a través de
red, guardarlo en un fichero, y después reconstruirlo al otra lado de la red,
leerlo del fichero.
Para que un objeto sea serializable basta con que implemente la
interfaz Serializable. Como la interfaz Serializable no tiene métodos, es muy
sencillo implementarla, basta con un implements Serializable y nada más. Por
ejemplo, la clase Datos siguiente es Serializable y java sabe perfectamente
enviarla o recibirla por red, a través de socket o de Rmi. También java sabe
escribirla en un fichero o reconstruirla a partir del fichero.
http://chuwiki.chuidiang.org/index.php?title=Serializaci%C3%B3n_de_objetos_en_java
Ejemplo
public class Datos implements Serializable
{
public int a;
public String b;
public char c;
}
7. Si dentro de la clase hay atributos que son otras clases, éstos a su vez también
deben ser Serializable. Con los tipos de java (String, Integer, etc.) no hay
problema porque lo son. Si ponemos como atributos nuestras propias clases,
éstas a su vez deben implementar Serializable.
Por ejemplo
/* Esta clase es Serializable porque implementa Serializable y todos
sus
* campos son Serializable, incluido "Datos f;"
*/
public class DatoGordo implements Serializable
{
public int d;
public Integer e;
Datos f;
}
http://www.buenastareas.com/ensayos/Java/3019756.html
Lectura de un archivo desde un servidor
La clase siguiente muestra cómo leer un archivo de texto denominado
Readme.txt del servidor. NOTA: Coloque todos los archivos en la misma
carpeta del servidor Web.
Los pasos siguientes proporcionan un ejemplo de cómo puede leer un
subprograma un archivo en un servidor Web:
1. Cree el archivo siguiente de nomenclatura de ello ReadFile.java:
2. //
3. // ReadFile.java
4. //
5. import java.io.*;
6. import java.net.*;
7. import java.applet.*;
8. import java.awt.*;
9.
10.public class ReadFile extends Applet {
11. public void start () {
12. TextArea textArea=new TextArea();
13. setLayout(new BorderLayout());
14. add("Center",textArea);
15. String text=null;
16. try {
17. URL url = new URL(getDocumentBase(),"readme.txt");
18. DataInputStream stream = new
19. DataInputStream(url.openStream());
20. do {
21. text = stream.readLine();
22. if (text!=null) textArea.appendText(text+"rn");
23. } while (text!=null);
8. 24. }
25. catch (IOException e) {
26. e.printStackTrace();
27. }
28. }
29.}
30. Compile la clase ReadFile.java que crea un ReadFile.class.
31. Cree un archivo de texto con al menos una línea de texto y conózcalo como Readme.txt.
32. Cree un archivo HTML denominado ReadFile.html con el código siguiente:
33.<html>
34.<head>
35.<title>readfile</title>
36.</head>
37.<body>
38.<hr>
39.<applet
40. code=ReadFile
41. name=readfile
42. width=320
43. height=240 >
44.</applet>
45.<hr>
46.<a href="ReadFile.java">The source.</a>
47.</body>
48.</html>
49. Ponga ReadFile.java, ReadFile.class, ReadFile.html y Readme.txt en la misma carpeta en su
servidor Web.
50. Abra ReadFile.html desde Internet Explorer.
Debería ser capaz de ver su texto de Readme.txt en el subprograma.
http://todojava.awardspace.com/ejemplos-java.html?desc=LeerArchivoServidor
JAVA FOUNDATION CLASSES (JFC) Y JAVA 2D
Las Java Foundation Classes (JFC, en castellano Clases Base Java) son
un framework gráfico para construir interfaces gráficas de usuario portables
basadas en Java. JFC se compone de Abstract Window
Toolkit (AWT), Swing y Java 2D. Juntas, suministran una interfaz de usuario
consistente para programas Java, tanto si el sistema de interfaz de usuario
subyacente es Windows, Mac OS X o Linux.
AWT es la más antigua de las dos APIs de interfaz, y fue criticada
duramente por ser poco más que una envoltura alrededor de las capacidades
gráficas nativas de la plataforma anfitrión. Esto significa que
9. los widgets estándar en la AWT confían en esas capacidades de los widgets
nativos, requiriendo que el desarrollador también este prevenido de las
diferencias entre plataformas anfitrión.
Una API de gráficos alternativa llamada Internet Foundation Classes fue
desarrollada en código más independiente de la plataforma por Netscape.
Últimamente, Sun mezcló la IFC con otras tecnologías bajo el nombre "Swing",
añadiendo la capacidad para un look and feel enchufable de los widgets. Esto
permite a los programas Swing mantener la base del código independiente de
la plataforma, pero imita el look de la aplicación nativa.
http://searchsoa.techtarget.com/definition/Java-Foundation-Classes
Java Media Frame
JMF es una API que nos sirve para incluir multimedia en nuestras aplicaciones
de Java, funciona básicamente, recibiendo el contenido multimedia de alguna
fuente, para después procesarlo y entregarlo en alguna salida multimedia.
Para entender mejor la arquitectura de JMF en la página de Java nos muestran
esta imagen, que es muy ilustrativa y nos ayuda a comprender mejor esta API.
10. La videocámara y el casete de video que se muestran en esta imagen, como
fuente de multimedia bien podría ser un archivo mpg y los dispositivos de salida
que en la imagen son una televisión y unas bocinas para nosotros serian el
applet en el cual vamos a presentar los contenidos multimedia. Lo único que
nos haría falta entonces sería el reproductor. La manera mas sencilla de poner
un reproductor en nuestro applet es utilizando el MediaPlayer Bean.
Instanciamos un Media Player, asi:
MediaPlayer player = new javax.media.bean.playerbean.MediaPlayer():
Para decirle al player que archivo queremos reproducir utilizamos la siguiente
linea:
player.setMediaLocation(dirección del archivo). Para iniciar, detener o pausar la
reproducción, usamos las siguientes líneas respectivamente:
player.start();
player.close();
player.stop();
http://blogdejuls.blogspot.com/2007/04/java-media-framework.html
Java 3D
Java 3D es un proyecto que permite crear entornos tridimensionales en el
lenguaje Java.
Es una API para gráficos 3D para el lenguaje de programación Java la cual
corre sobre OpenGL o Direct3D. Desde la version 1.2 Java 3D es desarrollado
bajo las especificaciones Java Community Process. JSR 926.
http://es.wikipedia.org/wiki/Java_3D
JavaBeans
Los JavaBeans son un modelo de componentes creado por Sun
Microsystems para la construcción de aplicaciones en Java.
11. Se usan para encapsular varios objetos en un único objeto (la vaina
o Bean en inglés), para hacer uso de un solo objeto en lugar de varios más
simples.
La especificación de JavaBeans de Sun Microsystems los define como
"componentes de software reutilizables que se puedan manipular visualmente
en una herramienta de construcción".
A pesar de haber muchas semejanzas, los JavaBeans no deben confundirse
con los Enterprise JavaBeans (EJB), una tecnología de componentes del lado
servidor que es parte de Java EE.
Dentro de un JavaBean podemos distinguir tres partes:
Propiedades: Los atributos que contiene.
Métodos: Se establecen los métodos get y set para acceder y modificar los
atributos.
Eventos: Permiten comunicar con otros JavaBeans.
http://es.wikipedia.org/wiki/JavaBean
RMI-IIOP
RMI-IIOP (leído RMI sobre IIOP) denota la interfaz RMI de Java sobre el
sistema CORBA.
Este estándar fue creado intentando simplificar el desarrollo de las
aplicaciones CORBA, mientras preservaba todos los beneficios principales.
RMI-IIOP está ampliamente basado en el concepto Objeto por Valor (descrito
en la página CORBA) que sirve como un contenedor o un reemplazo directo
para estructuras CORBA, uniones, secuencias, arrays y strings. La IDL no se
usa.
http://es.wikipedia.org/wiki/RMI-IIOP
En cambio, las definiciones de la estructura de datos "supuestas"
automáticamente, recolectan los datos necesarios a través de mecanismos de
reflexión. Cuando CORBA normalmente necesita una clase generada
12. suplementaria para cada estructura de datos no trivial que está siendo
transferida, RMI-IIOP solo usa el código generado para los objetos remotos.
Menos código generado resulta en menos huella.
Ambas CORBA y RMI-IIOP usan el mismo estándar de comunicación GIOP.
Si se necesitara, es posible generar las definiciones de IDL para las estructuras
de datos RMI-IIOP involucradas y usar esas definiciones para alcanzar la
interoperabilidad entre las aplicaciones RMI-IIOP y CORBA planas.
http://es.wikipedia.org/wiki/RMI-IIOP
Las versiones recientes de RMI-IIOP derivan sus servants desde la clase
estándar Servant (CORBA). Por lo tanto es posible conectarlos al CORBA ORB
manualmente, involucrando, si es necesario, el Adaptador de Objeto Portable,
Interceptores Portables, servicio de nombrado CORBA y todas las demás
características estándar CORBA.
Las interfaces:
public interface MyServer extends Remote
{
// El cliente se pasa a sí mismo como primer parámetro. El servidor
puede llamar a un
// método remoto en el cliente. Esto es útil cuando el
procesamiento de peticiones toma mucho tiempo.
void receiveRequest(MyClient client, String message) throws
RemoteException;
}
public interface MyClient extends Remote
{
// Este método remoto es llamado por el servidor.
void receiveReply(String message) throws RemoteException;
}
http://es.wikipedia.org/wiki/RMI-IIOP
13. JAVA NATIVE INTERFACE (JNI)
Java Native Interface (JNI) es un framework de programación que permite
que un programa escrito en Java ejecutado en la máquina virtual java (JVM)
pueda interactuar con programas escritos en otros lenguajes
como C, C++ y ensamblador.
http://es.wikipedia.org/wiki/Java_Native_Interface
Propósito y características
El JNI se usa para escribir métodos nativos que permitan solventar
situaciones en las que una aplicación no puede ser enteramente escrita
en Java, como por ejemplo en el caso de que la biblioteca estándar
de clases no proporcione soporte para funcionalidades dependientes de la
plataforma.
También se usa para modificar programas existentes escritos en algún otro
lenguaje, permitiéndoles ser accesibles desde aplicaciones Java. Muchas de
las clases de la API estándar de Java dependen del JNI para proporcionar
funcionalidad al desarrollador y al usuario, por ejemplo las funcionalidades de
sonido o lectura/escritura de ficheros. El desarrollador debe asegurarse que la
API estándar de Java no proporciona una determinada funcionalidad antes de
recurrir al JNI, ya que la primera ofrece una implementación segura e
independiente de la plataforma.
http://es.wikipedia.org/wiki/Java_Native_Interface
El framework JNI permite a un método nativo utilizar los objetos Java de la
misma forma en que el propio código de Java lo hace. Un método nativo puede
crear objetos Java; y examinarlos y utilizarlos para que lleven a cabo su
función. Un método nativo puede asimismo examinar y utilizar objetos que han
sido creados por código de aplicación escrito en Java.
A menudo se denomina a JNI como la "válvula de escape" para
desarrolladores dado que les permite añadir funcionalidades a sus aplicaciones
que el API de Java no puede proporcionar.
14. Dado que -como se ha dicho antes- puede ser usado para interactuar con
código escrito en otros lenguajes como C++, también se usa para operaciones
y cálculos de alta complejidad temporal, porque el código nativo es por lo
general más rápido que el que se ejecuta en una máquina virtual.
http://es.wikipedia.org/wiki/Java_Native_Interface
Por ejemplo, el siguiente fragmento de código convierte una cadena de Java en
una nativa.
//Código C++
JNIEXPORT void JNICALL Java_ClassName_MethodName
(JNIEnv *env, jobject obj, jstring javaString)
{
//Tomar la cadena nativa de la cadena de java
const char *nativeString = env->GetStringUTFChars(javaString, 0);
//Hacer algo con ella
/* NO OLVIDE ESTA LÍNEA, libera el espacio ocupado por la cadena
usada
* ésto tiene que ver con la forma en que Java maneja las cadenas
*/
env->ReleaseStringUTFChars(javaString, nativeString);
}
//C code
JNIEXPORT void JNICALL Java_ClassName_MethodName
(JNIEnv *env, jobject obj, jstring javaString)
{
//Tomar la cadena nativa de la cadena de java
const char *nativeString = (*env)->GetStringUTFChars(env,
javaString, 0);
//Hacer algo con ella
/* NO OLVIDE ESTA LÍNEA, libera el espacio ocupado por la cadena
usada
* ésto tiene que ver con la forma en que Java maneja las cadenas
*/
(*env)->ReleaseStringUTFChars(env, javaString, nativeString);
}
http://es.wikipedia.org/wiki/Java_Native_Interface
15. CONCLUSION
La entrada y salida estándar en Java se pueden definir como aquellos flujos
de datos que actúan como canales de comunicación permitiendo la interacción
entre un programa y su entorno en el sistema. En Java se puede tener acceso
a estos flujos de datos desde la clasejava.lang.System.
Los flujos estándar de entrada y salida siempre están abiertos mientras se
ejecuta el programa, listo para proporcionar datos (entrada) o para mostrar
datos (salida).
El paquete java.io proporciona dos clases para recuperar cadenas de
caracteres; FileReader y BufferedReader. Y Para escribir cadenas de
caracteres de un archivo, el paquete java.io proporciona dos clases también:
FileWriter y PrintWriter .
Para que un programa java pueda convertir un objeto en un montón
de bytes y pueda luego recuperarlo, el objeto necesita ser Serializable.
Las Java Foundation Classes (JFC, en castellano Clases Base Java) son un
framework gráfico para construir interfaces gráficas de usuario portables
basadas en Java.
Java 3D es un proyecto que permite crear entornos tridimensionales en el
lenguaje Java.
El framework JNI permite a un método nativo utilizar los objetos Java de la
misma forma en que el propio código de Java lo hace. Un método nativo puede
crear objetos Java; y examinarlos y utilizarlos para que lleven a cabo su
función. Un método nativo puede asimismo examinar y utilizar objetos que han
sido creados por código de aplicación escrito en Java.
16. REFERENCIAS BIBLIOGRAFICAS
http://prezi.com/sr6cgnwebcks/flujos-en-java/ [Consultada el 28 de Junio de 2013]
http://darkbyteblog.wordpress.com/2011/03/08/java-flujos-de-datos-entrada-y-
salida-estandar/ [Consultada el 28 de Junio de 2013]
http://chuwiki.chuidiang.org/index.php?title=Serializaci%C3%B3n_de_objetos_en_jav
a [Consultada el 28 de Junio de 2013]
http://searchsoa.techtarget.com/definition/Java-Foundation-Classes [ Consultada el
28 de Junio de 2013]
http://es.wikipedia.org/wiki/Java_Native_Interface [ Consultada el 29 de Junio de
2013]
http://es.wikipedia.org/wiki/RMI-IIOP [ Consultada el 29 de Junio de 2013]
http://blogdejuls.blogspot.com/2007/04/java-media-framework.html [ Consultada el
29 de Junio de 2013]
