JAVA PARA PRINCIPIANTES2342342432231.PPT

1
Introducción al lenguage JAVA
Programación en un lenguaje
orientado al objeto usando el
lenguaje de programación JAVA

2
¿ Por qué JAVA (por qué tan famoso ) ?
• Orientado al objeto (tendencia en boga)
• Simple (similar a c, sin complejidades)
• Multiplataforma (Windows, PowerMac, Unix)
• Robusto (hace chequeos, elimina punteros)
• Recolección de basura automática
• Bibliotecas estándar
• Realmente portable en un 100%
• Facilidades para programación en redes

3
JAVA es un lenguaje interpretado
Compilador de java (específico x plataforma) javac
P1.java
P1.java
P1.class
Intérprete de java (específico x plataforma) java P1 (class)
Salida
del
Prog.

4
Un primer programa en JAVA
public class Hello {
public static void main(String args[ ]) {
System.out.println(“Hola Mundo“);
}
}
• Todo programa es escrito como el método estático llamado main en una
clase cualquiera
• Este método se empieza a ejecutar cuando se invoca el intérprete de java
para una clase dada
• args es un arreglo de Strings que contiene los parámetros
• con los que fué invocado el programa.

5
Tipos primitivos de datos en JAVA
• enteros: int, long, short, byte
Const. 1, -1, 1024, 1L
• reales: float, double
Const. 1.0, -3.14159, 1.5e4, 1.0f
• caracter: char
Const. ‘a’, ‘X’, ‘@’
• lógico: boolean
Const. true, false
Constantes de String: “Hola“,“12 de Abril“

6
Declaraciones
int i;
int i = 1;
double pi = 3.14159;
char c = ‘a’;
boolean estamos_bien = true;
Las declaraciones de variables pueden ir en cualquier parte del
programa pero siempre antes de que la variable sea usada.Hay
que tener cuidado con el rango de validez (scope) de la
declaración

7
Expresiones y asignación
• Aritmeticas: suma + 20 * c / (mod % 3)
• Relacionales: a > b, b >= c, c != 4, a == 0
• De String: “hola “+ nombre + “ hoy es “+
dia + “de”+mes
• Casts: (int) pi (pi = 3.1) (int) (Math.random()*100)+1)
• Otros: a == 1 ? a+1 : a-1
• Asignacion: a = 1;
• Asignación como operador: a = b = c = d = 0;
boolean cero = ( b = c - 10) == 0;

8
Conversiones de tipo
• Java no reclama si un tipo de menor rango se
convierte as uno de mayor rango.
byte < short < int < long < float < double
Tipo Bits Rango
int 32 -2**31 .. 2**31-1
short 16 -2**15 .. 2**15-1
byte 8 -2**7 .. 2**7-1
long 64 -2**63 .. 2**63-1
float 32 -10**32 .. 10**32
double 64 -10**300 .. 10**300

9
Ejemplos
• int i = 1;
• long l = i; //ok
• l = 1000000000000;
• float f = l; //ok
• double d= 1.0e24; int i = d;
// Error
• float f = 1.0f; int i = f;
// Error
• short s = i; //Error
• double d = 1.0; int i = (int)d;
//ok
• int i = 256;
• byte b = (byte)i; //ok pero b ==0;

10
Instrucciones de Control
• Instrucción condicional: if (cond) instr;
if(cond) instr; else instr;
• Ciclos: while (cond) instr;
• Ciclos: do instr; while (cond);
• Ciclos for (instr1; i<10; instr2)
instr;
• Selección switch/case
• Agrupación de instrucciones bajo un if, else, while,
for, etc. se realiza con paréntesis crespo { }

11
Programa Ejemplo
public class MCD {
//calculo del maximo comun divisor entre 15 y 24
public static void main(String args[ ]) {
int x = 15, y = 24;
while (x != y) {
if (x < y)
y = y - x;
else
x = x - y;
}
System.out.println(“el MCD entre 15 y 24 es
“ + x);
}
}

