ORIENTACION PAF UF4: Hi haurà un tipus test que preguntarà sobre conceptes de la POO. Static, abstract, constructors, herència, polimorfisme, modificadors d'accés, etc. Les preguntes seran de veritat/fals i test, i s'assemblaran a les que es van anar plantejar al fòrum al llarg d'aquesta UF. Alguna pregunta d'entendre què fa un codi, o de detectar i arreglar els errors en un codi. UF5: Cal entendre i saber utilitzar les llistes, els conjunts i els diccionaris (List, Set i Map). Cal entendre el mecanisme de les excepcions i saber utilitzar-les: try, catch, throw i throws. Cal saber crear una interfície gràfica senzilla. Cal entendre el mecanisme dels layouts i com combinar-los utilitzant JPanel. Els layouts són els bàsics: FlowLayout, BorderLayout, GridLayout i BoxLayout. Els controls també són els bàsics: botons, etiquetes i quadres de text. Cal entendre i saber utilitzar el mecanisme d'esdeveniments i listeners: fer que una classe sigui listener, afegir listeners, respondre esdeveniments. Només els tipus de listeners més comuns. Cal saber llegir i escriure fitxers de text i binaris. UF6: UML: traducció d'un diagrama de BD a un diagrama de classes UML. Només casos senzills. BD relacionals: consultes SQL senzilles, Statement i PreparedStatement, recuperar dades de la BD. BD no relacionals: guardar i recuperar objectes utilitzant db4o.

_____________________________________________________________________

UF4:

RESUMEN DE CLASES EN JAVA

Clases

public class Persona { // Atributos protected String dni; protected String nombre; protected String apellido; protected short edad; //Constructores /** * Constructor por defecto */ public Persona(){ } /**

* Constructor implementado */ public Persona(String dni, String nombre, String apellido, short edad){ this.dni= dni; this.nombre = nombre; this.apellido = apellido; this.edad = edad; } /** * Método */

// Retorna: 0 si s'ha pogut canviar l'edat // 1 : Error per passar una edat negativa // 2 : Error per passar una edat "enorme" int setEdat(int novaEdat) { if (novaEdat<0) return 1; if (novaEdat>Short.MAX_VALUE) return 2; edad = (short)novaEdat; return 0; }

/** * Setters y Geters */

public void setDni(String dni) { this.dni = dni; }

public void setNombre(String nombre) { this.nombre = nombre; }

public void setApellido(String apellido) { this.apellido = apellido; }

public void setEdad(short edad) { this.edad = edad; }

public String getDni() { return dni; }

public String getNombre() { return nombre; }

public String getApellido() { return apellido; }

public short getEdad() { return edad; } /** * Implementación del toString */ public String toString (){ StringBuffer st = new StringBuffer(); st.append("\n\tDni: " + this.dni); st.append("\n\tNombre: " + this.nombre); st.append("\n\tApellido: " + this.apellido); st.append("\n\tEdad: " + this.edad); return ( st.toString() ); }

Interface

public interface Sobornable { void sobreB(double cantidad);}

Clase que extiende de otra clase (Persona)

//obtiene las características propias y hereda las de su padrepublic class Empleado extends Persona { //Atributos /** * Salario del empleado */ protected double salario; //Constructores /** * Constructor por defecto */ public Empleado(){

} /** * Constructor con 1 parametro * @param salario salario del empleado */ public Empleado(double salario){

//Inicializa el constructor de la clase extendida super(); this.salario=salario; } /** * Constructor con 5 parametros * @param dni dni del empleado * @param nombre nombre del empleado * @param apellido nombre del empleado * @param edad edad del empleado * @param salario salario del empleado */ public Empleado(String dni, String nombre, String apellido, short edad, double salario){

//Inicializa otro constructor de la clase extendida pasando parámetros

super(dni, nombre, apellido, edad); this.salario=salario; }

//Metodos publicos /** * Suma un plus al salario del empleado si el empleado tiene mas de 40 años * @param sueldoPlus * @return <ul> * <li>true: se suma el plus al sueldo</li> * <li>false: no se suma el plus al sueldo</li> * </ul> */ public boolean plus (double sueldoPlus){ boolean aumento=false; if (super.getEdad()>40 && compruebaNombre()){ salario+=sueldoPlus; aumento=true;

} return aumento; } //Metodos privados /** * Comprueba que el nombre no este vacio * @return <ul> * <li>true: el nombre es una cadena vacia</li> * <li>false: el nombre no es una cadena vacia</li> * </ul> */ private boolean compruebaNombre(){ if(super.getNombre().equals("")){ return false; } return true; } //Getters y Setters /** * Devuelve el salario de un empleado * @return salario del empleado */ public double getSalario() { return salario; } /** * Actualiza el salario * @param salario */ public void setSalario(double salario) { this.salario = salario; } public String getDatosPersona() { return (super.toString() ); } public String toString() { return( "\n\tSalario: " + this.getSalario() ); }

}

Clase que implementa una interface (Sobornable) y extiende de otra clase (Empleado) la cual a su vez extiende de otra clase (Persona)

//obtiene las características propias y hereda las de su padre (Empleado) y las de su abuelo(Persona)

