El documento describe conceptos básicos de Java como la máquina virtual de Java (JVM), programación orientada a objetos, manejo de archivos, applets, threads y más. Explica que la JVM se encuentra en cualquier equipo que navega en Internet y tiene un recolector de basura que libera memoria de forma automática, y que Java permite desarrollar programas multihilo.
Presentación guía sencilla en Microsoft Excel.pptx
Java clases dictadas
1. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Guayaquil, 31 de agosto de 2.009.
Máquina virtual de Java (JVM) se encuentra en cualquier equipo que navegue en Internet (interpretador).
La JVM tiene Garbage Collector el cual libera la memoria en forma automática.
Los hilos de ejecución sirven para desarrollar un programa que guarde en memoria otro programa.
Java tiene interfaces gráficas poderosas.
En programación orientada a objetos:
Características son las cosas con las que puedo reconocer al objeto.
Métodos enmarcan el comportamiento que va a tener el objeto.
Polimorfismo son características que tiene el objeto de comportarse en diferentes formas para
diferentes métodos, reutilización de códigos.
Java no permite usar herencia múltiple.
Clase
base
Clase
derivada
Hereda características y
comportamientos de clase base.
Lema del lenguaje Java “Write once, run everywhere”.
API (Application programming interface Java)
IDE s (Integrated development environment)
import es una palabra clave para importar clases.
Una palabra escrita por ejemplo String con mayúscula al inicio es una clase.
int x; //es una variable
String x; //No es una variable, es una referencia a un objeto que más adelante va a ser creado.
s = new String (“CASA”); // como se crea el objeto
clase constructor
System.out.println
clase sub-clase método
1
2. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
El nombre de la clase debe ser igual al nombre del programa
Ejercicio sencillo con java
import java.io.*;
public class hola
{
public static void main(String arg [])
{
System.out.println( i+ “ ; ” + arg [i] );
System.out.println(“Hola mundo JAVA”);
//Al método no se llama sino al dato miembro
for (int i=0; i < arg.length ( ) ; ++i);
{
System.out.println( arg [i] );
}
}
}
import java.io.*;
public class cadena
{
public static void main(String arg [])
{
String s1, s2;
s1 = new String (“CASA”);
s2 = new String (“CASA”);
//Aquí estoy comparando referencias, por lo tanto van a ser diferentes objetos.
if (s1 == s2)
System.out.println( “Son iguales” );
else
System.out.println(“Son diferentes”);
}
}
s1 s2
y
CASA CASA
Para comparar lo que se encuentra dentro del objeto utilizamos la palabra clave equals.
if ( s1.equals (s2) )
2
3. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Nota importante: los objetos no son variables, dentro de los objetos hay datos y métodos
import java.io.*;
public class numeros
{
public static void main(String arg [])
{
int x, y;
float f;
Integer ni; //referencia a un objeto de tipo integer
Float nf; //referencia a un objeto de tipo float
x = 5;
ni = new Integer (x);
System.out.println( ni );
//Hay diferentes tipos de datos en java, aparte de los enteros y flotantes.
}
}
Rutina.- conjunto de instrucciones básicas que me dan la pauta a la resolución de un
problema.
Función o método.- es una rutina codificada dentro de un ente que puede o no tener
parámetros
3
4. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Guayaquil, lunes 7 de septiembre del 2.009.
Entradas - datos
Flujos (stream)
• Canales que se establecen entre un dispositivo y otro.
• Nos brinda una transparencia entre un dispositivo y otro.
• Declarar una referencia (I n p u t S t r e a m R e a d e r i r ;).
• Declarar un objeto (B u f f e r e d R e a d e r b r ; ) .
• Manejo de excepciones.
• Instrucciones t r y y c a t c h .
//Rutina de flujo de entrada.
String entrada;
InputStreamReader ir;
BufferedReader br;
try {
System.out.println (“Ingrese una palabra”);
//Creo el flujo
ir = new InputStreamReader (System.in);
//System.in (in es una sub-clase)
//Creando el buffer
br = new BufferedReader (ir);
entrada = br.readLine ( );
}
catch (Exception e) {
System.out.println (“Error…….”);
}
Clases de las que puedo crear objetos son públicas.
Clases de las que NO puedo crear objetos son nominadas clases
privadas.
Ejemplo de error:
System sys;
sys = new System ( );
try: es una instrucción
De Exception se derivan una serie de clases, por ejemplo IoException
4
5. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Desarrollar una función que permita obtener información ingresada desde el teclado y que la devuelva
cada vez que se invoque como una cadena.
La función debe tener un tipo de retorno, implícitamente explica el retorno
public String getDatos ( )
{
String entrada = “ ”;
InputStreamReader ir;
BufferedReader br;
try
{
String s;
s = getDatos ( );
}
catch (Exception e) {
System.out.println (“Error........”);
}
return entrada;
}
Los métodos se pueden conocer como procedimientos cuando NO devuelven nada o funciones si tienen
retorno.
El comportamiento del objeto puede ser público o privado
Los métodos reflejan comportamientos.
Los datos reflejan características.
La clase Integer me permite crear objetos de tipo entero (datos de tipo primitivo)
5
6. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Primera forma de hacer conversiones de datos primitivos.
Integer oi;
Float of;
int x;
float f;
char c;
oi = new Integer (entrada);
of = new Float (entradaDos);
x = oi.intValue ( );
f = oi.intValue ( );
c = oi.intValue ( ); // No puede realizarse este tipo de dato primitivo.
//Segunda forma de hacer conversiones de datos primitivos.
int x;
x = Integer.parseInt (entrada);
//Forma reducida de la primera.
int x = (new Integer (entrada)).intValue( );
/*En esta sentencia el objeto no tiene referencia.
El Garbage Collector libera memoria en esta instancia porque no tiene
referencia, esta forma es la mejor para optimizar el uso de memoria */
Guayaquil, 8 de septiembre del 2.009.
Flujo de entrada
Verificar si número de cédula es original
6
7. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Creando clase cedula
public class Cedula //No se coloca import
{
private String ncedula;
public cedula (String ps) //Constructor
{
ncedula = new String (ps);
}
public boolean Validar ( )
{
boolean flag = false;
int dig, acu = 0;
// codificar algoritmo de validacion
for (int i=0; (i < ncedula.length( )-1); i++)
{
dig =(new Integer (ncedula.charAt( i ) ) ).intValue ( )-48;
if ((i % 2)==0)
{
dig = dig * 2;
if (dig > 9)
dig = dig - 9;
}
acu = acu + dig;
}
acu = acu % 10;
if (acu!=0)
acu = 10 - acu;
dig = (new Integer(ncedula.charAt( 9 ) ) ).intValue( )-48;
if (dig == acu)
flag = true;
return flag;
}
}
Dígito verificador
Algoritmo denominado módulo 1 2 1 2 1 2
2 1 2 10
0919208397 * 0 9 1 9 2 0 8 3 9
0 9 2 9 4 0 16 3 18
0 9 2 9 4 0 7 3 9
Sumo y divido para 10: 43 / 10 = 4 con residuo de 3;
El módulo 10 le resto el residuo y debe darme igual al dígito
verificador
La clase Cedula no tiene métodos, tiene constructor, está clase puede ser sólo compilada.
Puede ser usada para aplicar en un objeto.
7
8. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
import java.io.*;
public class flujoE
{
public static void main (String arg [ ] )
{
//String método que se encuentra en la clase base object
InputStreamReader ir;
BufferedReader br;
String entrada, nombre;
Cedula cedu;
try {
ir = new InputStreamReader (System.in);
//En esta sentencia se captura todo lo que ingrese por el flujo
br = new BufferedReader (ir);
System.out.println (“Ingrese un número de cédula”);
entrada = br.readLine ( );
cedu = new Cedula (entrada);
if (cedu.Validar ( ) == true)
System.out.println (nombre + “ con cédula Nº ” + entrada);
Else
System.out.println (“Número de cédula falso”);
}
catch (Exception e) {
System.out.println (“Error…” + e.toString ( ) );
}
}
}
println: el ln del final es para el salto de línea
8
9. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Manejo de flujos para lo que es manipulación de archivos
//Para poder leer datos de un archivo.
import java.io.*;
public class LeerDatosDeUnArchivo
{
public static void main (String arg [ ] )
{
BufferedReader br;
String nombre_file;
FileInputStream fin;
//Método para leer de un archivo
DataInputStream din;
try {
br = new BufferedReader (new InputStreamReader (System.in) );
System.out.println (“Ingrese nombre de archivo a leer”);
nombre_file = br.readLine ( );
fin = new FileInputStream (nombre_file);
din = new DataInputStream (fin);
while ( (nombre_file = din.readLine( ) ) != null )
{
System.out.println (nombre_file);
}
din.close ( );
fin.close ( );
}
catch (Exception e) {
System.out.println (“Error…” + e.toString ( ) );
}
}
}
9
10. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Manejo de flujos para lo que es manipulación de archivos
//Para poder CREAR archivos.
import java.io.*;
public class CrearArchivo
{
public static void main (String arg [ ] )
{
BufferedReader br;
String entrada, nombre_file;
FileOutputStream fout;
//Método para crear un archivo
DataOutputStream dout;
try {
//Flujo de entrada de datos por teclado.
br = new BufferedReader (new InputStreamReader (System.in) );
//new InputStreamReader es un argumento.
System.out.println (“Escriba nombre de archivo a crear”);
nombre_file = br.readLine ( );
fout = new FileOutputStream (nombre_file);
dout = new DataOutputStream (fout);
System.out.println (“Ingrese un texto”);
entrada = br.readLine ( );
dout.writeBytes(entrada);
dout.close ( );
fout.close ( );
}
catch (Exception e) {
System.out.println (“Error…” + e.toString ( ) );
}
}
}
//Si ya existiera el nombre del archivo se sobrescribe en él.
Características de JAVA.
Simple, distribuido, robusto, seguro, portable, interpretado, interpretador, multithreaded, dinámico.
Potente.
Fácil aprendizaje.
Posee el Garbage Collector (reciclador de memoria dinámica).
Reduce en un 50 % los errores.
Interprete completo de Java ocupa 215 kb de RAM.
Java trabaja con sus datos como objetos y con interfaces a esos objetos.
Soporta las 3 principales características de la POO:
ϒ Encapsulamiento.
ϒ Herencia.
ϒ Polimorfismo.
Java se ha construido con extensas capacidades de interconexión TCP / IP.
Java incorpora resolución dinámica de memoria, realiza una verificación de los byte-codes (resultado de
la compilación)
10
11. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Guayaquil, lunes 14 de septiembre, 2.009
Manejo de archivos
Texto (Editores que se pueden abrir desde el archivo)
Archivos
No texto (Estructura de datos que se esté utilizando, necesitan un
formato. Es una colección de datos de diferentes tipos)
¿Cuál es la estructura de almacenamiento?
El orden.
FileInputStream y FileOutputStream son constructores de DataInputStream y DataOutputStream
respectivamente.
RandomAccesFile puede aperturar un archivo en escritura o lectura.
Método seek permite mover el apuntador dentro del archivo.
La clase File es para poder crear objetos que puedan manipular algún archivo en lista.
Ejemplo:
File archivo;
archivo = new File (“Datos.txt”);
rf = new RandomAccesFile (archivo, “rw”);
int tamaño = rf.size ();
Las propiedades para abrir un archivo pueden ser:
r lectura,
w escritura,
rw lectura, escritura.
11
12. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Manejando y controlando paquetes gráficos.
Método init.- constructor de un applet (se utiliza una sola vez)
Método start es el que se ejecuta luego.
Método destroy para eliminar (salir).
java.util.*;
Puede manejar Vector, Lisk, LiskedList, stack (pila).
Todos me permiten insertar un objeto, a la lista enlazada LinkedList si se aplica un remove ( ) cambia el
tamaño.
Ejercicio:
Vector vc;
vc = new Vector ( );
int x = 5;
String s = new String (“Hola”);
Integer io = new Integer (“258”);
float f = 32.78;
vc.add ( x );
vc.add ( s );
vc.add ( io );
vc.add ( f );
//Dentro de vc se almacenan object
//El método get me devuelve un tipo object de una posición
String st = vc.get ( 1 );
//Realizo un casting en java se utiliza bastante.
String st = (String) vc.get ( 1 );
En java los hilos se manejan con la clase Thread proceso que se ejecuta dentro de un sistema
(microprocesador) tiempo de atención.
El procesador empieza a darles atención a los Thread dependiendo de la sincronización.
12
13. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Guayaquil, miércoles 07 de octubre del 2.009.
Programación Orientada a Objetos.
ParseInt.- método que pertenece a la clase Integer.
BufferedReader.- para escribir una línea y capturarla.
URL.- es un puntero a un recurso Web (directorio, archivo, motor de búsqueda).
Datagrama IP
Cabecera Datos
Otros campos:
Dirección IP de origen.
Dirección IP de
destino.
Tamaño.
Número de orden
APPLET
Miniprogramas
Navegador
Descargar
Página Web
13
14. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Ciclo de vida de los Thread
Creado
Activo Dormido
Muerto
De una interface no puedo crear objetos, lo que puedo tener es métodos los cuales están declarados,
utilizando interfaz puedo simular la herencia múltiple.
throws InterruptedException.- para forzar a manejar excepciones, notifica antes de que se
lance el objeto en el que hay que controlar las excepciones.
UTF es un formato de como se envían los mensajes. Por la red puedo enviar objetos o cadenas, para
objetos sería read.Object ( ) y writeObject ( ).
El contacto siempre es cliente-servidor.
Métodos de InetAddress:
getAddress ( ).- devuelve el IP de la máquina la cual me ha enviado la
información.
getPort ( ).- número de puerto que ha enviado la información.
getData ( ).- datos ha enviar.
getLength ( ).- longitud de datos.
14
15. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Cliente / Servidor
Ejercicios:
Cliente C1, C2, C3, Cn.
//CLIENTE
import java.net.*;
import java.io.*;
public class cliente
{
public static void main (String arg [ ] )
{
Socket sk;
DataInputStream din;
DataOutputStream dou;
String cadena;
try {
//Lectura de datos.
//Creación de socket de conexión, como parámetros tenemos al IP y número de puerto
sk = new Socket (“127.0.0.1”, 5000);
//Recibir información.
din = new DataInputStream (sk.getInputStream ( ) );
//Recibe lo que el servidor está enviando, din.readUTF ( ) es un método de DataInputStream.
String cadena = din.readUTF ( ) );
System.out.println ( cadena );
//Enviar información
dou = DataOutputStream (sk.getOutputStream ( ) );
dou.writeUTF (“Hola, recibí el mensaje”);
//Cierro los flujos
din.close ( );
dou.close ( );
//Cierro el socket
sk.close ( );
}
catch (Exception e) {
System.out.println (“Error” + e.toString ( ) );
}
}
}
15
16. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//SERVIDOR
ServerSocket ss;
Socket sk;
DataOutputStream dou;
DataInputStream din;
try {
ss = new ServerSocket (2000);
}
catch (Exception e) {
;
}
while (true) {
//Abre el canal quien es el que está infinito contactando al servidor
sk = ss.accept ( );
//Flujo de escritura.
dou = new DataOutputStream (sk.getOutputStream ( ) );
dou.writeUTF (“Hola mundo JAVA”);
din = new DataInputStream (sk.getInputStream ( ) );
String cadena = din.readUTF ( );
//Cierro el socket
sk.close ( );
}
Con sk.getInetAddress ( ) puedo obtener información.
UTF es un formato de cómo se envían los mensajes.
Por la red puedo enviar objetos o cadenas, para objetos sería:
ϒ read.Object ( )
ϒ write.Object ( )
Guayaquil, lunes 7 de noviembre del 2.009.
16
17. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
Datagramas
send (envío información)
DatagramSocket
receive (recibo información)
DatagramPacket
//dse envío y dsr recepción
DatagramSocket dse, dsr;
DatagramPacket dpe;
dse = new DatagramSocket (7000);
//Como parámetro tiene al DatagramPacket
dse.send (dpe);
P1 P2
A B
IP: 177.60.50.7 IP: 177.60.50.2
e: 7000 e: 5000
r: 3000 r: 2000
IP: 177.60.50.6 IP: 177.60.50.4
Formato de paquete de envío
Datos a enviarse, tamaño del paquete de envío, InetAddress de destino y número de puerto.
Enviar dpe (byte ibuf [ ], int long, InetAddress idest, int ipuerto)
Formato de paquetes a recibir
Vector de bytes, tamaño del vector de bytes.
Recibir dpr: byte ibuf [ ], int long
17
18. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Código P1 en la máquina A (rutina de envío)
byte ibuf [ ] = new byte [ 50 ];
InetAddress ip = (InetAddress) null;
DatagramSocket dse, dsr;
DatagramPacket dpe;
String cadena = “Hola mundo”;
String ipcad = “177.60.50.2”;
try {
dse = new DatagramSocket (7000);
//La siguiente sentencia es la forma como paso la cadena a vector de bytes.
cadena.getBytes ( 0, cadena.length ( ), ibuf, 0 );
//Y luego pasó de la cadena al objeto InetAddress.
ip = InetAddress.getByName (ipcad);
dpe = new DatagramPacket (ibuf, ibuf.length ( ), ip, 2000);
dse.send (dpe);
........
}
catch (Exception e) {
System.out.println (“Error..” + e.toString ( ) );
}
//En P2 tendría (rutina de recepción)
byte ibufr [ ] = new byte [ 50 ];
DatagramSocket dsr;
DatagramPacket dpr;
String cadena;
try {
dsr = new DatagramSocket (2000);
dpr = new DatagramPacket (ibufr, ibufr.length ( ) );
dsr.receive (dpr );
//Paso de un vector de byte a una cadena.
cadena = new String ( dpr.getData( ), 0, 0, dpr.getLength( ) );
System.out.println (cadena);
}
catch (Exception e) {
System.out.println (“Error..” + e.toString ( ) );
}
18
19. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Domingo 6 de diciembre, 2009
//Ejercicios tipo examen
// 1.- Desarrollar una rutina en la que se refleje la siguiente acción
/*Versión cliente: cada vez que un cliente se conecte a un servidor, esté
le va a enviar el nombre del equipo y la dirección IP de la máquina en la cual
se está ejecutando, debe mostrar el mensaje de respuesta del servidor que le
indica que ha recibido el mencionado IP
NOTA: Lo que se pide es una Rutina no un programa*/
Socket sk;
InetAddress ie; //objeto de referencia
String ies;
DataInputStream din;
DataOutputStream dou;
try
{
//Como en el ejercicio no me dan el IP ni el puerto, escribo cualquiera
sk = new Socket ("170.50.70.200", 2000);
ie = InetAddress.getLocalHost ( );
//Otra forma de escribir la línea anterior
//ies = InetAddress.getLocalHost ( ).toString ( );
//Las siguientes dos líneas envían datos al servidor
dou = new DataOutputStream (sk.getOutputStream ( ) );
dou.writeUTF (ies);
//Las siguientes dos líneas reciben datos del servidor
din = new DataInputStream (sk.getInputStream ( ));
ies = din.readUTF ( );
System.out.println (ies);
}
catch (Exception e)
{
System.out.println("Error.." + e.toString ( ) );
}
//UTF es un formato de transmisión.
//Método writeUTF ( ) recibe la cadena y la transforma en formato UNICODE.
19
20. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Domingo 6 de diciembre, 2009
//Ejercicios tipo examen
// 1.- Desarrollar una rutina en la que se refleje la siguiente acción
/* Versión servidor: en la que se registre en una estructura dinámica todos los IP
de los clientes que se conectan a él.
NOTA: El número de puerto es el 3000 y se admite como máximo 20 conexiones
al mismo tiempo */
ServerSocket ss;
Socket sok;
String sin;
DataInputStream din;
LinkedList lk; //debe ser creado fuera del while.
try
{
lk = new LinkedList ();
ss = new ServerSocket (3000, 20);
while (true)
{
sok = ss.accept ();
din = new DataInputStream (sok.getInputStream () );
//recibo IP del cliente
sin = din.readUTF ();
//validamos que no se encuentre repetido el IP
if ( !lk.contains (sin) )
lk.add (sin);
}
}
catch (Exception e)
{
System.out.println ("Error.." + e.toString () );
}
20
21. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
/Domingo 6 de diciembre, 2009
//Ejercicios tipo examen
//En la rutina del ejercicio versionServidor, regístrese además la cantidad de veces
//que un mismo cliente se está conectando al servidor.
ServerSocket ss;
Socket sok;
DataInputStream din;
String sip, scont;
LinkedList lk, lkacum;
int pos, valor;
try
{
lk = new LinkedList ( );
lkacum = new LinkedList ( );
ss = new ServerSocket (3000, 20);
while (true)
{
sok = ss.accept ( );
din = new DataInputStream (sok.getInputStream ( ) );
sip = din.readUTF ( ); // recibo IP del cliente
if (!lk.contains (sip) )
{
lk.add (sip);
lkacum.add ("1");
}
else
{
pos = lk.indexOff (sip);
scont = lkacum.get (pos).toString ( );
valor = Integer.parseInt (scont);
++ valor;
lkacum.set (pos, valor);
//verificar si es lkacum,add
}
}
}
catch (Exception e)
{
System.out.println ("Error.." + e.toString ( ) );
}
21
22. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
/*Desarrolle una clase hilada de un objeto de entorno gráfico en donde se visualice todos los IP que se
encuentran registrados en el Servidor.*/
import java.awt.*;
import java.net.*;
import java.io.*;
import java.util.*;
public class ListaGui extends java awt.List implementes Runnable
{
private Socket s;
private DataInputStream di;
private DataOutputStream dout;
private String cad;
private Thread t;
private long ind;
public ListaGui ( )
{
super ( );
t = new Thread (this);
}
public void activa ( )
{
t.start ( );;
}
public void run ( )
{
while ( true)
{
DataInputStream di;
String cad;
try {
s = new Socket (“203.15.10.7”, 2500);
di = new DataInputStream (s.getInputStream ( ) );
cad = di.readUTF ( );
String Tokenizer stok = new StringTokenizer (cad, “,”);
this.clear ( );
while (stok.hasMoreTokens ( ) )
{
this.addItem (stok.nextToken ( ) );
}
t.currentThread ( ).sleep (2000);
}
catch (Exception e) {
System.out.println (“No se puede visualizar los IP registrados” + e.toString ( ) );
}
}
}
}
22
23. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Ejercicios tipo examen.
/*Elaborar una rutina que permita enviar a cualquier máquina de la red un mensaje.
Nota: La dirección IP será ingresada por teclado vía línea de comando IP destino y el mensaje será
ingresado por teclado use datagramas*/
// String arg para capturar los parámetros vía línea de comando
public static void main (String arg [ ] )
{
InetAddress ip = (InetAddress) null;
byte ibuf [ ] = new byte [ 100 ];
DatagramSocket dse;
DatagramPacket dpe;
BufferedReader br;
String msj, ipcard;
try {
ipcard = arg [ 0];
System.out.println (“Ingrese mensaje”);
br = new BufferedReader (new InputStreamReader (System.in));
msj = br.readLine ( );
dse = new DatagramSocket (7000);
//Lleva 4 parámetros
msj.getBytes (0, msj.length ( ), ibuf, 0);
ip = InetAddress.getByName (ipcard);
//Lleva 3 parámetros
dpe = new DatagramPacket (ibuf, ibuf.length ( ), ip, 2000);
dse.send (dpe);
}
catch (Exception e) {
System.out.println (“Error..” + e.toString ( ) );
}
}
23
24. Ing. Darwin Patiño S4A
Galo Gabriel Galarza Acosta
//Ejercicios tipo examen. Lunes 21 de diciembre, 2.009.
/*Elaborar una rutina que permita transferir los datos de un archivo de texto a través de la red usando
datagramas
Nota: Asuma nombre del archivo, dirección IP y número de puerto.*/
// String arg para capturar los parámetros vía línea de comando
public static void main (String arg [ ] )
{
InetAddress ip = (InetAddress) null;
byte ibuf [ ] = new byte [ 100 ];
DatagramSocket dse;
DatagramPacket dpe;
BufferedReader br;
String msj, cadena, ipdir, ip;
FileInputStream fin;
DataInputStream din;
try {
cadena = “demo.txt”;
fin = new FileInputStream (cadena);
din = new DataInputStream (fin);
ipdir = “192.168.10.1”;
dse = new DatagramSocket (7000);
ip = InetAddress.getByName (ipdir);
while ( (cadena = din.readLine ( ) ) != null )
{
msj = cadena;
msj = getBytes (0, msj.length ( ), ibuf, 0);
dpe = new DatagramPacket (ibuf, ibuf.length ( ), ip, 3000);
dse.send (dpe);
}
}
fin.close ( );
din.close ( );
catch (Exception e) {
System.out.println (“Error..” + e.toString ( ) );
}
}
24