12
La clase String
• Son parte del lenguaje (no hay que importarlos)
• Se crean: String s = new String(“Hola Mundo”);
pero esto se puede resumir con String s = “Hola
Mundo”; u
• Tamaño de un String: int i = s.length();
• k-esimo carácter: char c = s.charAt(k);
• Subsecuencias: String sub = s.substring(k);
String sub = s.substring(inicio, fin);
• Búsqueda de subsecuencias: int i =
s.indexOf(“hola”);
• Comparacion: boolean iguales s1.equals(s2);
int i = s1.compareTo(s2);
0 si s1==s2, >0 si s1>s2, <0 si s1<s2

13
Búsqueda de Substrings
String s = “llego y dijo hola”;
int i = s.indexOf(“go”)´; i == 3 (parten
de 0)
Ej: Contar las apariciones de “hola” en un string
s:
public class Cuenta {
public static void main(String args[]) {
int i , apariciones = 0;
while ((i = s.indexOf(“hola”)) !0 -1) {
++apariciones;
s = s.substring(i+1);
}
System.out.println(“el string hola aparecio “+
apariciones+ “veces”);
}
}

14
Arreglos
• Se pueden declarar como: int[] A; int A[];
Esto es la declaración del puntero al arreglo, no se especifica tamaño en la
declaración;
• Inicialización: A = new int[10]; int[] A = new
int[10];
• Empiezan desde 0: for(int i=0; i < 10; ++i) A[i] =
0;
• Se puede averiguar el largo: int largo = A.length;
• length es un campo del objeto arreglo y no un
método. No es necesario el método ya que el
tamaño, como el contenido de un String no
varían despuésde su creación.

15
Los argumentos de un programa
• Si se invoca al programa P1 de ka siguiente manera: java P1
estos son parametros entonces en el programa se tendrá
args[0] = “estos”, args[1] = “son”, args[2] = “parametros”.
• Se reciben como un arreglo de strings en la variable declarada
como parámetro del programa String args[]
public class Parametros {
for(int i=0; i < args.length; i++)
System.out.pritnln(args[i]);
}
}

16
Exceptions
• Una Exeption es un evento que rompe la ejecución normal de un
programa (debido a un error). Cuando ocurre un evento como este un
objeto de la clase Exception es generado o “lanzado” (throw).
• Existen varios tipos de clases derivadas Exception dependiendo de que
fue lo que originó el evento: IOException,
IndexOutOfBoundsException, UnknownHostException, etc.
• Cuando esto sucede, el intérprete de JAVA busca un exception handler
adecuado para esta exception, que ejecuta un pedazo de código
(programado por el usuario) que debería reaccionar en forma adecuada
a esta falla del programa. Esto se llama “atrapar una exception” (catch).
• Cuando no se ha escrito ningún ningún handler que atrape esta
exception, el programa se detiene (se cae). La razón para introducir
exceptions es que la programación para reaccionar ante fallas se hace
más fácil (no hay que preverlas todas).

17
Cómo programar Exception Handlers ?
• Forma general: en un bloque try-catch
try {
lista de instrucciones que pueden generar un error
}
catch (ExceptionTipo1 e) {
lista de instrucciones para enmendar el error de Tipo1
{
}
}
• Si no se conoce o no importa el tipo de exception específico se
puede poner Exception y se atrapan todos (basta un solo bloque
cach). Si hay más de un bloque se ejecuta sólo un bloque catch
según el tipo de error.

18
Ejemplo de Exception I/O
• Muchas veces el compilador OBLIGA a programar el código de modo de atrapar
exceptions cuando estas pueden suceder con cierta probabilidad. Las más frecuentes
son las de IO.
import java.io.*; //importa clases de la biblioteca IO
public class ProgrmaÍO{
BufferedReader in; PrintWriter out; String line;
try { in = new BufferedReader(new FileReader(“Origen.txt”))};
catch (IOException e) {
System.out.println(“error en apertura”); System.exit(1);}
try { out = new PrintWriter( new FileWriter(“Destino.txt”))};
catch (IOException e) {
System.out.println(“error en creacion”); System.exit(1);}
try {
while( (line = in.readLine()) != null)
out.println(line);
catch (IOException e) { System.out.println(“problemas”);}
}
}

