TECNOLOGICO DE ESTUDIOS SUPERIORES DE

HUIXQUILUCAN


Pgina 1






























TPICOS AVANZADOS DE
PROGRAMACIN

SCD-1027




ISC. Vidal Acosta Durn.

Ing. Nstor Monroy Mndez
Nombre y Firma del Docente Vo. Bo. Jefe de Divisin

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 2



ndice

INTRODUCCIN --------------------------------------------------------------------------------------------------------------------------------------------------- 3

PRCTICA 1
Cuenta de votos ----------------------------------------------------------------------------------------------------------------------------------------------------- 4
PRCTICA 2
Calculadora ---------------------------------------------------------------------------------------------------------------------------------------------------------- 4
PRCTICA 3
Posiciones ----------------------------------------------------------------------------------------------------------------------------------------------------------- 5
PRCTICA 4
Bandera de Israel -------------------------------------------------------------------------------------------------------------------------------------------------- 7
PRCTICA 5
Componentes bsicos de interfaces graficas -------------------------------------------------------------------------------------------------------------- 8
PRCTICA 6
Sueldos --------------------------------------------------------------------------------------------------------------------------------------------------------------- 8
PRCTICA 7
Hilos -------------------------------------------------------------------------------------------------------------------------------------------------------------------- 19
PRCTICA 8
Sincronizacin de hilos -------------------------------------------------------------------------------------------------------------------------------------------- 22
PRCTICA 9
Cliente- Servidor en Java ----------------------------------------------------------------------------------------------------------------------------------------- 25
PRCTICA 10
Sockets UDP --------------------------------------------------------------------------------------------------------------------------------------------------------- 28
PRCTICA 11
Servidor --------------------------------------------------------------------------------------------------------------------------------------------------------------- 29
PRCTICA 12
Uso de JavaBeans-------------------------------------------------------------------------------------------------------------------------------------------------- 30
PRCTICA 13
Asociando conos y propiedades ligadas en JAVABEANS ---------------------------------------------------------------------------------------------- 33
PRCTICA 14
Hilos ------------------------------------------------------------------------------------------------------------------------------------------------------------------- 37
PRCTICA 15
Uso de hilos ---------------------------------------------------------------------------------------------------------------------------------------------------------- 38
PRCTICA 16
Midlets de mensaje ------------------------------------------------------------------------------------------------------------------------------------------------- 40
PRCTICA 17
Midlets ----------------------------------------------------------------------------------------------------------------------------------------------------------------- 43
PRCTICA 18
Conectividad Java ------------------------------------------------------------------------------------------------------------------------------------------------- 43
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 3



FORMATO DE PRCTICAS DE CENTRO DE CMPUTO
Carrera Plan de Estudio
Clave
Asignatura
Nombre de
Asignatura
Ingeniera en
Sistemas
Computacionales
PLAN ISIC-2010-224 SCD-1027 TPICOS AVANZADOS DE
PROGRAMACIN


1
Introduccin

El manual est dirigido a los alumnos que cursan el cuarto semestre de la
carrera Ing. Sistemas Computacionales, para poner en prctica sus habilidades
y conocimientos bsicos de programacin orientada a objetos y fundamentos de
programacin para la generacin de aplicaciones y conexiones en java
(NetBeans).

Las prcticas descritas en este manual pretenden guiar al alumno en su proceso
de aprendizaje en java para la programacin, manipulacin y modelado de
grficos.

Tambin se busca desarrollar habilidades creativas y emprendedoras, dando un
espacio al estudiante para que detecte las reas de oportunidad en su entorno y
genere el proyecto que desarrollara en el transcurso del curso. Del mismo modo
por la naturaleza de la materia debe promoverse la cultura de tica y respeto a
los derechos de autor, tanto en las aplicaciones desarrolladas como en el uso
de las herramientas utilizadas.















TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 4



PRCTICA 1. CUENTA DE VOTOS.

Escriba un programa en Java que lea una serie de votos de una eleccin y muestre
los resultados finales. Slo existen tres partidos: PRI, PAN y PRD. El programa
pregunta inicialmente cuantos votos se introducirn y posteriormente pide cada uno
de ellos. Al final muestra los votos que obtuvo cada partido. Las pantallas sern
similares a stas:


Figura 1 Figura 2 Figura 3


Figura 4 Figura 5


PRCTICA 2. CALCULADORA.

Complete el siguiente cdigo de tal forma que genere una calculadora como la
mostrada (los botones debern ir en el orden mostrado):


Figura 1
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 5



Cdigo:

//importar las clases necesarias
public class Practica2 {
public static void main(String[] args) {
JFrame calculadora = new JFrame("Calculadora 1.0");
Container p = calculadora.getContentPane();
JTextField display = new JTextField();
JPanel teclas = new JPanel();
// Establecer un GridLayout de 4x4 para el panel teclas
// Crear un arreglo de etiquetas llamado etiquetas
for (String eti: etiquetas) teclas.add(new JButton(eti));
p.add(display,BorderLayout.NORTH);
p.add(teclas,BorderLayout.CENTER);
calculadora.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
calculadora.setSize(200,200);
calculadora.setVisible(true);
} }


PRACTICA 3. POSICIONES.

Complete el cdigo en los lugares indicados para que se muestre la siguiente
ventana:


Figura 1 Figura 2 Figura 3








Figura 4

Cdigo:

package xxx; //Poner aqu el paquete
import java.awt.BorderLayout;
import java.awt.GridLayout;
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 6



import java.awt.FlowLayout;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class Practica3 extends JFrame {

JButton[] botones = new JButton[25];
JPanel panelPrincipal, panelIzquierdaArriba, panelIzquierdaAbajo, panelDerechaArriba,
panelDerechaAbajo;
JPanel[][] paneles = new JPanel[2][2];
public Practica3() {
super("JFrame con varios Administradores de Diseo");
for (int i = 0; i < 25; i++) {
botones[i] = new JButton("" + (i + 1));
}
panelPrincipal = (JPanel) getContentPane();

//Panel superior izquierdo
panelIzquierdaArriba = new JPanel();
panelIzquierdaArriba.setLayout(new FlowLayout());
panelIzquierdaArriba.add(new JButton("Aceptar"));
// Agregar lnea aqu .
//Panel superior derecho
panelDerechaArriba = new JPanel();
panelDerechaArriba.setLayout(new BorderLayout());
panelDerechaArriba.add(new JButton("Arriba"), BorderLayout.NORTH);
panelDerechaArriba.add(new JButton("Abajo"), BorderLayout.SOUTH);
// Agregar lineas aqui ..

//Panel inferior izquierdo
// Agregar lneas aqu .

//Panel inferior derecho
panelDerechaAbajo = new JPanel();
panelDerechaAbajo.setLayout(new GridLayout(5, 5));
for (int i = 0; i < 25; i++) {
// Agregar linea a qui.
}

//Panel principal
GridLayout gr = new GridLayout(2, 2);
gr.setHgap(20);gr.setVgap(20);
panelPrincipal.setLayout(gr);
panelPrincipal.add(panelIzquierdaArriba);
panelPrincipal.add(panelDerechaArriba);
// Agregar lneas aqu

// To close the window
setDefaultCloseOperation(EXIT_ON_CLOSE);
// Sets the width and height of the frame.
setBounds(300, 300, 600, 500);
setVisible(true);
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 7



}

public static void main(String args[]) {
Practica3 fe = new Practica3();
}
}


