Paso argumentos funciones Java

/
***********************************************************************************
***/
/********************************** Cap�tulo 1
****************************************/
/
***********************************************************************************
***/
/********* Paso de argumentos a una funci�n Java en tiempo de ejecuci�n ********/
/* Declaraci�n de la clase principal de la aplicaci�n */

public class MiClase
{
/* Declaraci�n del m�todo punto de entrada de la aplicaci�n*/
public static void main(String args[])
{
/* Mostrar los argumentos de la l�nea de comandos */
for (int i = 0 ; i < args.length; i++)

{
System.out.printIn("Argumento " +i + " = " + args[i]) ;
/* Conversi�n de los dos argumentos de l�nea de comandos de String a int, se

agregan valores enteros y se muestra el resultado */
int suma;
suma=(Integer.parselnt(args[3]))+(Integer.parselnt(args[4]));
System.out.println("Argumento 3 + Argumento 4 = " + suma);
}
}
/
***********************************************************************************
***/
/********************************** Cap�tulo 2
****************************************/
/
***********************************************************************************
***/
/********* concatenaci�n de cadenas de caracteres ********/
public class TestString

{
public static void main(String[] args)
{
long duracion;
String liebre;
String tortuga="";
long inicio, fin;
inicio = System.currentTimeMillis();
for (int i = 0; i <= 10000; i++)
{
tortuga = tortuga + " " + i;
}
fin = System.currentTimeMillis();
duracion = fin-inicio;
System.out.println("duraci�n para la tortuga: " + duracion + "ms");
inicio = System.currentTimeMillis();
StringBuffer sb = new StringBuffer();
for (int i = 0; i <= 10000; i++)
{
sb.append(" ");
sb.append(i);
}
liebre = sb.toString();
fin = System.currentTimeMillis();
duracion = fin-inicio;
System.out.println("duraci�n para la liebre: " + duracion + "ms");
if (liebre.equals(tortuga))
{
System.out.println("las dos cadenas son id�nticas");
}
}
}
/********* estructura de bucle ********/
import java.io.IOException;
public class TestEstructuras
{
static boolean stop;
{
new Thread()
{
public void run()
{
int c;
try
{
c=System.in.read();
stop=true;
}
catch (IOException e)
{
e.printStackTrace();
}
}
}.start();
long contador=0;
while(true)
{
contador++;
if (contador%2==0)
continue;
if (stop)
break;
System.out.println(contador);
}
}
}
/
***********************************************************************************
***/
/********************************** Ejercicios del cap�tulo 2
****************************************/
/
***********************************************************************************
***/
/********************************** Ejercicio 1
***************************************/
package ejercicios.capitulo2.ejercicio1;
public class Principal

{
static String[] direcciones;
static String[] listaProveedores;
static String[] nombresProveedores;
static int[] numCliente;
static int posicion;
static String proveedor;
{
direcciones=new String[10];
direcciones[0]="jpp@sfr.fr";
direcciones[1]="tom@gmail.com";
direcciones[2]="fred@sfr.fr";
direcciones[3]="victor@sfr.fr";
direcciones[4]="chris@sfr.fr";
direcciones[5]="robert@orange.fr";
direcciones[6]="paul@sfr.fr";
direcciones[7]="lise@gmail.com";
direcciones[8]="thierry@eni.fr";
direcciones[9]="marie@eni.fr";
listaProveedores =new String[10];

nombresProveedores=new String[10];
numCliente=new int[10];
for (int i=0;i<direcciones.length;i++)
{
listaProveedores[i]=direcciones[i].substring(direcciones[i].indexOf('@')+1);
}
for(int i=0;i<listaProveedores.length;i++)
{
int resultado;
resultado=busquedaProveedor(listaProveedores[i]);
if(resultado==-1)
{
nombresProveedores[posicion]=listaProveedores[i];
numCliente[posicion]++;
posicion++;
}
else
{
numCliente[resultado]++;
}
}
for(int i=0;i<posicion;i++)
{
System.out.println(nombresProveedores[i] + " : " +
(double)numCliente[i]/listaProveedores.length*100 + "%");
}
}
static int busquedaProveedor(String apellido)
{
for(int i=0;i<nombresProveedores.length;i++)
{
if(nombresProveedores[i]!=null &&
nombresProveedores[i].equals(apellido))
{
return i;
}
}
return -1;
}
}
/********************************** Ejercicio 2
***************************************/

{
{
int contador=0;
int num1,num2,num3;
do
{
num1=(int)(Math.random()*1000);
contador++;
System.out.println("numero 1:" + num1 + " numero 2:" + num2 + " numero 3:"
+ num3);
}
while(num1 % 2==1 || num2 % 2==1 || num3 % 2==0);
System.out.println("Resultado obtenido en " + contador + " ensayo(s)");
}
}
/********************************** Ejercicio 3
***************************************/
import java.util.Scanner;

{
{
int numEnsayos=0;
int numero;
int numIntroducido;
numero=(int)(Math.random()*1000);
Scanner sc;
sc=new Scanner(System.in);
do
{
numIntroducido=sc.nextInt();
numEnsayos++;
if(numIntroducido<numero)
{
System.out.println("es m�s");
}
if(numIntroducido>numero)
{
System.out.println("es menos");
}
} while (numero!=numIntroducido);
System.out.println("Enhorabuena, ha encontrado el n�mero en " + numEnsayos +
" ensayo(s)");
}
}
/********************************** Ejercicio 4
***************************************/
import java.time.Duration;
import java.time.LocalTime;
import java.time.OffsetTime;
import java.util.Scanner;

{
{
int numEnsayos=0;
int numero;
int numIntroducido;
OffsetTime inicio;
OffsetTime fin;
Duration tiempo;
numero=(int)(Math.random()*1000);
Scanner sc;
sc=new Scanner(System.in);
inicio=OffsetTime.now();
do
{
numIntroducido=sc.nextInt();
numEnsayos++;
if(numIntroducido<numero)
{
System.out.println("es m�s");
}
if(numIntroducido>numero)
{
System.out.println("es menos");
}
} while (numero!=numIntroducido);
fin=OffsetTime.now();
tiempo=Duration.between(inicio,fin);
LocalTime duracion;
duracion=LocalTime.ofSecondOfDay(tiempo.getSeconds());
System.out.println("Enhorabuena, ha encontrado el resultado en " +

numEnsayos +
" ensayo(s) y " + duracion.getHour()+" hora(s) " +
duracion.getMinute() + " minuto(s) " +
duracion.getSecond()+ " segundo(s)");
}
/
***********************************************************************************
***/
/********************************** Cap�tulo 3
****************************************/
/
***********************************************************************************
***/
/********* Clase Persona con atributos y m�todos ********/
public class Persona

{
private String apellido;
private String nombre;
private GregorianCalendar fecha_naci;
public long calculaEdad()

{
long edad;
fecha_naci=new GregorianCalendar(1963,11,29);
edad=new GregorianCalendar().getTimeInMillis()-
fecha_naci.getTimeInMillis();
edad=edad/1000/60/60/24/365;
return edad;
}
public void mensaje()

{
System.out.println("apellido : " + apellido);
System.out.println("nombre : " + nombre);
System.out.println("edad : " + calculaEdad());
}
}
/************** funci�n mensaje sobrecargada **************/

public void mensaje(boolean espa�ol)
{
if (espa�ol)
{
System.out.println("apellido : " + apellido);
System.out.println("nombre : " + nombre);
}
else
{
System.out.println("name : " + apellido);
System.out.println("first name : " + nombre);
}
/************** segunda funci�n mensaje sobrecargada ilegal **************/
public void mensaje(boolean mayuscula)

{
if (mayuscula)
{
System.out.println("apellido : " + apellido.toUpperCase());
System.out.println("nombre : " + nombre.toUpperCase());
}
else
{
System.out.println("apellido : " + apellido.toLowerCase());
System.out.println("nombre : " + nombre.toLowerCase());
}
}
/*********** funci�n con un n�mero cualquiera de par�metros **************/
public void mensaje(String...colores)

{
if (colores==null)
{
System.out.println("sin color");
return;
}
switch (colores.length)
{
case 1:
System.out.println("un color");
break;
case 2:
System.out.println("dos colores");
break;
case 3:
System.out.println("tres colores");
break;
default :
System.out.println("m�s de tres colores");
}
}
/************** accesores ***************/

{
public String getApellido()

{
return apellido;
}
public void setApellido(String n)

{
apellido = n.toUpperCase();
}
public String getNombre()

{
return nombre;
}
public void setNombre(String p)

{
nombre = p.toLowerCase();
}
}
/************* accesores con reglas de gesti�n ************/

{
// campo privado que representa el n�mero de la Persona
private int numero;
// campo est�tico privado que representa el contador de Personas
private static int numInstancias;

{
return apellido;
}

{
}

{
return nombre;
}

{
}
// m�todo de instancia que permite obtener el n�mero de una Persona
public int getNumero()
{
return numero;
}
// m�todo est�tico que permite obtener el n�mero de instancias creadas
public static int getNumInstancias()
{
return numInstancias;
}
public Persona()
{
apellido="";
nombre="";
fecha_naci=null;
// creaci�n de una nueva Persona e incremento del contador
numInstancias++;
// asignaci�na la nueva Persona de su n�mero
numero=numInstancias;
}
}
/************** campos y m�todos est�ticos **************/
import java.util.GregorianCalendar;
{
private String apellido="nuevoApellido";
private String nombre="nuevoNombre";
private GregorianCalendar fecha_naci=new GregorianCalendar(1900,01,01);
private int numero=0;
{
return apellido;
}

{
}

{
return nombre;
}

{
}
@Override
protected void finalize() throws Throwable
{
System.out.print("\u2020");
super.finalize();
}
{
return numero;
}

{
}
public Persona()
{
apellido="";
nombre="";
fecha_naci=null;
numInstancias++;
}
public Persona(String n,String p,GregorianCalendar d)
{
apellido=n;
nombre=p;
fecha_naci=d;
numInstancias++;
}
}
/************ acci�n del Garbage Collector ******************/
{
private String apellido="nuevoApellido";
private String nombre="nuevoNombre";
private GregorianCalendar fecha_naci=new GregorianCalendar(1900,01,01);
private int numero=0;
{
return apellido;
}

{
}

{
return nombre;
}

{
}
@Override
protected void finalize() throws Throwable
{
System.out.print("\u2020");
super.finalize();
}
{
return numero;
}

{
}
public Persona()
{
apellido="";
nombre="";
fecha_naci=null;
numInstancias++;
}
public Persona(String n,String p,GregorianCalendar d)
{
apellido=n;
nombre=p;
fecha_naci=d;
numInstancias++;
}
}
public class GestionMemoria

{
public static void main(String[] args) throws InterruptedException

{
double total;
double resto;
double porcentaje;
for (int j=0;j<1000;j++)

{
creacionTabla();
total=Runtime.getRuntime().totalMemory();
resto=Runtime.getRuntime().freeMemory();
porcentaje=100-(resto/total)*100;
System.out.println("creaci�n de la " + j + " tabla de memoria
llena al: " + porcentaje + "%" );
// peque�a pausa para poder leer los mensajes
Thread.sleep(1000);
}
public static void creacionTabla()

{
// creaci�n de una tabla de 1000 Personas en una variable local
// al final de esta funci�n los elementos de la tabla ya no est�n
// accesibles y pueden borrarse de la memoria
Persona[] tabla;
tabla=new Persona[1000];
for (int i=0;i<1000;i++)
{
tabla[i]=new Persona("Dupont","albert",new
GregorianCalendar(1956,12,13));
}
}
}
/************ sin usar this ni super *****************/

{
System.out.println("apellido : " + getApellido());
System.out.println("nombre : " + getNombre());
switch (type)
{
case 'P':
System.out.println("tipo de cliente : Particular");
break;
case 'E':
System.out.println("tipo de cliente : Empresa");
break;
case 'A':
System.out.println("tipo de cliente : Administraci�n");
break;
default:
System.out.println("tipo de cliente : Desconocido");
break;
}
}
/************ usando this y super ***************/

{
super.mensaje();
switch (type)
{
case 'P':
System.out.println("tipo de cliente : Particular");
break;
case 'E':
System.out.println("tipo de cliente : Empresa");
break;
case 'A':
System.out.println("tipo de cliente : Administraci�n");
break;
default:
System.out.println("tipo de cliente : Desconocido");
break;
}
}
/************* clase abstracta *****************/
public abstract class SerVivo

{
private double altura;
private double peso;
public double getAltura()
{
return altura;
}
public void setAltura(double altura)
{
this.altura = altura;
}
public double getPoids()
{
return peso;
}
public void setPoids(double peso)
{
this.peso = peso;
}
// este m�todo lo deber�n implementar las clases derivadas
protected abstract void desplazarse();
}
/************ Clonado ***************/
public class Solicitud implements Cloneable

{
Cliente cliente;
LineasDeSolicitud lineas;
public Solicitud()
{
super();
lineas=new LineasDeSolicitud();
}
public Object clone() throws CloneNotSupportedException
{
Solicitud cmd;
// creaci�n de una copia
cmd=(Solicitud)super.clone();
// duplicaci�n de las l�neas
cmd.lineas=(LineasDeSolicitud)lineas.clone();
return cmd;
}
public Cliente getCliente()
{
return cliente;
}
public void setCliente(Cliente cliente)
{
this.cliente = cliente;
}
public LineasDeSolicitud getLineas()
{
return lineas;
}
public void setLineas(LineasDeSolicitud lineas)
{
this.lineas = lineas;
}
}
public class LineasDeSolicitud implements Cloneable

{
public Object clone() throws CloneNotSupportedException
{
return super.clone();
}
}
Cliente c;
c=new Cliente("ENI","",new GregorianCalendar(1981,05,15),'E');
Solicitud cmd1,cmd2;
// creaci�n de inicializaci�n de solicitud
cmd1=new Solicitud();
cmd1.setCliente(c);
System.out.println("hashCode de la solicitud : " +cmd1.hashCode());
System.out.println("hashCode de cliente : " +cmd1.getCliente().hashCode());
System.out.println("hashCode de las l�neas : " +cmd1.getLineas().hashCode());
cmd2=(Solicitud)cmd1.clone();
System.out.println("hashCode de la copia : " +cmd2.hashCode());
System.out.println("hashCode del cliente de la copia : "
+cmd2.getCliente().hashCode());
System.out.println("hashCode de las l�neas de la
copia :"+cmd2.getLineas().hashCode());
/**************M�todo equals *****************/
public boolean equals(Object obj)

{
Cliente c;
// verificaci�n de si obj es null o referencia a una instancia
// de otra clase
if (obj ==null || obj.getClass()!=this.getClass())
{
return false;
}
else
{
c=(Cliente)obj;
// verificaci�n de criterios de igualdad en base a
// - apellido
// - nombre
// - fecha de nacimiento
// - tipo de cliente
if (c.getApellido().equals(getApellido())&
c.getNombre().equals(getNombre()) &
c.getFecha_naci().equals(getFecha_naci()) &
c.getType()== getType() )
{
return true;
}
else
{
return false;
}
}
}
/************** getClass (informaci�n acerca de la clase) ***************/
public static void infoClase(Object o)

{
Class c;
c=o.getClass();
System.out.println("nombre de la classe : " + c.getName());
System.out.println("contenida en el paquete : " + c.getPackedad().getName());
System.out.println("hereda de la clase : " + c.getSuperclass().getName());
System.out.println("posee los campos : ");
for (int i=0;i<c.getFields().length;i++)
{
System.out.print("\t" + c.getFields()[i].getName());
System.out.println(" de tipo :" + c.getFields()
[i].getType().getName());
}
System.out.println("posee los m�todos : ");
for (int i=0;i<c.getMethods().length;i++)
{
System.out.print("\t" + c.getMethods()[i].getName());
System.out.print(" que recibe como par�metro (");
for (int j=0;j<c.getMethods()[i].getParameterTypes().length;j++)
{
System.out.print(c.getMethods()[i].getParameterTypes()[j]+ " ");
}
System.out.println(")");
}
}
/************* creaci�n de una interfaz **************/
// interfaz a implementar en las clases

// que quieran clasificar instancias
public interface Clasificable
{
// m�todo que permite comparar
// la instancia en curso con una recibida
// el m�todo devuelve un valor entero cuyo valor depende de
// 1 si la instancia en curso es superior a la recibida
// 0 si ambas instancias son iguales
// -1 si la instancia en curso es inferior a la recibida
// -99 si es imposible realizar la comparaci�n
int compara(Object o);
public static final int INFERIOR=-1;

public static final int IGUAL=0;
public static final int SUPERIOR=1;
public static final int ERROR=-99;
/************* implementar una interfaz **************/

implements Clasificable
{
public int compara(Object o)

{
Persona p;
if (o instanceof Persona)
{
p=(Persona)o;
}
else
{
return Clasificable.ERROR;
}
if (getApellido().comparaTo(p.getApellido())<0)
{
return Clasificable.INFERIOR;
}
if (getApellido().comparaTo(p.getApellido())>0)
{
return Clasificable.SUPERIOR;
}
return Clasificable.IGUAL;
}
}
/************ Usar una interfaz *************/
public static Clasificable[] ordena(Clasificable[] tabla)

{
int i,j;
Clasificable c;
for (i=0;i< tabla.length;i++)
{
for( j = i + 1; j<tabla.length;j++)
{
if (tabla[j].compara(tabla[i])==Clasificable.INFERIOR)
{
c = tabla[j];
tabla[j] = tabla[i];
tabla[i] = c;
}
else if (tabla[j].compara(tabla[i])==Clasificable.ERROR)
{
return null;
}
}
}
return tabla;
}
/************** test de l'interface ***************/
Persona[] tab;
tab=new Persona[5];
tab[0] = new Persona("apellido2", "nombre2",new GregorianCalendar(1922,2,15));
tab[1] = new Persona("apellido1", "nombre1 ",new GregorianCalendar(1911,1,15));
Persona[] tabOrdenada;
tabOrdenada=(Persona[])ordena(tab);
for (int i=0;i<tabOrdenada.length;i++)
{
System.out.println(tabOrdenada[i]);
}
/*************** clases anonimas *****************/
public static Object[] ordena(Object[] tabla,Comparador ordenador)

{
int i,j;
Object c;
Object[] tablaOrdenada;
tablaOrdenada=Arrays.copyOf(tabla,tabla.length);
for (i=0;i< tablaOrdenada.length;i++)
{
for( j = i + 1; j<tablaOrdenada.length;j++)
{
// utiliza la funci�n compara del objeto recibido como par�metro para
// comparar el contendio de ambas clases de la tabla
if
(ordenador.compara(tablaOrdenada[j],tablaOrdenada[i])==Comparador.INFERIOR)
{
c = tablaOrdenada[j];
tablaOrdenada[j] = tablaOrdenada[i];
tablaOrdenada[i] = c;
}
else if
(ordenador.compara(tablaOrdenada[j],tablaOrdenada[i])==Comparador.ERROR)
{
return null;
}
}
}
return tablaOrdenada;
}
Persona[] tab;
tab=new Persona[5];
tab[0] = new Persona("apellido2", "nombre2",new GregorianCalendar(1922,2,15));
tabOrdenada=(Persona[])ordena(tab,
// creaci�n de una instancia de la clase que implementa la intefaz Comparador
new Comparador()
// he aqu� el c�digo de la clase
{
// como lo exige la interfaz he aqu� el m�todo compara
public int compara(Object o1, Object o2)
{
Persona p1,p2;
if (o1 instanceof Persona & o2 instanceof Persona)
{
p1=(Persona)o1;
p2=(Persona)o2;
}
else
{
}
if (p1.getApellido().comparaTo(p2.getApellido())<0)
{
}
if (p1.getApellido().comparaTo(p2.getApellido())>0)
{
}
} // par�ntesis de cierre del m�todo compara
} // par�ntesis de cierre de la clase

); // fin de la llamada de la funci�n ordena
// tabla ordenada

{
}
/************* clases an�nimas segunda version *************/
tabOrdenada=(Persona[])ordena(tab,
// creaci�n de una instancia de la clase que implementa la interfaz Comparador
new Comparador()
//he aqu� el c�digo de la clase
{
// como exige la interfaz, he aqu� el m�todo compara
public int compara(Object o1, Object o2)
{
Persona p1,p2;
if (o1 instanceof Persona & o2 instanceof Persona)
{
p1=(Persona)o1;
p2=(Persona)o2;
}
else
{
}
if (p1.calculaEdad()<p2.calculaEdad())
{
}
if (p1.calculaEdad()>p2.calculaEdad())
{
}
} // par�ntesis de cierre del m�todo
} // par�ntesis de cierre de la clase

); // fin de la llamada de la funci�n ordena

{
}
/*************** clase gen�rica ****************/
import java.util.ArrayList;
public class ListaGenerica <T>
{
// para almacenar los elementos de la lista
private ArrayList<T> lista;
// puntero en la lista
private int posicion;
// n�mero de elementos de la lista
private int numElementos;
// constructor con un par�metro que permite dimensionar la lista
public ListaGenerica(int altura)
{
lista=new ArrayList<T>(altura);
}
public void agrega(T element)
{
lista.add(element);
numElementos = numElementos + 1;
}
public void insert(T element,int index)
{
// se verifica si el �ndice no supera el n�mero de elementos
// y que no sea inferior a cero
if (index >= numElementos || index < 0)
{
return;
}
lista.add(index,element);
// se actualiza el n�mero de elementos
numElementos = numElementos + 1;
}
public void remplaza(T element,int index)
{
// se verifica si el �ndice no es superior al n�mero de elementos
{
return;
}
lista.set(index,element);
}
public void elimina(int index)
{
int i;
// se verifica si el �ndice no es superior al n�mero de elementos
{
return;
}
lista.remove(index);
// actualizamos el n�mero de elementos
numElementos = numElementos - 1;
}
public int getTama�oLista()
{
return numElementos;
}
public T primero() throws Exception
{
if (numElementos == 0)
{
throw new Exception("lista vac�a");
}
// se ubica el puntero sobre el primer elemento
posicion = 0;
return lista.get(0);
}
public T ultimo() throws Exception
{
{
throw new Exception("lista vac�a");
}
// se ubica el puntero sobre el �ltimo elemento
posicion = numElementos - 1;
return lista.get(posicion);
}
public T siguiente() throws Exception
{
{
throw new Exception("lista vacia");
}
//se verifica que no estamos al final de la lista
if (posicion == numElementos - 1)
{
throw new Exception("no existe elemento siguiente");
}
// se ubica el puntero en el elemento siguiente
posicion = posicion + 1;
}
public T anterior() throws Exception
{
{
throw new Exception("lista vacia");
}
// se verifica que no estamos en el primer elemento
if (posicion == 0)
{
throw new Exception("no existe elemento anterior");
}
// se ubica el puntero en el elemento anterior
posicion = posicion - 1;
}
}
/**************** Uso de una clase gen�rica ******************/
import java.io.BufferedReader;
import java.io.InputStreamReader;
public class TestListaGenerica
{
static ListaGenerica<String> lista = new ListaGenerica<String>(5);
{
lista.agrega("primero");
lista.agrega("segundo");
lista.agrega("tercero");
lista.agrega("cuarto");
lista.agrega("quinto");
menu();
}
public static void menu()
{
char seleccion='\0';
System.out.println("p (primero) < (anterior) >(siguiente) d (ultimo) f
(fin)");
while (seleccion != 'f')
{
try
{
BufferedReader br;
br=new BufferedReader(new InputStreamReader(System.in));
seleccion=br.readLine().charAt(0);
switch (seleccion)
{
case 'p':
System.out.println("primero " + lista.primero());
break;
case '<':
System.out.println("anterior " + lista.precedent());
break;
case '>':
System.out.println("siguiente " + lista.siguiente());
break;
case 'd':
System.out.println("ultimo " + lista.dernier());
break;
}
}
catch (Exception e)
{
System.out.println(e.getMensaje());
}
System.out.println("p (primero) < (anterior) >(siguiente) d (ultimo) f
(fin)");
}
}
}
/*************** m�todo gen�rico *****************/
public static <T extends Clasificable> void ordena(ListaGenerica<T> lista) throws

Exception
{
int i,j;
T c;
for (i=0;i< lista.getNumElementos()-1;i++)
{
for( j = i + 1; j<lista.getNumElementos();j++)
{
if
(lista.getElement(j).compara(lista.getElement(i))==Clasificable.INFERIOR)
{
c = lista.getElement(j);
lista.remplaza(lista.getElement(i), j);
lista.remplaza(c,i);
}
else if
(lista.getElement(j).compara(lista.getElement(i))==Clasificable.ERROR)
{
throw new Exception("se ha producido un error");
}
}
}
}
/***************** Recuperaci�n de excepciones ***************/
public void leerArchivo(String apellido)

{
FileInputStream archivo=null;
BufferedReader br=null;
String linea=null;
try
{
archivo=new FileInputStream("c:\\data\\informe.txt");
}
catch (FileNotFoundException e)
{
}
br=new BufferedReader(new InputStreamReader(archivo));
try
{
linea=br.readLine();
}
{
}
while (linea!=null)
{
System.out.println(linea);
try
{
}
{
}
}
}
/************* Recuperaci�n de excepciones con agrupaci�n **************/
public void leerArchivo(String apellido)

{
String linea=null;
try
{
archivo=new FileInputStream(apellido);
while (linea!=null)
{
}
}
{
}
{
}
/************ informaci�n acerca de una Exception **************/
import java.io.BufferedWriter;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileWriter;
public class LecturaArchivo

{
public static void main(String args[])
{
try {
leerArchivo("informe.txt");
}
catch (NoFuncionaException e)
{
FileWriter log;
BufferedWriter br;
try
{
log=new FileWriter("historico.txt",true);
br=new BufferedWriter(log);
br.write("------>"+ new GregorianCalendar().getTime()+"
<--------\r\n");
br.write("error : " + e.getMensaje()+"\r\n");
for (int i=0;i<e.getStackTrace().length;i++)
{
br.write("en el archivo " +e.getStackTrace()
[i].getFileName());
br.write(" en la l�nea " +e.getStackTrace()
[i].getLineNumber());
br.write(" en el m�todo " +e.getStackTrace()
[i].getMethodName());
br.write(" de la clase " + e.getStackTrace()
[i].getClassName()+ "\r\n");
}
br.close();
log.close();
}
catch (IOException ex)
{
System.out.println("error en la aplicaci�n");
}
}
}
public static void leerArchivo(String apellido) throws NoFuncionaException

{
String linea=null;
try
{
while (linea!=null)
{
}
}
{
throw new NoFuncionaException("el archivo no existe",e);
}
{
throw new NoFuncionaException("error de lectura del archivo",e);
}
}
}
/**************** Clase de excepci�n personalizada ***************/
public class NoFuncionaException extends Exception

{
public NoFuncionaException()
{
super();
}
public NoFuncionaException(String mensaje)
{
super(mensaje);
}
public NoFuncionaException(String mensaje, Throwable causa)
{
super(mensaje,causa);
}
public NoFuncionaException(Throwable causa)
{
super(causa);
}
}
public static void leerArchivo2(String apellido) throws NoFuncionaException

{
String linea=null;
try
{
while (linea!=null)
{
}
}
{
throw new NoFuncionaException("el archivo no existe",e);
}
{
throw new NoFuncionaException("error de lectura del archivo",e);
}
}
/**************** ejemplo ArrayList ***************/
import java.time.LocalDate;
import java.util.Iterator;
import java.util.ListIterator;
public class testArrayList
{
{
ArrayList<Persona> lista1;
ArrayList<Persona> lista2;
// creaci�n de las dos instancias
lista1=new ArrayList<Persona>();
lista2=new ArrayList<Persona>();
// creaci�nde las personas para completar la lista

Persona p1,p2,p3,p4,p5;
p1 = new Persona("Wayne", "John",LocalDate.of(1907,5,26));
p2 = new Persona("McQueen", "Steeve",LocalDate.of(1930,3,24));
p3 = new Persona("Lennon", "John",LocalDate.of(1940,10,9));
p4 = new Persona("Gibson", "Mel",LocalDate.of(1956,1,3));
p5 = new Persona("Willis", "Bruce",LocalDate.of(1955,3,19));
// se agregan las cuatro personas a la lista

lista1.add(p1);
lista1.add(p3);
lista1.add(p4);
lista1.add(p5);
// inserci�n de una persona entre p1 y p3

// en la posici�n 1 de la lista
lista1.add(1, p2);
// agrega el contenido de una lista en otra lista

// ambas listas contienen, ahora, los mismos objetos
// !!!! no confundir con lista2=lista1; !!!
lista2.addAll(lista1);
// n�mero de elementos de la lista

System.out.println("hay " + lista1.size() + " persona(s) en la lista");
// recorrer la lista
Iterator<Persona> it;
it=lista1.iterator();
Persona p;
// mientras queden elementos
while (it.hasNext())
{
// elemento en curso
p=it.next();
System.out.println(p.getApellido());
}
// recorrer la lista
// recuperar un ListIterator ubicado
// tras el �ltimo elemento (n�mero de elementos de la lista)
ListIterator<Persona> lit;
lit=lista1.listIterator(lista1.size());
// mientras queden elementos
while (lit.hasPrevious())
{
// recuperaci�n del elemento en curso
// recorriendo la lista
p=lit.previous();
}
// remplazar un elemento de la lista

lista1.set(2,new Persona("Grant", "Cary",LocalDate.of(1904,1,18)));
// tercera posici�n de la lista

System.out.println(lista1.get(2).getApellido());
// busqueda de un elemento de la lista

int posicion;
posicion=lista1.indexOf(p4);
if(posicion==-1)
System.out.println("no se encuentra en la lista");
else
System.out.println(lista1.get(posicion).getApellido());
// bsucar un elemento existente en la lista.

// John Lennon rempalzado por Cary Grant
posicion=lista1.lastIndexOf(p3);
if(posicion==-1)
System.out.println("no se encuentra en la lista");
else
System.out.println(lista1.get(posicion).getApellido());
// eliminaci�n selectiva de la lista

// la expresi�n lambda determina los elementos a borrar
lista1.removeIf((Persona pe)->pe.getFecha_naci().getYear()<1940);
// recorrer la lista para ver el resultado
it=lista1.iterator();
// mientras haya elementos
{
// recuperar el elemento en curso
p=it.next();
System.out.println(p.getApellido()+ " ne en " +
p.getFecha_naci().getYear() );
}
// otra forma de recorrer la lista
// la expresi�n lambda se ejecuta para cada
// elemento de la lista
lista1.forEach((Persona per)->System.out.println(per.getApellido()+ " edad

" + per.calculaEdad()));
}
}
/**************** ejemplo 1 HashSet ***************/
import java.time.temporal.ChronoUnit;
public class Persona implements Clasificable
{
private LocalDate fecha_naci=LocalDate.of(1963,11,29);
public Persona()
{
}
public Persona(String n,String p,LocalDate d)

{
this.apellido=n;
this.nombre=p;
this.fecha_naci=d;
}

{
return apellido;
}
public void setApellido(String apellido)

{
this.apellido = apellido;
}

{
return nombre;
}
public void setNombre(String nombre)

{
this.nombre = nombre;
}
public LocalDate getFecha_naci()

{
return fecha_naci;
}
public void setFecha_naci(LocalDate fecha_naci)

{
this.fecha_naci = fecha_naci;
}
@Override
public int hashCode()
{
// seleccionamos dos n�meros impares
int resultado = 7;
final int multiplicar = 17;
// Cada atributo calcula su hashcode

// que se suma al resultado tras multiplicarlo por
// el numero "multiplicar":
resultado = multiplicar*resultado + (apellido==null ? 0 :
apellido.hashCode());
resultado = multiplicar*resultado + (nombre==null ? 0 : nombre.hashCode());
resultado = multiplicar*resultado + (fecha_naci==null ? 0 :
fecha_naci.hashCode());
return resultado;
}
@Override
public boolean equals(Object obj)
{
// si el objeto es nulo no puede ser igual
if (obj == null)
{
return false;
}
// si no son del mismo tipo no pueden ser iguales
if (getClass() != obj.getClass())
{
return false;
}
// es preciso comprobar la igualdad de cada atributo
Persona p = (Persona) obj;
if (!apellido.equals(p.getApellido()))
return false;
if (!nombre.equals(p.getNombre()))
return false;
if (!fecha_naci.equals(getFecha_naci()))
return false;
return true;
}
public long calculaEdad()

{
return fecha_naci.until(LocalDate.now(),ChronoUnit.YEARS);
}
public int compara(Object o)

{
Persona p;
if (o instanceof Persona)
{
p=(Persona)o;
}
else
{
}
if (getApellido().comparaTo(p.getApellido())<0)
{
}
if (getApellido().comparaTo(p.getApellido())>0)
{
}
}
}

{
Persona p1,p2,p3;
System.out.println("hashCode de p1 : " + p1.hashCode());

if(p1.equals(p2))
System.out.println("p1 y p2 son id�nticos");
else
System.out.println("p1 y p2 son diferentes");
if(p1.equals(p3))
System.out.println("p1 y p3 son id�nticos");
else
System.out.println("p1 y p3 son diferentes");
/**************** ejemplo 2 HashSet ***************/
import java.util.HashSet;
public class TestHashSet1
{
{
HashSet<Persona> hash1;
HashSet<Persona> hash2;
// creaci�n de dos instancias
hash1=new HashSet<Persona>();
hash2=new HashSet<Persona>();
// creaci�n de personas para completar el HashSet

// agrega cuatro personas al HashSet
hash1.add(p1);
hash1.add(p3);
hash1.add(p4);
hash1.add(p5);
// agrega el contenido de un HashSet a otro HashSet

// ambos HashSet contienen ahora lis mismos objetos.
// !!!! no confundir con hash2=hash1; !!!
hash2.addAll(hash1);
// n�mero de elementos
System.out.println("hay " + hash1.size() + " persona(s) en el HashSet");
// recorrer el primer HashSet de inicio a fin

it=hash1.iterator();
// mientras haya elementos en el HashSet
Persona p;
{
// elemento en curso
p=it.next();
}
// borrado selectivo en el HashSet
// la expresi�n determina qu� elementos se borran
hash1.removeIf((Persona pe)->pe.getFecha_naci().getYear()<1940);
// recorrer el HashSet para ver el resultado
it=hash1.iterator();
// mientras haya elementos en el HashSet
{
// recuperaci�n del elemento en curso
p=it.next();
System.out.println(p.getApellido()+ " ne en " +
p.getFecha_naci().getYear() );
}
// otra forma particular de HashSet
// la expresi�n lambda se calcula para cada
// elemento del HashSet
hash1.forEach((Persona per)->System.out.println(per.getApellido()+ " edad "

+ per.calculaEdad()));
}
}
/**************** ejemplo 3 HashSet ***************/
import java.util.HashSet;
public class TestHashSet

{
{
HashSet<Persona> actores;
HashSet<Persona> cantantes;
actores=new HashSet<Persona>();
cantantes=new HashSet<Persona>();
// creaci�n de personas para rellenar la lista

actores.add(p1);
actores.add(p2);
actores.add(p4);
actores.add(p5);
cantantes.add(p1);
cantantes.add(p3);
// comprueba si son iguales

if (actores.containsAll(cantantes))
System.out.println("todos los cantantes son actores");
else
System.out.println("algunos cantantes no son actores");
System.out.println("******* artistars *****************");
// creaci�n de un HashSet artistas con actores y cantantes
HashSet<Persona> artistas;
artistas=new HashSet<Persona>(cantantes);
artistas.addAll(actores);
it=artistas.iterator();
Persona p;
{
p=it.next();
}
System.out.println("***** cantantes y actores *******************");
// creaci�n de un HashSet de personas que son
// cantantes y actores
HashSet<Persona> act_cant;
act_cant=new HashSet<Persona>(cantantes);
act_cant.retainAll(actores);
it=act_cant.iterator();
// mientras queden elementos en el HashSet
{
// recuperar el elemento en curso
p=it.next();
}
System.out.println("***** solo cantantes *******************");
// creaci�n de un HashSet de personas
// solo cantantes
HashSet<Persona> soloCantantes;
soloCantantes=new HashSet<Persona>(cantantes);
soloCantantes.removeAll(actores);
for(Persona pe:soloCantantes)
{
System.out.println(pe.getApellido());
}
System.out.println("***** solo actores *******************");

HashSet<Persona> soloActores;
soloActores=new HashSet<Persona>(actores);
soloActores.removeAll(cantantes);
for(Persona pe:soloActores)
{
System.out.println(pe.getApellido());
}
}
}
/**************** ejemplo LinkedList ***************/
import java.util.LinkedList;
public class TestLinkedList

{
{
LinkedList<Persona> ll;
ll=new LinkedList<Persona>();
// creaci�n de personas para completar el HashSet
// agrega elementos en la lista
ll.addFirst(p1);
ll.addFirst(p2);
ll.addFirst(p3);
ll.addFirst(p4);
ll.addFirst(p5);
Persona p=null;
// extracci�n y borrado de elementos
// de la lista comenzando por el m�s antiguo
do
{
p=ll.pollLast();
if (p!=null)
} while(p!=null);
ll.clear();
}
}
/**************** ejemplo Streams y Pipelines ***************/
public class TestStream
{
{
ArrayList<Persona> lista;
// creaci�n de dos instancias

lista=new ArrayList<Persona>();
// creaci�n de personas para completar la lista

// agrega personas a la lista

lista.add(p1);
lista.add(p2);
lista.add(p3);
lista.add(p4);
lista.add(p5);
//la funci�n allMatch devuelve true si todos los elementos

// de la lista cumplen la condici�n
// expresada por la expresi�n lambda
if(lista.stream().allMatch(p->p.getFecha_naci().getYear()>1945))
System.out.println("todos los actores han nacido despu�s de 1945");
else
System.out.println("algunas personas han nacido antes de 1945");
// filtra personas nacidas en marzo
lista.stream().filter(p->p.getFecha_naci().getMonthValue()==3).forEach(p-
>System.out.println(p.getApellido()));
// busca la persona m�s anciana de la lista

// la expresi�n lambda representa la implementaci�n
// de la interfaz Comparator
System.out.println(lista.stream().max((pe1,pe2)->
{
if (pe1.calculaEdad()>pe2.calculaEdad())
return 1;
if (pe1.calculaEdad()<pe2.calculaEdad())
return -1;
return 0;
}).get().getApellido());
// calcula la edad media de las personas de la lista

double edadMedia = lista
.stream()
.mapToLong(Persona::calculaEdad)
.averedad()
.getAsDouble();
System.out.println("edad media de las personas de la lista: " + edadMedia + "

a�os");
}
}
/
***********************************************************************************
***/
/********************************** Ejercicios del cap�tulo 3
***************************/
/
***********************************************************************************
***/
/********************************** Ejercicio 1
***************************************/
public class Articulo

{
private int referencia;
private double precio;
public Articulo()
{
super();
}
public Articulo(int referencia)

{
this();
setReferencia(referencia);
}
public Articulo(int referencia,String nombre)
{
this(referencia);
setNombre(nombre);
}
public Articulo(int referencia,String nombre,double precio)

{
this(referencia,nombre);
setPrecio(precio);
}
public int getReferencia()

{
return referencia;
}
public void setReferencia(int referencia)

{
this.referencia = referencia;
}

{
return nombre;
}

{
}
public double getPrecio() {

return precio;
}
public void setPrecio(double precio)

{
this.precio = precio;
}
public String toString()

{
return getReferencia() + " " + getNombre() + " " + getPrecio();
}

{
{
Articulo a1,a2;
a1=new Articulo();
a1.setReferencia(100);
a1.setNombre("tintin en congo");
a1.setPrecio(8.5);
a2=new Articulo(110,"El escarabajo de oro",8.5);
test(a1);
System.out.println(a1.toString());
test(a2);
System.out.println(a2.toString());
public static void test(Articulo a)

{
System.out.println("referencia : " + a.getReferencia());
System.out.println("nombre : " + a.getNombre());
System.out.println("precio : " + a.getPrecio() + " �");
}
}
/********************************** Ejercicio 2
***************************************/

{
public Articulo()
{
super();
}

{
this();
}
{
this(referencia);
setNombre(nombre);
}

{
setPrecio(precio);
}

{
return referencia;
}

{
}

{
return nombre;
}

{
}

return precio;
}

{
}

{
}
public class Dvd extends Articulo

{
private Duration duracion;
private String realizador;
public Dvd()
{
super();
}
public Dvd(int referencia,String nombre,double precio,Duration duracion,String

realizador)
{
super(referencia,nombre,precio);
setDuracion(duracion);
setRealizador(realizador);
}
public Duration getDuracion()

{
return duracion;
}
public void setDuracion(Duration duracion)

{
this.duracion = duracion;
}
public String getRealizador()

{
return realizador;
}
public void setRealizador(String realizador)

{
this.realizador = realizador;
}

{
return super.toString() + " " + getDuracion().toMinutes() + " " +
getRealizador();
}
}
public class Libro extends Articulo

{
private String isbn;
private int numPaginas;
private String autor;
public Libro()
{
super();
}
public Libro(int referencia,String nombre,double precio,String isbn,int

numPaginas,String autor)
{
setIsbn(isbn);
setNumPaginas(numPaginas);
setAutor(autor);
}
public String getIsbn() {

return isbn;
}
public void setIsbn(String isbn) {

this.isbn = isbn;
}
public int getNumPaginas() {

return numPaginas;
}
public void setNumPaginas(int numPaginas) {

this.numPaginas = numPaginas;
}
public String getAutor() {

return autor;
}
public void setAutor(String autor) {

this.autor = autor;
}
{
return super.toString() + " " + getNumPaginas() + " " + getAutor();
}
{
{
Libro l;
Dvd d;
l=new Libro();
l.setReferencia(100);
l.setNombre("El escarabajo de oro");
l.setPrecio(8.5);
l.setNumPaginas(86);
l.setAutor("Poe");
testLibro(l);
System.out.println(l.toString());
d=new Dvd();
d.setReferencia(110);
d.setNombre("Sopa de ganso");
d.setPrecio(19.50);
d.setDuracion(Duration.ofMinutes(98));
d.setRealizador("Marx");
testDvd(d);
System.out.println(d.toString());

{
}
public static void testLibro(Libro l)

{
test(l);
System.out.println("numero de paginas : " + l.getNumPaginas());
System.out.println("autor : " + l.getAutor());
}
public static void testDvd(Dvd d)

{
test(d);
System.out.println("duraci�n : " + d.getDuracion().toMinutes() + "
minutos");
System.out.println("realizador : " + d.getRealizador());
}
}
/********************************** Ejercicio 3
***************************************/

{
public Articulo()
{
super();
}

{
this();
}
{
this(referencia);
setNombre(nombre);
}

{
setPrecio(precio);
}

{
return referencia;
}

{
}

{
return nombre;
}

{
}

return precio;
}

{
}

{
}
}

{
private Persona realizador;
public Dvd()
{
super();
}
public Dvd(int referencia,String nombre,double precio,Duration duracion,Persona

realizador)
{
}

{
return duracion;
}

{
}
public Persona getRealizador()

{
return realizador;
}
public void setRealizador(Persona realizador)

{
}

{
getRealizador();
}
}

{
private Persona autor;
public Libro()
{
super();
}

numPaginas,Persona autor)
{
setIsbn(isbn);
setAutor(autor);
}

return isbn;
}

this.isbn = isbn;
}

return numPaginas;
}

}
public Persona getAutor() {

return autor;
}
public void setAutor(Persona autor) {

this.autor = autor;
}
{
}

{
public Persona()
{
super();
}
{
this.apellido=n;
this.nombre=p;
this.fecha_naci=d;
}

{
return apellido;
}

{
}

{
return nombre;
}

{
}

{
return fecha_naci;
}

{
}
public String toString() {

return nombre + " " + apellido;
}

{
{
Libro l;
Dvd d;
l=new Libro();
l.setReferencia(100);
l.setNombre("El escarabajo de oro");
l.setPrecio(8.5);
l.setNumPaginas(86);
l.setAutor(new Persona("Poe","Edgar",LocalDate.of(1809,1,19)));
testLibro(l);
System.out.println(l.toString());
d=new Dvd();
d.setReferencia(110);
d.setNombre("Sopa de ganso");
d.setPrecio(19.50);
d.setDuracion(Duration.ofMinutes(98));
d.setRealizador(new Persona("Marx","Groucho",LocalDate.of(1890,2,10)));
testDvd(d);
System.out.println(d.toString());

{
}

{
test(l);
System.out.println("autor : " + l.getAutor().toString());
}

{
test(d);
minutos");
System.out.println("realizador : " + d.getRealizador().toString());
}
}
/********************************** Ejercicio 4
***************************************/

{
public Articulo()
{
super();
}

{
this();
}
{
this(referencia);
setNombre(nombre);
}

{
setPrecio(precio);
}

{
return referencia;
}

{
}

{
return nombre;
}

{
}

return precio;
}

{
}

{
}

{
private Persona realizador;
public Dvd()
{
super();
}
public Dvd(int referencia,String nombre,double precio,Duration duracion,Persona

realizador)
{
}

{
return duracion;
}

{
}
public Persona getRealizador()

{
return realizador;
}
public void setRealizador(Persona realizador)

{
ArrayList<Articulo> lst;
lst=realizador.getObras();
if (!lst.contains(this))
{
lst.add(this);
}
}

{
getRealizador();
}
}

{
private Persona autor;
public Libro()
{
super();
}

numPaginas,Persona autor)
{
setIsbn(isbn);
setAutor(autor);
}

return isbn;
}

this.isbn = isbn;
}

return numPaginas;
}

}
public Persona getAutor() {

return autor;
}
public void setAutor(Persona autor) {

this.autor = autor;
ArrayList<Articulo> lst;
lst=autor.getObras();
if (!lst.contains(this))
{
lst.add(this);
}
}
{
}
{
private ArrayList<Articulo> obras;
public Persona()
{
super();
obras=new ArrayList<> ();
}

{
this();
this.apellido=n;
this.nombre=p;
this.fecha_naci=d;
}

{
return apellido;
}

{
}

{
return nombre;
}

{
}

{
return fecha_naci;
}

{
}
public ArrayList<Articulo> getObras()

{
return obras;
}
public String toString() {

return nombre + " " + apellido;
}
}

{
{
Persona p1;
p1=new Persona("Poe","Edgar",LocalDate.of(1809,1,19));
Libro l1,l2;
l1=new Libro();
l1.setReferencia(100);
l1.setNombre("El escarabajo de oro");
l1.setPrecio(8.5);
l1.setNumPaginas(86);
l1.setAutor(p1);
l2=new Libro();
l2.setReferencia(120);
l2.setNombre("El gato negro");
l2.setPrecio(10.5);
l2.setNumPaginas(78);
l2.setAutor(p1);
for(Articulo a:p1.getObras())
{
System.out.println(a.toString());
}

{
}

{
test(l);
System.out.println("autor : " + l.getAutor().toString());
}

{
test(d);
minutos");
System.out.println("realizador : " + d.getRealizador().toString());
}
}
/
***********************************************************************************
***/
/********************************** Cap�tulo 4
****************************************/
/
***********************************************************************************
***/
/**************** primera aplicaci�n gr�fica ***************/
package es.eni;
import javax.swing.JFrame;
public class Principal {
{
JFrame ventana;
// creaci�n de la instancia de la clase JFrame
ventana=new JFrame();
// modificacion de la posicion y de la
// altura de la ventana
ventana.setBounds(0,0,300,400);
// modification del t�tulo de la ventana
ventana.setTitle("primera ventana en JAVA");
// mensaje de la ventana
ventana.setVisible(true);
}
/**************** interfaz de usuario compuesta de tres botones ***************/
package es.eni;
import java.awt.Graphics;
import javax.swing.JButton;
import javax.swing.JPanel;
{
// creacion de la ventana
JFrame ventana;
ventana=new JFrame();
ventana.setTitle("primera ventana en JAVA");
ventana.setBounds(0,0,300,100);
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// creacion de los tres botones
JButton b1,b2,b3;
b1=new JButton("Rojo");
b2=new JButton("Verde");
b3=new JButton("Azul");
// creaci�n del contenedor intermedio
JPanel panel;
panel=new JPanel();
// agrega los botones al contenedor intermedio
panel.add(b1);
panel.add(b2);
panel.add(b3);
// agrega el contenedor intermedio al ContentPane
ventana.getContentPane().add(panel);
}
}
/**************** base de trabajo gesti�n de eventos ***************/
package es.eni;
public class Pantalla

extends JFrame
{
public Pantalla()
{
setTitle("primera ventana en JAVA");
setBounds(0,0,300,100);
setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
JButton b1,b2,b3;
// creacion del contenedor intermedio
JPanel panel;
panel=new JPanel();
// agrega botones en el contenedor intermedio
panel.add(b1);
panel.add(b2);
panel.add(b3);
// agrega el contenedor en el ContentPane
getContentPane().add(panel);
}
}
package es.eni;
{
Pantalla ventana;
ventana=new Pantalla();
}
}
/**************** Uso de una clase "normal" que implementa la interfaz

***************/
package es.eni;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;
public class EscuchadorVentana implements WindowListener {
public void windowActivated(WindowEvent arg0)

{
}
public void windowClosed(WindowEvent arg0)
{
}
public void windowClosing(WindowEvent arg0)
{
System.exit(0);
}
public void windowDeactivated(WindowEvent arg0)
{
}
public void windowDeiconified(WindowEvent arg0)
{
}
public void windowIconified(WindowEvent arg0)
{
}
public void windowOpened(WindowEvent arg0)
{
}
}
package es.eni;
{
Pantalla ventana;
// creaci�n de una instancia de la clase encargada
// de gestionar los eventos
EscuchadorVentana ef;
ef=new EscuchadorVentana();
// referencia de esta instancia de clase
// como listener de eventos para la ventana
ventana.addWindowListener(ef);
}
}
/**************** implementar la interfaz de una clase existente ***************/
package es.eni;
public class Pantalla extends JFrame

implements WindowListener
{
public Pantalla()
{
setBounds(0,0,300,100);
JButton b1,b2,b3;
JPanel panel;
panel=new JPanel();
panel.add(b1);
panel.add(b2);
panel.add(b3);
// agrega el contenedor intermedio en el ContentPane
// rerefencia de la propia ventana
// como listener de sus propios eventos
addWindowListener(this);
}
{
}
{
}
{
System.exit(0);
}
{
}
{
}
{
}
{
}
}
package es.eni;
{
Pantalla ventana;
}
}
/**************** clase interna que implementa la interfaz ***************/
package es.eni;
{
public Pantalla()
{
setBounds(0,0,300,100);
JButton b1,b2,b3;
JPanel panel;
panel=new JPanel();
panel.add(b1);
panel.add(b2);
panel.add(b3);
addWindowListener(ef);
}
public class EscuchadorVentana implements WindowListener

{
{
}
{
}
{
System.exit(0);
}
{
}
{
}
{
}
{
}
}
}
package es.eni;
{
Pantalla ventana;
}
}
/**************** clase interna an�nima que implementa la interfaz ***************/
package es.eni;

{
public Pantalla()
{
setBounds(0,0,300,100);
JButton b1,b2,b3;
JPanel panel;
panel=new JPanel();
panel.add(b1);
panel.add(b2);
panel.add(b3);
// creaci�n de una instancia de una clase an�nima
// encargada de gestionar los eventos
addWindowListener(new WindowListener()
// inicio de la definici�n de la clase
{
{
}
{
}
{
System.exit(0);
}
{
}
{
}
{
}
{
}
} // fin de la definici�n de la clase
); // fin de la llamada del m�todo addWindowListener
}// fin del constructor
}// fin de la clase Pantalla
package es.eni;
{
Pantalla ventana;
}
}
/**************** clase "normal" que hereda de una clase XXXXAdapter

***************/
package es.eni;
import java.awt.event.WindowAdapter;
public class EscuchadorVentana extends WindowAdapter

{
{
System.exit(0);
}
}
package es.eni;
{
Pantalla ventana;
ventana.addWindowListener(ef);
}
}
/**************** clase interna que hereda de una clase XXXXAdapter

***************/
package es.eni;
{
public Pantalla()
{
setBounds(0,0,300,100);
JButton b1,b2,b3;
JPanel panel;
panel=new JPanel();
panel.add(b1);
panel.add(b2);
panel.add(b3);
addWindowListener(ef);
}
public class EscuchadorVentana extends WindowAdapter

{
{
System.exit(0);
}
}
}
package es.eni;
{
Pantalla ventana;
}
}
/**************** clase interna an�nima que hereda de XXXXAdapter ***************/

package es.eni;
{
public Pantalla()
{
setBounds(0,0,300,100);
JButton b1,b2,b3;
JPanel panel;
panel=new JPanel();
panel.add(b1);
panel.add(b2);
panel.add(b3);
addWindowListener(new WindowAdapter()
// inicio de la d�finition de la classe
{
{
System.exit(0);
}
} // fin de la definici�n de la clase
); // fin de la llamada al m�todo addWindowListener
}// fin del constructor
}// fin de la clase Pantalla
package es.eni;
{
Pantalla ventana;
}
}
/**************** el mismo listener para dos fuentes de eventos ***************/
package es.eni;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
{
JPanel panel;
public Pantalla ()
{
setBounds(0,0,300,100);
JButton btnRojo,btnVerde,btnAzul;
btnRojo=new JButton("Rojo");
btnVerde=new JButton("Verde");
btnAzul=new JButton("Azul");
// creaci�n de los tres listeners
EscuchadorRojo ecR;
EscuchadorVerde ecV;
EscuchadorAzul ecA;
ecR=new EscuchadorRojo();
ecV=new EscuchadorVerde();
ecA=new EscuchadorAzul();
// asociar el listener a cada bot�n
btnRojo.addActionListener(ecR);
btnVerde.addActionListener(ecV);
btnAzul.addActionListener(ecA);
// Creaci�n del men�
JMenuBar barraMenu;
barraMenu=new JMenuBar();
JMenu mnuColores;
mnuColores=new JMenu("Colores");
barraMenu.add(mnuColores);
JMenuItem mnuRojo,mnuVerde,mnuAzul;
mnuRojo=new JMenuItem("Rojo");
mnuVerde=new JMenuItem("Verde");
mnuAzul=new JMenuItem("Azul");
mnuColores.add(mnuRojo);
mnuColores.add(mnuVerde);
mnuColores.add(mnuAzul);
// asociaci�n del listener a cada menu
// ( los mismos que para los botones )
mnuRojo.addActionListener(ecR);
mnuVerde.addActionListener(ecV);
mnuAzul.addActionListener(ecA);
// agrega el men� a la ventana
setJMenuBar(barraMenu);
panel=new JPanel();
panel.add(btnRojo);
panel.add(btnVerde);
panel.add(btnAzul);
// encargada de gestionar los eventos de la ventana
{
{
System.exit(0);
}
}
);
}
public class EscuchadorRojo implements ActionListener
{
public void actionPerformed(ActionEvent arg0)
{
panel.setBackground(Color.RED);
}
}
public class EscuchadorVerde implements ActionListener
{
{
panel.setBackground(Color.GREEN);
}
}
public class EscuchadorAzul implements ActionListener
{
{
panel.setBackground(Color.BLUE);
}
}
/**************** el mismo listener para dos fuentes de eventos (c�digo

simplificado) ***************/
package es.eni;
{
JPanel panel;
public Pantalla ()
{
setBounds(0,0,300,100);
EscuchadorColor ec;
ec=new EscuchadorColor();
// asociaci�n del listener a cada bot�n
btnRojo.addActionListener(ec);
btnVerde.addActionListener(ec);
btnAzul.addActionListener(ec);
JMenuBar barraMenu;
JMenu mnuColores;
// asociaci�n del listener a cada men�
// ( el mismo que para los botones )
mnuRojo.addActionListener(ec);
mnuVerde.addActionListener(ec);
mnuAzul.addActionListener(ec);
panel=new JPanel();
panel.add(btnRojo);
panel.add(btnAzul);
// agrega el contenedor intermedio en el Content-Pane
{
{
System.exit(0);
}
}
);
}
public class EscuchadorColor implements ActionListener
{
{
if (arg0.getSource()==btnRojo | arg0.getSource()==mnuRojo)
{
}
if (arg0.getSource()==btnVerde | arg0.getSource()==mnuVerde)
{
}
if (arg0.getSource()==btnAzul | arg0.getSource()==mnuAzul)
{
}
}
}
/**************** el mismo listener para dos fuentes de eventos utilizando

ActionCommand ***************/
package es.eni;
{
JPanel panel;
public Pantalla ()
{
setBounds(0,0,300,100);
btnRojo.setActionCommand("red");
btnVerde.setActionCommand("green");
btnAzul.setActionCommand("blue");
EscuchadorColor ec;
JMenuBar barraMenu;
JMenu mnuColores;
mnuRojo.setActionCommand("red");
mnuVerde.setActionCommand("green");
mnuAzul.setActionCommand("blue");
panel=new JPanel();
panel.add(btnRojo);
panel.add(btnAzul);
{
{
System.exit(0);
}
}
);
}
{
{
String solicitud;
solicitud=arg0.getActionCommand();
if (solicitud.equals("red"))
{
}
if (solicitud.equals("green"))
{
}
if (solicitud.equals("blue"))
{
}
}
}
/**************** varios listeners para una misma fuente de eventos

***************/
package es.eni;
import java.text.SimpleDateFormat;
import java.util.Date;
import javax.swing.AbstractButton;
public class ConsoleLog implements ActionListener

{
public void actionPerformed(ActionEvent e)
{
String mensaje;
SimpleDateFormat sdf;
sdf=new SimpleDateFormat("dd/MM/yyyy hh:mm:ss");
mensaje=sdf.format(new Date());
mensaje=mensaje + " clic en el ";
if (e.getSource() instanceof JButton)
{
mensaje=mensaje+ "boton ";
}
if (e.getSource() instanceof JMenuItem)
{
mensaje=mensaje+ "menu ";
}
mensaje=mensaje + ((AbstractButton)e.getSource()).getText();
System.out.println(mensaje);
}
}
package es.eni;
import javax.swing.JCheckBox;
{
JPanel panel;
ConsoleLog lg;
public Pantalla ()
{
setBounds(0,0,300,100);
EscuchadorColor ec;
// creaci�n del chekcbox
JCheckBox chkLog;
chkLog=new JCheckBox("log en la consola");
// agrega un listener al checkbox
chkLog.addActionListener(new ActionListener()
{
{
JCheckBox chk;
chk=(JCheckBox)arg0.getSource();
if (chk.isSelected())
{
// agrega un listener suplementario
// a los botones y men�s
lg=new ConsoleLog();
btnAzul.addActionListener(lg);
btnRojo.addActionListener(lg);
btnVerde.addActionListener(lg);
mnuAzul.addActionListener(lg);
mnuRojo.addActionListener(lg);
mnuVerde.addActionListener(lg);
}
else
{
// borrado del listener suplementario
// botones y menus
btnAzul.removeActionListener(lg);
btnRojo.removeActionListener(lg);
btnVerde.removeActionListener(lg);
mnuAzul.removeActionListener(lg);
mnuRojo.removeActionListener(lg);
mnuVerde.removeActionListener(lg);
}
}
});
JMenuBar barraMenu;
JMenu mnuColores;
panel=new JPanel();
panel.add(btnRojo);
panel.add(btnAzul);
panel.add(chkLog);
{
{
System.exit(0);
}
}
);
}
{
{
String solicitud;
{
}
{
}
{
}
}
}
/**************** BorderLayout ***************/
package es.eni;
import java.awt.BorderLayout;
import java.awt.FlowLayout;
public class Pantalla9 extends JFrame
{
JPanel panelBotones;
JPanel panelChk;
JPanel panelColor;
ConsoleLog lg;
public Pantalla9()
{
setBounds(0,0,300,100);
EscuchadorColor ec;
// creaci�n del chekcbox
JCheckBox chkLog;
chkLog=new JCheckBox("log en la consola");
// agrega un listener al checkbox
chkLog.addActionListener(new ActionListener()
{
{
JCheckBox chk;
chk=(JCheckBox)arg0.getSource();
if (chk.isSelected())
{
// agrega un listener suplementario
// a los botones y men�s
lg=new ConsoleLog();
btnAzul.addActionListener(lg);
btnRojo.addActionListener(lg);
btnVerde.addActionListener(lg);
mnuAzul.addActionListener(lg);
mnuRojo.addActionListener(lg);
mnuVerde.addActionListener(lg);
}
else
{
// borrar el listener suplementario
// botones y menus
btnAzul.removeActionListener(lg);
btnRojo.removeActionListener(lg);
btnVerde.removeActionListener(lg);
mnuAzul.removeActionListener(lg);
mnuRojo.removeActionListener(lg);
mnuVerde.removeActionListener(lg);
}
}
});
JMenuBar barraMenu;
JMenu mnuColores;
panelBotones=new JPanel();
panelBotones.add(btnRojo);
panelBotones.add(btnVerde);
panelBotones.add(btnAzul);
// agrega el contenedor intermedio en el Content-Pane zona norte
getContentPane().add(panelBotones,BorderLayout.NORTH);
// creacion del contenedor para el checkbox
panelChk=new JPanel();
panelChk.add(chkLog);
// agrega el contenedor en la zona sur
getContentPane().add(panelChk,BorderLayout.SOUTH);
// creacion del contenedor para el mensaje del color
panelColor=new JPanel();
// agrega el contenedor en la zona central
getContent-Pane().add(panelColor,BorderLayout.CENTER);
{
{
System.exit(0);
}
}
);
((FlowLay-out)panelBotones.getLayout()).setAlignment(FlowLayout.LEFT);
((FlowLayout)panelBotones.getLayout()).setHgap(50);
((FlowLayout)panelBotones.getLayout()).setVgap(20);
}
{
{
String solicitud;
{
panelColor.setBackground(Color.RED);
}
{
panelColor.setBackground(Color.GREEN);
}
{
panelColor.setBackground(Color.BLUE);
}
}
}
}
/**************** GridBagLayout ***************/
package es.eni;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JList;
import javax.swing.JScrollPane;
{
JPanel panel;
JCheckBox chkNegrita,chkCursiva;
JLabel lblTama�o,lblEjemplo;
JComboBox comboTama�o;
JList lstFuentes;
JScrollPane dsplzFuentes;
public Pantalla()
{
setTitle("seleccionar tipo de letra");
setBounds(0,0,300,100);
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// creaci�n de los componentes
panel=new JPanel();
chkNegrita=new JCheckBox("negrita");
chkCursiva=new JCheckBox("cursiva");
lblTama�o=new JLabel("altura");
lblEjemplo=new JLabel("ejemplo de fuente");
comboTama�o=new JComboBox(new String[]{"10","12","14","16","18","20"});
lstFuentes=new JList(new String[]
{"arial","courier","letter","helvetica","times roman","symbole","antique"});
dsplzFuentes=new JScrollPane(lstFuentes);
GridBagLayout gbl;
gbl=new GridBagLayout();
panel.setLayout(gbl);
GridBagConstraints gbc;
gbc=new GridBagConstraints();
// posicion en 0,0
gbc.gridx=0;
gbc.gridy=0;
// una columna de ancho
gbc.gridwidth=1;
// tres lineas de alto
gbc.gridheight=3;
// ponderar en caso de agrandar el contenedor
gbc.weightx=100;
gbc.weighty=100;
// el componente se redimensiona para ocupar
// todo el espacio disponible en su contenedor
gbc.fill=GridBagConstraints.BOTH;
panel.add(dsplzFuentes,gbc);
// posicion en 1,0
gbc.gridx=1;
gbc.gridy=0;
// dos columnas de ancho
gbc.gridwidth=2;
// una linea de alto
gbc.gridheight=1;
gbc.weightx=100;
gbc.weighty=100;
// el componente no se redimensiona para ocupar
// todo el espacio disponible en su contendor
gbc.fill=GridBagConstraints.NONE;
panel.add(chkNegrita,gbc);
// posicion en 1,1
gbc.gridx=1;
gbc.gridy=1;
// dos columnas de ancho
gbc.gridwidth=2;
gbc.gridheight=1;
gbc.weightx=100;
gbc.weighty=100;
panel.add(chkCursiva,gbc);
// posicion en 1,2
gbc.gridx=1;
gbc.gridy=2;
gbc.gridwidth=1;
gbc.gridheight=1;
gbc.weightx=100;
gbc.weighty=100;
panel.add(lblTama�o,gbc);
// posicion en 2,2
gbc.gridx=2;
gbc.gridy=2;
gbc.gridwidth=1;
// y una linea de alto
gbc.gridheight=1;
gbc.weightx=100;
gbc.weighty=100;
panel.add(comboTama�o,gbc);
// posicion en 0,3
gbc.gridx=0;
gbc.gridy=3;
// tres columnas de ancho
gbc.gridwidth=3;
gbc.gridheight=1;
gbc.weightx=100;
gbc.weighty=100;
panel.add(lblEjemplo,gbc);
}
}
/**************** sin gestionar representaci�n en la p�gina ***************/
package es.eni;
import java.awt.GridBagConstraints;
import java.awt.GridBagLayout;
import javax.swing.JLabel;
{
JPanel panel;
JLabel lblTama�o,lblEjemplo;
JList lstFuentes;
public Pantalla()
{
setTitle("seleccionar fuente");
setBounds(0,0,300,100);
panel=new JPanel();
chkNegrita=new JCheckBox("negrita");
chkCursiva=new JCheckBox("cursiva");
lblTama�o=new JLabel("altura");
lblEjemplo=new JLabel("prueba de fuente");
comboTama�o=new JComboBox(new String[]{"10","12","14","16","18","20"});
lstFuentes=new JList(new String[]{"arial","courier","letter","helvetica","times
roman","symbole","antique"});
dsplzFuentes=new JScrollPane(lstFuentes);
// agrega en el contenedor
panel.setLayout(null);
panel.add(dsplzFuentes);
panel.add(chkNegrita);
panel.add(chkCursiva);
panel.add(lblTama�o);
panel.add(comboTama�o);
panel.add(lblEjemplo);
// posici�n de los componentes.

dsplzFuentes.setBounds(24, 29, 156, 255);
chkNegrita.setBounds(258, 78, 170, 25);
chkCursiva.setBounds(261, 139, 167, 46);
lblTama�o.setBounds(215, 211, 106, 24);
comboTama�o.setBounds(354, 208, 107, 32);
lblEjemplo.setBounds(17, 309, 459, 28);
}
/**************** reloj original *************************/
package es.eni;
import javax.swing.JProgressBar;
{
JPanel panel;
JProgressBar pgbHora,pgbMinuto,pgbSegundo,pbgTiempo;
public Pantalla13()
{
setTitle("reloj");
setBounds(0,0,300,100);
pgbHora =new JProgressBar();
pgbMinuto=new JProgressBar();
pgbSegundo=new JProgressBar();
pbgTiempo=new JProgressBar();
pgbHora.setMinimum(0);
pgbHora.setMaximum(23);
pgbMinuto.setMinimum(0);
pgbMinuto.setMaximum(59);
pgbSegundo.setMinimum(0);
pgbSegundo.setMaximum(59);
pgbHora.setString("hora");
pgbHora.setStringPainted(true);
pgbMinuto.setString("minuto");
pgbMinuto.setStringPainted(true);
pgbSegundo.setString("segundo");
pgbSegundo.setStringPainted(true);
pbgTiempo.setString("el tiempo pasa");
pbgTiempo.setStringPainted(true);
pbgTiempo.setIndeterminate(true);
panel=new JPanel();
panel.add(pgbHora);
panel.add(pgbMinuto);
panel.add(pgbSegundo);
panel.add(pbgTiempo);
Thread th;
th=new Thread()
{
public void run()
{
while (true)
{
GregorianCalendar d;
d=new GregorianCalendar();
pgbHora.setValue(d.get(GregorianCalendar.HOUR));
pgbMinuto.setValue(d.get(GregorianCalendar.MINUTE));
pgbSegundo.setValue(d.get(GregorianCalendar.SECOND));
try
{
sleep(500);
}
catch (InterruptedException e)
{
}
}
}};
th.start();
}
}
/**************** JTextArea **************/

package es.eni;
import javax.swing.JTextArea;

{
JPanel panel;
JTextArea txt;
JCheckBox chkWrap,chkWrapWord;
JScrollPane scroll;
public Pantalla()
{
setTitle("editor de texto");
setBounds(0,0,300,100);
panel=new JPanel();
txt=new JTextArea(10,40);
scroll=new JScrollPane(txt);
panel.add(scroll);
chkWrap=new JCheckBox("saltos de l�nea autom�ticos");
chkWrapWord=new JCheckBox("saltos entre dos palabras");
chkWrap.addActionListener(new ActionListener()
{
{
txt.setLineWrap(chkWrap.isSelected());
}
});
chkWrapWord.addActionListener(new ActionListener()
{
{
txt.setWrapStyleWord(chkWrapWord.isSelected());
}
});
panel.add(chkWrap);
panel.add(chkWrapWord);
}
}
/************* menus **************/
package es.eni;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintWriter;
import javax.swing.JFileChooser;
import javax.swing.JSeparator;

{
JPanel panel;
JTextArea txt;
JScrollPane scroll;
JMenuBar barra;
JMenu mnuArchivo,mnuEdicion,mnuSalvaguardar;
JMenuItem mnuNuevo,mnuAbrir,mnuGuardar,mnuGuardarEn,mnuSalir;
JMenuItem mnuCopiar,mnuCortar,mnuPegar;
File archivo;
public Pantalla14()
{
setBounds(0,0,300,100);
panel=new JPanel();
panel.setLayout(new BorderLayout());
txt=new JTextArea();
panel.add(scroll,BorderLayout.CENTER);
// creaci�n de los componentes de los menus
barra=new JMenuBar();
mnuArchivo=new JMenu("Archivo");
mnuEdicion=new JMenu("Edicion");
mnuSalvaguardar=new JMenu("Guardar");
mnuNuevo=new JMenuItem("Nuevo");
mnuAbrir=new JMenuItem("Abrir");
mnuGuardar=new JMenuItem("Guardar");
mnuGuardar.setEnabled(false);
mnuGuardarEn=new JMenuItem("Guardar en");
mnuCopiar=new JMenuItem("Copiar");
mnuCortar=new JMenuItem("Cortar");
mnuPegar=new JMenuItem("Pegar");
mnuSalir=new JMenuItem("Salir");
// asociaci�n de los elementos
barra.add(mnuArchivo);
barra.add(mnuEdicion);
mnuArchivo.add(mnuNuevo);
mnuArchivo.add(mnuAbrir);
mnuArchivo.add(mnuSalvaguardar);
mnuSalvaguardar.add(mnuGuardar);
mnuSalvaguardar.add(mnuGuardarEn);
mnuArchivo.add(new JSeparator());
mnuArchivo.add(mnuSalir);
mnuEdicion.add(mnuCopiar);
mnuEdicion.add(mnuCortar);
mnuEdicion.add(mnuPegar);
// asociar el men� con la JFrame
setJMenuBar(barra);
// listeners asociados a los menus
mnuNuevo.addActionListener(new ActionListener()
{
{
archivo=null;
txt.setText("");
}
});
mnuAbrir.addActionListener(new ActionListener()
{
{
JFileChooser dlg;
dlg=new JFileChooser();
dlg.showDialog(null,"Abrir");
archivo=dlg.getSelectedFile();
FileInputStream in;
try
{
in=new FileInputStream(archivo);
BufferedReader br;
br=new BufferedReader(new InputStream-Reader(in));
String linea;
txt.setText("");
while ((linea=br.readLine())!=null)
{
txt.append(linea+"\r\n");
}
br.close();
mnuGuardar.setEnabled(true);
}
{
}
{
}
}
});
mnuSalir.addActionListener(new ActionListener()
{
{
System.exit(0);
}
});
mnuCopiar.addActionListener(new ActionListener()
{
{
txt.copy();
}
});
mnuCortar.addActionListener(new ActionListener()
{
{
txt.cut();
}
});
mnuPegar.addActionListener(new ActionListener()
{
{
txt.paste();
}
});
mnuGuardar.addActionListener(new ActionListener()
{
{
try
{
PrintWriter pw;
pw=new PrintWriter(archivo);
pw.write(txt.getText());
pw.close();
}
{
}
}
});
mnuGuardarEn.addActionListener(new ActionListener()
{
{
try
{
JFileChooser dlg;
dlg.showDialog(null,"guardar en");
PrintWriter pw;
pw.close();
}
{
}
}
});
}
}
/************** JToolBar ******************************/
JToolBar tlbr;
tlbr=new JToolBar();
JButton btnNuevo,btnAbrir,btnGuardar;
JButton btnCopiar,btnCortar,btnPegar;
// creacion botones
btnNuevo=new JButton(new ImedadIcon("new.jpg"));
btnAbrir=new JButton(new ImedadIcon("open.jpg"));
btnGuardar=new JButton(new ImedadIcon("save.jpg"));
btnCopiar=new JButton(new ImedadIcon("copy.jpg"));
btnPegar=new JButton(new ImedadIcon("paste.jpg"));
btnCortar=new JButton(new ImedadIcon("cut.jpg"));
// agrega botones a la barra de herramientas
tlbr.add(btnNuevo);
tlbr.add(btnAbrir);
tlbr.add(btnGuardar);
tlbr.addSeparator();
tlbr.add(btnCopiar);
tlbr.add(btnCortar);
tlbr.add(btnPegar);
// agrega la barra de herramientas a su contenedor
panel.add(tlbr,BorderLayout.NORTH);
// reutilizar los listeners ya asociados a los menus
btnNuevo.addActionListener(mnuNuevo.getActionListeners()[0]);
btnAbrir.addActionListener(mnuAbrir.getActionListeners()[0]);
btnGuardar.addActionListener(mnuGuardar.getActionListeners()[0]);
btnCopiar.addActionListener(mnuCopiar.getActionListeners()[0]);
btnCortar.addActionListener(mnuCortar.getActionListeners()[0]);
btnPegar.addActionListener(mnuPegar.getActionListeners()[0]);
/*************** JCheckBox *****************/

JPanel options;
GridLayout gl;
options=new JPanel();
gl=new GridLayout(2,1);
options.setLayout(gl);
chkNegrita=new JCheckBox("Negrita");
chkCursiva=new JCheckBox("Cursiva");
options.add(chkNegrita);
options.add(chkCursiva);
chkNegrita.addActionListener(new ActionListener()
{
{
cambiaFuente();
}
});
chkCursiva.addActionListener(new ActionListener()
{
{
cambiaFuente();
}
});
panel.add(options,BorderLayout.SOUTH);
}
public void cambiaFuente()

{
int atributos;
atributos=0;
if (chkNegrita.isSelected())
{
atributos=atributos+Font.BOLD;
}
if (chkCursiva.isSelected())
{
atributos=atributos+Font.ITALIC;
}
Font fuente;
fuente=new
Font(txt.getFont().getName(),atributos,txt.getFont().getSize());
txt.setFont(fuente);
}
/***************** JRadioButton *****************/
JRadioButton optFondoRojo,optFondoVerde,optFondoAzul;
JRadioButton optRojo,optVerde,optAzul;
JPanel color,colorFondo;
ButtonGroup grpColor,grpColorFondo;
// creacion botones
optRojo=new JRadioButton("Rojo");
optVerde=new JRadioButton("Verde");
optAzul=new JRadioButton("Azul");
optFondoRojo=new JRadioButton("Rojo");
optFondoVerde=new JRadioButton("Verde");
optFondoAzul=new JRadioButton("Azul");
// regroupement logique botones
grpColor=new ButtonGroup();
grpColor.add(optRojo);
grpColor.add(optVerde);
grpColor.add(optAzul);
grpColorFondo=new ButtonGroup();
grpColorFondo.add(optFondoRojo);
grpColorFondo.add(optFondoVerde);
grpColorFondo.add(optFondoAzul);
// agrupaci�n f�sica de botones
color=new JPanel();
color.setLayout(new GridLayout(0,1));
color.add(optRojo);
color.add(optVerde);
color.add(optAzul);
colorFondo=new JPanel();
colorFondo.setLayout(new GridLayout(0,1));
colorFondo.add(optFondoRojo);
colorFondo.add(optFondoVerde);
colorFondo.add(optFondoAzul);
// agrega t�tulo
color.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder()
,"color fuente"));
colorFondo.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBor
der(),"color fondo"));
// referencement des ecouteurs
optAzul.addActionListener(new ActionListener()
{
{
txt.setForeground(Color.BLUE);
}
});
optVerde.addActionListener(new ActionListener()
{
{
txt.setForeground(Color.GREEN);
}
});
optRojo.addActionListener(new ActionListener()
{
{
txt.setForeground(Color.RED);
}
});
optFondoAzul.addActionListener(new ActionListener()
{
{
txt.setBackground(Color.BLUE);
}
});
optFondoRojo.addActionListener(new ActionListener()
{
{
txt.setBackground(Color.RED);
}
});
optFondoVerde.addActionListener(new ActionListener()
{
{
txt.setBackground(Color.GREEN);
}
});
/************** JList ****************/
JList fuentes ;
String[] nombresFuentes={"Dialog","DialogInput","Monospaced","Serif","SansSerif"};
fuentes=new JList(nombresFuentes);
fuentes.setSelectedIndex(0);
dsplzFuentes=new JScrollPane(fuentes);
dsplzFuentes.setPreferredSize(new Dimension(100,60));
options.add(dsplzFuentes);
fuentes.addListSelectionListener(new ListSelectionListener()
{
public void valueChanged(ListSelectionEvent e)
{
if (!e.getValueIsAdjusting())
{
cambiaFuente();
}
}
});
�
�
�
{
int atributos;
atributos=0;
{
}
{
}
Font fuente;
fuente=new
Font(fuentes.getSelectedValue().toString(),atributos,txt.getFont().getSize());
}
/************************* JComboBox ******************/
JComboBox comboTama�o ;
String alturas[]={"10","12","14","16","20"};
comboTama�o=new JComboBox(alturas);
comboTama�o.setEditable(true);
options.add(comboTama�o);
comboTama�o.addActionListener(new ActionListener()
{
{
cambiaFuente();
}
});
�
�
�
{
int atributos;
atributos=0;
{
}
{
}
Font fuente;
System.out.println(comboTama�o.getSelectedItem().toString());
fuente=new
Font(fuentes.getSelectedValue().toString(),atributos,Integer.parseInt(comboTama�o.g
etSelectedItem().toString()));
}
/*************** Editor de texto completo ****************/
package es.eni;
import java.awt.BorderLayout;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.GridLayout;
import java.io.File;
import java.io.FileOutputStream;
import java.io.InputStream;
import java.io.PrintWriter;
import javax.swing.BorderFactory;
import javax.swing.ButtonGroup;
import javax.swing.ImedadIcon;
import javax.swing.JFileChooser;
import javax.swing.JRadioButton;
import javax.swing.JSeparator;
import javax.swing.JToolBar;
import javax.swing.event.ListSelectionEvent;
import javax.swing.event.ListSelectionListener;

{
JPanel panel;
JTextArea txt;
JScrollPane scroll;
JMenuBar barra;
JMenu mnuArchivo,mnuEdicion,mnuSalvaguardar;
JMenuItem mnuNuevo,mnuAbrir,mnuGuardar,mnuGuardarEn,mnuSalir;
JMenuItem mnuCopiar,mnuCortar,mnuPegar;
File archivo;
JList fuentes;
public Pantalla14()
{
setBounds(0,0,300,100);
panel=new JPanel();
panel.setLayout(new BorderLayout());
txt=new JTextArea();
panel.add(scroll,BorderLayout.CENTER);
// creaci�n de los componentes de los menus
barra=new JMenuBar();
mnuArchivo=new JMenu("Archivo");
mnuEdicion=new JMenu("Edicion");
mnuSalvaguardar=new JMenu("Guardar");
mnuNuevo=new JMenuItem("Nuevo");
mnuAbrir=new JMenuItem("Abrir");
mnuGuardar=new JMenuItem("Guardar");
mnuGuardarEn=new JMenuItem("Guardar en");
mnuCopiar=new JMenuItem("Copiar");
mnuCortar=new JMenuItem("Cortar");
mnuPegar=new JMenuItem("Pegar");
mnuSalir=new JMenuItem("Salir");
// asociaci�n de elementos
barra.add(mnuArchivo);
barra.add(mnuEdicion);
mnuArchivo.add(mnuNuevo);
mnuArchivo.add(mnuAbrir);
mnuArchivo.add(mnuSalvaguardar);
mnuSalvaguardar.add(mnuGuardar);
mnuSalvaguardar.add(mnuGuardarEn);
mnuArchivo.add(new JSeparator());
mnuArchivo.add(mnuSalir);
mnuEdicion.add(mnuCopiar);
mnuEdicion.add(mnuCortar);
mnuEdicion.add(mnuPegar);
// asociaci�n del men� con la JFrame
setJMenuBar(barra);
// listeners asociados a los distintos men�s
mnuNuevo.addActionListener(new ActionListener()
{
{
archivo=null;
txt.setText("");
}
});
mnuAbrir.addActionListener(new ActionListener()
{
{
JFileChooser dlg;
dlg.showDialog(null,"Abrir");
FileInputStream in;
try
{
in=new FileInputStream(archivo);
BufferedReader br;
br=new BufferedReader(new InputStreamReader(in));
String linea;
txt.setText("");
while ((linea=br.readLine())!=null)
{
txt.append(linea+"\r\n");
}
br.close();
mnuGuardar.setEnabled(true);
}
{
}
{
}
}
});
mnuSalir.addActionListener(new ActionListener()
{
{
System.exit(0);
}
});
mnuCopiar.addActionListener(new ActionListener()
{
{
txt.copy();
}
});
mnuCortar.addActionListener(new ActionListener()
{
{
txt.cut();
}
});
mnuPegar.addActionListener(new ActionListener()
{
{
txt.paste();
}
});
mnuGuardar.addActionListener(new ActionListener()
{
{
try
{
PrintWriter pw;
pw.close();
}
{
}
}
});
mnuGuardarEn.addActionListener(new ActionListener()
{
{
try
{
JFileChooser dlg;
dlg.showDialog(null,"guardar en");
PrintWriter pw;
pw.close();
}
{
}
}
});
JToolBar tlbr;
tlbr=new JToolBar();
JButton btnNuevo,btnAbrir,btnGuardar;
JButton btnCopiar,btnCortar,btnPegar;
btnNuevo=new JButton(new ImedadIcon("new.jpg"));
btnAbrir=new JButton(new ImedadIcon("open.jpg"));
btnGuardar=new JButton(new ImedadIcon("save.jpg"));
btnCopiar=new JButton(new ImedadIcon("copy.jpg"));
btnPegar=new JButton(new ImedadIcon("paste.jpg"));
btnCortar=new JButton(new ImedadIcon("cut.jpg"));
tlbr.add(btnNuevo);
tlbr.add(btnAbrir);
tlbr.add(btnGuardar);
tlbr.addSeparator();
tlbr.add(btnCopiar);
tlbr.add(btnCortar);
tlbr.add(btnPegar);
panel.add(tlbr,BorderLayout.NORTH);
btnNuevo.addActionListener(mnuNuevo.getActionListeners()[0]);
btnAbrir.addActionListener(mnuAbrir.getActionListeners()[0]);
btnGuardar.addActionListener(mnuGuardar.getActionListeners()[0]);
btnCopiar.addActionListener(mnuCopiar.getActionListeners()[0]);
btnCortar.addActionListener(mnuCortar.getActionListeners()[0]);
btnPegar.addActionListener(mnuPegar.getActionListeners()[0]);
JPanel options;
GridLayout gl;
options=new JPanel();
gl=new GridLayout(2,3);
//options.setLayout(gl);
chkNegrita=new JCheckBox("Negrita");
chkCursiva=new JCheckBox("Cursiva");
options.add(chkNegrita);
options.add(chkCursiva);
chkNegrita.addActionListener(new ActionListener()
{
{
cambiaFuente();
}
});
chkCursiva.addActionListener(new ActionListener()
{
{
cambiaFuente();
}
});
String[]
nombresFuentes={"Dialog","DialogInput","Monospaced","Serif","SansSerif"};
fuentes=new JList(nombresFuentes);
fuentes.setSelectedIndex(0);
dsplzFuentes=new JScrollPane(fuentes);
dsplzFuentes.setPreferredSize(new Dimension(100,60));
options.add(dsplzFuentes);
fuentes.addListSelectionListener(new ListSelectionListener()
{
public void valueChanged(ListSelectionEvent e)
{
if (!e.getValueIsAdjusting())
{
cambiaFuente();
}
}
});
String tama�os[]={"10","12","14","16","20"};
comboTama�o=new JComboBox(tama�os);
comboTama�o.setEditable(true);
options.add(comboTama�o);
comboTama�o.addActionListener(new ActionListener()
{
{
cambiaFuente();
}
});
JRadioButton optFondoRojo,optFondoVerde,optFondoAzul;
JRadioButton optRojo,optVerde,optAzul;
JPanel color,colorFondo;
ButtonGroup grpColor,grpColorFondo;
// creacion botones
optRojo=new JRadioButton("Rojo");
optVerde=new JRadioButton("Verde");
optAzul=new JRadioButton("Azul");
optFondoRojo=new JRadioButton("Rojo");
optFondoVerde=new JRadioButton("Verde");
optFondoAzul=new JRadioButton("Azul");
// agrupacion l�gica de botones
grpColor=new ButtonGroup();
grpColor.add(optRojo);
grpColor.add(optVerde);
grpColor.add(optAzul);
grpColorFondo=new ButtonGroup();
grpColorFondo.add(optFondoRojo);
grpColorFondo.add(optFondoVerde);
grpColorFondo.add(optFondoAzul);
// agrupaci�n f�sica de botones
color=new JPanel();
color.setLayout(new GridLayout(0,1));
color.add(optRojo);
color.add(optVerde);
color.add(optAzul);
colorFondo=new JPanel();
colorFondo.setLayout(new GridLayout(0,1));
colorFondo.add(optFondoRojo);
colorFondo.add(optFondoVerde);
colorFondo.add(optFondoAzul);
// agrega un t�tulo
color.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBorder()
,"color fuente"));
colorFondo.setBorder(BorderFactory.createTitledBorder(BorderFactory.createEtchedBor
der(),"color fondo"));
// referencia a los listeners
optAzul.addActionListener(new ActionListener()
{
{
txt.setForeground(Color.BLUE);
}
});
optVerde.addActionListener(new ActionListener()
{
{
txt.setForeground(Color.GREEN);
}
});
optRojo.addActionListener(new ActionListener()
{
{
txt.setForeground(Color.RED);
}
});
optFondoAzul.addActionListener(new ActionListener()
{
{
txt.setBackground(Color.BLUE);
}
});
optFondoRojo.addActionListener(new ActionListener()
{
{
txt.setBackground(Color.RED);
}
});
optFondoVerde.addActionListener(new ActionListener()
{
{
txt.setBackground(Color.GREEN);
}
});
options.add(color);
options.add(colorFondo);
panel.add(options,BorderLayout.SOUTH);
}
{
int atributos;
atributos=0;
{
}
{
}
Font fuente;
System.out.println(comboTama�o.getSelectedItem().toString());
fuente=new
Font(fuentes.getSelectedValue().toString(),atributos,Integer.parseInt(comboTama�o.g
etSelectedItem().toString()));
}
}
/
***********************************************************************************
***/
/********************************** Cap�tulo 5
****************************************/
/
***********************************************************************************
***/
/**************** Ciclo de vida de un applet ***************/
import java.applet.Applet;
public class TestApplet extends Applet

{
private String mensaje="";
public void destroy()
{
mensaje=mensaje + "metodo destroy \r\n";
}
public void init()

{
mensaje=mensaje + "metodo init \r\n";
}
public void start()

{
mensaje=mensaje + "metodo start \r\n";
}
public void stop()

{
mensaje=mensaje + "metodo stop \r\n";
}
public void paint(Graphics g)

{
mensaje=mensaje + "metodo paint \r\n";
g.drawString(mensaje, 10, 20);
}
}
Para verificar el correcto funcionamiento del applet, debemos insertarlo en una

p�gina html y visualizarla en un navegador mediante la herramienta appletViewer del
jdk.
<html>
<head>
<title> primer applet </title>
</head>
<body>
<h1>visualizaci�n de las llamadas de los m�toso de un applet</h1>
<applet code="TestApplet"></applet>
</body>
</html>
/**************** applet con gesti�n de mensajes ***************/
import java.awt.Font;
import java.awt.FontMetrics;
import javax.swing.JApplet;
public class TestApplet2 extends JApplet

{
{
}
public void init()

{
mensaje=mensaje + "metodo init \r\n";
}
public void start()

{
mensaje=mensaje + "metodo start \r\n";
}
public void stop()

{
mensaje=mensaje + "metodo stop \r\n";
}

{
// creacion de la fuente de caracteres
Font fuente=null;
fuente =new Font("SansSerif",Font.PLAIN,14);
// se asigna la fuente al contexto gr�fico
g.setFont(fuente);
// determinar ancho y alto del applet
int anchoApplet;
int altoApplet;
anchoApplet=getWidth();
altoApplet=getHeight();
// crear un objeto FontMetrics para obtener informaci�n
// acerca del tama�o de los caracteres
FontMetrics fm;
fm=g.getFontMetrics(fuente);
int alturaFuente;
int anchoCaracter;
alturaFuente=fm.getHeight();
// declarar variables para gestionar la posici�n del mensaje
int cursorX;
int cursorY;
cursorX=0;
cursorY=alturaFuente;
mensaje=mensaje + "metodo paint \r\n";
// bucle de procesamiento de caracteres uno a uno
for (int i=0;i<mensaje.length();i++)
{
// recuperar el caracter a procesar y su tama�o
String caracterEnCurso;
caracterEnCurso=mensaje.substring(i,i+1);
anchoCaracter=fm.stringWidth(caracterEnCurso);
// verificar si queda espacio en la l�nea
if (cursorX+anchoCaracter>anchoApplet)
{
// salto a la l�nea siguiente
cursorY=cursorY+alturaFuente;
cursorX=0;
}
// caracter en la posici�n en curso
g.drawString(caracterEnCurso,cursorX,cursorY);
// actualizaci�n del cursor
cursorX=cursorX+anchoCaracter;
}
}
}
/**************** applet con gesti�n de mensaje en un TextArea ***************/
import java.awt.ScrollPane;
import java.awt.TextArea;
public class TestApplet3 extends Applet

{
ScrollPane scroll;
TextArea txt;

{
}
public void init()

{
txt=new TextArea(50,50);
scroll=new ScrollPane();
scroll.add(txt);
add(scroll);
txt.append("metodo init \r\n");
}
public void start()

{
txt.append("metodo start \r\n");
}
public void stop()

{
txt.append("metodo stop \r\n");
}

{
txt.append("metodo paint \r\n");
}
}
/**************** Thread en un applet ***************/
import java.awt.Imedad;
public class TestApplet5 extends Applet implements Runnable

{
Thread th;
final int MAXI=100;
final int MINI=10;
int ancho=MINI;
int alto=MINI;
Imedad img;
public void run()

{
boolean ensanchar=true;
Thread t;
t=Thread.currentThread();
while (th==t)
{
if(ancho>MAXI & ensanchar)
{
ensanchar=false;
}
if (ancho<MINI & !ensanchar)
{
ensanchar=true;
}
if (ensanchar)
{
ancho++;
alto++;
}
else
{
ancho--;
alto--;
}
repaint();
try
{
th.sleep(10);
}
catch (InterruptedException e)
{}
}
public void init()

{
img=getImedad(getCodeBase(),"imedads/duke.gif");
}
public void start()

{
th=new Thread(this);
th.start();
}
public void stop()

{
th=null;
}

{
g.drawImedad(img,30,0,ancho,alto,this);
}
}
/**************** sonido en un applet ***************/
import java.applet.AudioClip;
public class TestAppletAudio extends Applet implements Runnable

{
AudioClip ac;
public void init()
{
Thread th;
th=new Thread(this);
th.start();
}
public void start()

{
if (ac!=null)
{
ac.loop();
}
}
public void stop()
{
if (ac!=null)
{
ac.stop();
}
}
public void run()
{
ac=getAudioClip(getCodeBase(),"sonido.wav");
ac.loop();
}
}
/**************** paso de par�metro a un applet ***************/
import java.awt.Imedad;
public class TestApplet5 extends Applet implements Runnable

{
Thread th;
int MAXI=100;
int MINI=10;
int ancho=MINI;
int alto=MINI;
Imedad img;
public void init()

{
String min;
String max;
min=getParameter("minimo");
if(min!=null)
{
MINI=Integer.parseInt(min);
}
max=getParameter("maximo");
if(max!=null)
{
MAXI=Integer.parseInt(max);
}
MAXI=Integer.parseInt(max);
img=getImedad(getCodeBase(),"imedads/duke.gif");
}
�
}
/**************** mensaje en la consola java del navegador ***************/
public class TestApplet extends Applet

{
{
System.out.println("metodo destroy�);
}
public void init()

{
System.out.println("metodo init�);
}
public void start()

{
System.out.println("metodo start�);
}
public void stop()

{
System.out.println("metodo stop");
}

{
System.out.println("metodo paint");
}
/**************** obtener las propiedades del sistema ***************/
public class Proprietes extends Applet

{
public void start()

{
System.out.print("versi�n del jre \t");
System.out.println(System.getProperty("java.version"));
System.out.print("fabricante del jre \t");
System.out.println(System.getProperty("java.vendor"));
System.out.print("sitio web del fabricante del jre \t");
System.out.println(System.getProperty("java.vendor.url"));
System.out.print("nombre del sistema operativo \t");
System.out.println(System.getProperty("os.name"));
System.out.print("plataforma del sistema operativo \t");
System.out.println(System.getProperty("os.arch"));
System.out.print("separador de rutas de acceso \t");
System.out.println(System.getProperty("file.separator"));
System.out.print("separador en la variable PATH \t");
System.out.println(System.getProperty("path.separator"));
}
}
/
***********************************************************************************
***/
/********************************** Cap�tulo 6
****************************************/
/
***********************************************************************************
***/
/**************** conexi�n piloto SQL Server ***************/
import java.sql.Connection;
import java.sql.DriverManedadr;
import java.sql.SQLException;
public class ConexionDirecta

{
{
try
{
Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
}
catch (ClassNotFoundException e)
{
System.out.println("error cargando el controlador");
}
Connection cnxDirect=null;
try
{
cnxDirect=DriverManedadr.getConnection("jdbc:sqlserver://localhost;databaseName=nor
thwind; user=thierry;password=secret;");
}
catch (SQLException e)
{
System.out.println("error durante la conexi�n");
}
}
}
/**************** Conexi�n piloto ODBC ***************/
import java.sql.Connection;
import java.sql.DriverManedadr;
import java.sql.SQLException;
public class ConexionDirecta

{
{
try
{
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
}
catch (ClassNotFoundException e)
{
System.out.println("error cargando el controlador");
}
Connection cnxOdbc=null;
try
{
cnxOdbc=DriverManedadr.getConnection("jdbc:odbc:nwd","thierry","secreto");
}
{
System.out.println("error durante la conexi�n");
}
}
}
/**************** propiedades de la conexi�n ***************/
public static void testSoloLectura(Connection cnx)

{
boolean estado;
try
{
estado = cnx.isReadOnly();
cnx.setReadOnly(!estado);
if (cnx.isReadOnly() != estado)
{
System.out
.println("modo de solo lectura para este
controlador");
}
else
{
System.out
.println("modo de solo lectura no se tiene en
cuenta en este controlador");
}
cnx.setReadOnly(estado);
}
{
}
}
/**************** mensajes de aviso del servidor ***************/
public static void mensajeWarnings(Connection cnx)

{
SQLWarning aviso;
try
{
aviso=cnx.getWarnings();
if (aviso==null)
{
System.out.println("no hay avisos");
}
else
{
while (aviso!=null)
{
System.out.println(aviso.getMensaje());
System.out.println(aviso.getSQLState());
System.out.println(aviso.getErrorCode());
aviso=aviso.getNextWarning();
}
}
cnx.clearWarnings();
}
{
}
}
/**************** informaci�n acerca de la estructura de la base de datos

***************/
public static void infosBase(Connection cn)

{
ResultSet rs;
DatabaseMetaData dbmd;
try
{
dbmd=cn.getMetaData();
System.out.println("tipo de base de datos: " +
dbmd.getDatabaseProductName());
System.out.println("versi�n: " +
dbmd.getDatabaseProductVersion());
System.out.println("nombre del controlador: " +
dbmd.getDriverName());
System.out.println("versi�n del controlador: " +
dbmd.getDriverVersion());
System.out.println("nombre del usuario: " + dbmd.getUserName());
System.out.println("url de conexi�n: " + dbmd.getURL());
rs=dbmd.getTables(null,null,"%",null);
System.out.println("estructura de la base de datos");
System.out.println("base\tesquema\tnombre tabla\ttipo tabla");
while(rs.next())
{
for (int i = 1; i <=4 ; i++)
{
System.out.print(rs.getString(i)+"\t");
}
System.out.println();
}
rs.close();
rs=dbmd.getProcedures(null,null,"%");
System.out.println("procedimientos almacenados");
System.out.println("base\tesquema\tnombre procedimiento");
while(rs.next())
{
for (int i = 1; i <=3 ; i++)
{
}
}
rs.close();
}
{
}
}
/**************** ejecuci�n de instrucciones SQL b�sicas ***************/

public static void testExecute(Connection cnx)
{
Statement stm;
BufferedReader br;
String consulta;
ResultSet rs;
boolean resultado;
try
{
stm=cnx.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY)
;
System.out.println("escriba su instrucci�n SQL:");
consulta=br.readLine();
resultado=stm.execute(consulta);
if (resultado)
{
System.out.println("su instrucci�n ha generado un juego de
registros");
rs=stm.getResultSet();
rs.last();
System.out.println("contiene " + rs.getRow() + "
registros");
}
else
{
System.out.println("su instrucci�n ha modificado registros
en la base de datos");
System.out.println("n�mero de registros modificados:" +
stm.getUpdateCount());
}
}
{
System.out.println("su instrucci�n no ha funcionado
correctamente");
}
{
}
}
/**************** ejecuci�n de instrucciones en lote ***************/
public static void testExecuteBatch(Connection cnx)

{
Statement stm;
BufferedReader br;
String consulta="";
int[] resultados;
try
{
;
System.out.println("escriba sus instrucciones SQL y, a
continuaci�n, run para ejecutar el lote:");
while (!consulta.equalsIgnoreCase("run"))
{
stm.addBatch(consulta);
}
System.out.println("ejecuci�n del lote de instrucciones");
resultados=stm.executeBatch();
for (int i=0; i<resultados.length;i++)
{
switch (resultados[i])
{
case Statement.EXECUTE_FAILED:
System.out.println("ejecuci�n de la instrucci�n " + i
+ " ha fallado");
break;
case Statement.SUCCESS_NO_INFO:
+ " ha funcionado");
System.out.println("n�mero de registros modificados
desconocido");
break;
default:
+ " ha funcionado");
System.out.println("ha modificado " + resultados[i] +
" registros");
break;
}
}
}
{
}
{
}
}
/**************** ejecutar varias instrucciones ***************/
public static void testExecuteMultiple(Connection cnx)

{
Statement stm;
BufferedReader br;
String consulta;
ResultSet rs;
boolean resultado;
try
{
;
System.out.println("escriba sus instrucciones SQL separadas por ;
:");
int i=1;
// procesar el resultado de la primera instrucci�n
if (resultado)
{
System.out.println("su instrucci�n N� " + i + " ha generado
un juego de registros");
rs.last();
registros");
}
else
{
System.out.println("su instrucci�n N� " + i + " ha
modificado registros en la base de datos");
System.out.println("n�mero de registros modificados :" +
stm.getUpdateCount());
}
i++;
// desplazar el puntero al siguiente resultado
resultado=stm.getMoreResults();
// bucle mientras haya resultados -> resultado==true
//o haya registros modificados -> getUpdateCount != -1
while (resultado || stm.getUpdateCount()!=-1)
{
if (resultado)
{
generado un juego de registros");
rs.last();
registros");
}
else
{
modificado registros en la base de datos");
System.out.println("n�mero de registros
modificados :" + stm.getUpdateCount());
}
i++;
// desplazar el puntero al siguiente registro
resultado=stm.getMoreResults();
}
}
{
System.out.println("su instrucci�n no ha funcionado
correctamente");
}
{
}
}
/**************** creaci�n de consulta por concatenaci�n ***************/
public static void testConsultaConcat(Connection cnx)

{
Statement stm;
BufferedReader br;
String consulta;
String code;
ResultSet rs;
boolean resultado;
try
{
;
System.out.println("escriba el c�digo de cliente para realizar la
b�squeda :");
code=br.readLine();
consulta="select * from customers where customerID=\'" + code +
"\'";
}
{
} catch (IOException e) {
// TODO Bloque catch autogenerado
}
}
/**************** ejecuci�n de la consulta con par�metros ***************/
public static void testPreparedStatement(Connection cnx)

{
{
PreparedStatement stm;
BufferedReader br;
String code;
ResultSet rs;
try
{
stm=cnx.prepareStatement("select * from customers where
customerID like ?",ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
System.out.println("escriba el c�digo de cliente para
realizar la b�squeda :");
code=br.readLine();
stm.setString(1,code);
rs=stm.executeQuery();
while (rs.next())
{
for (int i = 1; i
<=rs.getMetaData().getColumnCount(); i++)
{
}
}
}
{
}
{
}
}
}
/**************** ejecuci�n de procedimientos almacenados ***************/
create PROCEDURE solicitudesPorCliente @code nchar(5)

AS
SELECT OrderID,
OrderDate,
RequiredDate,
ShippedDate
FROM Orders
WHERE CustomerID = @code
ORDER BY OrderID
CREATE procedure numSolicitudes @code nchar(5) as

declare @num int
select @num=count(*) from orders where customerid=@code
return @num
public static void testProcedimientoAlmacenado(Connection cnx)

{
CallableStatement cstm1,cstm2;
BufferedReader br;
String code;
ResultSet rs;
int numSolicitudes;
try
{
System.out.println("escriba el c�digo de cliente para realizar la
b�squeda :");
code=br.readLine();
cstm1=cnx.prepareCall("{ ?=call numSolicitudes ( ? )}");
cstm1.setString(2,code);
cstm1.registerOutParameter(1,java.sql.Types.INTEGER);
cstm1.execute();
numSolicitudes=cstm1.getInt(1);
System.out.println("n�mero de solicitudes del cliente " + code +
" : " + numSolicitudes );
cstm2=cnx.prepareCall("{ call solicitudesPorCliente
( ? )}",ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_READ_ONLY);
cstm2.setString(1,code);
rs=cstm2.executeQuery();
System.out.println("detalle de las solicitudes");
System.out.println("numero de solicitud\tfecha de solicitud");
while (rs.next())
{
System.out.print(rs.getInt("OrderID") + "\t");
System.out.println(new
SimpleDateFormat("dd/MM/yy").format(rs.getDate("OrderDate")));
}
}
{
}
{
}
}
/**************** informaci�n en el juego de resultados ***************/
public static void infosResultset(ResultSet rs)

{
try {
switch (rs.getType())
{
case ResultSet.TYPE_FORWARD_ONLY:
System.out.println("el resultado se puede recorrer
hacia adelante �nicamente");
break;
case ResultSet.TYPE_SCROLL_INSENSITIVE:
System.out.println("el resultado puede recorrerse en
ambos sentidos");
System.out.println("no es sensible a las
modificaciones realizadas por otros usuarios");
break;
case ResultSet.TYPE_SCROLL_SENSITIVE:
System.out.println("el resultado puede recorrerse en
ambos sentidos");
System.out.println("es sensible a las modificaciones
realizadas por otros usuarios");
break;
}
switch (rs.getConcurrency())
{
case ResultSet.CONCUR_READ_ONLY:
System.out.println("los datos del resultado son de
s�lo lectura");
break;
case ResultSet.CONCUR_UPDATABLE:
System.out.println("es posible modificar los datos
del resultado");
break;
}
}
{
}
}
/**************** posici�n en el juego de resultados ***************/
public static void posicionRs(ResultSet rs)

{
try {
if (rs.isBeforeFirst())
{
System.out.println("el puntero est� antes del primer
registro");
}
if (rs.isAfterLast())
{
System.out.println("el puntero est� despu�s del �ltimo
registro");
}
if (rs.isFirst())
{
System.out.println("el puntero est� en el primer
registro");
}
if (rs.isLast())
{
System.out.println("el puntero est� en el �ltimo
registro");
}
int posicion;
posicion=rs.getRow();
if (posicion!=0)
{
System.out.println("es el registro n�mero " + posicion);
}
} catch (SQLException e) {
// TODO Bloque catch
}
}
}
/**************** leer el juego de resutlados ***************/
public static void lecturaRs(Connection cnx)

{
Statement stm;
String consulta;
ResultSet rs;
try
{
;
consulta="select * from products " ;
rs=stm.executeQuery(consulta);
System.out.println("codigo producto\tnombre\tprecio
unitario\tstock\tdisponible\tfecha caducidad");
while(rs.next())
{
System.out.print(rs.getInt("ProductID")+"\t");
System.out.print(rs.getString("ProductName")+"\t");
System.out.print(rs.getDouble("UnitPrice")+"\t");
rs.getShort("UnitsInStock");
if (rs.wasNull())
{
System.out.print("desconocido\t");
}
else
{
System.out.print(rs.getShort("UnitsInStock")+"\t");
}
System.out.print(rs.getBoolean("Discontinued")+"\t");
if (rs.getDate("FechaCaducidad")!=null)
{
System.out.println(rs.getDate("FechaCaducidad"));
}
else
System.out.println("no caduca");
}
rs.close();
stm.close();
}
{
}
}
/**************** modificar el juego de resultados ***************/
public static void modificarRs(Connection cnx)

{
Statement stm;
String consulta;
ResultSet rs;
int num=0;
BufferedReader br;
String reponse;
try
{
stm=cnx.createStatement(ResultSet.TYPE_SCROLL_SENSITIVE,ResultSet.CONCUR_UPDATABLE)
;
System.out.println("numero de linea\tcodigo
producto\tnombre\tprecio unitario\tstock\tdisponibilidad\tfecha caducidad");
while(rs.next())
{
num++;
System.out.print(num + "\t");
if (rs.wasNull())
{
}
else
{
}
{
}
else
}
System.out.println("�qu� registro desea modificar? ");
reponse=br.readLine();
rs.absolute(Integer.parseInt(reponse));
System.out.println("nombre actual " +
rs.getString("ProductName"));
System.out.println("escriba el nuevo valor o presion enter para
conservar el valor actual");
if (!reponse.equals(""))
{
rs.updateString("ProductName",reponse);
}
System.out.println("precio unitario actual " +
rs.getDouble("UnitPrice"));
{
rs.updateDouble("UnitPrice",Double.parseDouble(reponse));
}
if (rs.wasNull())
{
System.out.println ("cantidad en stock actual
desconocida");
}
else
{
System.out.println("cantidad en stock actual " +
rs.getShort("UnitsInStock"));
}
{
rs.updateShort("UnitsInStock",Short.parseShort(reponse));
}
System.out.println("desea aplicar las modificaciones S/N");
if (reponse.toLowerCase().equals("S"))
{
rs.updateRow();
}
else
{
rs.cancelRowUpdates();
}
System.out.println("Valores actuales ");
if (rs.wasNull())
{
}
else
{
}
rs.close();
stm.close();
}
{
} catch (IOException e) {
}
}
/**************** borrar el juego de resultados ***************/
public static void borrarRs(Connection cnx)

{
Statement stm;
String consulta;
ResultSet rs;
int num=0;
BufferedReader br;
String reponse;
try
{
;
System.out.println("numero de linea\tcodigo
producto\tnombre\tprecio unitario\tstock\tdisponibilidad\tfecha caducidad");
while(rs.next())
{
num++;
System.out.print(num + "\t");
if (rs.wasNull())
{
}
else
{
}
{
}
else
}
System.out.println("�Qu� fila desea borrar? ");
rs.absolute(Integer.parseInt(reponse));
rs.deleteRow();
System.out.println("el puntero est� ahora en la fila " +
rs.getRow());
}
catch (Exception e)
{
}
}
/**************** agrega un elemento al juego de resultados ***************/
public static void agregaRs(Connection cnx)

{
Statement stm;
String consulta;
ResultSet rs;
int num=0;
BufferedReader br;
String reponse;
try
{
;
System.out.println("escriba los valores para la nueva fila");
rs.moveToInsertRow();
System.out.print("Codigo producto : ");
rs.updateInt ("ProductID",Integer.parseInt(reponse));
System.out.print("Nombre : ");
rs.updateString ("ProductName",reponse);
System.out.print("Precio unitario : ");
rs.updateDouble("UnitPrice",Double.parseDouble(reponse));
System.out.print("Cantidad en stock : ");
rs.updateDouble("UnitsInStock",Short.parseShort(reponse));
rs.insertRow();
}
catch (Exception e)
{
}
}
/**************** ejemplo sin transacci�n ***************/
public static void mouvement(String cuentaDebito,String cuentaCredito,double suma)

{
try
{
Connection cnx=null;
cnx=DriverManedadr.getConnection("jdbc:sqlserver://localhost;databaseName=banque;
user=sa;password=;");
stm=cnx.prepareStatement("update cuentas set saldo=saldo + ?
where numero=?");
stm.setDouble(1,suma * -1);
stm.setString(2,cuentaDebito);
stm.executeUpdate();
imprimirInforme(cuentaDebito, suma);
stm.setDouble(1,suma);
stm.setString(2,cuentaCredito);
imprimirInforme(cuentaCredito, suma);
}
catch (Exception e)
{
}
}
/**************** uso de transacciones ***************/
public static void mouvement1(String cuentaDebito,String cuentaCredito,double suma)

{
Connection cnx=null;
try
{
cnx=DriverManedadr.getConnection("jdbc:sqlserver://localhost;databaseName=banque;
user=sa;password=;");
cnx.setAutoCommit(false);
stm=cnx.prepareStatement("update cuentas set saldo=saldo + ?
where numero=?");
stm.setDouble(1,suma * -1);
stm.setString(2,cuentaDebito);
imprimirInforme(cuentaDebito, suma);
stm.setDouble(1,suma);
stm.setString(2,cuentaCredito);
imprimirInforme(cuentaCredito, suma);
cnx.commit();
}
catch (Exception e)
{
try {
cnx.rollback();
}
catch (SQLException e1)
{
e1.printStackTrace();
}
}
}

Paso argumentos funciones Java

Transféré par

Informations du document

Description originale:

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Paso argumentos funciones Java

Transféré par

Droits d'auteur :

Formats disponibles

/

/********* Paso de argumentos a una funci�n Java en tiempo de ejecuci�n ********/

/* Declaraci�n de la clase principal de la aplicaci�n */

/* Mostrar los argumentos de la l�nea de comandos */

for (int i = 0 ; i < args.length; i++)

System.out.printIn("Argumento " +i + " = " + args[i]) ;

/* Conversi�n de los dos argumentos de l�nea de comandos de String a int, se

/********* concatenaci�n de cadenas de caracteres ********/

public class TestString

/********* estructura de bucle ********/

public class Principal

listaProveedores =new String[10];

public class Principal

public class Principal

public class Principal

System.out.println("Enhorabuena, ha encontrado el resultado en " +

/********* Clase Persona con atributos y m�todos ********/

public class Persona

public long calculaEdad()

public void mensaje()

/************** funci�n mensaje sobrecargada **************/

/************** segunda funci�n mensaje sobrecargada ilegal **************/

public void mensaje(boolean mayuscula)

/*********** funci�n con un n�mero cualquiera de par�metros **************/

public void mensaje(String...colores)

public class Persona

public String getApellido()

public void setApellido(String n)

public String getNombre()

public void setNombre(String p)

/************* accesores con reglas de gesti�n ************/

public class Persona

public String getApellido()

public void setApellido(String n)

public String getNombre()

public void setNombre(String p)

/************** campos y m�todos est�ticos **************/

public void setApellido(String n)

public String getNombre()

public void setNombre(String p)

public static int getNumInstancias()

/************ acci�n del Garbage Collector ******************/

public void setApellido(String n)

public String getNombre()

public void setNombre(String p)

public static int getNumInstancias()

public class GestionMemoria

public static void main(String[] args) throws InterruptedException

for (int j=0;j<1000;j++)

public static void creacionTabla()

/************ sin usar this ni super *****************/

public void mensaje()

/************ usando this y super ***************/

public void mensaje()

/************* clase abstracta *****************/

public abstract class SerVivo

/************ Clonado ***************/

public class Solicitud implements Cloneable

public class LineasDeSolicitud implements Cloneable

/**************M�todo equals *****************/

public boolean equals(Object obj)

/************** getClass (informaci�n acerca de la clase) ***************/

/* Paso de argumentos a una funci�n Java en tiempo de ejecuci�n /

/* concatenaci�n de cadenas de caracteres /

/* estructura de bucle /

/* Clase Persona con atributos y m�todos /

/ funci�n mensaje sobrecargada /

/ segunda funci�n mensaje sobrecargada ilegal /

/* funci�n con un n�mero cualquiera de par�metros ****/

/* accesores con reglas de gesti�n /

/ campos y m�todos est�ticos /

/ acci�n del Garbage Collector ******/

/ sin usar this ni super *****/

/ usando this y super ***/

/* clase abstracta *****/

/ Clonado ***/

/M�todo equals ***/

/ getClass (informaci�n acerca de la clase) */

/* creaci�n de una interfaz **/

/* implementar una interfaz **/

/ Usar una interfaz */

/ test de l'interface */

/* clases anonimas ***/

/* clases an�nimas segunda version */

/* clase gen�rica **/

/ Uso de una clase gen�rica **/

/* m�todo gen�rico ***/

/*** Recuperaci�n de excepciones */

/* Recuperaci�n de excepciones con agrupaci�n **/

/ informaci�n acerca de una Exception **/

/** Clase de excepci�n personalizada */

/** ejemplo ArrayList */

/** ejemplo 1 HashSet */

/** ejemplo 2 HashSet */

/** ejemplo 3 HashSet */

System.out.println("* solo actores ***************");

/** ejemplo LinkedList */