public class Comercial extends Empleado implements Sobornable{ //Atributos, aunque no indiquemos nada es como si tuviera los atributos del padre /** * Comision por venta del comercial */ private double comision; /** * Comision por corrupcion del comercial */ private double sobreB; /** * Constructor por defecto */ //Inicializa el constructor propio public Comercial(){

this.comision=0; } /** * Constructor con 5 parametros * @param dni dni del comercial * @param nombre nombre del comercial * @param apellido apellido del comercial * @param edad edad del comercial * @param salario salario del comercial * @param comision comision del comercial */ public Comercial(String dni, String nombre, String apellido, short edad, double salario, double comision) {

//Inicializa otro constructor de la clase extendida pasando parámetros super(dni, nombre, apellido, edad, salario); this.comision=comision; } // Getters y Setters public double getComision() { return comision; }

public void setSobreB(double sobreB) { this.sobreB = sobreB; } public double getSobreB(){ return this.sobreB; } @Override public void sobreB(double cantidad) { this.setSobreB(cantidad); } }

Clases y tipos genéricos en Java

En Java, cuando definimos una nueva clase, debemos conocer el tipo de dato con el que trabajaremos. Si queremos realizar una operación específica dentro de esta nueva clase, sea cual sea el tipo de datos que va a recibir, podemos hacer uso de los tipos genéricos. Este tipo genérico asumirá el tipo de dato que realmente le pasaremos a la clase.

Unos apuntes:

T es el tipo genérico que será reemplazado por un tipo real. T es el nombre que damos al parámetro genérico. Este nombre se sustituirá por el tipo real que se le pasará a la clase.

El resultado será el siguiente:

El tipo de T es java.lang.IntegerEl tipo de T es java.lang.String

Hay que tener en cuenta que los genéricos de java solo funcionan con objetos. El código siguiente nos mostrará un error:

ClaseGenerica<int> myOb = new ClaseGenerica<int>(53); // Error, can't use primitive type

Existen una serie de convenciones para nombrar a los genéricos:

E - Element (usado bastante por Java Collections Framework) K - Key (Llave, usado en mapas) N - Number (para números) T - Type (Representa un tipo, es decir, una clase)

V - Value (representa el valor, también se usa en mapas) S,U,V etc. - usado para representar otros tipos.

Mejor con un ejemplo:

