TEMA 1 .......................................................................................................................

2
CLASE HOLAMUNDO .......................................................................................... 2
CLASE SUMA ......................................................................................................... 2
CLASE TEST (ejercicio resuelto n 1) ...................................................................... 3
CLASE INTERCAMBIO (ejercicio resuelto n 4)..................................................... 3
CLASE TEST (ejercicio resuelto n 6) ...................................................................... 3
CLASE TEST (ejercicio propuesto n 1) ................................................................... 4
CLASE TEST (ejercicio propuesto n 2) ................................................................... 4
CLASE TEST (ejercicio propuesto n 3) ................................................................... 4
TEMA 2 ....................................................................................................................... 4
CLASES PAJARO Y TEST (apartado 2.3) ............................................................... 4
CLASE PAJARO (apartado 2.6) ............................................................................... 5
CLASE PAJARO (apartado 2.7) ............................................................................... 6
CLASE TEMPERATURA (ejercicio resuelto 1) ....................................................... 6
CLASE PAJARO (ejercicio resuelto 4)..................................................................... 7
CLASE SATELITE (ejercicio resuelto 5).................................................................. 7
CLASE REBAJAS (ejercicio resuelto 6)................................................................... 7
TEMA 3 ....................................................................................................................... 8
CLASE TEST (apartado 3.4)..................................................................................... 8
CLASE LETRAS (ejercicio resuelto 5)..................................................................... 8
CLASE CUENTA (ejercicio resuelto 6).................................................................... 8
CLASE CUENTAINGLES (ejercicio resuelto 7) ...................................................... 9
TEMA 4 ....................................................................................................................... 9
CLASES DEL PAQUETE EDUCACION (apartado 4.1) .......................................... 9
CLASES RECTANGULO Y TESTEOCLONE (apartado 4.2.3)............................. 10
CLASE TEST (apartado 4.3.4)................................................................................ 10
CLASE TESTPARAM (apartado 4.4.1) .................................................................. 11
CLASE RECTANGULO (apartado 4.5.2)............................................................... 11
CLASE TEST (ejercicio resuelto 1a)....................................................................... 12
CLASE TEST (ejercicio resuelto 1b) ...................................................................... 12
CLASE TEST (ejercicio resuelto 2) ........................................................................ 13
CLASE PIRAMIDE (ejercicio resuelto 3)............................................................... 13
CLASE PIRAMIDE (ejercicio resuelto 4)............................................................... 13
CLASE TRANSFORMABASE (ejercicio resuelto 5) ............................................. 14
CLASE BEBE (ejercicio propuesto 9)..................................................................... 14
TEMA 5 ..................................................................................................................... 15
CLASE TEST (apartado 5.1.1)................................................................................ 15
CLASE FECHA (apartado 5.2) ............................................................................... 15
JERARQUIA CLASES (apartado 5.4) .................................................................... 16
JERARQUIA CLASES (apartado 5.5) .................................................................... 16
DIVERSAS CLASES (apartado 5.8)....................................................................... 17
TEMA 6 ..................................................................................................................... 18
CLASE EJEMPLOFLUJOS (apartado 6.2) ............................................................. 18
CLASE EJEMPLOLECTURAPORCONSOLA (Apartado 6.3) ............................. 19
CLASE ESCRITURAPORPANTALLA (Apartado 6.3).......................................... 19
CLASE EJEMPLOPUSHBACKREADER (Ejemplo seccin a fondo)................... 20
CLASE TESTFICHERO (Apartado 6.4.1.1) ........................................................... 20
CLASE TESTFICHERO (Apartado 6.4.1.2) ........................................................... 21
CLASE TESTFICHERO (Apartado 6.4.2) .............................................................. 22
CLASE TESTFICHERO (Apartado 6.4.3) .............................................................. 22

CLASE TESTFICHERO2 (Apartado 6.4.3) ............................................................ 23

DIVERSAS CLASES (Apartado 6.5)...................................................................... 24
CLASE HOLAMUNDOSWING (Apartado 6.6.1) .................................................. 26
CLASE SWINGTEST (Apartado 6.7)..................................................................... 26
CLASE SWINGTEST (Apartado 6.7)..................................................................... 27
CLASE SWINGCONVERSOR (Apartado 6.8)....................................................... 28
TEMA 7 ..................................................................................................................... 31
CLASE TEMPERATURAS (Apartado 7.1.5) ......................................................... 31
CLASE TEST (Apartado 7.4) ................................................................................. 31
CLASE DICCIONARIO (Seccin a fondo)............................................................. 32
TEMA 8 ..................................................................................................................... 33
Creando Tablas con JDBC (Apartado 8.4.1)............................................................ 33
Carga de datos en las tablas (Apartado 8.4.2) .......................................................... 34
TEMA 9 ..................................................................................................................... 34
CLASE ALUMNO (Apartado 9.5).......................................................................... 34
CLASE TESTSODA (Apartado 9.6.1) .................................................................... 35
CLASE PROYECTO (Apartado 9.7) ...................................................................... 36
FUNCION ALMACENARPROYECTOS (Apartado 9.7) ....................................... 37
CLASE TESTBORRADO (Apartado 9.7.3)............................................................ 38
CLASE PROFESOR (Apartado 9.8) ....................................................................... 39
CLASE TESTBORRADO (Apartado 9.8.1)............................................................ 41

TEMA 1
CLASE HOLAMUNDO
public class holamundo {
/* programa holamundo*/
public static void main(String[] args) {
/* lo nico que hace este programa es mostrar
la cadena "Hola Mundo" por pantalla*/
System.out.println("Hola Mundo");
}
}

CLASE SUMA
class suma
{
static int n1=50; // variable miembro de la clase
public static void main(String [] args)
{
int n2=30, suma=0; // variables locales
suma=n1+n2;

System.out.println("LA SUMA ES: " + suma);

}
}

CLASE TEST (ejercicio resuelto n 1)

class Test {
public static char getLetras(){
return (char)(Math.random()*26 + 'a');
}
public static void main(String[] args) {
System.out.println(getLetras());
System.out.println(getLetras());
System.out.println(getLetras());
System.out.println(getLetras());
}
}

CLASE INTERCAMBIO (ejercicio resuelto n 4)

class intercambio {
public static void main(String[] args) {
int a= 5, b= 8;
int tmp;
tmp=a;
a=b;
b=tmp;
System.out.println("El valor de a ahora es: "+a);
System.out.println("El valor de b ahora es: "+b);
}
}

CLASE TEST (ejercicio resuelto n 6)

public class Test {
public static void main(String[] args) {
int i=0x100;
i >>>= 1;
System.out.println(i);
}
}

CLASE TEST (ejercicio propuesto n 1)

class suma
{
static int n1=50;
public static void main(String [] args)
{
int n2=30, suma=0, n3;
suma=n1+n2;
System.out.println("LA SUMA ES: " + suma);
suma=suma+n3;
System.out.println(suma);
}
}

CLASE TEST (ejercicio propuesto n 2)