PRCTICA 4. BANDERA DE ISRAEL.

Escriba un programa en Java que dibuje la Bandera de Israel:


Figura 1


















TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 8



PRCTICA 5. COMPONENTES BSICOS DE INTERFACES
GRFICAS

Escribir un programa que muestre una pantalla similar a la siguiente:


Figura 1

El programa deber hacerse sin ninguna ayuda visual (se debe teclear el cdigo
completo)


PRCTICA 6. SUELDOS.

En sta prctica vamos a crear una interface grfica para calcular el sueldo de una
persona utilizando la ayuda para programacin visual de NetBeans. En la primera
parte crearemos los componentes y los distribuiremos en el rea de trabajo. En la
segunda parte agregaremos el cdigo para realizar el clculo.

Abre Netbeans y selecciona File->New Project->General->Java Application. Deber
aparecer una pantalla como esta:

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 9




Figura 1

Oprime Next. Vamos a crear una aplicacin con una interface grfica que calcule e
imprima el sueldo de un trabajador a partir de las horas trabajadas. Al terminar la
prctica, el programa resultante deber producir una pantalla similar a esta:


Figura 2

Regresemos al NetBeans, en la pantalla que aparece, deja el nombre por default
del proyecto.

Figura 3
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 10



Selecciona un directorio para esta aplicacin. Deselecciona el botn Create Main
Class Presiona Finish y debes tener una pantalla como la siguiente:


Figura 4

Para crear la interface, debes usar el editor de formas y crear un contenedor para tu
aplicacin usando una forma especfica. Los contenedores ms generales son:
JFrame, Jdialog y JApplet. Cada componente debe ser parte de alguna jerarqua
que es un rbol de componentes que tiene un contenedor general como la raz.
Cada contenedor tiene un content pane o rea visible que contiene los
componentes visibles de ese contenedor.

Puedes agregar una barra de men a un contenedor general.

Ahora, selecciona el menu File->New File y selecciona Java GUI Forms. Nota los
Tipos de archivo que aparecen a la derecha. Para esta aplicacin usaremos un
JFrame.

Selecciona JFrame Form y dale Click al boton Next. Nombra al Frame
SamplesFrame y dale click al boton Finish. Deber aparecer una pantalla como
esta:
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 11




Figura 5

Para ver el cdigo creado por NetBeans, selecciona Source. Puedes en todo
momento ver el cdigo o regresar al diseo de la forma oprimiendo Design. Con el
editor de formas, poder agregar y editar componentes utilizando cualquiera de las
tres reas de trabajo:

Palette Contiene los componentes y Layout managers
Inspector Despliega la estructura jerrquica de los componentes
Properties Despliega las propiedades del componente seleccionado.


Figura 6

Hasta ahora, has creado un proyecto y un JFrame llamado SamplesFrame. Ahora
vamos a agregar componentes. Dale Click al componente JTabbedPane que se
encuentra en Palette, y colcalo en el area blanca de tu diseo. Ahora, has click en
JPanel y colcalo adentro del JTabbedPane. Esto ha agregado un JPanel al
JTabbedPane, agrega otro JPanel procurando colocarlo en la parte superior de tal
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 12



forma que se agrega al mismo nivel del JPanel anterior. Debes tener algo similar a
esto:

Figura 7

Puedes observar las propiedades de cada objeto seleccionndolo en la ventana del
Inspector. Vamos a cambiar el texto de cada pestaa. Selecciona cada uno de los
JPane y en el rea de propiedades cambia el ttulo (Tab Title). Cambia el ttulo de la
pestaa 1 por Calculadora y el de la dos por Imagen. Ahora, vamos a establecer
cmo van a ser desplegados los componentes. En la ventana de Inspector dale
click derecho al JFrame, y selecciona Set Layout-> GridBagLayout.

Vamos a agregar ms componentes al JPanel1. Seleccinalo (al JPanel1) en la
ventana del inspector y vamos agregar 8 etiquetas (JLabel) dos Campos de Texto
(JTextField) y un botn (JButton). Tu ventana del Inspector y del diseo debe ser
algo parecido a esto:


Figura 8
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 13



Ahora vamos a cambiar los ttulos de los componentes. En el caso de las etiquetas
6,7 y 8 no pondremos ttulos pues las usaremos para desplegar los clculos. Al final
debe quedar algo as:


Figura 9

Puedes probar tu diseo oprimiendo el botn o puedes ejecutar el archivo
seleccionando Run->Run File->SamplesFrame.java. La pantalla debe ser algo
parecido a esto:

Figura 10

Con esto terminamos la primera parte de la prctica. En la segunda parte
introduciremos el cdigo para realizar los clculos.
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 14



PRACTICA SOBRE NETBEANS (SEGUNDA PARTE).

En esta parte de la prctica vamos a trabajar con la parte dinmica de la interface
grfica de la calculadora. Empezaremos con el diseo que hicimos en la primera
parte de la prctica:


Figura 11

Hasta ahora, esta aplicacin no tiene funcionalidad. Agregaremos un manejador de
eventos para el botn, pero primero crearemos un men para esta aplicacin.
Aunque frecuentemente los mens son de los primeros objetos creados en una
Aplicacin, lo haremos de otra forma para demostrar lo fcil que resulta modificar el
diseo de la aplicacin creando componentes en cualquier orden. En la ventana del
Inspector puedes seleccionar el objeto que desees y modificar, agregar o borrar
componentes.

Regresemos a la pantalla de diseo, en la ventana del Inspector, selecciona el
JFrame. Nota que en la ventana de propiedades puedes cambiar cualquiera de
ellas.