class ClaseGenerica<T> { T obj; public ClaseGenerica(T o) { obj = o; } public void classType() { System.out.println("El tipo de T es " + obj.getClass().getName()); }} public class MainClass { public static void main(String args[]) { // Creamos una instancia de ClaseGenerica para Integer. //El tipo de T es java.lang.Integer ClaseGenerica<Integer> intObj = new ClaseGenerica<Integer>(88); intObj.classType();

// Creamos una instancia de ClaseGenerica para String. //El tipo de T es java.lang.String ClaseGenerica<String> strObj = new ClaseGenerica<String>("Test"); strObj.classType(); }}

Ejemplos sobre herenciaTenemos una clase Apublic class A { protected int d = 10;

public void xxx() { System.out.println ("d en A = " + d); }

public void xxx(int x) { char aux; if (this instanceof C) aux = 'C'; else if (this instanceof B) aux = 'B'; else aux = 'A'; System.out.println ("Sóc xxx d'A aplicat sobre un objecte de la classe " + aux ); }}Una clase B que extiende de Apublic class B extends A{ protected int d=20;

public void xxx() { System.out.println ("d en B = " + d); super.xxx(); }}Y una clase C que extiende de Bpublic class C extends B{ protected int d = 30;

public void xxx(){ System.out.println ("d en C = " + d); super.xxx(); }

public void visibilitat () { System.out.println ("Des del mètode \"visibilitat\" en C:"); System.out.println ("d en C = " + d); System.out.println ("d en B = " + super.d); } }

Si hacemos lo siguientepublic class EjerciciosClases {

public static void main(String[] args) { int aux; A oa = new A(); A ob = new B(); A oc = new C(); ((C)oc).visibilitat(); // (1) System.out.println("Crides al mètode xxx() existent a les tres classes:"); oa.xxx(); // (2) ob.xxx(); // (3) oc.xxx(); // (4) System.out.println("Crides al mètode xxx(int x) existent a les tres classes:"); oa.xxx(0); // (5) ob.xxx(0); // (6) oc.xxx(0); // (7) Sobornable sb = new Comercial(); Comercial c = new Comercial(); Persona p = c; //c= new Empleado(); Empleado e = new Comercial(); } } La salida quedaría así:Des del mètode "visibilitat" en C:d en C = 30d en B = 20Crides al mètode xxx() existent a les tres classes:d en A = 10d en B = 20d en A = 10d en C = 30d en B = 20d en A = 10Crides al mètode xxx(int x) existent a les tres classes:Sóc xxx d'A aplicat sobre un objecte de la classe ASóc xxx d'A aplicat sobre un objecte de la classe BSóc xxx d'A aplicat sobre un objecte de la classe C

_____________________________________________________________________

UF5:

RESUMEN DE COLECCIONES EN JAVA

Creación de un List:List <Integer> li = new LinkedList<>();List<String> li = new LinkedList<String>();Creacción e inicializacion de un List:String llenguatges[] = {"Java", "C", "C++", "Visual Basic", "PHP", "Python", "Perl", "C#", "JavaScript","Delphi"};List<String> li = Arrays.asList(llenguatges);List<String> li = new LinkedList<>(Arrays.asList(llenguatges));List<Integer> li = new ArrayList<Integer>(Arrays.asList(10, 20, 30, 40, 50, 60, 70, 80, 90));

List<String> li = new ArrayList<String>(Arrays.asList("10", "20", "30", "40", "50", "60", "70", "80", "90"));Recorrer un List:List <Integer> li = new LinkedList<>();for ( int i = 1 ; i<l.size()-1; i++){

System.out.println(l.get(i));}

Recorrer un List con un iterator:

List <Integer> li = new LinkedList<>();Iterator it = li.iterator();while(it.hasNext()) {

System.out.println(it.next());}

Métodos sobre un List:List <Integer> li = new LinkedList<Integer>();List<String> ls = new LinkedList<String>();

-Añadir valorli.add(100);ls.add(“texto”);-Añadir valor en una posicion//pos es un entero que cuenta desde 0 (primera posicion)li.add(pos,40);ls.add(pos,”texto”);-Sumar 2 listas

List<Integer> li2 = Arrays.asList(llista2); li.addAll(li2);

-Sustituir un valor de la posicion posli.set(pos, 30);ls.set(pos, “texto2”);-Eliminar el elemento 70li.remove(new Integer(70));-Saber la posicion del elemento pos = li.indexOf(new Integer(20));pos = ls.indexOf(“texto”);-Saber si una lista contiene un elementoli.contains(70);li.contains(“texto”);-Eliminar el elemento “texto”li.remove(“texto”);-Obtener valoresli.get(pos);-Tamaño del Listli.size();-Invertir una listaCollections.reverse(li);

Creación de un ListIterator:List<String> li = new LinkedList<String>();ListIterator<String> it = li.listIterator();Recorrer un ListIterator:while (it.hasNext()){

System.out.println(it.next());}Creación de un HashSet:HashSet<String> li = new HashSet<String>();Recorrer un HashSet:HashSet hSet = new HashSet();//creamos un iteratorIterator it = hSet.iterator();while(it.hasNext())

System.out.println(it.next());}Creación de un HashMap:Map<String, String> paisos = new HashMap<String, String>();Métodos sobre un HashMap:-- Devuelve el numero de elementos del Mappaisos.size();

-- Devuelve true si no hay elementos en el Map y false si si los haypaisos.isEmpty(); -- Añade un elemento al Mappaisos.put(K clave, V valor); -- Devuelve el valor de la clave que se le pasa como parámetro o 'null' si la clave no existepaisos.get(K clave); -- Borra todos los componentes del Mappaisos.clear(); -- Borra el par clave/valor de la clave que se le pasa como parámetropaisos.remove(K clave); -- Devuelve true si en el map hay una clave que coincide con Kpaisos.containsKey(K clave); -- Devuelve true si en el map hay un Valor que coincide con Vpaisos.containsValue(V valor); -- Devuelve una "Collection" con los valores del Mappaisos.values(); Recorrer un HashMap:--mostrar por pantalla todas las claves del mapafor (String key : paisos.keySet()) {

System.out.println(key);}--mostrar por pantalla todos los valores del mapafor (String value : paisos.values()) {

System.out.println(value);}--mostrar por pantalla todos los pares Clave-Valor del mapafor (Map.Entry entry : paisos.entrySet()) {

String key = entry.getKey();Object value = entry.getValue();System.out.println(“Clave: ” + key + " - Valor: " + value);

}--mostrar con un Iterator por pantalla todos los pares Clave-Valor del mapaIterator it = paisos.entrySet().iterator();while (it.hasNext()) {

Map.Entry e = (Map.Entry)it.next();System.out.println("Clave: "+e.getKey()+" - Valor:"+e.getValue());

}

Con un HashMapMap<Integer, String> map = new HashMap<Integer, String>();map.put(1, "Casillas"); map.put(15, "Ramos");map.put(3, "Pique"); map.put(5, "Puyol");map.put(11, "Capdevila"); map.put(14, "Xabi Alonso");map.put(16, "Busquets"); map.put(8, "Xavi Hernandez");map.put(18, "Pedrito"); map.put(6, "Iniesta");map.put(7, "Villa");

// Imprimimos el Map con un IteradorIterator it = map.keySet().iterator();while(it.hasNext()){ Integer key = it.next(); System.out.println("Clave: " + key + " -> Valor: " + map.get(key));}Con un TreeMap

Map<Integer, String> treeMap = new TreeMap<Integer, String>();treeMap.put(1, "Casillas"); treeMap.put(15, "Ramos");treeMap.put(3, "Pique"); treeMap.put(5, "Puyol");treeMap.put(11, "Capdevila"); treeMap.put(14, "Xabi Alonso");treeMap.put(16, "Busquets"); treeMap.put(8, "Xavi Hernandez");treeMap.put(18, "Pedrito"); treeMap.put(6, "Iniesta");treeMap.put(7, "Villa");

// Imprimimos el Map con un Iterador que ya hemos instanciado anteriormenteit = treeMap.keySet().iterator();while(it.hasNext()){ Integer key = it.next(); System.out.println("Clave: " + key + " -> Valor: " + treeMap.get(key));}Con un LinkedHashMap

Map<Integer, String> linkedHashMap = new LinkedHashMap<Integer, String>();linkedHashMap.put(1, "Casillas"); linkedHashMap.put(15, "Ramos");linkedHashMap.put(3, "Pique"); linkedHashMap.put(5, "Puyol");linkedHashMap.put(11, "Capdevila"); linkedHashMap.put(14, "Xabi Alonso");linkedHashMap.put(16, "Busquets"); linkedHashMap.put(8, "Xavi Hernandez");linkedHashMap.put(18, "Pedrito"); linkedHashMap.put(6, "Iniesta");linkedHashMap.put(7, "Villa");

// Imprimimos el Map con un Iterador que ya hemos instanciado anteriormenteit = linkedHashMap.keySet().iterator();while(it.hasNext()){ Integer key = it.next(); System.out.println("Clave: " + key + " -> Valor: " + linkedHashMap.get(key));}

--Forma alternativa para recorrer los Map mostrando la Clave y el valor como si fuese un ArrayListfor (Entry<Integer, String> jugador : linkedHashMap.entrySet()){

Integer clave = jugador.getKey();String valor = jugador.getValue();System.out.println(clave+" -> "+valor);

}Métodos de TreeMapSystem.out.println("********* Trabajando con los métodos de Map *********");System.out.println("Mostramos el numero de elementos que tiene el TreeMap: treeMap.size() = "+treeMap.size());System.out.println("Vemos si el TreeMap esta vacio : treeMap.isEmpty() = "+treeMap.isEmpty());System.out.println("Obtenemos un elemento del Map pasandole la clave 6: treeMap.get(6) = "+treeMap.get(6));System.out.println("Borramos un elemento del Map el 18 (porque fue sustituido): treeMap.remove(18)"+treeMap.remove(18));System.out.println("Vemos que pasa si queremos obtener la clave 18 que ya no existe: treeMap.get(18) = "+treeMap.get(18));System.out.println("Vemos si existe un elemento con la clave 18: treeMap.containsKey(18) = "+treeMap.containsKey(18));System.out.println("Vemos si existe un elemento con la clave 1: treeMap.containsKey(1) = "+treeMap.containsKey(1));System.out.println("Vemos si existe el valo 'Villa' en el Map: treeMap.containsValue(\"Villa\") = "+treeMap.containsValue("Villa"));System.out.println("Vemos si existe el valo 'Ricardo' en el Map: treeMap.containsValue(\"Ricardo\") = "+treeMap.containsValue("Ricardo"));System.out.println("Borramos todos los elementos del Map: treeMap.clear()");treeMap.clear();System.out.println("Comprobamos si lo hemos eliminado viendo su tamaño: treeMap.size() = "+treeMap.size());System.out.println("Lo comprobamos tambien viendo si esta vacio treeMap.isEmpty() = "+treeMap.isEmpty());

RESUMEN EXCEPCIONES

Captura de una excepcióntry {

System.out.println("Abans d'executar el for"); for (int i=0; i<=t.length; i++) System.out.println("Posició " + i + " : " + t[i]);System.out.println("Després d'executar el for");} catch (Exception e) {

System.out.println(e.toString()); System.out.println(e.getLocalizedMessage()); System.out.println("El programador estava a la lluna... S'ha sortir de límits!!");}finally{

System.out.println("Sacabao.");}--Otratry {

System.out.println("Entrem en el mètode met01 i anem a executar met02");met02();System.out.println("Tornem a estar en met01 després de finalitzar met02");

} catch (ArrayIndexOutOfBoundsException e) {System.out.println("El programador estava a la lluna... S'ha sortir de límits!!");

System.out.println(e.getMessage()); e.printStackTrace();}Lanzamiento de una Excepción ://Metodo con throws para apertura de ficherospublic void metodoconThrows (String nomFitxer) throws FileNotFoundException, IOException{

FileInputStream f = new FileInputStream (nomFitxer); f.close(); System.out.println ("\n\tEl metodeAmbClausulaThrows ha finalitzat.");}--Otra--Mètode que avalua si la taula t té n cel·les, provocant, en cas de ser avaluada com a fals, una excepció d'obligada gestió: Exception */public void verificaLengthTaula (int n, String t[]) throws Exception {

if (t.length!=n) throw new Exception ("La taula no té la llargada indicada.");System.out.println ("Sortida de verificaLengthTaula.");

}--Otraint valor = 1;if (valor!=0)

throw new RuntimeException ("\"1>2\" no puede ser cierto");

Creación de una Excepción propia:

public class MiExcepcion extends Exception { private Integer valor;

public MiExcepcion (int xxx) { valor = new Integer(xxx); }

public String toString () { return "Exception MiExcepcion: Error motivat per valor = " + valor.toString(); }}– y provoco la excepcionint valor = 1;if (valor!=0)

throw new MiExcepcion (valor);System.out.println ("No s'ha provocat l'excepció.");

Lectura de ficheros XML

Recorrer un fichero XML con una lista de productos y contar cuantos hay a la venta

import javax.xml.parsers.*; import org.w3c.dom.*;

DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance(); Document document = null; try {

DocumentBuilder builder = builderFactory.newDocumentBuilder(); File f = new File ("miFichero.xml"); document = builder.parse(f); Element e = document.getDocumentElement(); NodeList l = e.getElementsByTagName("Producte"); for (int i = 0; i < l.getLength(); i++) {

Element elem = (Element)l.item(i); String venda = elem.getAttribute("aLaVenda"); if ("true".equals( venda) ) {

nreArticles++; }

} System.out.println("Articles a la venda: " + nreArticles); } catch (Exception ex) {

System.out.println("Error en la lectura del documento: " + ex);

}

Creacion de ficheros XML

import javax.xml.parsers.*; import org.w3c.dom.*;

//Creación del documentoDocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = builderFactory.newDocumentBuilder(); Document doc = builder.newDocument(); //Elemento raiz Element raiz = doc.createElement("ListaProductos"); doc.appendChild(raiz); //Elemento hijo de la raiz Element prod = doc.createElement("Producto"); prod.setAttribute("id", "1"); prod.setAttribute("aLaVenta", "true"); //Elementos hijo del anterior Element hijo = doc.createElement("Nombre"); hijo.setTextContent("Producto 1"); prod.appendChild(hijo); hijo = doc.createElement("Precio"); hijo.setTextContent("10.0"); prod.appendChild(hijo); hijo = doc.createElement("Estoc"); hijo.setTextContent("4"); prod.appendChild(hijo); raiz.appendChild(prod);

Para grabar el documento XML a un fichero, siempre es lo mismo:

import javax.xml.transform.*; import javax.xml.transform.dom.DOMSource; import javax.xml.transform.stream.StreamResult;

...

try { TransformerFactory tf = TransformerFactory.newInstance(); Transformer transformer = tf.newTransformer(); DOMSource source = new DOMSource(doc); File f = new File("nuevoDocumento.xml"); StreamResult result = new StreamResult(f); transformer.transform(source, result);

} catch (Exception ex) { System.out.println("Error guardando fichero: " + ex);

}

RESUMEN DE JAVA SWING

showMessageDialog

JOptionPane.showMessageDialog(null, "Hola mundo!!!");

showInputDialog

String ax = JOptionPane.showInputDialog("Ingrese un numero: ");JOptionPane.showMessageDialog(null, "El numero ingresado es: "+ax);

showConfirmDialog

int ax = JOptionPane.showConfirmDialog(null, "Estas en java?");if(ax == JOptionPane.YES_OPTION) JOptionPane.showMessageDialog(null, "Has seleccionado SI.");else if(ax == JOptionPane.NO_OPTION) JOptionPane.showMessageDialog(null, "Has seleccionado NO.");

showOptionDialog

int seleccion = JOptionPane.showOptionDialog( unComponentePadre, "Seleccione opcion", "Selector de opciones", JOptionPane.QUESTION_MESSAGE, null, new Object[] { "opcion 1", "opcion 2", "opcion 3" }, opcion 1");

JColorChooser

JColorChooser chooser = new JColorChooser();Color res = chooser.showDialog(frame, "Tria el color", Color.WHITE);JLabel label = new JLabel("Un text amb fons de colors");if (null != res) {

label.setBackground(res);}

JFileChooser

JFileChooser selector = new JFileChooser();selector.setFileSelectionMode(JFileChooser.FILES_ONLY);FileNameExtensionFilter filtre = new FileNameExtensionFilter(".lin; Fitxers de llista de lineas.", "lin");selector.setFileFilter(filtre);selector.showOpenDialog(frame);

Estructura básica de una aplicación Swing.

Una aplicación Swing se construye mezclando componentes con las siguientes reglas.

Debe existir, al menos, un contenedor de alto nivel (Top-Level Container), que provee el soporte que las componentes Swing necesitan para el pintado y el manejo de eventos.

Otros componentes colgando del contenedor de alto nivel (éstas pueden ser contenedores o componentes simples).

Ejemplo 1: import javax.swing.*;import java.awt.*;import java.awt.event.*;

public class HolaMundoSwing { public static void main(String[] args) { JFrame frame = new JFrame("HolaMundoSwing"); final JLabel label = new JLabel("Hola Mundo"); frame.getContentPane().add(label);

//frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.addWindowListener(new java.awt.event.WindowAdapter(){ public void windowClosing(WindowEvent e){ System.exit(0); } } );

frame.pack(); frame.setVisible(true); }}

Otro Hola mundo:

Hemos creado dos botones y un campo de texto con listeners para los botones que modifican el campo de texto y un labelHay que importar lo siguiente:import java.awt.*;import java.awt.event.*;

import javax.swing.*;

/** creamos la ventana */ private JFrame ventana; /** creamos los paneles */ private JPanel panel1, panel2; /** Creamos los botones */ private JButton boton1, boton2; /** Creamos el campo de texto */ private JTextField texto; /** Creamos la etiqueta de texto */ private JLabel etiqueta;

// inicializamos la ventanaventana = new Jframe(“Esta el la ventana del Hola Mundo”);

// Se le pone un FlowLayout para que el botón y campo de texto quede alineados.ventana.getContentPane().setLayout(new FlowLayout());

//inicializamos los panelespanel1 = New JPanel();panel2 = new JPanel();//inicializamos la etiqueta del tituloetiqueta = new Jlabel(“Mi primer Hola Mundocon Swing”);//insertamos la etiqueta en el panel panel1.add(etiqueta);//añadimos el panel 1 a la ventanaventana.getContentPane().add(panel1);

//inicializamos el boton 1boton1 = new Jbutton(“Púlse“);//inicializamos el campo de textotexto = new JtextField();//inicializamos el boton 2boton2 = new Jbutton(“Bórrame”);//añadimos los botones y el texto al panel 2panel2.add(boton1);panel2.add(texto);panel2.add(boton2);//añadimos el panel 2 a la ventanaventana.getContentPane().add(panel2);// Se le dice a los botones qué tienen que hacer cuando los pulsemos.// Para cada elemento que queramos que haga algo hay que poner un listenerboton1.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){//añade texto a la etiqueta “texto”texto.setText ("Hola mundo");//modifica el texto de la etiqueta

etiqueta.setText("He cambiado la etiqueta"); }}); boton2.addActionListener(new ActionListener(){

public void actionPerformed(ActionEvent e){//borra el texto de la etiqueta “texto”texto.setText ("");//modifica el texto de la etiquetaetiqueta.setText("Vuelvo a ser Hola Mundo");

}});// Se le dice a la ventana que termine el programa cuando se la cierreventana.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);//se le da un tamaño a la ventanaventana.ssetSize(600,200);//para dar a una ventana el tamaño justo de su contenido se hace//ventana.pack();//finalmente, se hace visible la ventanaventana.setVisible(true);//ventana.pack();

