Java clases dictadas

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


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
{
{
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


Nota importante: los objetos no son variables, dentro de los objetos hay datos y métodos

import java.io.*;
public class numeros
{
{
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


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


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 = “ ”;
BufferedReader br;
try
{
String s;
s = getDatos ( );
}
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


//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


//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


import java.io.*;
public class flujoE
{
public static void main (String arg [ ] )
{
//String método que se encuentra en la clase base object
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”);
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”);
}
System.out.println (“Error…” + e.toString ( ) );
}
}
}

println: el ln del final es para el salto de línea

8


//Manejo de flujos para lo que es manipulación de archivos
//Para poder leer datos de un archivo.

import java.io.*;
public class LeerDatosDeUnArchivo
{
{
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 ( );
}
}
}
}

9


//Manejo de flujos para lo que es manipulación de archivos
//Para poder CREAR archivos.

import java.io.*;
public class CrearArchivo
{
{
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”);
dout.writeBytes(entrada);
dout.close ( );
fout.close ( );
}
}
}
}
//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


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


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


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


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


Cliente / Servidor
Ejercicios:
Cliente C1, C2, C3, Cn.

//CLIENTE
import java.net.*;
import java.io.*;
public class cliente
{
{
Socket sk;
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 ( );
}
System.out.println (“Error” + e.toString ( ) );
}
}
}

15


//SERVIDOR
ServerSocket ss;
Socket sk;
try {
ss = new ServerSocket (2000);
}
;
}
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

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


//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 {
//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);
........
}
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);
}
}

18


//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;
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


//Domingo 6 de diciembre, 2009
// 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;
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


/Domingo 6 de diciembre, 2009
//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;
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


/*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);
}
System.out.println (“No se puede visualizar los IP registrados” + e.toString ( ) );
}
}
}
}

22


//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
{
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 ( );
//Lleva 4 parámetros
msj.getBytes (0, msj.length ( ), ibuf, 0);
ip = InetAddress.getByName (ipcard);
//Lleva 3 parámetros
dse.send (dpe);
}
}
}

23


//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
{
DatagramSocket dse;
DatagramPacket dpe;
BufferedReader br;
String msj, cadena, ipdir, ip;
FileInputStream fin;
try {
cadena = “demo.txt”;
fin = new FileInputStream (cadena);
din = new DataInputStream (fin);
ipdir = “192.168.10.1”;
ip = InetAddress.getByName (ipdir);
while ( (cadena = din.readLine ( ) ) != null )
{
msj = cadena;
msj = getBytes (0, msj.length ( ), ibuf, 0);
dse.send (dpe);
}
}
fin.close ( );
din.close ( );
}
}

24

Java clases dictadas

Más contenido relacionado

La actualidad más candente

Similar a Java clases dictadas

Java clases dictadas