19
Ejemplo de Exception I/O (2)
• Se puede omitir poner tantos try-catch si no importa donde sucedió
public class ProgrmaÍO2{
try {
in = new BufferedReader(
new InputStreamReader(System.in));
out = new PrintWriter( new FileWriter(“Destino.txt”));
System.out.println(“ingrese linea”);
while( (line = in.readLine()) != “”){
out.println(line);
System.out.println(“ingrese linea”);
}
catch (Exception e) { System.out.println(“problemas”);
}
}
}

20
Ejemplo de Exception I/O (3)
• También se puede evitar tener que preocuparse de las exceptions siempre y
cuando el método que la pordría generar se declare como que “lanza” una
excepción:
public class ProgrmaÍO3{
public static void main(String args[]) throws IOException{
in = new BufferedReader(new FileReader(“Origen.txt”));
out = new PrintWriter( new FileWriter(“Destino.txt”));
while( (line = in.readLine()) != null)
out.println(line);
}
}
• Esto implica que el programa se caerá si hay una excepción durante la
generación del programa. En otros casos se puede declarar que uno o más
métodos lanzan una IOException y el programa o método principal se
preocupa de escribir el Exception handler.

21
Networking con Java (introducción)
• Java es un lenguaje que nace cuando la internet está en pleno
desasarrollo.
• Los diseñadores de java ya saben que se necesita un lenguaje
que apoye la programación distribuida en la internet con
protocolos TCP/IP
• Es importante contar con un lenguaje que sea independiente de
la plataforma para programar las comunicaciones entre dos
procesos, ya que la internet también es independiente de la
plataforma.
• Java implementa una serie de clases que apoyan esto
independientemente de la plataforma (URL, sockets, RMI,
IDL-CORBA, JDBL. Veamos un par de ellas:

22
Los URL
• Un URL es un UNIFORM RESOURCE LOCATOR. Consiste en
una dirección de un recurso que un servidor en la internet pone a
disposición de los usuarios, como por ej. http://www.arminco.com
• En un objeto URL existen dos componentes principales: El
descriptor de protocolo (ej. http) y el nombre del recurso (ej.
www.arminco.com). http significa Hyper Text Transfer protocol
pero hay otros protocolos de transferencia de datos en la internet
como: el File Transfer protocol (ftp), Gopher, File o News.
• En java es posible abrir una direccion de URL leer el contenido
como si fuera un archivo cualquiera. Para ello debemos crear un
objeto URL, con el nombre del protocolo y la dirección del
recurso que queremos recuperar.

23
Los URL (2)
• Existen varios constructores de URL:
– URL unRUL = new URL(“http://www.arminco.com/index.html”);
– unURL = new URL(“http”;”www.arminco.com”,”index.html”);
– inURL = new URL(“http”,”www.arminco.com”,80,”index.html”);
• Al crear una variable URL se puede producir una excepcion del
tipo MalformedURLException por eso se deben tomar las
medidas necesarias (como por ej: usar un bloque try-catch)
try {
URL miURL = new URL(....); }
catch(MalFormedURLException e) {
// codigo para atrapar la exception
}
• Métodos que se pueden aplicar a un objeto de la clase URL:
getProtocol(), getHost(), getPort(), getFile(), openConnection()

24
Leyendo el contenido de un URL
• Si sabemos a priori que el contenido de un URL es texto podemos
leerlo de la siguiente manera:
import java.net.*;
import java,io.*;
public class Leer URL {
try {
URL miURL = new URL(“http://www.dcc.uchile.cl”);
URLConnection c = miURL.openConnection();
BufferedReader in = new BufferedReader (
new InputStreamReader(
c.getInputStream()));
String line;
while ((line = in.readLine() != null)
System.out.prinln(line);
c.close();
catch(MalFormedURLException e) { }
}
}

25
Los Sockets
• Sockets se pueden describir como dos puntos que arman un puente
de transporte de datos entre dos programas. Dos programas pueden
establecer gracias a los sockets una comunicación segura (hay
recuperación de errores de transmisión). Un proggrama puede leer
datos de un socket (lo que otro pragrama escribió) o puede escribir
datos en un socket ( para que lo lea otro programa)
• En una comunicación entre dos programas con sockets siempre hay
un servidor y un cliente. El servidor es el que primero establece la
posibilidad de comunicación y se queda escuchando a ver si hay
alguien que quiere comuncarse con el por medio de este socket.El
cliente es un programa que, sabiendo que hay un programa servidor
escuchando, se conecta al socket del servidor y escribe y/o lee de
el.

26
Los Sockets (2)
• Ver programas de las hojas repartidas

27
Clases definidas por usuario
Partamos con un ejemplo; en el archivo Auto.java se tiene:
public class Auto {
public String nombre;
public int construccion;
public float rendimiento;
}
Podemos entonces escribir un programa que use esto:
public class Programa {
Auto miAuto1 = new Auto(); // el constructor clase()
es gratis!
miAuto1.nombre = “Volkswagen”; //porque es public
!!!!
miAuto1.construccion = 1994;
miAuto1.rendimiento = 9.65;
System.out.println(“mi auto es un “+miAuto1.nombre+
“fue construido el “+miAuto1.construccion+
“y gasta “+rendimiento+”litros cada
100km”);
} }

28
Métodos de una Clase
• Son los que tienen la responsabilidad de:
- Entregar datos acerca del objeto
- Modificar datos dentro del objeto (especialmente si las componenetes del
objeto no fueron declarados como public)
- Crear un nuevo objeto (constructores)
• Los métodos pueden ser públicos, privados o protegidos
(public, private, protected), al igual que
las compoenetes
- pirvate: implica que pueden ser vistas sólo en la clase actual. Son
invisibles incluso para clases derivadas de esta.
- protected: implica que pueden ser vistas por las derivadas. Tambien son
vistas dentro del paquete (agrupación de clases en un archivo). Este es
eldefault.
- public:son vistas desde cualquier lado.

29
Agreguemos métodos a la clase Auto
public class Auto {
String nombre; int construccion= 1990; float
rend;
public Auto() {
nombre = “Yiguly”; rend = 15; //se crea con estos
valores
}
public void cambiaConstrucción(int año) {
construccion = año;
}
public Auto(String nombre; int construccion;
float rend) {
this.construccion = construccion;
this.nombre = nombre; this.rend = rend //no hay
ambigüedad!
}
public float redimientoEnKxL() {
return 100/rend;
}
}

30
Herencia y estáticos
public class AutoColeccion extends Auto {
String comentarios; int valorColeccion;
static cantidad = 0; // una sola variable para
toda la clase
// conocida por todos los objetos
AutoColeccion() { //no se heredan !!!!
super(); ++cantidad;
cometarios = “nada por ahora”;
valorColeccion = 0;
}
public void cambiaConstrucción(int año) {
construccion = año;
comentarios = “se cambio el valos de
construccion”;
}
public static int cuantos() {
return cantidad;
}
}

31
Más sobre métodos
• Los métodos dinámicos (sobre objetos) se invocan:
variableObjeto.nombreMétodo(parametro1,..,parámetroN)
Ej: miAuto.cambiaConstruccion(1999)
• En el caso de los métodos estáticos:
NombreClase.nombreMétodo(parámetro1,..,parámetroN)
Ej: int i = AutoColeccion.cuantos()
• En Java existe la clase Math cuya función más importante es
proveer al leguage de los métodos matemáticos típicos:
Math.sqr(x), Math.sin(x), Math.max(x,y), Math.pow(x,y)
• El paso de parámetros es siempre por valor, salvo en el caso de
objetos y arreglos, que es por referencia (se pasa una copia del
puntero al objeto)
• main es un método estático de una clase !!!!!

32
Clases Abstractas
• Son clases de las cuales no se pueden crear directamente objetos.
Están destinadas a ser superclases de otras. Definen un conjunto de
atributos comunes para todas las clases derivadas.
abstract class Personal {
int numero; String nombre; int ingreso;
public Personal(int num, String nom){
numero=num; nombre=nom;
}
public abstract int sueldoBruto(); //implementar en clase derivada
}

33
Clases Abstractas (2)
• Si en la declaración de alguna clase hay al menos un método
abstracto, toda la clase debe ser declarada como abstracta.
• Los métodos abstractos actúan como interfaz del concreto
• Al declarar una clase derivada de una abstracta DEBEMOS
implementar todos los métodos abstractos que se habían declarado.
public class Trabajador extends Personal {
int HN, HE, VHN=5000, VHE=10000;
public Trabajador(String nom, int num, int hn, int he) {
super(nom,num); HN = hn; HE = he;
}
public int sueldoBruto() {
return HN*VHN+HE*VHE;
}
}

34
public class Empleado extends Personal {
int sueldoBase, asignacion;
public Empleado(String nom, int num, int sb, int as) {
super(nom,num); sueldoBase = sb; asignacion = as; }
return sueldoBase+asignacion;
}
}
public class Gerente extends Personal {
int sueldoFijo, participacion;
public Gerente(String nom, int num, int sf, int pa) {
super(nom,num); sueldofijo = sf; participacion = pa; }
return sueldofijo+participacion*1.5;
}
}

35
public class ProgramaSueldos {
public static void main(String args[]){
Personal[] P = new Personal[100];
/* aquí llenar arreglo por ej. con
P[0] = new Trabajador(a1,b1,c,d);
P[1] = new Trabajador(a2,b2,c,d);
P[2] = new Empleado(e1,f1,g,h);
P[3] = new Gerente(g1,l1,xy); o llamando rutina*/
int sumaSueldosBruto = 0;
for(int i = 0; i<100;++i)
sumaSueldosBruto += P[i].sueldoBruto();
System.out.println(“la suma de los sueldos es”+ sumaSueldosBruto;
}
}
• Otro ejemplo muy bueno sería el de un programa para animar figuras
representadas por objetos distintos (cuadrados, rect., circ., figuras
humanas) en una ventana. Estas figuras pueden rotar, agrandarse,
achicarse, moverse, etc. Si queremos que un conjunto de ellas se traslade
y se vuelva a dibujar, esta es la forma de hacerlo!

36
Interfaces
• Una interfaz es una forma especial de una clase que consiste
exclusivamente de declaraciones de métodos abstractos y constantes.
En vez de la palabra clave “class” las interfaces tienen la palabra
“interface”. Todos los métodos declarados son abstractos. Esto
implica que tienen que ser implementadas por alguna clase que use
esta interfaz. Ej.
public interface ObjetoGrafico {
public final int MaxAncho = 800;
public final int MaxAalto = 600;
public void trasladar(int x, int y);
public void escalar(float p);
public boolean visible();
etc...
}

37
Interfaces (2)
• La interfaz funciona como un protocolo: cualquier clase que ocupoe la
interfaz debe implementar todos los métodos que la interfaz declara.
public class MiOjetosGrafico1 implements ObjetoGrafico{
private int origenX, origenY, ancho, alto;
private estaVisible;
public void trasladar(int x, int y) {
if (origenX+x <= MaxAncho)
origenX += x;
else ....
if (origenY+y <= MaxAlto)
origenY +=y;
else ......
}
public void escalar(float p){ ......}
public boolean visible(){ .......}
etc...
}

38
Interfaces(3)
A estas alturas nos deberíamos estar preguntando por qué no lo
hicimos con clases abstractas, acaso no es lo mismo ? NO!!!!
Si quisieramos hacer una clase abstracta entonces los objetos
gráficos están obligados a ser derivados de esta única clase
abstracta (Java no permite múltiple herencia). En muchos casos
querríamos que los objetos gráficos fueran heredados de otras
clases (incluso distintas clases para distintos objetos gráficos)
pero que todos tuvieran la misma interfaz.

39
Interfaces(4)
• O sea que las interfaces definitivamente no sirven para
implementar herencia múltiple ? SI y No:
• Una clase solo puede heredar constantes de la interfaz
• Una clase no puede heredar implementaciones de una interfaz
• Una interfaz se puede usar como una clase
• Una interfaz puede ser una extensión de una clase abstracta, con
lo cual se heredan características de otra clase más:
Ej: public interface ObjetoGrafico extends ObjetoGeometrico
public class ComponenteGrafica extends JPanel implements
ObjetoGráfico:

40
Haciendo más de una cosa a la vez: Threads
• Un thread es una secuencia o flujo de de instrucciones que se
ejecutan dentro de un programa. Tiene un comienzo y un fin.
Entonces qué diferencia tiene con un proceso ?
• El thread sólo puede ser creado dentro de un proceso. Y un proceso
(programa) puede crear varios threads dentro de él que se ejecutan
en paralelo.
• Entonces, qué diferencia tiene con multiprocesos a la UNIX ? (para
los que programaron en C, qué los difiere del fork ?)
• El programa principal está “conciente” de los threads que existen,
hay variables que los identifican. Pueden ser creados, inicializados,
sustendidos, reactivados o parados por el el programa que los creó.
• El programa principal puede darles parámetros distintos a cada
thread. Los thread se pueden programar con la canatidad de
variables necesarias para su ejecución (no lo heredan TODO)

41
El método run de la clase Thread
• Los threads son una clase existente. Lo que un thread en particular
hace cuando se echa a correr se debe escribir en el método run de la
clase thread, que es un método que se debe escribir siempre.
• Hay dos formas de implementar Threads en Java (que coincide con
las dos formas vistas de implementar métodos definidos):
– Crear una nueva clase que extienda la clase abstracta Thread e
implementar el método abstracto run.
– Implementar la interfaz runnable, lo cual implica que se va a
reescribir el método run.
• La razón para escoger una u otra forma es simplemente si
queremos que la clase que implementa el thread sea además
extendida de otra clase (aparte de la clase thread).

42
public class SimpleThread extends Thread {
public SimpleThread(String str) {
super(str);
}
public void run() {
for (int i = 0; i < 10; i++) {
System.out.println(i + " " + getName());
try {
this.sleep((int)(Math.random() * 1000));
} catch (InterruptedException e) {}
}
System.out.println("DONE! " + getName());
}
}
• El método this.sleep(milisegundos) debe ir en un bloque try and
catch

43
La forma extendida de Thread(2)
public class TwoThreadsTest {
public static void main (String[] args) {
new SimpleThread("Jamaica").start();
new SimpleThread("Fiji").start();
}
}
• El método start() inicia la ejecucón de un thread. Esto implica que
se empieza a ejecutar el código escrito en el método run del
thread. También existen otros métodos que se le pueden aplicar a
un thread: suspend(), resume(), stop().

44
Implentación haciendo interface
public class MiThread2 implements Runnable {
public void run() {
int i = 0;
while(true)
System.out.println(i++);
}
}
public class TestThread {
b = new MiThread2();
Thread t = new Thread(b);t.start();
for (int i=0; i<1000; i++);
t.stop();
}
}

45
Usando threads para atender clientes de un
Servidor de Sockets
• La forma de implementar servidores que atiendan a varios clientes
paralelamente a la vez es combinando threads con sockets
• El servidor abre un ServerSocket desde donde oye ciualquier
intento por conectarse con él de un cliente.
• Una vez establecida la conexión, abre un socket normal e inicia un
thread que atiende a este cliente. El socket abierto se pasa como
parámetro. De esa manera puede seguir oyendo por el
ServerSocket sin estar bloqueado.
• El thread tiene un método run que atiende los pedidos del cliente
• El cliente se conecta al servidor sin saber que finalmente será un
socket el que está atendiéndolo.
• Si el protocolo de atención especifica la manipulación de datos
comunes (por ejemplo a un archivo con información sobre cuentas
corrientes), hay que tener cuidado con los accesos concurrentes a
estos datos (métodos synchronized).

46
Ejemplos de programas interesantes
• El programa MultiServer.java es el del servidor que establece el
ServerSocket y se queda oyendo para ver si viene un cliente. Si llega
un cliente crea un socket y un nuevo thread, al cual le pasa el socket,
para que sea atendido. El server siguie esperando clientes en el ciclo.
• El programa MultiServerThread es el thread que atiende al cliente. En
este caso sólo manda dos strings, uno avisándole que número de
cliente es el otro para despedirse.
• El programa Client.java se comunica con el servidor y lee los dos
strings desde el socket establecido, los cuales los imprime en pantalla.
• El programa Syncron.java muestra como debe declararse un método
al cual acceden varios threads de modo que no se produzca problema
de acceso indebido (más de un thread puede obtener el mismo
número!!)
• Los programas DateServer y DateClient muestran como se pueden
traspasar objetos facilmente por un socket (siempre que estos sean
serializables)

47
Objetos Remotos en JAVA
• La tecnología RMI (Remote Method Invocation) permite a un programa
corriendo en una máquina virtual de java (un intérprete) invocar el
método de un objeto localizado en otra máquina virtual de java (ubicada
en cualquier parte de la red TCP/IP que se pueda acceder desde el lugar)
• Normalmente se tiende a ver aplicaciones que usan RMI como
aplicaciones de cliente servidor. Una típica aplicación de servidor crea
un objeto, lo “publica” para que pueda ser accesible de cualquier otro
lado y espera a que llamen clientes pidiendo la invocación de sus
métodos. Una típica aplicación cliente obtiene una referencia al objeto
remoto en el servidor y luego invoca sus métodos como si fuera un
objeto local.
• RMI provee mecanismos con los cuales el cliente y el servidor se
pueden intercambiar información, convirtiendolas en aplicaciones de
objetos distribuidos. Estos mecanismos deben hacer posible: 1) localizar
objetos remotos, 2) comunicarse con los objetos remotos 3) traspasar el
código de los objetos remotos (deben ser serializables)

