ORIENTACION PAF

UF4:
Hi haur un tipus test que preguntar sobre conceptes de la POO. Static,
abstract, constructors, herncia, polimorfisme, modificadors d'accs, etc. Les
preguntes seran de veritat/fals i test, i s'assemblaran a les que es van anar plantejar al
frum 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 interfcie grfica senzilla. Cal entendre el mecanisme dels
layouts i com combinar-los utilitzant JPanel. Els layouts sn els bsics: FlowLayout,
BorderLayout, GridLayout i BoxLayout. Els controls tamb sn els bsics: 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. Noms els tipus de
listeners ms 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. Noms 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;
}
/**
* Mtodo
*/
// 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;
}
/**
* Implementacin 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 caractersticas propias y hereda las de su padre
public 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 parmetros
super(dni, nombre, apellido, edad);
this.salario=salario;
}
//Metodos publicos

/**
* Suma un plus al salario del empleado si el empleado tiene mas de 40 aos
* @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 caractersticas 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 parmetros
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 genricos en Java
En Java, cuando definimos una nueva clase, debemos conocer el tipo de dato con el que trabajaremos. Si queremos
realizar una operacin especfica dentro de esta nueva clase, sea cual sea el tipo de datos que va a recibir,
podemos hacer uso de los tipos genricos. Este tipo genrico asumir el tipo de dato que realmente le pasaremos a
la clase.
Unos apuntes:
T es el tipo genrico que ser reemplazado por un tipo real.
T es el nombre que damos al parmetro genrico.
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.Integer
El tipo de T es java.lang.String
Hay que tener en cuenta que los genricos de java solo funcionan con objetos. El cdigo 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 genricos:
E - Element (usado bastante por Java Collections Framework)
K - Key (Llave, usado en mapas)
N - Number (para nmeros)
T - Type (Representa un tipo, es decir, una clase)

V - Value (representa el valor, tambin 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 herencia
Tenemos una clase A
public 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 ("Sc xxx d'A aplicat sobre un objecte de la classe " + aux );
}
}
Una clase B que extiende de A
public 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 B
public 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 mtode \"visibilitat\" en C:");
System.out.println ("d en C = " + d);
System.out.println ("d en B = " + super.d);
}
}
Si hacemos lo siguiente
public 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 mtode xxx() existent a les tres classes:");
oa.xxx(); // (2)
ob.xxx(); // (3)
oc.xxx(); // (4)
System.out.println("Crides al mtode 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 quedara as:
Des del mtode "visibilitat" en C:
d en C = 30
d en B = 20
Crides al mtode xxx() existent a les tres
d en A = 10
d en B = 20
d en A = 10
d en C = 30
d en B = 20
d en A = 10
Crides al mtode xxx(int x) existent a les
Sc xxx d'A aplicat sobre un objecte de la
Sc xxx d'A aplicat sobre un objecte de la
Sc xxx d'A aplicat sobre un objecte de la

classes:

tres classes:
classe A
classe B
classe C

_____________________________________________________________________

UF5:

RESUMEN DE COLECCIONES EN JAVA

Creacin de un List:
List <Integer> li = new LinkedList<>();
List<String> li = new LinkedList<String>();
Creaccin 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());
}
Mtodos sobre un List:
List <Integer> li = new LinkedList<Integer>();
List<String> ls = new LinkedList<String>();
-Aadir valor
li.add(100);
ls.add(texto);
-Aadir 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 pos
li.set(pos, 30);
ls.set(pos, texto2);
-Eliminar el elemento 70
li.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 elemento
li.contains(70);
li.contains(texto);
-Eliminar el elemento texto
li.remove(texto);
-Obtener valores
li.get(pos);
-Tamao del List
li.size();
-Invertir una lista
Collections.reverse(li);
Creacin 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());
}
Creacin de un HashSet:
HashSet<String> li = new HashSet<String>();
Recorrer un HashSet:
HashSet hSet = new HashSet();
//creamos un iterator
Iterator it = hSet.iterator();
while(it.hasNext())
System.out.println(it.next());
}
Creacin de un HashMap:
Map<String, String> paisos = new HashMap<String, String>();
Mtodos sobre un HashMap:
-- Devuelve el numero de elementos del Map
paisos.size();

-- Devuelve true si no hay elementos en el Map y false si si los hay

paisos.isEmpty();
-- Aade un elemento al Map
paisos.put(K clave, V valor);
-- Devuelve el valor de la clave que se le pasa como parmetro o 'null' si la clave no existe
paisos.get(K clave);
-- Borra todos los componentes del Map
paisos.clear();
-- Borra el par clave/valor de la clave que se le pasa como parmetro
paisos.remove(K clave);
-- Devuelve true si en el map hay una clave que coincide con K
paisos.containsKey(K clave);
-- Devuelve true si en el map hay un Valor que coincide con V
paisos.containsValue(V valor);
-- Devuelve una "Collection" con los valores del Map
paisos.values();
Recorrer un HashMap:
--mostrar por pantalla todas las claves del mapa
for (String key : paisos.keySet()) {
System.out.println(key);
}
--mostrar por pantalla todos los valores del mapa
for (String value : paisos.values()) {
System.out.println(value);
}
--mostrar por pantalla todos los pares Clave-Valor del mapa
for (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 mapa
Iterator 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 HashMap
Map<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 Iterador
Iterator 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 anteriormente
it = 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 anteriormente
it = 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 ArrayList
for (Entry<Integer, String> jugador : linkedHashMap.entrySet()){
Integer clave = jugador.getKey();
String valor = jugador.getValue();
System.out.println(clave+" -> "+valor);
}
Mtodos de TreeMap
System.out.println("********* Trabajando con los mtodos 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 tamao: treeMap.size() =
"+treeMap.size());
System.out.println("Lo comprobamos tambien viendo si esta vacio treeMap.isEmpty() =
"+treeMap.isEmpty());

RESUMEN EXCEPCIONES
Captura de una excepcin
try {
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("Desprs 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 lmits!!");
}finally{
System.out.println("Sacabao.");
}
--Otra
try {
System.out.println("Entrem en el mtode met01 i anem a executar met02");
met02();
System.out.println("Tornem a estar en met01 desprs de finalitzar met02");
} catch (ArrayIndexOutOfBoundsException e) {
System.out.println("El programador estava a la lluna... S'ha sortir de lmits!!");

System.out.println(e.getMessage());
e.printStackTrace();
}
Lanzamiento de una Excepcin :
//Metodo con throws para apertura de ficheros
public void metodoconThrows (String nomFitxer) throws FileNotFoundException, IOException{
FileInputStream f = new FileInputStream (nomFitxer);
f.close();
System.out.println ("\n\tEl metodeAmbClausulaThrows ha finalitzat.");
}
--Otra
--Mtode que avalua si la taula t t n celles, 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.");
}
--Otra
int valor = 1;
if (valor!=0)
throw new RuntimeException ("\"1>2\" no puede ser cierto");
Creacin de una Excepcin 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 excepcion
int 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.*;
//Creacin del documento
DocumentBuilderFactory 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 bsica de una aplicacin Swing.

Una aplicacin 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 label
Hay 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 ventana
ventana = new Jframe(Esta el la ventana del Hola Mundo);
// Se le pone un FlowLayout para que el botn y campo de texto quede alineados.
ventana.getContentPane().setLayout(new FlowLayout());
//inicializamos los paneles
panel1 = New JPanel();
panel2 = new JPanel();
//inicializamos la etiqueta del titulo
etiqueta = new Jlabel(Mi primer Hola Mundocon Swing);
//insertamos la etiqueta en el panel
panel1.add(etiqueta);
//aadimos el panel 1 a la ventana
ventana.getContentPane().add(panel1);
//inicializamos el boton 1
boton1 = new Jbutton(Plse);
//inicializamos el campo de texto
texto = new JtextField();
//inicializamos el boton 2
boton2 = new Jbutton(Brrame);
//aadimos los botones y el texto al panel 2
panel2.add(boton1);
panel2.add(texto);
panel2.add(boton2);
//aadimos el panel 2 a la ventana
ventana.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 listener
boton1.addActionListener(new ActionListener(){
public void actionPerformed(ActionEvent e){
//aade 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 etiqueta
etiqueta.setText("Vuelvo a ser Hola Mundo");
}
});
// Se le dice a la ventana que termine el programa cuando se la cierre
ventana.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
//se le da un tamao a la ventana
ventana.ssetSize(600,200);
//para dar a una ventana el tamao justo de su contenido se hace
//ventana.pack();
//finalmente, se hace visible la ventana
ventana.setVisible(true);
//ventana.pack();

Despus de pulsar el botn Plsame

Despus de pulsar el botn Brrame

Otro Hola mundo ms:

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
import
import
import

java.awt.*;
java.awt.event.ActionEvent;
java.awt.event.ActionListener;
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 listener
ActionListener escuchador = new escuchador();
//constructor
public Interfaz(){
// inicializamos la ventana
JFrame ventana = new JFrame("Otro Hola Mundo");
//le aadimos un layout
ventana.setLayout(new BorderLayout(4, 4));
//inicializamos los paneles
//creo el panel 1
panel1 = new JPanel(new BorderLayout(6, 50));
//creo el panel 2
panel2 = new JPanel();
//redimensionamos el panel1
panel1.setSize(270, 57);
//hacemos visible el panel 1
panel1.setVisible(true);
//redimensiono el panel2
panel2.setSize(270, 57);
//hacemos visible el panel 2
panel2.setVisible(true);
//llamamos a dos funciones que rellenan los paneles 1 y 2
norte();
sur();
//aadimos los paneles a la ventana
ventana.add(panel1, BorderLayout.NORTH);
ventana.add(panel2);
//colocamos la ventana en la pantalla
ventana.setLocation(100, 80);
//la hacemos visible
ventana.setVisible(true);
//cambiamos su tamao
ventana.setSize(300, 100);
// Se le dice a la ventana que termine el programa cuando se la cierre
ventana.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
}
public void norte(){
//iniciamos la caja de texto
texto = new JTextField("");
//la alineamos a la derecho
texto.setHorizontalAlignment(JTextField.RIGHT);
//Quitar bordes a los campos de texto
texto.setBorder(BorderFactory.createLineBorder(Color.white));
//desabilitando los campos de texto
texto.setEditable(false);
//cambiamos el color de fondo
texto.setBackground(Color.white);
//cambiamos el tipo de letra
texto.setFont(new Font("Verdana", Font.BOLD, 12));
//redimensionamos la caja de texto
texto.setBounds(35, 10, 220, 20);
//aadimos la caja de texto al panel
panel1.add(texto);
}
public void sur(){
//funcion para crear botones
pongobotones();
}
public void pongobotones(){
//inicializamos el boton 1

boton1 = new JButton("Plse");

//inicializamos el boton 2
boton2 = new JButton("Brrame");
//cambiamos el tipo de letra de los botones
boton1.setFont(new Font("Arial", Font.BOLD, 11));
boton2.setFont(new Font("Verdana", Font.BOLD, 11));
//Aqui el cambio a la hora de hacer el listener
boton1.addActionListener(escuchador);
boton2.addActionListener(escuchador);
//aadimos los botones al panel
panel2.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("Plse"))
texto.setText ("Hola mundo");
if (temp.equalsIgnoreCase("Brrame"))
texto.setText ("");
}
}
}

Accin que lanza un evento

Tipo de listener

El usuario hace un click, presiona Return

en 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 seleccin en una lista o tabla

ListSelectionListener

Crear un APPLET:
//Per incloure un applet dins una pgina web cal usar letiqueta 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 mtode createNewFile
//Crea un directorio, si no existe.
public boolean mkdir();
//ficheros de entrada
FileInputStream(File fichero)
//fichero con su ruta de entrada
FileInputStream(String ruta)
//fichero de salida
FileOutputStream(File fichero)
//fichero con ruta de salida
FileOutputStream(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 diferncias de la copia de ficheros de texto son mnimes 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 necerarias
import 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 bin como si salta una excepcin.
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";
/**
* Sentncia SQL que insereix una cosa a la BD.
*/
private static String consultainsereixSQL = "" +
"INSERT INTO TABLA1 " +
"( ID ) " +
"VALUES ( ? )";
/*
* Sentncies 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 sentncies preparades.
*
* @throws SQLException Si es produeix una excepci a l'establir la connexi (en
* aquest cas, posa la referncia 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 referncia 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 mtode 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(); // Noms 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);
}
}