class suma
{
public static void main(String [] args)
{
int n1=50,n2=30,
boolean suma=0;
suma=n1+n2;
System.out.println("LA SUMA ES: " + suma);
}
}

CLASE TEST (ejercicio propuesto n 3)

class cuadrado
{
public static void main(String [] args)
{
int numero=2,
cuad=numero * nmero;
System.out.println("EL CUADRADO DE "+NUMERO+" ES: " + cuad);
}
}

TEMA 2
CLASES PAJARO Y TEST (apartado 2.3)
class pajaro

//*** atributos o propiedades ****

private char color; //propiedad o atributo color
private int edad; //propiedad o atributo edad
//*** mtodos de la clase ****
public void setedad(int e){edad = e;}
public void printedad(){System.out.println(edad);}
public void setcolor(char c){color=c;}
public void printcolor(){
switch(color){
//Los pjaros son verdes, amarillos, grises, negros o blancos
//No existen pjaros de otros colores
case 'v': System.out.println("verde");break;
case 'a': System.out.println("amarillo");break;
case 'g': System.out.println("gris");break;
case 'n': System.out.println("negro");break;
case 'b': System.out.println("blanco");break;
default: System.out.println("color no establecido");
}
}

}
class test
{
public static void main(String[] args) {
pajaro p;
p=new pajaro();
p.setedad(5);
p.printedad();
}
}

CLASE PAJARO (apartado 2.6)

class pajaro
{
//*** atributos o propiedades ****
private char color; //propiedad o atributo color
private int edad; //propiedad o atributo edad
//*** mtodos de la clase ****
pajaro(){color = 'v'; edad = 0;} //constructor de la clase pjaro
pajaro(char c, int e){color = c; edad = e;} // constructor de la clase pjaro
/* Aqu irn los dems mtodos de la clase */
public static void main(String[] args) { //mtodo main
pajaro p1,p2;
p1=new pajaro();
p2=new pajaro('a',3);
}
}

CLASE PAJARO (apartado 2.7)

class pajaro
{
//*** atributos o propiedades ****
private static int numpajaros=0;
private char color; //propiedad o atributo color
private int edad; //propiedad o atributo edad
//*** mtodos de la clase ****
static void nuevopajaro(){numpajaros++;};
pajaro(){color = 'v'; edad = 0; nuevopajaro();}
pajaro(char c, int e){color = c; edad = e; nuevopajaro();}
static void muestrapajaros(){System.out.println(numpajaros);};
public static void main(String[] args) {
pajaro p1,p2;
p1=new pajaro();
p2=new pajaro('a',3);
p1.muestrapajaros();
p2.muestrapajaros();
}
}

CLASE TEMPERATURA (ejercicio resuelto 1)