Ahora, en la ventana del Inspector, oprime el botn derecho sobre el componente
JFrame, selecciona Add From Palette y selecciona: swing->JMenuBar. Cuando
veas que el objeto ha sido creado en la ventana del Inspector, observa que tambin
se ha creado el objeto JMenu1. Posteriormente oprime el botn derecho en JMenu1
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 15



y renmbralo (change variable name) como Archivo. Tambin cambia el texto que
aparece en el diseo por Archivo (edit text). Tu pantalla debe ser similar a esta:


Figura 12

Ahora, en la ventana del Inspector, oprime el botn derecho en el componente
Archivo y selecciona Add JMenuItem. Renmbralo como Abrir. Puedes agregar
ms opciones.

Oprime botn izquierdo sobre el componente JmenuBar1, selecciona Add JMenu y
renmbralo como Ayuda. Prueba tu diseo, debers tener algo similar a esto:


Figura 13

De esta forma puedes agregar ms mens y ms opciones por cada men.
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 16



El ltimo componente que debemos agregar es una imagen de la persona. Una manera de
mostrar imgenes en Java Swing es decorando componentes como etiquetas, botones,
etc., con un cono. Un cono es una figura de tamao fijo.

Vamos a poner una imagen en la pestaa de Imgenes. En la ventana del inspector,
selecciona con doble-click a JPanel2.

Ahora, selecciona el layout to BorderLayout (Click derecho en JPanel2-> setLayout -
>BorderLayout). En la paleta de componentes, selecciona JLabel y coloca la etiqueta
adentro del Panel. En la paleta de propiedades, cambia el icono por una imagen.

Colcala en el centro del panel seleccionando las propiedades horizontalAlignment y
verticalAlignment. Tu pantalla deber verse parecida a esta:


Figura 14

Finalmente, vamos a agregar el cdigo para que al oprimir un botn, se calcule el
pago del trabajador. Selecciona en la pantalla de diseo o en la ventana del
Inspector el botn Calcula. Dale click derecho, y selecciona Events->Action-
>ActionPerformed:
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 17





Figura 15

Aparecer el cdigo del mtodo que maneja el botn. Agrega el siguiente cdigo en el mtodo
jButton1ActionPerformed:

//Lee las horas trabajadas del campo de texto y lo convierte a int
int hw = Integer.parseInt(jTextField1.getText());
// Lee el salario por hora y lo converte a int
double rateEntered =
Double.parseDouble(jTextField2.getText());
//Crea dos variables de tipo Double.
double regularPay = 0;
double overTimePay = 0;
//Si trabaj mas de 40 horas se le paga 150%
if (hw > 40) {
regularPay = 40 * rateEntered;
overTimePay = (hw - 40) * 1.5 * rateEntered;

} else {
regularPay = hw * rateEntered;
overTimePay = 0.0;
}
double total = regularPay + overTimePay;
//Variables para formateo de numeros
NumberFormat nfRegular =
NumberFormat.getCurrencyInstance(Locale.US);
NumberFormat nfOverTime =
NumberFormat.getCurrencyInstance(Locale.US);
NumberFormat nfTotal =
NumberFormat.getCurrencyInstance(Locale.US);
//Writes the totals in the correct format to the labels jLabel6.setText(" " +
nfRegular.format(regularPay));
jLabel7.setText(" " + nfOverTime.format(overTimePay));
jLabel8.setText(" " + nfTotal.format(total));
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 18




Probablemente tengas que importar algunos paquetes. Agrega el cdigo al
principio:

import java.text.NumberFormat;
import java.util.Locale;

Nota: Si tienes diferentes nombres para los campos de texto y etiquetas modifica el
cdigo anterior. Ahora corre el archivo. Debers tener una pantalla como esta:


Figura 16











TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 19



PRCTICA 7. HILOS

En esta prctica vamos a crear hilos (Threads) en Java. Los hilos van a
comunicarse a travs de un objeto que servir para controlar la velocidad en que se
mueven los objetos grficos de cada hilo as como para suspender o terminar la
ejecucin de los hilos.

Figura 1

El botn de disminuir, disminuye la velocidad con la que se mueven los puntos
blancos, el de Aumentar, aumenta la velocidad. El botn de Suspender, provoca
que los puntos se detengan y el botn de terminar provoca que los Threads de
cada punto terminen. El cdigo que crea los hilos es el siguiente:

import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class Practica5 extends Frame{
Button inicio;
Control c = new Control();

public Practica5(){
super("Ejemplo de Hilos");
setSize(420,420);
setLayout(new FlowLayout());
inicio = new Button("Iniciar");
add(inicio);
setBackground(Color.BLACK);
c.setLocation(50,50);
c.setVisible(true);
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 20



setLocation(500,50);
setVisible(true);

addWindowListener(new WindowAdapter(){
public void windowClosing(WindowEvent e){
System.exit(0);
}
});
inicio.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
Graphics g = getGraphics();
Balon b = new Balon(g,c);
b.start();
}
});
}

public static void main(String[] args) {
Practica5 p = new Practica5();
}

private class Balon extends Thread{
int x, y, diametro;
boolean direccionX=true;
boolean direccionY=true;
Graphics g;
Control c;

public Balon(Graphics g, Control c){
x=(int)(Math.random()*300+1);
y=(int)(Math.random()*300+1);
diametro=10;
this.g = g;
this.c = c;
}

public void run(){
int incX,incY;
while(!c.salir){
g.setColor(Color.BLACK);
g.fillOval(x,y,diametro,diametro);
if (direccionX) incX = c.IncX;
else incX = -c.IncX;
if(x + incX <= 0 || x + incX >= 400)
direccionX = !direccionX;
if (direccionY) incY = c.IncY;
else incY = -c.IncY;
if(y + incY <= 30 || y + incY >= 400)
direccionY = !direccionY;
x+=incX;
y+=incY;
g.setColor(Color.WHITE);
g.fillOval(x,y,diametro,diametro);
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 21



try{
sleep(50);
} catch(InterruptedException e){
System.err.println("Error de excepcion");
}
}
}
}
}

El cdigo para cada uno de los botones de la clase Control es el siguiente:

public class Control extends javax.swing.JFrame {
int IncX=1;
int IncY=1;
boolean salir = false;
/** Creates new form Control */
public Control() {

}


private void SuspenderActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
IncX=0;
IncY=0;
}
private void AumentarActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
IncX+=1;
IncY+=1;
if (IncX > 10) IncX = 10;
if (IncY > 10) IncY = 10;
}