48
Interfaces, objetos y métodos remotos
• Como en otras aplicaciones, una aplicación distribuida que usa RMI
está constituida por interfaces y clases. Las interfaces definen los
métodos que serán conocidos por los clientes de los objetos remotos.
Las clases remotas implementan estos y quizas otros métodos
también.
• Un objeto remoto se implementa siguiendo los siguientes pasos:
1) Diseño e implementación de las componentes de la aplicación
distribuida
2) Compilar los códigos fuentes y generar los llamados “stubs” y
skeletons
3) echar a andar la aplicación

49
Diseñar e implementar las componentes
de la aplicación
• Definir las interfaces remotas: Una interfaz remota especifica
los métodos que pueden ser invocados en forma remota por un
cliente. Los clientes conocerán los objetos remotos sólo a
través de las interfaces.
• Implementación de los objetos remotos: los objetos remotos
deben implementar una o más interfaces remotas. Además
pueden implementar otros métodos que no corresponden a las
interfaces remotas y que son de uso local.
• Implementar los clientes: Los clientes que usan los objetos
remotos se pueden implementar una vez que las interfaces
remotas están definidas.

50
Un ej: Un objeto remoto que contiene un
número
//el archivo de definición de la interfaz
import java.rmi.*;
public interface Numero extends Remote {
public int getNumero() throws RemoteException;
}
• Este es la definición de la interfaz: implica que los clientes sólo
conocerán el método getNumero() de el objeto remoto. Para los
clientes la clase de este objeto es Numero, no importa cómo lo haya
llamado en el archivo de implementación del tipo de objeto.