Después de pulsar el botón Púlsame

Después de pulsar el botón Bórrame

Otro Hola mundo más:

Hemos creado dos botones y un campo de texto con otra forma de llamar a los listeners para los botones que modifican el campo de texto.

import java.awt.*;import java.awt.event.ActionEvent;import java.awt.event.ActionListener;import javax.swing.*;

public class Interfaz {/** creamos la ventana */private JFrame ventana;

/** creamos los paneles */private JPanel panel1, panel2;

/** Creamos los botones */private JButton boton1, boton2;

/** Creamos el campo de texto */private JTextField texto;

/** Creamos la etiqueta de texto */private JLabel etiqueta;//Se llama a un solo listenerActionListener escuchador = new escuchador();//constructorpublic Interfaz(){

// inicializamos la ventanaJFrame ventana = new JFrame("Otro Hola Mundo");//le añadimos un layoutventana.setLayout(new BorderLayout(4, 4));

//inicializamos los paneles//creo el panel 1

panel1 = new JPanel(new BorderLayout(6, 50));//creo el panel 2panel2 = new JPanel();//redimensionamos el panel1panel1.setSize(270, 57);//hacemos visible el panel 1panel1.setVisible(true);//redimensiono el panel2panel2.setSize(270, 57);//hacemos visible el panel 2panel2.setVisible(true);//llamamos a dos funciones que rellenan los paneles 1 y 2norte();sur();//añadimos los paneles a la ventanaventana.add(panel1, BorderLayout.NORTH);ventana.add(panel2);//colocamos la ventana en la pantallaventana.setLocation(100, 80);//la hacemos visibleventana.setVisible(true);//cambiamos su tamañoventana.setSize(300, 100);// Se le dice a la ventana que termine el programa cuando se la cierreventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

}public void norte(){

//iniciamos la caja de textotexto = new JTextField("");//la alineamos a la derechotexto.setHorizontalAlignment(JTextField.RIGHT);//Quitar bordes a los campos de textotexto.setBorder(BorderFactory.createLineBorder(Color.white));//desabilitando los campos de textotexto.setEditable(false);//cambiamos el color de fondotexto.setBackground(Color.white);//cambiamos el tipo de letratexto.setFont(new Font("Verdana", Font.BOLD, 12));//redimensionamos la caja de textotexto.setBounds(35, 10, 220, 20);//añadimos la caja de texto al panelpanel1.add(texto);

}public void sur(){

//funcion para crear botonespongobotones();

}public void pongobotones(){

//inicializamos el boton 1

boton1 = new JButton("Púlse");//inicializamos el boton 2boton2 = new JButton("Bórrame");//cambiamos el tipo de letra de los botonesboton1.setFont(new Font("Arial", Font.BOLD, 11));boton2.setFont(new Font("Verdana", Font.BOLD, 11));//Aqui el cambio a la hora de hacer el listenerboton1.addActionListener(escuchador);boton2.addActionListener(escuchador);//añadimos los botones al panelpanel2.add(boton1); panel2.add(boton2);

}private class escuchador implements ActionListener {

public void actionPerformed(ActionEvent e) {JButton botoPulsado = (JButton)e.getSource();String temp = botoPulsado.getText();if (temp.equalsIgnoreCase("Púlse"))

texto.setText ("Hola mundo");if (temp.equalsIgnoreCase("Bórrame"))

texto.setText ("");}

}

}