private void DisminuirActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
IncX-=1;
IncY-=1;
if (IncX < -10) IncX = -10;
if (IncY < -10) IncY = -10;
}
private void TerminarActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
salir = true;
}


}

Usando Netbeans, complete el cdigo de la clase Control para hacer funcionar el programa.
Puede utilizar la ayuda de programacin visual de Netbeans.
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 22



PRCTICA 8. SINCRONIZACIN DE HILOS

Elaborar un programa un java que utilice java Threads para simular depsitos y retiros de
un banco por una familia formada por un padre, una madre y dos hijos. El padre y la madre
debern ser simulados por dos hilos que constantemente depositan dinero a la cuenta. Los
hijos tambin sern simulados por hilos que constantemente retiran dinero de la cuenta.

El programa deber tener las siguientes clases:

Banco.- Clase principal que inicia cuatro Threads. Dos de ellas corresponden a los hijos y
dos a los padres.

Cuenta.- Este es el objeto que comparten los hijos y los padres, el cual contiene el atributo
saldo y los mtodos sincronizados: retiro (cantidad) y deposito (cantidad).

Productor.- Esta clase debe implementar la interface runnable y dentro de su mtodo run
debe de realizar una cantidad infinita de depsitos de cantidades generadas
aleatoriamente. Despus de haber realizado un depsito debe esperar un nmero aleatorio
de milisegundos. Tanto el hilo del padre como el de la madre utilizan este cdigo.

Hijo.- Esta clase debe implementar la interface runnable y dentro de su mtodo run debe
de realizar una cantidad infinita de retiros de cantidades generadas aleatoriamente.
Despus de haber realizado un depsito debe esperar un nmero aleatorio de
milisegundos.

Nota: Los hilos correspondientes a los hijos deben esperar hasta que haya suficiente
dinero para poder hacer los retiros.

Un ejemplo de la salida del programa sera la siguiente:

El Padre realiz un depsito de: 6, nuevo saldo= 6
La Madre realiz un depsito de: 19, nuevo saldo= 25
Hijo 1 ha intentado realizar un retiro de: 66 pesos
No hubo saldo, Hijo 1 se va a dormir
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 23



Hijo 2 ha intentado realizar un retiro de: 17 pesos
Hijo 2 ha retirado 17, nuevo saldo= 8 pesos
El Padre realiz un depsito de: 10, nuevo saldo= 18
No hubo saldo, Hijo 1 se va a dormir
El Padre realiz un depsito de: 43, nuevo saldo= 61
No hubo saldo, Hijo 1 se va a dormir
El Padre realiz un depsito de: 11, nuevo saldo= 72
Hijo 1 ha retirado 66, nuevo saldo= 6 pesos
Hijo 2 ha intentado realizar un retiro de: 29 pesos
No hubo saldo, Hijo 2 se va a dormir
Hijo 1 ha intentado realizar un retiro de: 54 pesos
No hubo saldo, Hijo 1 se va a dormir
La Madre realiz un depsito de: 85, nuevo saldo= 91
Hijo 2 ha retirado 29, nuevo saldo= 62 pesos
Hijo 1 ha retirado 54, nuevo saldo= 8 pesos
El Padre realiz un depsito de: 7, nuevo saldo= 15
El Padre realiz un depsito de: 44, nuevo saldo= 59
Hijo 2 ha intentado realizar un retiro de: 89 pesos
No hubo saldo, Hijo 2 se va a dormir
La Madre realiz un depsito de: 13, nuevo saldo= 72
No hubo saldo, Hijo 2 se va a dormir
La Madre realiz un depsito de: 64, nuevo saldo= 136
Hijo 2 ha retirado 89, nuevo saldo= 47 pesos
El Padre realiz un depsito de: 24, nuevo saldo= 71
Hijo 1 ha intentado realizar un retiro de: 22 pesos
Hijo 1 ha retirado 22, nuevo saldo= 49 pesos Puede utilizar el siguiente cdigo
como base para escribir el programa:

public class Banco {

/** Creates a new instance of Banco */
public Banco() {
}
public static void main(String[] args) {
Cuenta cuenta = new Cuenta();

Productor p1 = new Productor(cuenta);
Thread t1 = new Thread(p1,"El Padre");
t1.start();

//Cdigo para crear el Segundo productor

Hijo h1 = new Hijo(cuenta);
Thread t3 = new Thread(h1,"Hijo 1");
t3.start();

//Cdigo para crear el Segundo hijo
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 24




}
}
public class Cuenta {
int saldo=0;

/** Creates a new instance of Cuenta */
public Cuenta() {
}
public synchronized void deposito(int cantidad){
String nombre = Thread.currentThread().getName(); // Se obtiene el nombre del hilo
saldo=saldo+cantidad;
System.out.println(nombre+" realiz un depsito de: "+cantidad+", nuevo saldo= "+saldo);
//Debe notificar a los hilos que estn esperando que haya ms dinero
}

public synchronized void retiro(int cantidad){
String nombre = Thread.currentThread().getName(); // Se obtiene el nombre del hilo
System.out.println(nombre+" ha intentado realizar un retiro de: "+cantidad+" pesos");
while (?) //Cecar que pueda ser retirada la cantidad {
try {
System.out.println("No hubo saldo, "+nombre+" se va a dormir");
// El hilo debe esperar a que se cumpla la condicin (No usar sleep)
} catch (InterruptedException ex) {
ex.printStackTrace();
}
}
saldo=saldo-cantidad;
System.out.println(nombre+" ha retirado "+cantidad+", nuevo saldo= "+saldo+" pesos");
}
} public class Hijo implements Runnable {

public Hijo(Cuenta c) {

}

public void run() {
// Debe realizar retiros de la cuenta de manera continua
// y dormir una cantidad aleatoria de milisegundos

} }
public class Productor implements Runnable {

public Productor(Cuenta c) {

}
public void run()

// Debe de realizar depsitos a la cuenta de manera continua
// y dormir una cantidad aleatoria de milisegundos

} }
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 25



PRACTICA 9. CLIENTE-SERVIDOR EN JAVA

En sta prctica vamos a utilizar sockets para crear un cliente y un servidor
sencillos. El servidor abre un puerto y enva mensajes al cliente. El cliente los recibe
y los muestra en la consola. Al correr el servidor aparece una ventana que pide el
mensaje y al oprimir el botn de enviar se enva el mensaje al cliente.


Figura 1

CDIGO DEL SERVIDOR:

import java.awt.*;
import java.awt.event.*;
import java.net.*;
import java.io.*;