class Temperatura {
public static double celsiusToFarenheit(double temp)
{
return (1.8)*temp + 32;
}
public static double farenheitToCelsius(double temp)
{
return (temp - 32)/1.8;
}
public static void main(String[] args) {
System.out.println("0 grados Celsius son "+celsiusToFarenheit(0)+" Grados
Farenheit");
System.out.println("15 grados Celsius son "+celsiusToFarenheit(15)+" Grados
Farenheit");
System.out.println("20 grados Celsius son "+celsiusToFarenheit(20)+" Grados
Farenheit");
System.out.println("0 grados Farenheit son "+farenheitToCelsius(0)+" Grados
Celsius");
System.out.println("40 grados Farenheit son "+farenheitToCelsius(45)+" Grados
Celsius");
System.out.println("70 grados Farenheit son "+farenheitToCelsius(70)+" Grados
Celsius");
}
}

CLASE PAJARO (ejercicio resuelto 4)

class pajaro {
public void setEdad(int e){edad = e;}
public void printEdad(){System.out.println(edad);}
public void setcolor(char c){color=c;}
private char color;
private int edad;
}

CLASE SATELITE (ejercicio resuelto 5)

public class satelite {
private double meridiano;
private double paralelo;
private double distancia_tierra;
satelite (double m,double p,double d){
meridiano=m;
paralelo=p;
distancia_tierra=d;
}
satelite (){
meridiano=paralelo=distancia_tierra=0;
}
public void setPosicion(double m,double p,double d){
meridiano=m;
paralelo=p;
distancia_tierra=d;
}
public void printPosicion(){
System.out.println("El satlite se encuentra en el paralelo "+ paralelo+ "
Meridiano "+meridiano+" a una distancia de la tierra de "+distancia_tierra+"
Kilmetros");
}
}

CLASE REBAJAS (ejercicio resuelto 6)

public class rebajas {
public static double descubrePorcentaje(double original, double actual){
return(original-actual)*100/original;
}
public static void main(String[] args) {
System.out.println(descubrePorcentaje(100,79));
System.out.println(descubrePorcentaje(100,50));
}
}

TEMA 3
CLASE TEST (apartado 3.4)
class Test
{
public static void main(String [] args)
{
int a=10, b=0, c;
try{
c=a/b;
}
catch(ArithmeticException e){
System.out.println("Error: "+e.getMessage());
return;
}
System.out.println("Resultado:"+c);
}
}

CLASE LETRAS (ejercicio resuelto 5)

public class letras {
private char letra;
letras(char l){
letra = l;
if (l >= 'a'){
letra -= 'a';
letra += 'A';
}
}
public char getLetra(){return letra;}
public void printLetra(){
System.out.println(letra);
}
}

CLASE CUENTA (ejercicio resuelto 6)

public class cuenta {
public static void main(String[] args) {
for(int i = 200; i < 301; i++){
System.out.println(i);

}
}
}

CLASE CUENTAINGLES (ejercicio resuelto 7)

public class cuentaingles {
public static void main(String[] args) {
for(int i = 1; i < 11; i++) {
switch(i) {
case 1: System.out.println("one"); break;
case 2: System.out.println("two"); break;
case 3: System.out.println("three"); break;
case 4: System.out.println("four"); break;
case 5: System.out.println("five"); break;
case 6: System.out.println("six"); break;
case 7: System.out.println("seven"); break;
case 8: System.out.println("eight"); break;
case 9: System.out.println("nine"); break;
default: System.out.println("ten");
}
}
}
}

TEMA 4
CLASES DEL PAQUETE EDUCACION (apartado 4.1)
//** Inicio cdigo****
package Utilidades.educacion;
import java.io.*;
public class saludar{
public void saludo(){
System.out.println("Hola");
}
}
//** Fin cdigo****
//** Inicio cdigo****
package Utilidades.educacion;
import java.io.*;
public class despedirse{
public void despedida(){
System.out.println("Adios");
}

CLASES RECTANGULO Y TESTEOCLONE (apartado 4.2.3)

public class rectangulo implements Cloneable
{
private int ancho;
private int alto;
private String nombre;
public Object clone(){
Object objeto=null;
try{
objeto =super.clone();
}catch(CloneNotSupportedException ex){
System.out.println(" Error al duplicar");
}
return objeto;
}
........
}
class testeoclone {
public static void main(String[] args) {
rectangulo r1 = new rectangulo(5,7);
rectangulo r2 = (rectangulo) r1.clone();
r2.incrementarAncho();
r2.incrementarAlto();
r1.setNombre("Chiquito");
r2.setNombre("Grande");
System.out.println("Alto: "+r1.getAlto());
System.out.println("Ancho: "+r1.getAncho());
System.out.println("Alto: "+r2.getAlto());
System.out.println("Ancho: "+r2.getAncho());
System.out.println("Nombre: "+r1.getNombre());
System.out.println("Nombre: "+r2.getNombre());
}
}

CLASE TEST (apartado 4.3.4)

public class Test {
public int dato=0;
public static int datostatico=0;
public void metodo(){this.datostatico++;}
public static void metodostatico(){
this.datostatico++; // Esto da error al compilar
datostatico++;

}
public static void main(String[] args) {
dato++; // Esto da error al compilar
datostatico++;
metodostatico();
metodo(); // Esto da error al compilar
}
}

CLASE TESTPARAM (apartado 4.4.1)

public class testparam {
public static void cambiar(int x){
x++;
}
public static void cambiar2(int[] par){
par[0]++;
}
public static void main(String[] args) {
int x = 3;
int []arrx={3};
cambiar(x);
System.out.println(x);
cambiar2(arrx);
System.out.println(arrx[0]);
}
}

CLASE RECTANGULO (apartado 4.5.2)

public class rectangulo
{
private int ancho;
private int alto;
rectangulo(int an, int al){
this.ancho = an;
this.alto = al;
}
rectangulo(){ ancho=alto=0; }
rectangulo(int dato){ ancho=alto=dato; }
public int getAncho(){return this.ancho;}
public int getAlto(){return this.alto;}
public rectangulo incrementarAncho(){
ancho++;
return this;
}
public rectangulo incrementarAlto(){
this.alto++;

return this;
}
}

CLASE TEST (ejercicio resuelto 1a)

class Test {
public static int factorial(int num)
{
if (num == 0) return 1;
return num * factorial(num-1);
}
public static void main(String[] args) {
System.out.println("El factorial de 0 es : "+factorial(0));
System.out.println("El factorial de 1 es : "+factorial(1));
System.out.println("El factorial de 2 es : "+factorial(2));
System.out.println("El factorial de 3 es : "+factorial(3));
System.out.println("El factorial de 4 es : "+factorial(4));
System.out.println("El factorial de 5 es : "+factorial(5));
}
}

CLASE TEST (ejercicio resuelto 1b)

class Test {
public static int factorial(int num)
{
int factorial=1;
while(num>0){
factorial *= num;
num--;
}
return factorial;
}
public static void main(String[] args) {
System.out.println("El factorial de 0 es : "+factorial(0));
System.out.println("El factorial de 1 es : "+factorial(1));
System.out.println("El factorial de 2 es : "+factorial(2));
System.out.println("El factorial de 3 es : "+factorial(3));
System.out.println("El factorial de 4 es : "+factorial(4));
System.out.println("El factorial de 5 es : "+factorial(5));
}
}

CLASE TEST (ejercicio resuelto 2)

class Test {
public static int fibonacci(int num)
{
if (num == 0) return 0;
if (num == 1) return 1;
return fibonacci(num-1)+fibonacci(num-2);
}
public static void main(String[] args) {
for (int i=0;i<10;i++){
System.out.print(fibonacci(i)+", ");
}
}
}

CLASE PIRAMIDE (ejercicio resuelto 3)

class piramide {
public static int elemento(int fila, int columna){
if (columna == 1 ) return 1;
if (columna < 1 || columna > fila) return 0;
return elemento(fila-1,columna)+elemento(fila-1,columna-1);
}
public static void main(String[] args) {
int numfilas = 5;
for (int i=1; i<(numfilas+1) ; i++){
for (int e=0; e<(numfilas - i);e++)System.out.print(" ");
for (int j=1; j<(numfilas+1) ; j++){
int dato = elemento(i,j);
if (dato > 0 ) System.out.print(dato+" ");
}
System.out.println("");
}
}
}

CLASE PIRAMIDE (ejercicio resuelto 4)

class piramide {
public static int elemento(int fila, int columna){
if (fila < 1 || columna < 1 ) return 0;
if (columna == 1 ) return 1;
return elemento(fila-1,columna)+elemento(fila-1,columna-1)+elemento(fila1,columna-2);
}
public static void main(String[] args) {

int numfilas = 4;
for (int i=1; i<(numfilas+1) ; i++){
for (int e=0; e<(numfilas - i);e++)System.out.print(" ");
for (int j=1; j<(2*numfilas+1) ; j++){
int dato = elemento(i,j);
if (dato > 0 ) System.out.print(dato+" ");
}
System.out.println("");
}
}
}

CLASE TRANSFORMABASE (ejercicio resuelto 5)

class TransformaBase {
public static void muestraCifra(int dat) {
if (dat<10) {
System.out.print(dat);
} else {
dat-=10;
char c = (char)('A'+ dat);
System.out.print(c);
}
}
public static void transforma(int dato, int base) {
if (base > dato) {
muestraCifra(dato);
} else {
transforma(dato/base,base);
muestraCifra(dato%base);
}
}
public static void main(String[] args) {
transforma(8,2);
System.out.println("");
transforma(12,16);
System.out.println("");
transforma(13,8);
System.out.println("");
}
}

CLASE BEBE (ejercicio propuesto 9)

public class bebe {
bebe (int i) {
this("Soy un bebe consentido");

System.out.println("Hola, tengo " + i + " meses");

}
bebe (String s) {
System.out.println( s );
}
void berrea() {
System.out.println("Buaaaaaaaaaa");
}
public static void main(String[] args) {
new bebe (8).berrea();
}
}

TEMA 5
CLASE TEST (apartado 5.1.1)
class test {
public static void main(String[] args) {
Integer i1 = new Integer(5);
Integer i2 = new Integer("7");
String s1 = i1.toString();
System.out.println(s1);//muestra 5 por pantalla
int i3 = Integer.parseInt("10",10);
int i4 = Integer.parseInt("10",8);
int i5 = Integer.parseInt("BABA",16);
System.out.println(i3);//muestra 10 por pantalla
System.out.println(i4);//muestra 8 por pantalla
System.out.println(i5);//muestra 47.802 por pantalla
System.out.println(Integer.toOctalString(i4));//muestra 10 por pantalla
System.out.println(Integer.toHexString(i5));//muestra baba por pantalla
int i6 = Integer.valueOf("22").intValue();
System.out.println(i6);//muestra 22 por pantalla
}
}

CLASE FECHA (apartado 5.2)

import java.util.*;
class fecha {
public static void main(String[] args) {
Date d = new Date();
GregorianCalendar c = new GregorianCalendar();
c.setTime(d);
System.out.print(c.get(Calendar.DAY_OF_MONTH));

System.out.print("-");
System.out.print(c.get(Calendar.MONTH)+1);
System.out.print("-");
System.out.println(c.get(Calendar.YEAR));
}
}

JERARQUIA CLASES (apartado 5.4)

public class persona {
private String nombre;
public void setNombre(String nom){
nombre = nom;
}
public String getNombre(){
return nombre;
}
}
public class empleado extends persona{
protected int sueldoBase;
public int getSueldo(){ return sueldoBase; }
public void setSueldoBase(int s){ sueldoBase = s; }
}
public class encargado extends empleado{
public int getSueldo(){
Double d = new Double(sueldoBase*1.1);
return d.intValue();
}
}

JERARQUIA CLASES (apartado 5.5)

package sobreescribe;
public class Pajaro {
protected String nombre;
protected String color;
public String getDetalles(){
return "Nombre: " + nombre + "\n" + "Color: " + color;
}
}
package sobreescribe;
public class Loro extends Pajaro {
protected String pedigri;
public String getDetalles(){
return "Nombre: " + nombre + "\n" + "Color: " + color + "\n" + "Pedrigri: "+ pedigri;
}
}

DIVERSAS CLASES (apartado 5.8)

class padre{
protected int dato;
public void m(){
System.out.println("mtodo clase padre");
}
}
class hijo extends padre{
private int dato;
public void m(){
System.out.println("mtodo clase hijo");
super.dato = 10;
dato = 20;
}
public void getDato(){
System.out.println(super.dato);
}
public void mostrar(){
this.m();
m();
super.m();
}
}
class test {
public static void main(String[] args) {
hijo h = new hijo();
h.mostrar();
h.getDato();
}
}

class padre{
protected int dato1, dato2;
padre(int x,int y){dato1 = x; dato2 = y;}
padre(){
this(5,5);
}
}
class hijo extends padre{
private int dato1, dato2;
hijo(int x,int y){
super(2,2);

dato1 = x;
dato2 = y;
}
hijo(){
dato1 = 3;
dato2 = 3;
}
public void getDato(){
System.out.println("Padre dato1:" + super.dato1);
System.out.println("Padre dato2:" + super.dato2);
System.out.println("hijo dato1:" + this.dato1);
System.out.println("hijo dato2:" + this.dato2);
}
}
class test {
public static void main(String[] args) {
hijo h1 = new hijo(1,1);
h1.getDato();
hijo h2 = new hijo();
h2.getDato();
}
}

TEMA 6
CLASE EJEMPLOFLUJOS (apartado 6.2)
import java.io.*;
public class EjemploFlujos
{
public static void main(String[] args)
{
String s = new String("En un lugar de la mancha de cuyo nombre no quiero
acordarme, ");
s = s + "no ha mucho tiempo que viva un hidalgo de los de lanza en astillero, ";
s = s + "adarga antigua, rocn flaco y galgo corredor...";
char[] arr = new char[s.length()];
int car = 0;
StringReader flujoInput = new StringReader(s);
flujoOutput = new CharArrayWriter();
try
{
while ((car = flujoInput.read()) != -1){
flujoOutput.write(car);
}
arr = flujoOutput.toCharArray();

System.out.println(arr);
}
catch (IOException e) {
e.printStackTrace();
}
finally
{
flujoInput.close();
flujoOutput.close();
}
}
}

CLASE EJEMPLOLECTURAPORCONSOLA (Apartado 6.3)

import java.io.*;
public class EjemploLecturaPorConsola {
public static String leercadena(){
String cad="";
BufferedReader br;
br = new BufferedReader(new InputStreamReader(System.in));
try{
cad = br.readLine();
}catch (IOException e ) {
e.printStackTrace();
}
return cad;
}
public static void main(String args[]) throws IOException {
String cad;
System.out.println("Este programa hace eco hasta que escribas para");
do {
cad = leercadena();
System.out.println(cad);
} while(!cad.equals("para"));
}
}

CLASE ESCRITURAPORPANTALLA (Apartado 6.3)

public class EscrituraPorPantalla {
public static void main(String args[]) throws IOException {
PrintWriter pantalla = new PrintWriter(System.out);
char[] array = { 'M', 'o', 'r', 'e', 'n', 'o' };
String str = new String("Juan Carlos");
pantalla.write(str);
pantalla.print(" ");

pantalla.write(array, 0, 6);
pantalla.println("");
pantalla.flush();
}
}

CLASE EJEMPLOPUSHBACKREADER (Ejemplo seccin a

fondo)
import java.io.*;
class ejemploPushbackReader {
public static void main(String args[]) throws IOException {
String sentencias = "a=a+1;c++;b+=5;c=a+b;b++;";
StringReader sr = new StringReader(sentencias);
PushbackReader pbr = new PushbackReader(sr);
int ultimo=pbr.read(),penultimo=0;
while (ultimo != -1) {
switch(ultimo) {
case '+':
if ((ultimo = pbr.read()) == '+'){
System.out.print("="+(char) penultimo+"+1");
}else{
pbr.unread(ultimo);
System.out.print('+');
}
break;
case ';':
System.out.println((char)ultimo);
break;
default:
System.out.print((char) ultimo);
}
penultimo=ultimo;
ultimo = pbr.read();
}
}
}

CLASE TESTFICHERO (Apartado 6.4.1.1)

import java.io.*;
public class TestFichero{
public static void main(String[] args){
FileOutputStream f=null;
String s = "En un lugar de la mancha de cuyo nombre no quiero
acordarme...";

char c=0;
try{
f=new FileOutputStream("datos.txt");
for (int i=0; i<s.length();i++){
c=s.charAt(i);
f.write((byte)c);
}
}catch(IOException e){
e.printStackTrace();
}finally{
try{
f.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}

CLASE TESTFICHERO (Apartado 6.4.1.2)

import java.io.*;
public class TestFichero{
public static void main(String[] args){
FileInputStream f=null;
String s="";
char c;
try{
f=new FileInputStream("datos.txt");
int size = f.available();
for (int i=0;i<size;i++){
c=(char)f.read();
s=s+c;
}
}catch(IOException e){
e.printStackTrace();
}finally{
System.out.println(s);
try{
f.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}

CLASE TESTFICHERO (Apartado 6.4.2)

import java.io.File;
public class TestFichero{
public static void main(String[] args){
File dir = new File("/home/jcmoreno/programacion");
if (dir.exists()) {
System.out.println("Existe el directorio "+dir.getName());
}else{
System.out.println("El directorio no existe");
}
if (dir.canRead())
System.out.println("El directorio existe y tiene permiso de lectura");
if (dir.canWrite())
System.out.println("El directorio existe y tiene permiso de escritura");
File[] ficheros = dir.listFiles();
for (File f : ficheros)
System.out.println(f.getName());
}
}

CLASE TESTFICHERO (Apartado 6.4.3)

import java.io.*;
public class TestFichero{
public static void main(String[] args){
String []amigos={"Andrs Rosique","Pedro Ruiz","Isaac Sanchez","Juan
Serrano"};
File fs = new File("amigos.txt");
try{
FileWriter fw = new FileWriter(fs);
for (String s : amigos){
fw.write(s,0,s.length());
fw.write("\r\n");
}
if (fw != null) fw.close();
}catch(IOException e){
e.printStackTrace();
}
File fe = new File("amigos.txt");
if (fe.exists()){
try{
FileReader fr = new FileReader(fe);
BufferedReader br = new BufferedReader(fr);
String s;

while((s = br.readLine()) != null) {

System.out.println(s);
}
if (fr != null) fr.close();
}catch(IOException e){
e.printStackTrace();
}
}
}
}

CLASE TESTFICHERO2 (Apartado 6.4.3)

import java.io.*;
public class TestFichero2{
public static void main(String[] args){
String []amigos={"Andrs Rosique","Pedro Ruiz","Isaac Sanchez","Juan
Serrano"};
long []telefonos={653364787,627463746,644567346,623746348};
//escritura del fichero
try{
FileOutputStream fs = new FileOutputStream("amigos.txt");
DataOutputStream d = new DataOutputStream(fs);
for (int i=0;i<4;i++){
d.writeUTF(amigos[i]);
d.writeLong(telefonos[i]);
}
if (d != null){
d.close();
fs.close();
}
}catch(IOException e){
e.printStackTrace();
}
//lectura del fichero
try{
File f=null;
FileInputStream fe = null;
DataInputStream d = null;
try{
f = new File("amigos.txt");
if (f.exists()){
fe = new FileInputStream(f);
d = new DataInputStream(fe);
String s;
Long l;
while(true){
s = d.readUTF();
System.out.print(s+" -> ");

l = d.readLong();
System.out.println(l);
}
}
}catch (EOFException eof) {
System.out.println(" --------------------------");
}catch (FileNotFoundException fnf) {
System.err.println("Fichero no encontrado " + fnf);
}catch(IOException e){
System.err.println("Se ha producido una IOException");
e.printStackTrace();
}catch (Throwable e) {
System.err.println("Error de programa: " + e);
e.printStackTrace();
}finally{
if (d != null) {
d.close();
fe.close();
}
}
}catch(IOException e){
e.printStackTrace();
}
}
}

DIVERSAS CLASES (Apartado 6.5)

public class amigo implements java.io.Serializable{
protected String nombre;
protected long telefono;
public amigo(String n, long t){
nombre = n;
telefono = t;
}
public void print(){
System.out.println(nombre + " -> " + telefono);
}
}
import java.io.*;
public class TestFichero3{
public static void main(String[] args){
String []amigos={"Andrs Rosique","Pedro Ruiz","Isaac Sanchez","Juan
Serrano"};
long []telefonos={653364787,627463746,644567346,623746348};
//escritura del fichero
try{
FileOutputStream fs = new FileOutputStream("amigos.txt");

ObjectOutputStream oos = new ObjectOutputStream(fs);

for (int i=0;i<4;i++){
amigo a = new amigo(amigos[i],telefonos[i]);
oos.writeObject(a);
}
if (oos != null){
oos.close();
fs.close();
}
}catch(IOException e){
e.printStackTrace();
}
//lectura del fichero
try{
File f=null;
FileInputStream fe = null;
ObjectInputStream ois = null;
try{
f = new File("amigos.txt");
if (f.exists()){
fe = new FileInputStream(f);
ois = new ObjectInputStream(fe);
while(true){
amigo a = null;
a = (amigo)ois.readObject();
a.print();
System.out.println("");
}
}
}catch (EOFException eof) {
System.out.println(" --------------------------");
}catch (FileNotFoundException fnf) {
System.err.println("Fichero no encontrado " + fnf);
}catch(IOException e){
System.err.println("Se ha producido una IOException");
e.printStackTrace();
}catch (Throwable e) {
System.err.println("Error de programa: " + e);
e.printStackTrace();
}finally{
if (ois != null) {
ois.close();
fe.close();
}
}
}catch(IOException e){
e.printStackTrace();
}
}
}

CLASE HOLAMUNDOSWING (Apartado 6.6.1)

import javax.swing.*;
public class holamundoswing{
public static void main(String[] args) {
JFrame frame = new JFrame("Ventana Hola Mundo");
frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
JLabel label= new JLabel("Hola Mundo");
frame.getContentPane().add(label);
frame.pack();
frame.setLocationRelativeTo(null);
frame.setVisible(true);
}
}

CLASE SWINGTEST (Apartado 6.7)

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class SwingTest {
private static JLabel label = new JLabel("--");
private static JButton btnlimpia = new JButton("Limpia");
private static JButton btnescribe = new JButton("Escribe");
public static void acciones(ActionEvent e) {
Object obj=e.getSource();
if (obj == btnlimpia){
label.setText("");
}
if (obj == btnescribe){
label.setText("Hola Mundo");
}
}
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(
UIManager.getCrossPlatformLookAndFeelClassName());
} catch (Exception e) { }
JFrame frame = new JFrame("Controlando eventos");
btnlimpia.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
acciones(e);
}
});
btnescribe.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

acciones(e);
}
});
frame.getContentPane().add(label);
frame.getContentPane().add(btnlimpia);
frame.getContentPane().add(btnescribe);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.setLayout(new GridLayout(0,1));
frame.pack();
frame.setVisible(true);
}
}

CLASE SWINGTEST (Apartado 6.7)

import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
public class SwingTest {
private static JLabel label = new JLabel("--");
private static JButton btnlimpia = new JButton("Limpia");
private static JButton btnescribe = new JButton("Escribe");
public static void acciones(ActionEvent e) {
Object obj=e.getSource();
if (obj == btnlimpia){
label.setText("");
}
if (obj == btnescribe){
label.setText("Hola Mundo");
}
}
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(
UIManager.getCrossPlatformLookAndFeelClassName());
} catch (Exception e) { }
JFrame frame = new JFrame("Controlando eventos");
btnlimpia.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
acciones(e);
}
});
btnescribe.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {

acciones(e);
}
});
frame.getContentPane().add(label);
frame.getContentPane().add(btnlimpia);
frame.getContentPane().add(btnescribe);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
frame.setLayout(new GridLayout(0,1));
frame.pack();
frame.setVisible(true);
}
}

CLASE SWINGCONVERSOR (Apartado 6.8)

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
import javax.swing.event.*;
public class SwingConversor {
static final int MIN = 0;
static final int MAX = 1000;
static final int INIT = 0;
private static JLabel label = new JLabel("1 Euro son en dolares:");
private static JLabel lbleuros = new JLabel("Euros:");
private static JLabel lbldolares = new JLabel("Dolares:");
private static JFrame frame = new JFrame("Conversor Euros - Dolares");
private static JPanel panel1 = new JPanel();
private static JPanel panel2 = new JPanel();
private static JPanel panel3 = new JPanel();
private static JTextField txteuro = new JTextField("0");
private static JTextField txtdolar = new JTextField("0");
private static JTextField txtcambio = new JTextField("1.36");
private static JSlider sliderdolar = new
JSlider(JSlider.HORIZONTAL,MIN,MAX,INIT);
private static JSlider slidereuro = new
JSlider(JSlider.HORIZONTAL,MIN,MAX,INIT);
public static void cambiotexto(ActionEvent e) {
if ( e.getSource() == txteuro ){
float icambio=Float.parseFloat(txteuro.getText());
icambio=100*icambio*Float.parseFloat(txtcambio.getText());
icambio = Math.round(icambio);
icambio = icambio/100;

txtdolar.setText(String.valueOf(icambio));
//cambiar los slider
sliderdolar.setValue(Math.round(Float.parseFloat(txtdolar.getText())));
slidereuro.setValue(Math.round(Float.parseFloat(txteuro.getText())));
}
if ( e.getSource() == txtdolar ){
System.out.println("dentro");
float icambio=Float.parseFloat(txtdolar.getText());
icambio=100*icambio/Float.parseFloat(txtcambio.getText());
icambio = Math.round(icambio);
icambio = icambio/100;
txteuro.setText(String.valueOf(icambio));
}
}
public static void mueveSlider(ChangeEvent e) {
int valor;
JSlider obj=(JSlider)e.getSource();
System.out.println(obj.getValueIsAdjusting());
System.out.println(obj.getValue());
if (!obj.getValueIsAdjusting()) {
System.out.println(obj.getValue());
valor = (int)obj.getValue();
if (obj == sliderdolar){
txtdolar.setText(String.valueOf(valor));
float
icambio=100*valor/Float.parseFloat(txtcambio.getText());
icambio=Math.round(icambio);
icambio=icambio/100;
//cambiar el txteuro
txteuro.setText(String.valueOf(icambio));
//cambiar el slidereuro
int i = Math.round(icambio);
slidereuro.setValue(i);
}
if (obj == slidereuro){
txteuro.setText(String.valueOf(valor));
float
icambio=100*valor*Float.parseFloat(txtcambio.getText());
icambio=Math.round(icambio);
icambio=icambio/100;
//cambiar el txtdolar
txtdolar.setText(String.valueOf(icambio));
//cambiar el sliderdolar
int i = Math.round(icambio);
slidereuro.setValue(i);
}
}
}
public static void colocaelementos(){

frame.getContentPane().add(panel1);
frame.getContentPane().add(panel2);
frame.getContentPane().add(panel3);
slidereuro.setBorder(BorderFactory.createTitledBorder("Euros"));
slidereuro.setMajorTickSpacing(200);
slidereuro.setMinorTickSpacing(100);
slidereuro.setPaintTicks(true);
slidereuro.setPaintLabels(true);
slidereuro.disable();
sliderdolar.setBorder(BorderFactory.createTitledBorder("Dolares"));
sliderdolar.setMajorTickSpacing(200);
sliderdolar.setMinorTickSpacing(100);
sliderdolar.setPaintTicks(true);
sliderdolar.setPaintLabels(true);
sliderdolar.disable();
panel1.add(lbleuros);
panel1.add(txteuro);
panel1.add(slidereuro);
panel2.add(label);
panel2.add(txtcambio);
panel3.add(lbldolares);
panel3.add(txtdolar);
panel3.add(sliderdolar);
frame.addWindowListener(new WindowAdapter() {
public void windowClosing(WindowEvent e) {
System.exit(0);
}
});
txteuro.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
cambiotexto(e);
}
});
txtdolar.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
cambiotexto(e);
}
});
frame.setLayout(new FlowLayout());
panel1.setLayout(new GridLayout(0,1));
panel2.setLayout(new GridLayout(0,1));
panel3.setLayout(new GridLayout(0,1));
frame.pack();
frame.setVisible(true);

}
public static void main(String[] args) {
try {
UIManager.setLookAndFeel(
UIManager.getCrossPlatformLookAndFeelClassName());
} catch (Exception e) { }
colocaelementos();
}
}