Acción que lanza un evento Tipo de listener

El usuario hace un click, presiona Returnen un área de texto o selecciona un menú

ActionListener

El usuario escoge un frame (ventana principal) WindowListener

El usuario hace un click sobre un componente MouseListener

El usuario pasa el mouse sobre un componente MouseMotionListener

Un componente se hace visible ComponentListener

Un componente adquiere el foco del teclado FocusListener

Cambia la selección en una lista o tabla ListSelectionListener

Crear un APPLET:

//Per incloure un applet dins una pàgina web cal usar l’etiqueta o tag HTML:

<HTML><HEAD><TITLE>Mi Primer Applet</TITLE></HEAD><BODY><APPLET CODEBASE = "." CODE = "applet.class" NAME = "TestApplet" WIDTH = 400 HEIGHT = 300 HSPACE = 0 VSPACE = 0 ALIGN = middle></APPLET></BODY>

</HTML>

//La clase tiene que extender de Applet

import java.applet.*;

public class Applet1 extends Applet { public void init(){ setBackgroung(Color.white); } public void paint(Graphics g){ g.drawString("Primer applet", 10, 10); }}

RESUMEN DE COSAS DE FICHEROS

Crear un fichero:File file = new File(ruta);if (!file.exists()) file.createNewFile();//El fitxer no es crea realment en el sistema de fitxers fins a executar el mètode createNewFile