51
Un ej: Un objeto remoto(2)
//el archivo de definición de la implementación
import java.rmi.*;
import java.rmi.server.UnicastRemoteObject;
public class NumeroImpl extends UnicastRemoteObject implements Numero
{ int cont = 0;
public int getNumero() throws RemoteException {
int ret = cont++;
return ret;
}
System.setSecurityManager(new RMISecurityManager());
try { NumeroImpl n = new NumeroImpl();
Naming.rebind("//"+args[0]+"/elNumero",n);
System.out.println("Numero creado");
} catch (Exception e) {}
}
}

52
Aclaración: Existe un servidor de
comunicaciones !!!!
• Es un programa que provee java llamado rmiregistry
• Se echa a correr en la máquina donde está el programa
servidor del objeto remoto
• Cualquier cliente que quiera ocupar el objeto remoto debe
pedirle a él una referencia al objeto remoto antes de
ocuparlo => debe saber con qué nombre se registró y en
qué máquina esta corriendo.
Cliente
rmiregistry
servidor
Internet Naming.rebind(1)
Naming.lookup(2)
Objeto.metodo() (3)

53
Un ej: Un objeto remoto que contiene un
número(3)
//el archivo del cliente
import java.rmi*;
import java.rmi.server.*;
class ClienteNumero {
try {
Numero N = (Numero) Naming.lookup("//"+args[0]+"/elNumero");
System.out.println("El numero vale ahora "+N.getNumero();
} catch( Exception e) {}
}
}