public class ChatServer extends Frame implements ActionListener,WindowListener {

private BufferedReader reader;
private BufferedWriter writer;
private TextField texto;
private Button boton;
private Socket conexion;
public ChatServer() {
int port = 2882;
ServerSocket server = null;
setBounds(200,100,700,600);
setLayout(new FlowLayout());
add(new Label("Servidor"));
texto = new TextField(80);
boton = new Button("Enviar");
boton.addActionListener(this);
add(texto);
add(boton);
addWindowListener(this);
setVisible(true);
try {
server = new ServerSocket(port);
} catch (IOException ioe) {
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 26



System.err.println("No se puede correr en el puerto "+port);
System.exit(0);
}
try {
conexion = server.accept();
InputStream flujoBE = conexion.getInputStream();
Reader flujoCE = new InputStreamReader(flujoBE);
BufferedReader reader = new BufferedReader(flujoCE);
OutputStream flujoBS = conexion.getOutputStream(); Writer flujoCS = new
OutputStreamWriter(conexion.getOutputStream());
writer = new BufferedWriter(flujoCS);
String s;
while ((s=reader.readLine()) != null) {
System.out.println(s);
}
} catch (IOException ex) {
ex.printStackTrace();
}
}
public void envia(String cad){
try {
writer.write(cad+"\n"); // Note que se agrega el retorno de carro al mensaje
writer.flush();
} catch (IOException ex) {
ex.printStackTrace();
}
}
public void actionPerformed(ActionEvent e) {
String s=texto.getText();
texto.setText("");
envia(s);
}

public static void main(String [] args){
ChatServer Server = new ChatServer();
}

public void windowOpened(WindowEvent e) {
}
public void windowClosing(WindowEvent e) {
//Al salir cierra todos los sockets
System.exit(0);
}
// Implementar los dems mtodos abstractos
}

CODIGO DEL CLIENTE:

import java.io.*;
import java.net.*;
class ChatClient {

public static void main(String[] args) {
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 27



int port = 2882;
Socket cliente = null;
try {
//Se asigna una mquina que ser el servidor
//se hace la conexin al servidor por el nombre y el puerto
cliente = new Socket("localhost", port);
} catch (IOException ioe) {
System.err.println("Fallo la conexion");
System.exit(0);
}
try {
// getInputStream() da el flujo de entrada de bytes
// InputStreamReader convierte un flujo de byte a flujo de caracteres
// BufferedReader permite leer lineas completas
InputStream flujoBE = cliente.getInputStream();
Reader flujoCE = new InputStreamReader(flujoBE);
BufferedReader reader = new BufferedReader(flujoCE); //se asocia un flujo de salida al cliente
//con getOutputStream()
OutputStream flujoBS = cliente.getOutputStream();
Writer flujoCS = new OutputStreamWriter(cliente.getOutputStream());
BufferedWriter writer = new BufferedWriter(flujoCS);
//envia su nombre de host al servidor
writer.write(InetAddress.getLocalHost()+"\n");
writer.flush();
String entrada;
do{
entrada = reader.readLine();
System.out.println("Recibido: "+entrada);
writer.write("mensaje recibido: "+entrada+"\n");
writer.flush();
}
while(entrada != null);
} catch (IOException ioe1) {
}
}
}

Corra los dos programas en su mquina. Posteriormente pida a un compaero su
direccin IP. Esto lo obtiene con el comando ipconfig o en conexiones de red y
trate de comunicarse con l o ella. Pruebe primero siendo Usted el servidor y su
compaero el cliente y luego viceversa.




TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 28



PRACTICA 10. SOCKETS UDP

En esta prctica vamos a programar un Chat que nos permita enviar mensajes a
diferentes usuarios. Cada usuario tendr la opcin de enviar un mensaje a un
destinatario que pertenece a un grupo de usuarios (en este caso slo sern tres).
Las pantallas para cada usuario sern similares a la mostrada:


Figura 1 Figura 2 Figura 3

Para realizar esta prctica puedes basarte en el cdigo proporcionado:
ServerUDP.java y ClienteUDP.java. Puedes modificar cualquiera de los dos
programas para obtener el programa ChatUDP que ser el que debers entregar.

Algunas restricciones para la elaboracin de la prctica:
Utilizar slo sockets UDP
Ser un solo cdigo que se deber correr tres veces (uno por cada usuario).
Cada usuario tendr su propio puerto de entrada y su propio host (aunque el
host puede ser el mismo si se corre en la misma mquina).
Puede preguntar al inicio el nombre del usuario y el nmero de puerto de
entrada o se puede modificar el programa antes de ejecutarse.








TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 29



PRCTICA 11. SERVIDOR

Escriba un servidor y un cliente que permita jugar nmero secreto. El servidor crea
aleatoriamente un nmero entre 0 y 10 y permite que los clientes traten de adivinar
el nmero creado. El servidor informa a los clientes si el nmero enviado fue el
correcto.

Cuando algn cliente adivina el nmero, tanto el servidor como los clientes deben
terminar su ejecucin. Las salidas del servidor y de los clientes debern ser
parecidas a estas;

SERVIDOR CLIENTE1: CLIENTE2:
El nmero secreto es: 5 Mensaje del servidor:
Enva un numero
intentando con el
nmero: 6
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 10
El puerto utilizado por el
socket es: 5432
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 1
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 2
Los clientes debern
conectarse a este servidor
usando este puerto
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 1
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 2
La direccin IP del servidor
es:
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 6
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 3
HAndrade/169.254.199.69 Mensaje del servidor:
Enva un numero
intentando con el
nmero: 6
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 8
Acepta conexin del cliente 1 Mensaje del servidor:
Enva un numero
intentando con el
nmero: 0
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 4
Acepta conexin del cliente 2 Mensaje del servidor:
Enva un numero
intentando con el
nmero: 2
Mensaje del servidor:
Enva un numero
intentando con el
nmero: 5
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 30