TEMA 7
CLASE TEMPERATURAS (Apartado 7.1.5)
public class temperaturas {
private static int[] temperaturas1;
final static int POS=10; //nmero de posiciones del array
public static void main(String[] args) {
int dato=0;
int media=0;
temperaturas1 = new int[POS];
for (int i=0;i<POS;i++){ //leer los valores de temperatura
try{
System.out.println("Introduzca Temperatura:");
String sdato = System.console().readLine();
dato = Integer.parseInt(sdato);
}catch(Exception e){
System.out.println("Error en la introduccin de datos");
}
temperaturas1[i]=dato;
}
for (int i=0;i<POS;i++){//hacer la media
media = media + temperaturas1[i];
}
media = media / POS;
System.out.println("La media de temperaturas es "+media);
}
}

CLASE TEST (Apartado 7.4)

public class test {
private static String[] lista;
final static int POS=10; //nmero de posiciones del array
public static void muestra(){

for (int i=0;i<POS;i++)

System.out.print(lista[i]+" ");
}
public static void main(String[] args) {
lista = new String[POS];
for (int i=0;i<POS;i++){
String ln = System.console().readLine();
lista[i]=ln.toString();
}
System.out.println("");
muestra();
System.out.println("");
}
}

CLASE DICCIONARIO (Seccin a fondo)