//Crea un directorio, si no existe. public boolean mkdir();

//ficheros de entradaFileInputStream(File fichero) //fichero con su ruta de entradaFileInputStream(String ruta) //fichero de salidaFileOutputStream(File fichero) //fichero con ruta de salidaFileOutputStream(String ruta)

Copiar un fichero de datos:InputStream in = new FileInputStream(ruta); OutputStream out = new FileOutputStream(novaRuta); copiaDatos(in, out);

public void copiaDatos(InputStream in, OutputStream out) { try {

byte[] datos = new byte[100]; int leidos = 0; while (-1 != (leidos = in.read(datos))) out.write(datos,0,leidos); out.close(); in.close();

} catch (IOException) { System.out.println("Error en entrada/salida del fichero")

} }Copiar un fichero de texto:

Las diferèncias de la copia de ficheros de texto son mínimes respecto a la forma de operar de los flujos orientados a datos.

Reader in = new Filereader(ruta); Writer out = new FileWriter(novaRuta); copiaDatos(in, out); ... public void copiaDatos(Reader in, Writer out) {

try { char[] datos = new char[100]; int leidos = 0; while (-1 != (leidos = in.read(datos)))

out.write(datos,0,leidos);

out.close(); in.close();

} catch (IOException) { System.out.println("Error en entrada/salida del fichero")

} }