54
Compilar los códigos fuentes y generar las
clases y los llamados “stubs” y skeletons
• Una vez implementados las 3 clases hay que
compilarlas para generar
– Numero.class: la interfaz que define lo que se conocerá del
objeto en toda la red.
– NumeroImpl.class: que es el que implementa el objeto
remoto. Además de implementar el constructor y el método
de la interfaz contiene un main que lo único que hace es
crear el objeto y registrarlo o publicarlo con un nobre dado.
– Cliente.class
– Esto se hace con el compilador javac

55
Compilar los códigos fuentes y generar las
clases y los llamados “stubs” y skeletons(2)
• Una vez generadas las 3 clases hay que compilar la clase
implementadora para generar el stub y skel.
– NumeroImpl_stub.class: Es el llamado stub del objeto remoto.
Es el encargado de recibir y transmitir los datos necesarios
para servir a los clientes que piden acceso al objeto remoto
NumeroImpl.
– NumeroImpl_skel.class: es como un esqueleto de la clase.
Tiene sólo la estructura de la clase pero es suficiente
información para que el cliente pueda reunir todo los
antecedentes para llegar a hacer un pedido al stub
– Esto se hace con el compilador rmic NumeroImpl

56
Echar a andar la aplicación
• Echar a correr rmiregistry: java rmiregistry
• Echar a correr el programa servidor de objeto
remoto: java NumeroImpl
• Echar a correr cliente(s): java Cliente.
• Una vez obtenida la referencia por el cliente el
flujo de datos corre: cliente -> skel->stub->Server-
>stub->skel->cliente
• Veamos una aplicación más interesante: Un
Banco: los clientes son un ejecutivo de cuentas y
un cliente cualquiera. El servidor tiene la info
sobre las cuentas.

JAVA PARA PRINCIPIANTES2342342432231.PPT

Más contenido relacionado

Similar a JAVA PARA PRINCIPIANTES2342342432231.PPT (20)

Más de LDACORGANIZACION (20)

Último (20)

JAVA PARA PRINCIPIANTES2342342432231.PPT