import java.util.*;
public class diccionario {
public static void main(String[] args) {
Hashtable dic = new Hashtable();
dic.put("HOLA","HELLO");
dic.put("ADIOS", "BYE");
dic.put("MESA","TABLE");
dic.put("SILLA","CHAIR");
dic.put("CABEZA","HEAD");
dic.put("CARA","FACE");
String saludo = (String) dic.get("HOLA");
String despedida = (String) dic.get("ADIOS");
String brazo = (String) dic.get("BRAZO");
System.out.println("HOLA : " + saludo);//muestra HELLO por pantalla
System.out.println("ADIOS : " + despedida);//muestra BYE por pantalla
System.out.println("BRAZO : " + brazo); //muestra null por pantalla
System.out.println("dic contiene " + dic.size() + " pares.");
if( dic.containsKey("HOLA") ){
System.out.println("dic contiene HOLA como clave");
}else{
System.out.println("dic NO contiene HOLA como clave");
}
if( dic.contains("HELLO") ){
System.out.println("dic contiene HELLO como valor");
}else{

System.out.println("dic NO contiene HELLO como valor");

}
System.out.println("Mostrando todos los datos de la tabla hash...");
Enumeration k = dic.keys();
while( k.hasMoreElements() ) System.out.println( k.nextElement() );
System.out.println("Mostrando todos los elementos de la tabla hash...");
Enumeration e = dic.elements();
while( e.hasMoreElements() ) System.out.println( e.nextElement() );
System.out.println( "Eliminando el dato " + dic.remove("HOLA"));
}
}