Escritura y lectura de tipos primitivos

DataOutputStream dos = new DataOutputStream(new FileOutputStream(ruta)); dos.writeInt(enter); dos.writeBoolean(boolea1); dos.writeBoolean(boolea2); dos.writeDouble(doble); dos.close();

DataInputStream dis = new DataInputStream(new FileInputStream(ruta)); double d = dis.readDouble(); boolean b1 = dis.readBoolean(); boolean b2 = dis.readBoolean(); int i = dis.readInt(); dis.close();

Retrocediendo en la lectura de un flujo

BufferedInputStream bis = new BufferedInputStream(new FileInputStream(ruta)); byte[] dades = new int[100]; bis.mark(500); //Marca. El buffer serà de 500 bytes bis.read(dades); //Llegim els bytes 0-99 del fitxer bis.read(dades); //Llegim els bytes 100-199 del fitxer bis.reset(); //Tornem a la marca bis.read(dades); //Llegim els bytes 0-99 del fitxer bis.read(dades); //Llegim els bytes 100-199 del fitxer bis.read(dades); //Llegim els bytes 200-299 del fitxer bis.read(dades); //Llegim els bytes 300-399 del fitxer bis.read(dades); //Llegim els bytes 400-499 del fitxer bis.read(dades); //La marca es perd. Ja no es pot fer reset() ... bis.close();

Compressió i descompressió de dades

try { GZIPInputStream gis = new GZIPInputStream(new FileInputStream(ruta)); OutputStream out = new FileOutputStream(outFilename); byte[] datos = new byte[1024]; int leidos = 0; while (-1 != (leidos = in.read(datos)))

out.write(datos,0,leidos); gis.close(); out.close();

} catch (IOException) {

}De InputStream a Reader

Pasar de flujo orientado a datos a fichero de texto, siempre que se sepa a priori que el fichero contiene texto.

FileInputStream fis = new FileInputStream (ruta); FileOutputStream fos = new FileOutputStream (novaRuta);

public void copiaTexto(InputStream in, OutputStream out) { try {

Reader rd = new InputStreamReader(in); Writer wr = new OutputStreamWriter(out); char[] datos = new char[100]; int leidos = 0; while (-1 != (leidos = rd.read(datos)))

wr.write(datos,0,leidos); wr.close(); rd.close();

} catch (IOException) {

} }

Leer linea a linea un fichero de texto

BufferedReader br = new BufferedReader (new FileReader(ruta)); String linea = null; //Se muestra todo el contenido per pantalla while (null != (linea = br.readLine()))

System.out.println(linea); br.close();

Abrir fichero con filtro del tipo de fichero, con java swing:

//Importamos las librerias necerariasimport java.io.*;import javax.swing.*;import javax.swing.filechooser.*;private static String abrirLeerArchivo() { String aux=""; String texto=""; FileReader archivo; BufferedReader lee=null; try{ /**llamamos el metodo que permite cargar JFileChooser*/ JFileChooser file=new JFileChooser(); //Determinamos el tipo de fichero que queremos abrir FileNameExtensionFilter filter = new FileNameExtensionFilter("fitxer .txt", "txt"); //asignamos el filtro a la ventana file.setFileFilter(filter); //Ponemos como directorio por defecto el mismo del proyecto file.setCurrentDirectory(new File(".")); // abrimos la ventana de JFilechooser file.showOpenDialog(file); /**abrimos el archivo seleccionado*/ File abre=file.getSelectedFile(); //asignamos al FileReader el archivo abierto archivo=new FileReader(abre); //cargamos en el BufferedReader el archivo a leer lee=new BufferedReader(archivo); /**recorremos el archivo, lo leemos para plasmarlo *en la consola*/ while((aux=lee.readLine())!=null){ texto+= aux+ "\n"; } //lanzamos una excepcion si el fichero no se encuentra } catch (FileNotFoundException e) { throw new RuntimeException("Error, El fichero no existe"); //lanzamos una excepcion si el fichero no se puede leer } catch (IOException e) { throw new RuntimeException("Error, No se puede leer el fichero"); // lanzamos una excepcion si el error no es ninguno de los anteriores } catch (Exception e) { throw new RuntimeException("Error, desconocido");

} finally { // Cerramos el fichero // En el finally cerramos el fichero, para asegurar que se cierra // tanto si todo va bién como si salta una excepción. try{ // si el BufferedReader no es nulo if( null != lee ){ // cerramos el fichero lee.close(); } // capturamos una posible excepcion al cerrar el fichero

}catch (Exception e2){ e2.printStackTrace(); } } return texto;//El texto que mostraremos en la consola}

Escribir un texto en un fichero:

private static void escribirArchivo() { FileWriter archivo; BufferedWriter escribe = null; try {

String contenido = "Contenido para escribir en un fichero";

File file = new File("miFichero.txt");

// si el fichero no existe, se crea if (!file.exists()) { file.createNewFile(); }

archivo = new FileWriter(file.getAbsoluteFile()); escribe = new BufferedWriter(archivo); escribe.write(contenido);

System.out.println("Fichero grabado correctamente");

//lanzamos una excepcion si el fichero no se encuentra } catch (FileNotFoundException e) { throw new RuntimeException("Error, El fichero no existe"); //lanzamos una excepcion si el fichero no se puede leer } catch (IOException e) { throw new RuntimeException("Error, No se puede leer el fichero"); // lanzamos una excepcion si el error no es ninguno de los anteriores } catch (Exception e) { throw new RuntimeException("Error, desconocido"); }finally{ // si el BufferedReader no es nulo try{ // si el BufferedReader no es nulo if( null != escribe ){ // cerramos el fichero escribe.close(); } // capturamos una posible excepcion al cerrar el fichero }catch (Exception e2){ e2.printStackTrace(); } }}

_____________________________________________________________________

UF6:

RESUMEN DE STATEMENT UTILITZANT DB4O

/** * Connexió a la base de dades. Ha de valer null quan no hi hagi cap connexió * establerta. */ private Connection conn; /**

* Consulta SQL. */ private static String consultaSQL = "" + "SELECT * \n" + "FROM TABLA1 T1 \n" + " JOIN TABLA2 T2 ON ( T1.ID = T2.ID ) \n" + "WHERE COSA = ? \n" + "ORDER_BY COSA"; /** * Sentència SQL que insereix una cosa a la BD. */ private static String consultainsereixSQL = "" + "INSERT INTO TABLA1 " + "( ID ) " + "VALUES ( ? )";/* * Sentències preparades corresponents a les anteriors consultes SQL */ private PreparedStatement consultaSt; private PreparedStatement ConsultaInsereixSt; /** * Constructor. Carrega el driver per accedir a la BD. Obre la connexió * amb la BD. * * @throws JocsDeTaulaException si no s'ha pogut carregar el driver o establir la connexió. */ public AccesBD() throws JocsDeTaulaException { try { Class.forName("org.apache.derby.jdbc.ClientDriver"); estableixConnexio(); } catch (ClassNotFoundException ex) { throw new JocsDeTaulaException(ex.getMessage(), ex); } catch (SQLException ex) { throw new JocsDeTaulaException(ex.getMessage(), ex); } } /** * Estableix la connexió amb la base de dades. Crea les sentències preparades. * * @throws SQLException Si es produeix una excepció a l'establir la connexió (en * aquest cas, posa la referència a la connexió a null). */ private void estableixConnexio() throws SQLException { String urlBaseDades = "jdbc:derby://localhost:1527/eac11"; String usuari = "root"; String contrasenya = "root123"; try { conn = DriverManager.getConnection(urlBaseDades , usuari, contrasenya); consultaSt = conn.prepareStatement(consultaSQL); ConsultaInsereixSt = conn.prepareStatement(consultainsereixSQL, Statement.RETURN_GENERATED_KEYS); } catch (SQLException e) { conn = null; throw e; } } /** * Tanca la connexió i posa la referència a la connexió a null. * * @throws SQLException */ public void tancaConnexio() throws SQLException { if (conn != null) { try { conn.close(); } finally { conn = null; }

} }

/** * Obté les dades d'una cosa donat part de una cosa * */ public void consultaCosa1(String cosa) { try { consultaSt.setString(1, "%"+cosa+"%"); ResultSet rs = consultaSt.executeQuery(); // Agafem tots els resultats while (rs.next()) { System.out.println(rs.getInt("cosa1")

, rs.getString("cosa2") , rs.getInt("cosa3") , rs.getInt("conaN"));

} } catch (SQLException ex) { System.err.println(ex.getMessage()); } }

/** * Obté una dada d'una cosa donat part de una cosa * */ public void consultaCosa2(String cosa) { try { consultaSt.setString(1, "%"+cosa+"%"); ResultSet rs = consultaSt.executeQuery(); // Agafem sempre el primer resultat

rs.next(); // sempre té un únic resultat de la consulta System.out.println(rs.getInt("cosa1")

, rs.getString("cosa2") , rs.getInt("cosa3") , rs.getInt("cosaN"));

} } catch (SQLException ex) { System.err.println(ex.getMessage()); } } /** * Pinta una llista amb totes les coses donat part de una cosa * * Noteu que aquest és un mètode molt ineficient: es recupera la BD sencera i * molts registres es recuperen diversos cops * */ public void consultaCosa3() { String cosa; List<String> coses = new ArrayList<String>(); try { consultaSt.setString(1, "%"+cosa+"%"); ResultSet rs = consultaSt.executeQuery(); // Agafem tots els resultats while (rsPartides.next()) { coses.add(rs.getString("cosa2")); } } catch (SQLException ex) { System.err.println(ex.getMessage()); } System.out.println( coses ); } /** * Insereix una nova partida a la BD. * * @param partida La Partida a inserir. * @throws JocsDeTaulaException si la partida no s'ha pogut guardar a la BD. */ public void guardaCosa() throws JocsDeTaulaException { try {

ConsultaInsereixSt.setInt(1, partida.getJoc().getId()); ConsultaInsereixSt.executeUpdate(); // inserim la partida i recuperem la clau id que se li ha generat. ResultSet rsGeneratedKeys = ConsultaInsereixSt.getGeneratedKeys(); rsGeneratedKeys.next(); // Només té un resultat int id = rsGeneratedKeys.getInt(1);

System.out.println ("La id de la insercion es " + id)} catch (SQLException ex) {

throw new JocsDeTaulaException(ex.getMessage(), ex); } }