nmero del cliente 1: 6 Mensaje del servidor:
Perdiste!
Mensaje del servidor:
Ganaste!
nmero del cliente 2: 10 BUILD SUCCESSFUL
(total time: 4
seconds
BUILD
SUCCESSFUL (total
time: 0
Second
nmero del cliente 1: 1
nmero del cliente 2: 2
nmero del cliente 1: 1
nmero del cliente 2: 2
nmero del cliente 1: 6
nmero del cliente 2: 3
nmero del cliente 1: 6
nmero del cliente 2: 8
nmero del cliente 1: 0
nmero del cliente 2: 4
nmero del cliente 1: 2
nmero del cliente 2: 5
El ganador es el cliente dos
BUILD SUCCESSFUL (total
time: 8 seconds)



PRCTICA 12. USO DE JAVABEANS

En sta prctica vamos a crear y utilizar javaBeans para desarrollar una sencilla
aplicacin de conexin entre componentes. En el directorio componentes
encontrars los archivos .jar necesarios para la prctica

1. Crear un nuevo proyecto (New Proyect General).
Nombrarlo:EjemploBeans
Desmarcar la casilla Create Main Class, Oprimir Finish
2. Ahora vamos a agregar un nuevo componente. Abrir Source Packages
en la ventana de proyectos y dar click derecho en ejemplobeans. Elegir
NewJavaBeans Component. Nombrarlo: GeneradorEventosBean



TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 31



Sustituir el cdigo generado por el siguiente cdigo:
import java.awt.Color;
import java.awt.Component;
import java.awt.Font;
import java.awt.Graphics;
import java.beans.*;
import java.io.Serializable;

/**
* @author Somebody
*/
public class GeneradorEventosBean extends Component implements Serializable {

private double [] values = new double [10];

private PropertyChangeSupport propertySupport;

public GeneradorEventosBean() {
propertySupport = new PropertyChangeSupport(this);
setSize(200,200);
}

public double getValues (int index){
return values[index];
}
public double[] getValues(){
for (int i=0; i<10; i++) values[i]=Math.random()*100;
return values;
}

public void setValues(int index, double value){
values[index]=value;
}

public void paint(Graphics g){
g.setColor(new Color(100,100,100));
g.fillRect(0,0,this.getSize().width,this.getSize().height);
g.setColor(Color.WHITE);
g.setFont(new Font("Arial",10,15));
g.drawString("Generador de Eventos:",0,40);
}

public void addPropertyChangeListener(PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(listener);
}
public void removePropertyChangeListener(PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(listener);
}
}

Ahora debemos compilar el proyecto (build bulid main project)
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 32




3. El siguiente paso es crear un JFrame (no JPanel) que fungir como contenedor
de los componentes. En la ventana de proyecto dar click derecho en el paquete
ejemplobeans y agregar el JFrame. Nombrarlo Contenedor

4. El siguiente paso es agregar el Generador de Eventos a la paleta:

Estando en modo de diseo, dar click derecho en la paleta y seleccionar "palette
manager". Seleccionar from project y seleccionar el proyecto creado recientemente
deber aparecer: GeneradorEventosBean, seleccionarlo y agregarlo a la categoria
de Beans
Ahora ya tenemos el Bean GeneradorEventosBean en la paleta.
4. Ahora debemos agregar el generador de eventos a la aplicacin. Arrastrar el
Generador de Eventos al rea del JFame.
En la pantalla de diseo deber aparecer el generador de eventos
5. En este paso agregaremos los demas componentes a la paleta. El proceso es
similar al punto 4, pero en lugar de seleccionar from project, seleccionar add from
jar
Seleccionar el directorio en donde est los archivos jar
Agregar los componentes LevelGauge, NeedleGauge, NumericalDialGauge y
ThermometerGauge. Debern aparecer los componentes en la paleta con sus
respectivos conos.
6. Agreguemos ahora los componentes al Contenedor arrastrndolos al rea del
JFrame. Ahora conectaremos los eventos utilizando el modo de conexin.


Figura 1
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 33




Conectar los componentes con el generador dando click al generador y despus al
otro componente que se desea conectar con el generador de eventos de acuerdo a
los siguientes eventos:

a. Cuando le den Click al generador, aumentar el valor del termmetro en 10
(mouse mouseClicked).
Set property value:

thermometerGauge1.getValue()+10

b. Cuando pongan el cursor sobre el generador de eventos aumentar el valor del
numericDialGauge en 2 (mouse mouseEntered). Set propertyvalue:
numericDialGauge1.getValue()+2

c. Cuando salga el cursor del generador de eventos ponga un valor aleatorio entre
0 y 9 en el levelGauge (mousemouseExited). Set propertyNeedleValue:
(int)(Math.random()*10)

d. cuando den click desaparezca/aparezca el needleGauge1
(mousemouseClicked). Set propertyvisible !needleGauge1.isVisible()

7. Construye y corre el proyecto pare verificar que funcione correcta.


PRACTICA 13 ASOCIANDO CONOS Y PROPIEDADES LIGADAS
EN JAVABEANS

En sta prctica vamos a crear un JavaBean y le asociaremos sus conos. Tambin
ligaremos propiedades para comunicar a los Beans.

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 34



Crea un nuevo proyecto. Llmalo ControlCarita. Desmarca la opcin Create Main
Class.

Ubcate en la ventana de proyectos y dale click derecho a Source Packages. Crea un
nuevo paquete, llmalo: controlCarita

Estando en el paquete, crea un nuevo JavaBean (JavaBean Component) y ponle como
nombre: CaritaFelizBean. Introduce el siguiente cdigo:
package controlCarita;
import java.awt.*;
import java.beans.*;
import java.io.Serializable;
public class CaritaFelizBean extends Component implements Serializable {
public static final String PROP_SAMPLE_PROPERTY = "felizProperty";
private int felizProperty = 0;
private PropertyChangeSupport propertySupport;
public CaritaFelizBean() {
propertySupport = new PropertyChangeSupport(this);
}
public int getFelizProperty() {
return felizProperty;
}
public void setFelizProperty(int value) {
int oldValue = felizProperty;
felizProperty = value;
repaint();
propertySupport.firePropertyChange(PROP_SAMPLE_PROPERTY, oldValue,
felizProperty);
}
@Override
public void paint(Graphics g) {
g.setColor(Color.YELLOW);
g.fillOval(40, 60, 200, 200);
g.setColor(Color.BLACK);
g.fillOval(90, 130 - 10, 20, 20);
g.fillOval(170, 130 - 10, 20, 20);
if (felizProperty <= 50) {
g.drawArc(80, 170, 120, (50-felizProperty) * (60 / 50), 0, 180);
} else {
g.drawArc(80, 170, 120, (felizProperty-50) * (60 / 50), 180, 180);
}
}
@Override
public void addPropertyChangeListener(PropertyChangeListener listener) {
propertySupport.addPropertyChangeListener(listener);
}
@Override
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 35



public void removePropertyChangeListener(PropertyChangeListener listener) {
propertySupport.removePropertyChangeListener(listener);
}
}

Este sencillo JavaBean dibuja una carita cuyo nivel de felicidad est dado por una
propiedad entera llamada felizProperty. Ahora vamos a asociarle unos conos al bean.
Estando en la ventana de proyectos. Dle click derecho al archivo CaritaFelizBean y
selecciona la opcin BeanInfoEditor.. Te preguntar si deseas crear el archivo >
BeanInfo. Selecciona yes. NetBeans crear un archivo fuente llamado
CaritaFelizBeanBeanInfo.java. Este archivo contiene los descriptores de
CaritaFelizBean.java.

Selecciona la pestaa de Designer. Vers algo parecido a esto:


Figura 1

Copia los archivos gif proporcionados para esta prctica al directorio
ControlCarita\src\controlCarita de tu proyecto.
Selecciona BeanInfo (ver figura anterior) y elige los archivos de conos que
copiaste.
Compila el broyecto (Build Build Main Project)
Ahora, ya podemos utilizar CaritaFeliz con sus conos. Vamos a crear un JFrame
(no JPanel). Llmalo Tablero. Agrega CaritaFelizBean a la paleta como lo hemos
hecho en las prcticas anteriores. Debers tener una pantalla parecida a sta:
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 36




Figura 2

Arrstrala al Tablero.

Finalmente vamos a conectarla con un JSlider. Utilizando la caractersticas de los
JavaBeans de ligar las propiedades. Selecciona el JSlider y agrgalo al tablero.
Selecciona CaritaFelizBean y en la ventana de propiedades selecciona Binding.
Lgalo con la propiedad value de JSlider. Tu pantalla ser similar a sta:



Figura 3

Compila y corre tu proyecto. El JSlider controlar el nivel de felicidad de la carita.

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 37





Figura4


PRCTICA 14. HILOS

Introduzca, compile y ejecute el siguiente cdigo:







TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 38



Contesta las siguientes preguntas:

1. Ejecuta el cdigo 7 veces Cul es la salida del programa? Mostr los mismos
resultados?

2. Es la salida que t esperaras? Qu salida esperaras de acuerdo al cdigo?

3. Si no es la salida esperada, explica brevemente porque no es

4. Modifica el cdigo para que la salida sea correcta y siempre la misma. Describe la
modificacin que realizaste

5. Modifica el cdigo de tal forma que dos hilos (t3 y t4) realicen depsitos 50000
depsitos cada uno de un peso a la misma cuenta y comprueba que el saldo final sea
el esperado.

Escribe a continuacin el cdigo que agregaste.


PRCTICA 15. USO DE HILOS

Usando la interface visual de NetBeans cree un formulario JFrame (JFrame Form)
similar a la ventana mostrada:


Figura1

Asocie a los eventos (ActionEvent) de los botones el cdigo siguiente:
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
ProcesoMuyComplejo.salir=false;
ProcesoMuyComplejo pmc = new ProcesoMuyComplejo(jTextArea1);
pmc.corre();
}
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
// TODO add your handling code here:
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 39



ProcesoMuyComplejo.salir();
}