TEMA 8
Creando Tablas con JDBC (Apartado 8.4.1)
public static void createEQUIPO(Connection con, String BDNombre) throws SQLException {
String createString = "create table " + BDNombre + ".EQUIPO " +
"(TEAM_ID integer NOT NULL," +
"EQ_NOMBRE varchar(40) NOT NULL," +
"ESTADIO varchar(40) NOT NULL," +
"POBLACION varchar(20) NOT NULL," +
"PROVINCIA varchar(20) NOT NULL," +
"COD_POSTAL char(5)," +
"PRIMARY KEY (TEAM_ID))";
Statement stmt = null;
try {
stmt = con.createStatement();
stmt.executeUpdate(createString);
} catch (SQLException e) {
printSQLException(e);
} finally {
stmt.close();
}
}
public static void createJUGADORES(Connection con, String BDNombre) throws SQLException
{
String createString = "create table " + BDNombre + ".JUGADORES" +
"(PLAYER_ID integer NOT NULL," +
"TEAM_ID integer NOT NULL," +
"NOMBRE varchar(40) NOT NULL," +
"DORSAL integer NOT NULL," +
"EDAD integer NOT NULL," +
"PRIMARY KEY (PLAYER_ID)," +
"FOREIGN KEY (TEAM_ID) REFERENCES EQUIPO (TEAM_ID))";
Statement stmt = null;
try {
stmt = con.createStatement();
stmt.executeUpdate(createString);
} catch (SQLException e) {
printSQLException(e);
} finally {
stmt.close();
}
}

Carga de datos en las tablas (Apartado 8.4.2)

public static void cargaEQUIPO(Connection con, String BDNombre) throws SQLException {
Statement stmt = null;
try {
stmt = con.createStatement();
stmt.executeUpdate("INSERT INTO " + BDNombre + ".EQUIPO VALUES ("
+"1,'ESTEPONA','MONTERROSO','ESTEPONA','MALAGA','29680')");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".EQUIPO VALUES ("
+"2,'ALCORCON','SANTO DOMINGO','ALCORCON','MADRID','28924')");

stmt.executeUpdate("INSERT INTO " + BDNombre + ".EQUIPO VALUES ("

+"3,'PORCUNA','SAN CRISTOBAL','PORCUNA','JAEN','23790')");
} catch (SQLException e) {
printSQLException(e);
} finally {
stmt.close();
}
}
public static void cargaJUGADORES(Connection con, String BDNombre) throws SQLException {
Statement stmt = null;
try {
stmt = con.createStatement();
//Cargando datos de Estepona
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"1,1,'JOSE ANTONIO',1,42)");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"2,1,'IGNACIO',2,62)");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"3,1,'DIEGO',3,20)");
//Cargando datos de Alcorcn
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"4,2,'TURRION',1,37)");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"5,2,'LUIS ABEL',2,37)");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"6,2,'ISAAC',3,40)");
//Cargando datos de Porcuna
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"7,3,'JUAN FRANCISCO',1,33)");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"8,3,'PARRA',2,37)");
stmt.executeUpdate("INSERT INTO " + BDNombre + ".JUGADORES VALUES ("
+"9,3,'RAUL',3,19)");
} catch (SQLException e) {
printSQLException(e);
} finally {
stmt.close();
}
}

TEMA 9
CLASE ALUMNO (Apartado 9.5)
public class alumno{
private String nombre;
private int edad;
private double nota;

public alumno(){
this.nombre = null;
edad = 0;
nota = 0;
}
public alumno(String n,int e) {
this.nombre = n;
this.edad = e;
this.nota = -1; //nota no establecida
}
public alumno(String nom,int e, double not) {
this.nombre = nom;
this.edad = e;
this.nota = not;
}
public void setNombre(String n) {
this.nombre = n;
}
public String getNombre() {
return this.nombre;
}
public void setNota(double n) {
this.nota=n;
}
public double getNota() {
return this.nota;
}
public void setEdad(int e) {
this.edad=e;
}
public int getEdad() {
return this.edad;
}
public String toString() {
if (this.nota != -1)
return this.nombre+"("+this.edad+") Nota:"+this.nota;
return this.nombre+"("+this.edad+")";
}
}

CLASE TESTSODA (Apartado 9.6.1)

import java.io.*;
import com.db4o.*;
import com.db4o.query.*;
public class testSODA {
public static void main(String[] args) {

new File("alumnos.db4o").delete();
ObjectContainer bd = Db4oEmbedded.openFile(Db4oEmbedded
.newConfiguration(), "alumnos.db4o");
try {
almacenarAlumnos(bd);
consultaSODA(bd);
} catch(Exception e){
e.printStackTrace();
}finally {
bd.close();
}
}
public static void mostrarResultado(ObjectSet res){
System.out.println("Recuperados "+res.size()+" Objetos");
while(res.hasNext()) {
System.out.println(res.next());
}
}
public static void almacenarAlumnos(ObjectContainer bd) {
alumno a1 = new alumno("Juan Gmez",23,8.75);
bd.store(a1);
System.out.println(a1.getNombre()+" Almacenado");
alumno a2 = new alumno("Emilio Anaya",24,6.25);
bd.store(a2);
System.out.println(a2.getNombre()+" Almacenado");
alumno a3 = new alumno("Angeles Blanco",26,7);
bd.store(a3);
System.out.println(a3.getNombre()+" Almacenado");
}
public static void consultaSODA(ObjectContainer bd) {
Query query=bd.query();
query.constrain(alumno.class);
Constraint constr=query.descend("nota").constrain(7).smaller();
query.descend("edad").constrain(25).greater().or(constr);
ObjectSet result=query.execute();
mostrarResultado(result);
}
}

CLASE PROYECTO (Apartado 9.7)

public class proyecto{
private String descripcion;
private alumno al;
public proyecto(String descripcion) {

this.descripcion=descripcion;
this.al=null;
}
public alumno getAlumno() {
return al;
}
public void setAlumno(alumno a) {
this.al = a;
}
public String getDescripcion() {
return descripcion;
}
public String toString(){
return descripcion + "-> "+ al;
}
}

FUNCION ALMACENARPROYECTOS (Apartado 9.7)

public static void almacenarProyectos(ObjectContainer bd) {
proyecto p1 = new proyecto("Robot con microcontroladores");
alumno a1 = new alumno("Juan Gmez",23,8.75);
p1.setAlumno(a1);
bd.store(p1);
System.out.println(p1.toString()+" Almacenado");
proyecto p2 = new proyecto("Webmin sobre Ubuntu");
alumno a2 = new alumno("Emilio Anaya",24,6.25);
p2.setAlumno(a2);
bd.store(p2);
System.out.println(p2.toString()+" Almacenado");
proyecto p3 = new proyecto("Joomla y Drupal");
alumno a3 = new alumno("Angeles Blanco",26,7);
p3.setAlumno(a3);
bd.store(p3);
System.out.println(p3.toString()+" Almacenado");
proyecto p4 = new proyecto("Doctor Profiler");
alumno a4 = new alumno("Luis Alberto Garca",29,9.5);
p4.setAlumno(a4);
bd.store(p4);
System.out.println(p4.toString()+" Almacenado");
}

CLASE TESTBORRADO (Apartado 9.7.3)