Cree la clase Proceso muy Complejo. Con el siguiente cdigo:

package hilos; //Poner el paquete adecuado aqui!!
import javax.swing.JTextArea;
public class ProcesoMuyComplejo {
private JTextArea jt;
static boolean salir;
public ProcesoMuyComplejo(JTextArea jt) {
this.jt = jt;
}
public void corre() {
while (!salir){
double d = Math.random(); //calculos increiblemente complejos!!
jt.setText("Calculo:"+d+"\n");
}
}
public static void salir(){
salir=true;
}
}

Compile y ejecute el programa. Describa lo que pasa cuando se oprime el botn de
empezar. Convierta la clase ProcesoMuyComplejo en un hilo extendiendo de la clase
Thread. Modifique el cdigo del JFrame para que arranque al hilo. Describa lo que pasa
cuando se oprime el botn de empezar y el de pausar.













TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 40



PRCTICA.16 MIDLETS DE MENSAJE

En esta prctica vamos a crear una aplicacin mvil muy simple consistente de un
midlet que despliega un mensaje en la pantalla del dispositivo. Primero crearemos un
proyecto en la categora de Java ME y seleccionamos Mobile.

Application:

Figura 1
Le ponemos HolaMundo al proyecto (desmarcamos la opcin: Create Hello MIDlet):


Figura 2

Creamos un nuevo paquete holamundo dentro de source packages y un nuevo
midlet dentro del paquete holamundo:

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 41




Figura 3

Nombramos al midlet : PrimerMidlet y agregamos el cdigo:

package holamundo;
import javax.microedition.lcdui.*;
import javax.microedition.midlet.*;
public class PrimerMidlet extends MIDlet implements CommandListener {
private Command salir;
private Command regresar;
private Command cancelar;
private Command ignorar;
private Display display;
private Form pantalla;
public PrimerMidlet() {
// Obtenemos el objeto Display
display = Display.getDisplay(this);
// Creamos el comando de salida
salir = new Command("Salir", Command.EXIT, 4);
regresar = new Command("Regresar", Command.BACK, 3);
cancelar = new Command("Cancelar", Command.ITEM, 2);
ignorar = new Command("Ignorar", Command.ITEM, 1);
// Creamos el "Form" de la pantalla principal
pantalla = new Form("Primer MIDLet");
// Creamos una cadena y la ponemos en pantalla
String cad = new String("Este es mi primer MIDLet");
pantalla.append(cad);
// Aadimos comandos y configuramos el comando de salida
pantalla.addCommand(salir);
pantalla.addCommand(regresar);
pantalla.addCommand(cancelar);
pantalla.addCommand(salir);
pantalla.addCommand(ignorar);
pantalla.setCommandListener(this);
}

public void startApp() throws MIDletStateChangeException {
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 42



// Establecemos el "Display" actual a nuestra pantalla
display.setCurrent(pantalla);
}
public void pauseApp() {
}
public void destroyApp(boolean incondicional) {
}
public void commandAction(Command c, Displayable s) {
if (c == salir) {
destroyApp(false);
notifyDestroyed();
}
}
}

Corremos el proyecto. Deber mostrar un emulador de un telfono celular parecido
al siguiente:


Figura 4
Observa los comandos que aparecen agregados en la pantalla.

Construye (build) el proyecto y copia el archivo jar que se gener en el directorio
dist a un celular y prueba tu programa. Debes checar que la versin del CLDC y del
MIDP de NetBeans (Propiedades del proyecto) coincide con las del dispositivo
mvil.

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 43



PRACTICA 17. MIDLETS

Escriba un MIDlet que dibuje las banderas de Israel y de Japn. El usuario
seleccionar cual bandera desea en un men. Agregue la opcin del salir del
programa. El programa mostrar pantallas parecidas a estas:


Figura 1
Restricciones: Utilice primitivas de dibujo para dibujar la bandera de Japn y una
archivo de imagen para la de Israel.


PRACTICA 18 CONECTIVIDAD EN JAVA


El siguiente cdigo contiene un MIDlet que se comunica con un servidor para
calcular el promedio dada una serie 10 de nmeros generados de manera aleatoria.
----------------------------------------------------------------------
import javax.microedition.midlet.*;
import javax.microedition.io.*;
import javax.microedition.lcdui.*;
import java.io.*;
import java.util.random;

public class socketmidlet extends midlet {
// interface streamconnection allows bidirectional communication
private streamconnection streamconnection = null;
// use outputstream to send requests
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 44



private outputstream outputstream = null;
private dataoutputstream dataoutputstream = null;
// use inputstream to receive responses from web server
private inputstream inputstream = null;
private datainputstream datainputstream = null;
// specify the connect string
private string connectstring = "socket://127.0.0.1:4445";
// use a strignbuffer to store the retrieved page contents
private stringbuffer results;
// define gui components
private display mydisplay = null;
private form resultscreen;
private stringitem resultfield;

public socketmidlet() {
// initializing gui display
results = new stringbuffer();
mydisplay = display.getdisplay(this);
resultscreen = new form("promedio:");
}

public void startapp() {
try {
// establish a socket connection with remote server
streamconnection =
(streamconnection) connector.open(connectstring);

// create dataouputstream on top of the socket connection
outputstream = streamconnection.openoutputstream();
dataoutputstream = new dataoutputstream(outputstream);


// create datainputstream on top of the socket connection
inputstream = streamconnection.openinputstream();
datainputstream = new datainputstream(inputstream);
// sends 10 randomly generated numbers to server
for (int i = 1; i <= 10; i++) {
random r = new random();
int n = r.nextint(100);
dataoutputstream.writeutf(n + "\n");
dataoutputstream.flush();
}
dataoutputstream.writeutf("-1\n");
dataoutputstream.flush();
int inputchar;
// reads answer from server
while ((inputchar = datainputstream.read()) != -1) {
results.append((char) inputchar);
}
resultfield = new stringitem(null, results.tostring());
resultscreen.append(resultfield);
mydisplay.setcurrent(resultscreen);

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 45




} catch (ioexception e) {
system.err.println("exception caught:" + e);
} finally {
// free up i/o streams and close the socket connection
try {
if (datainputstream != null) {
datainputstream.close();
}
} catch (exception ignored) {
}
try {
if (dataoutputstream != null) {
dataoutputstream.close();
}
} catch (exception ignored) {
}
try {
if (outputstream != null) {
outputstream.close();
}
} catch (exception ignored) {
}
try {
if (inputstream != null) {
inputstream.close();
}
} catch (exception ignored) {
}
try {
if (streamconnection != null) {
streamconnection.close();
}
} catch (exception ignored) {
} }
}

public void pauseapp() {
}

public void destroyapp(boolean unconditional) {
}
}
-------------------------------------------------------------------------------------------------------------
ste es el cdigo del servidor:
-----------------------------------------------------------------------------------------------------------
import java.net.*;
import java.io.*;
import javax.swing.jframe;
import javax.swing.jscrollpane;
import javax.swing.jtextarea;

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 46



public class servidorpromedio {

public static void main(string[] args) throws ioexception {
int port = 4445;
//la clase serversocket sirve para implementar
//un socket en el servidor
//se crea una referencia a un objeto de tipo serversocket
serversocket server = null;
try {
//creando el socket y abriendo el puerto
//port determina el nmero de puerto que se utiliza
server = new serversocket(port);
} catch (ioexception ioe) {
ioe.printstacktrace();
system.exit(0);
}

jframe ventana = new jframe("servidor promedios");
jtextarea jt = new jtextarea(10, 50);
jscrollpane jp = new jscrollpane(jt);
ventana.getcontentpane().add(jp);
ventana.setbounds(100, 100, 500, 300);
ventana.setdefaultcloseoperation(jframe.exit_on_close);
ventana.setvisible(true);
while (true) {

system.out.println("esperando un cliente");
//al encontrar una peticin de conexin est se
//acepta
socket conexion = server.accept(); //crea un nuevo hilo para atender a este cliente
new atiendepeticionpromedio(conexion, jt).start();
}
}
}

class atiendepeticionpromedio extends thread {

socket s;
jtextarea jt;

atiendepeticionpromedio(socket s, jtextarea jt) {
this.s = s;
this.jt = jt;
}

@override
public void run() {
try {
int numero = 0, cont = 0, suma = 0;
system.out.println("acepta conexin");
inputstream flujobe = s.getinputstream();
reader flujoce = new inputstreamreader(flujobe);
bufferedreader reader = new bufferedreader(flujoce);
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 47



outputstream flujobs = s.getoutputstream();
writer flujocs = new outputstreamwriter(flujobs);
bufferedwriter writer = new bufferedwriter(flujocs);
try {
string linea = reader.readline();
numero = integer.parseint(linea.trim());
} catch (numberformatexception e) {
numero = 0;
}
jt.append("recib numero:" + numero + "\n");
while (numero != -1) {
suma += numero;
cont++;
try {
string linea = reader.readline();
numero = integer.parseint(linea.trim());
} catch (numberformatexception e) {
numero = 0;
}
jt.append("recib numero:" + numero + "\n");
}
float promedio = (float) suma / cont;
writer.write("promedio:" + promedio + "\n");
writer.flush();
jt.append("promedio:" + promedio + "\n");

//se cierran los flujos
reader.close();
writer.close(); //se cierra la conexin
s.close();
} catch (exception e) {
e.printstacktrace();
}
}
}
------------------------------------------------------------------------------------------------------------

1. Cree un proyecto de Java ME para el MIDlet y otro para el Servidor
2. Cheque que el proyecto del MIDlet tenga los permisos para el uso de las APIs de
conexin (Esto se ve en las propiedades del proyecto):
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 48





Figura 1

3. Compile y corra ambos programas (El servidor primero). Deber obtener las
siguientes pantallas:


Figura 2

4. Modifique el Servidor para que adicionalmente al promedio, enve el nmero
mayor y el menor. Deber producir la siguiente salida:

TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 49




Figura 3























ISC. Vidal Acosta Duran.

Ing. Nstor Monroy Mndez
Nombre y Firma del Docente Vo. Bo. Jefe de Divisin
TECNOLOGICO DE ESTUDIOS SUPERIORES DE
HUIXQUILUCAN


Pgina 50