import java.io.*;
import com.db4o.*;
import com.db4o.query.*;
public class TestBorrado {
public static void main(String[] args) {
new File("alumnos.db4o").delete();
ObjectContainer bd = Db4oEmbedded.openFile(Db4oEmbedded
.newConfiguration(), "alumnos.db4o");
try {
almacenarProyectos(bd);
borraPorDescripcion(bd);
mostrarTodosProyectos(bd);
mostrarTodosAlumnos(bd);
} catch(Exception e){
e.printStackTrace();
}finally {
bd.close();
}
}
public static void mostrarResultado(ObjectSet res){
System.out.println("Recuperados "+res.size()+" Objetos");
while(res.hasNext()) {
System.out.println(res.next());
}
}
public static void almacenarProyectos(ObjectContainer bd) {
proyecto p1 = new proyecto("Robot con microcontroladores");
alumno a1 = new alumno("Juan Gmez",23,8.75);
p1.setAlumno(a1);
bd.store(p1);
System.out.println(p1.toString()+" Almacenado");
proyecto p2 = new proyecto("Webmin sobre Ubuntu");
alumno a2 = new alumno("Emilio Anaya",24,6.25);
p2.setAlumno(a2);
bd.store(p2);
System.out.println(p2.toString()+" Almacenado");
proyecto p3 = new proyecto("Joomla y Drupal");
alumno a3 = new alumno("Angeles Blanco",26,7);
p3.setAlumno(a3);
bd.store(p3);
System.out.println(p3.toString()+" Almacenado");
proyecto p4 = new proyecto("Doctor Profiler");

alumno a4 = new alumno("Luis Alberto Garca",29,9.5);

p4.setAlumno(a4);
bd.store(p4);
System.out.println(p4.toString()+" Almacenado");
}
public static void mostrarTodosAlumnos(ObjectContainer bd) {
Query query=bd.query();
query.constrain(alumno.class);
ObjectSet result=query.execute();
mostrarResultado(result);
}
public static void mostrarTodosProyectos(ObjectContainer bd) {
Query query=bd.query();
query.constrain(proyecto.class);
ObjectSet result=query.execute();
mostrarResultado(result);
}
public static void borraPorDescripcion(ObjectContainer bd) {
Query query=bd.query();
query.constrain(proyecto.class);
query.descend("descripcion").constrain("Doctor Profiler");
ObjectSet result=query.execute();
while(result.hasNext()) {
proyecto p= (proyecto)result.next();
System.out.println("Borrado: "+p);
bd.delete(p);
}
}
}

CLASE PROFESOR (Apartado 9.8)

import java.io.*;
import com.db4o.*;
import com.db4o.query.*;
public class TestBorrado {
public static void main(String[] args) {
new File("alumnos.db4o").delete();
ObjectContainer bd = Db4oEmbedded.openFile(Db4oEmbedded
.newConfiguration(), "alumnos.db4o");
try {
almacenarProyectos(bd);
borraPorDescripcion(bd);

mostrarTodosProyectos(bd);
mostrarTodosAlumnos(bd);
} catch(Exception e){
e.printStackTrace();
}finally {
bd.close();
}
}
public static void mostrarResultado(ObjectSet res){
System.out.println("Recuperados "+res.size()+" Objetos");
while(res.hasNext()) {
System.out.println(res.next());
}
}
public static void almacenarProyectos(ObjectContainer bd) {
proyecto p1 = new proyecto("Robot con microcontroladores");
alumno a1 = new alumno("Juan Gmez",23,8.75);
p1.setAlumno(a1);
bd.store(p1);
System.out.println(p1.toString()+" Almacenado");
proyecto p2 = new proyecto("Webmin sobre Ubuntu");
alumno a2 = new alumno("Emilio Anaya",24,6.25);
p2.setAlumno(a2);
bd.store(p2);
System.out.println(p2.toString()+" Almacenado");
proyecto p3 = new proyecto("Joomla y Drupal");
alumno a3 = new alumno("Angeles Blanco",26,7);
p3.setAlumno(a3);
bd.store(p3);
System.out.println(p3.toString()+" Almacenado");
proyecto p4 = new proyecto("Doctor Profiler");
alumno a4 = new alumno("Luis Alberto Garca",29,9.5);
p4.setAlumno(a4);
bd.store(p4);
System.out.println(p4.toString()+" Almacenado");
}
public static void mostrarTodosAlumnos(ObjectContainer bd) {
Query query=bd.query();
query.constrain(alumno.class);
ObjectSet result=query.execute();
mostrarResultado(result);
}
public static void mostrarTodosProyectos(ObjectContainer bd) {
Query query=bd.query();

query.constrain(proyecto.class);
ObjectSet result=query.execute();
mostrarResultado(result);
}
public static void borraPorDescripcion(ObjectContainer bd) {
Query query=bd.query();
query.constrain(proyecto.class);
query.descend("descripcion").constrain("Doctor Profiler");
ObjectSet result=query.execute();
while(result.hasNext()) {
proyecto p= (proyecto)result.next();
System.out.println("Borrado: "+p);
bd.delete(p);
}
}
}

CLASE TESTBORRADO (Apartado 9.8.1)

import java.io.*;
import com.db4o.*;
import com.db4o.query.*;
public class TestBorrado {
public static void main(String[] args) {
new File("alumnos.db4o").delete();
ObjectContainer bd = Db4oEmbedded.openFile(Db4oEmbedded
.newConfiguration(), "alumnos.db4o");
try {
almacenarProyectos(bd);
borraPorDescripcion(bd);
mostrarTodosProyectos(bd);
mostrarTodosAlumnos(bd);
} catch(Exception e){
e.printStackTrace();
}finally {
bd.close();
}
}
public static void mostrarResultado(ObjectSet res){
System.out.println("Recuperados "+res.size()+" Objetos");
while(res.hasNext()) {
System.out.println(res.next());
}
}

public static void almacenarProyectos(ObjectContainer bd) {

proyecto p1 = new proyecto("Robot con microcontroladores");
alumno a1 = new alumno("Juan Gmez",23,8.75);
p1.setAlumno(a1);
bd.store(p1);
System.out.println(p1.toString()+" Almacenado");
proyecto p2 = new proyecto("Webmin sobre Ubuntu");
alumno a2 = new alumno("Emilio Anaya",24,6.25);
p2.setAlumno(a2);
bd.store(p2);
System.out.println(p2.toString()+" Almacenado");
proyecto p3 = new proyecto("Joomla y Drupal");
alumno a3 = new alumno("Angeles Blanco",26,7);
p3.setAlumno(a3);
bd.store(p3);
System.out.println(p3.toString()+" Almacenado");
proyecto p4 = new proyecto("Doctor Profiler");
alumno a4 = new alumno("Luis Alberto Garca",29,9.5);
p4.setAlumno(a4);
bd.store(p4);
System.out.println(p4.toString()+" Almacenado");
}
public static void mostrarTodosAlumnos(ObjectContainer bd) {
Query query=bd.query();
query.constrain(alumno.class);
ObjectSet result=query.execute();
mostrarResultado(result);
}
public static void mostrarTodosProyectos(ObjectContainer bd) {
Query query=bd.query();
query.constrain(proyecto.class);
ObjectSet result=query.execute();
mostrarResultado(result);
}
public static void borraPorDescripcion(ObjectContainer bd) {
Query query=bd.query();
query.constrain(proyecto.class);
query.descend("descripcion").constrain("Doctor Profiler");
ObjectSet result=query.execute();
while(result.hasNext()) {
proyecto p= (proyecto)result.next();
System.out.println("Borrado: "+p);
bd.delete(p);
}