Tenemos que crear un projecto web dinámico, seleccionar el tomcat (en principio ya lo tenéis instalado por el xampp, pero si no es así el eclipse permite descargarlo e instalarlo al momento) y ejecutarlo en el servidor:
https://www.javatpoint.com/creating-jsp-in-eclipse-ide
Vamos a crear las siguientes clases:
Televisor
Propiedades:
String modelo
int pulgadas
int peso
Ordenador
Propiedades
String nombre
int ram
int hdd
String placa
Lavavajillas
String marca
int capacidad
Todas las propiedades privadas con getters y setters. COnstructores con todas las propiedades.
No está de más crear una sobrecarga del toString.
Crearemos también el interfaz Paqueteria que tiene los siguientes métodos:
int getPeso()
int getDiagonal()
Las tres clases anteriores DEBEN implementar los métodos.
En el caso del televisor el peso que tiene en la propiedad peso. La diagonal son las pulgadas*5
En el caso del ordenador el peso es 500 y la diagonal 70
En el caso del lavavajilas el peso es 200* capacidad y la diagonal la capacidad/.7
Cread un main para probar que todo funcione.
Nuestra empresa se dedica a almacenar objetos de todo tipo y se organizan en palés. Vamos a crear una clase Pale que tiene como propiedades:
int capacidad
int lado
List<Paqueteria>
El constructor está sobrecargado, podemos tenerlo pasando las propiedades capacidad y lado, en cuyo caso se agina el valor que nos están pasando, o podemos tenerlo sin parámetros, en cuyo caso la capacidad es de 2000 y el lado es de 500.
Tendrá un método addPaquete(Paqueteria paquete) que nos añade un paquete al arrayList
Tendrá un método eliminarMasPesados(int peso) que nos elimine los elementos del arrayList que sean más pesados que el peso que se le pasa como parámetro.
Tendrá un método totalPeso que nos diga el total de los pesos de los componentes del arraylist
Y un método totalAncho que nos devolverá la suma de las diagonales de los componentes del arrayList
Una vez tengamos esto en addPaquete tendremos que comprobar que el elemento que añadimos no hace que el total del peso sea mayor que la capacidad, no que el total del ancho sea mayor que el lado.
Por último crear un método fueraTelevisores() que nos elimine del arraylist todos los televisores.
Vamos a crear la clase Almacen que tiene como propiedades
Un array de 20 pales
Un arrayList de Paqueteria
En el contructor inicializamos el array con los 20 pales sin parámetros y el arraylist.
Tenemos un método addPaquete que nos añade el paquete a la paquetería.
Y un método llenarPales que nos va cogiendo los elementos que hay en el arraylist y metiéndolos en los palés hasta su capacidad. Cuando llenamos uno, pasamos al siguiente.
package com.trifulcas.preexamen;
public class Televisor implements Paqueteria {
private String modelo;
private int pulgadas;
private int peso;
public Televisor(String modelo, int pulgadas, int peso) {
super();
this.modelo = modelo;
this.pulgadas = pulgadas;
this.peso = peso;
}
/**
* @return the modelo
*/
public String getModelo() {
return modelo;
}
/**
* @param modelo the modelo to set
*/
public void setModelo(String modelo) {
this.modelo = modelo;
}
/**
* @return the pulgadas
*/
public int getPulgadas() {
return pulgadas;
}
/**
* @param pulgadas the pulgadas to set
*/
public void setPulgadas(int pulgadas) {
this.pulgadas = pulgadas;
}
/**
* @return the peso
*/
public int getPeso() {
return peso;
}
/**
* @param peso the peso to set
*/
public void setPeso(int peso) {
this.peso = peso;
}
@Override
public String toString() {
return "Televisor [modelo=" + modelo + ", pulgadas=" + pulgadas + ", peso=" + peso + "]";
}
@Override
public int getDiagonal() {
// TODO Auto-generated method stub
return getPulgadas()*5;
}
}
package com.trifulcas.preexamen;
public class Ordenador implements Paqueteria{
private String nombre;
private int ram;
private int hdd;
private String placa;
public Ordenador(String nombre, int ram, int hdd, String placa) {
super();
this.nombre = nombre;
this.ram = ram;
this.hdd = hdd;
this.placa = placa;
}
/**
* @return the nombre
*/
public String getNombre() {
return nombre;
}
/**
* @param nombre the nombre to set
*/
public void setNombre(String nombre) {
this.nombre = nombre;
}
/**
* @return the ram
*/
public int getRam() {
return ram;
}
/**
* @param ram the ram to set
*/
public void setRam(int ram) {
this.ram = ram;
}
/**
* @return the hdd
*/
public int getHdd() {
return hdd;
}
/**
* @param hdd the hdd to set
*/
public void setHdd(int hdd) {
this.hdd = hdd;
}
/**
* @return the placa
*/
public String getPlaca() {
return placa;
}
/**
* @param placa the placa to set
*/
public void setPlaca(String placa) {
this.placa = placa;
}
@Override
public String toString() {
return "Ordenador [nombre=" + nombre + ", ram=" + ram + ", hdd=" + hdd + ", placa=" + placa + "]";
}
@Override
public int getPeso() {
// TODO Auto-generated method stub
return 500;
}
@Override
public int getDiagonal() {
// TODO Auto-generated method stub
return 70;
}
}
package com.trifulcas.preexamen;
public class Lavavajillas implements Paqueteria {
private String marca;
private int capacidad;
public Lavavajillas(String marca, int capacidad) {
super();
this.marca = marca;
this.capacidad = capacidad;
}
/**
* @return the marca
*/
public String getMarca() {
return marca;
}
/**
* @param marca the marca to set
*/
public void setMarca(String marca) {
this.marca = marca;
}
/**
* @return the capacidad
*/
public int getCapacidad() {
return capacidad;
}
/**
* @param capacidad the capacidad to set
*/
public void setCapacidad(int capacidad) {
this.capacidad = capacidad;
}
@Override
public String toString() {
return "Lavavajillas [marca=" + marca + ", capacidad=" + capacidad + "]";
}
@Override
public int getPeso() {
// TODO Auto-generated method stub
return 200*getCapacidad();
}
@Override
public int getDiagonal() {
// TODO Auto-generated method stub
return (int) (getCapacidad()*.7);
}
}
package com.trifulcas.preexamen;
public interface Paqueteria {
int getPeso();
int getDiagonal();
}
package com.trifulcas.preexamen;
import java.util.ArrayList;
import java.util.List;
public class Pale {
private int capacidad;
private int lado;
private List<Paqueteria> paquetes;
public Pale(int capacidad, int lado) {
super();
this.capacidad = capacidad;
this.lado = lado;
paquetes = new ArrayList<Paqueteria>();
}
public Pale() {
this(2000, 500);
}
public void addPaquete(Paqueteria paquete) {
if (cabePaquete(paquete)) {
paquetes.add(paquete);
}
}
public void eliminarMasPesados(int peso) {
// Voy del final al principio para que no se me 'mueva' el arraylist
for (int i = paquetes.size() - 1; i >= 0; i--) {
if (paquetes.get(i).getPeso() > peso) {
paquetes.remove(i);
}
}
}
public int totalPeso() {
int res = 0;
for (Paqueteria paquete : paquetes) {
res += paquete.getPeso();
}
return res;
}
public int totalAncho() {
int res = 0;
for (Paqueteria paquete : paquetes) {
res += paquete.getDiagonal();
}
return res;
}
@Override
public String toString() {
return "Pale [capacidad=" + capacidad + ", lado=" + lado + ", paquetes=" + paquetes + "]";
}
public void fueraTelevisores() {
for (int i = paquetes.size() - 1; i >= 0; i--) {
if (paquetes.get(i) instanceof Televisor) {
paquetes.remove(i);
}
}
}
public boolean cabePaquete(Paqueteria paquete) {
return totalPeso() + paquete.getPeso() <= capacidad && totalAncho()+paquete.getDiagonal()<=lado;
}
}
package com.trifulcas.preexamen;
import java.util.ArrayList;
import java.util.List;
public class Almacen {
private Pale[] pales;
private List<Paqueteria> paquetes;
public Almacen() {
paquetes = new ArrayList<Paqueteria>();
pales = new Pale[20];
for (int i = 0; i < 20; i++) {
pales[i] = new Pale();
}
}
public void addPaquete(Paqueteria paquete) {
paquetes.add(paquete);
}
public void llenarPales() {
for (int i = paquetes.size() - 1; i >= 0; i--) {
for (int j = 0; j < 20; j++) {
if (pales[j].cabePaquete(paquetes.get(i))) {
pales[j].addPaquete(paquetes.get(i));
paquetes.remove(i);
break;
}
}
}
}
}
package com.trifulcas.preexamen;
public class TestPreExamen {
public static void main(String[] args) {
Televisor lg = new Televisor("lg", 40, 100);
System.out.println(lg);
System.out.println(lg.getDiagonal());
Ordenador dell=new Ordenador("Dell",10,10,"AMD");
System.out.println(dell);
Lavavajillas braun=new Lavavajillas("Braun",200);
System.out.println(braun);
System.out.println(braun.getDiagonal());
System.out.println(braun.getPeso());
Pale pale=new Pale(3000,700);
pale.addPaquete(braun);
pale.addPaquete(dell);
pale.addPaquete(lg);
System.out.println(pale);
pale.fueraTelevisores();
System.out.println(pale);
}
}
package com.trifulcas.ejemplos;
public class EjemploStatic {
public String nombre;
// Quiere decir dos cosas: Existe aunque no haya instancia de la clase
// El valor es compartido por todas las instancias de esta clase
public static String aula;
public void saludo() {
System.out.println("Hola "+nombre);
}
public static void despedida() {
// Esto da un error no puedo acceder a propiedades no estáticas
//System.out.println("Adios "+nombre);
}
public static void dondeEstoy() {
System.out.println("Estoy en el aula "+aula);
}
}
EjemploStatic.aula="Aula 10"; EjemploStatic a=new EjemploStatic(); a.nombre="Ana"; System.out.println(a.aula); a.saludo(); a.dondeEstoy(); EjemploStatic b=new EjemploStatic(); b.nombre="Eva"; b.dondeEstoy(); System.out.println(b.aula);
No están del todo mal y vienen resueltos:
https://www3.ntu.edu.sg/home/ehchua/programming/java/J3f_OOPExercises.html#zz-6.
package com.trifulcas.cartas;
public abstract class Carta {
private String palo;
private int numero;
public abstract int getValor();
/**
* @return the palo
*/
public String getPalo() {
return palo;
}
/**
* @param palo the palo to set
*/
public void setPalo(String palo) {
this.palo = palo;
}
/**
* @return the numero
*/
public int getNumero() {
return numero;
}
/**
* @param numero the numero to set
*/
public void setNumero(int numero) {
this.numero = numero;
}
public String toString() {
return palo+" | "+numero;
}
}
package com.trifulcas.cartas;
public class Espanyola extends Carta {
@Override
public int getValor() {
int res = getNumero();
if (res == 11 || res == 12) {
res = 10;
}
return res;
}
}
package com.trifulcas.cartas;
public class Francesa extends Carta {
@Override
public int getValor() {
return getNumero();
}
public void quienSoy() {
System.out.println("Carta de la baraja Francesa");
}
}
package com.trifulcas.cartas;
import java.util.ArrayList;
import java.util.List;
public class Baraja implements JuegoAzar {
private List<Carta> cartas;
public Baraja() {
cartas = new ArrayList<Carta>();
}
public void addCarta(Carta carta) {
if (carta instanceof Francesa) {
Francesa temp=(Francesa)carta;
temp.quienSoy();
}
cartas.add(carta);
}
public int totalValor() {
int res = 0;
for (Carta carta : cartas) {
res += carta.getValor();
}
return res;
}
public String toString() {
String res = "";
for (Carta carta : cartas) {
res += carta + " - ";
}
return res;
}
@Override
public void mezclar() {
System.out.println("Mezclando las cartas");
}
}
package com.trifulcas.cartas;
public interface JuegoAzar {
public void mezclar();
}
package com.trifulcas.cartas;
import java.util.ArrayList;
import java.util.List;
public class Domino implements JuegoAzar{
List<String> piezas;
public Domino() {
piezas = new ArrayList<String>();
}
public void esDomino() {
System.out.println("Dominó");
}
@Override
public void mezclar() {
System.out.println("Mezclando las fichas");
}
}
package com.trifulcas.cartas;
import java.util.ArrayList;
import java.util.List;
public class TestCartas {
public static void main(String[] args) {
Carta sotabastos = new Espanyola();
sotabastos.setPalo("Bastos");
sotabastos.setNumero(10);
System.out.println(sotabastos);
Carta sietepicas = new Francesa();
sietepicas.setNumero(7);
sietepicas.setPalo("Picas");
System.out.println(sietepicas);
((Francesa)sietepicas).quienSoy();
Francesa cuatrotreboles=new Francesa();
cuatrotreboles.setNumero(4);
cuatrotreboles.setPalo("Treboles");
cuatrotreboles.quienSoy();
Carta reyespadas = new Espanyola();
reyespadas.setPalo("Espadas");
reyespadas.setNumero(12);
System.out.println(reyespadas);
Baraja miBaraja = new Baraja();
miBaraja.addCarta(sietepicas);
miBaraja.addCarta(sotabastos);
miBaraja.addCarta(reyespadas);
miBaraja.addCarta(cuatrotreboles);
System.out.println(miBaraja);
System.out.println(miBaraja.totalValor());
JuegoAzar[] juegos= {new Baraja(),new Domino()};
for(JuegoAzar juego:juegos) {
if (juego instanceof Domino) {
((Domino) juego).esDomino();
}
juego.mezclar();
}
}
}
Vamos a crear la siguiente clase abstracta:
Carta
Que tiene dos propiedades:
String palo
int numero
Con sus getters y setters
Y un método abstracto
getValor()
De ahí vamos a derivar dos clases NO abstractas
Espanyola
Francesa
En Espanyola la función getValor nos devuelve el número que hay en numero EXCEPTO si número es 11 o 12 que devuelve 10.
En Francesa la función getValor nos devuelve siempre el número.
Después podemos crear una clase Baraja que tenga un arraylist de tipo Carta.
Añadimos los métodos addCarta que nos añada una carta al arraylist y un método totalValor que nos sume los valores de las cartas.
package com.trifulcas.cartas;
public abstract class Carta {
private String palo;
private int numero;
public abstract int getValor();
/**
* @return the palo
*/
public String getPalo() {
return palo;
}
/**
* @param palo the palo to set
*/
public void setPalo(String palo) {
this.palo = palo;
}
/**
* @return the numero
*/
public int getNumero() {
return numero;
}
/**
* @param numero the numero to set
*/
public void setNumero(int numero) {
this.numero = numero;
}
public String toString() {
return palo+" | "+numero;
}
}
package com.trifulcas.cartas;
public class Espanyola extends Carta {
@Override
public int getValor() {
int res = getNumero();
if (res == 11 || res == 12) {
res = 10;
}
return res;
}
}
package com.trifulcas.cartas;
public class Francesa extends Carta {
@Override
public int getValor() {
return getNumero();
}
}
package com.trifulcas.cartas;
import java.util.ArrayList;
import java.util.List;
public class Baraja {
private List<Carta> cartas;
public Baraja() {
cartas = new ArrayList<Carta>();
}
public void addCarta(Carta carta) {
cartas.add(carta);
}
public int totalValor() {
int res = 0;
for (Carta carta : cartas) {
res += carta.getValor();
}
return res;
}
public String toString() {
String res="";
for (Carta carta : cartas) {
res += carta+" - ";
}
return res;
}
}
package com.trifulcas.cartas;
public class TestCartas {
public static void main(String[] args) {
Carta sotabastos=new Espanyola();
sotabastos.setPalo("Bastos");
sotabastos.setNumero(10);
System.out.println(sotabastos);
Carta sietepicas=new Francesa();
sietepicas.setNumero(7);
sietepicas.setPalo("Picas");
System.out.println(sietepicas);
Carta reyespadas=new Espanyola();
reyespadas.setPalo("Espadas");
reyespadas.setNumero(12);
System.out.println(reyespadas);
Baraja miBaraja=new Baraja();
miBaraja.addCarta(sietepicas);
miBaraja.addCarta(sotabastos);
miBaraja.addCarta(reyespadas);
System.out.println(miBaraja);
System.out.println(miBaraja.totalValor());
}
}
Vamos a crear un POJO y una capa DAO para ‘category’
Nosotros sabemos acceder a la base de datos vía el conector y sql. Pero nunca vamos a acceder directamente. Siempre colocaremos una capa entre el acceso a la base de datos y el programa.
Esto actualmente se hace de dos maneras: Creando una capa de datos o usando un framework ORM.
¿Que necesitamos?
En primer lugar un POJO que refleje el registro de la base de datos. Es un objeto plano para alamacenar información. COsas básicas: los mismos campos que en la base de datos y setters y getters. Cosas útiles: Un constructor con todos los campos y una sobrecarga de toString.
¿Es necesario que sea igualito que la base de datos? No, pero sí es conveniente.
Si yo en mi base de datos tengo los campos ‘id’ y ‘nombre’ en mi POJO tendré las propiedades ‘id’ y ‘nombre’
private int id; private String nombre;
Después me creo una capa para conectar con la BD y realizar las operaciones de mantenimento. Se le suele llamar DAO (Data Access Object) . Esto nos separa la base de datos concreta del uso de la misma en el código. Estamos DESACOPLANDO. En programación es importante tener las piezas lo menos dependientes unas de otras.
¿Qué tiene que tener la capa DAO? La funcionalidad básica (CRUD) de acceso a los datos más todas las sobrecargas o métodos que consideremos útiles. Se encargará de recuperar los datos de la base de datos, empaquetarlos en el POJO y mandarlos al usuario. O obtener el POJO del usuario y mapearlo con el registro de la base de datos.
Ejemplos: getActor(), addActor(),….
Una vez creado esto yo puedo utilizar en mi programa el POJO para almacenar información recuperada de la base de datos, para crear información nueva y la capa de datos para tratar con los registros de la base de datos.
Usar mi capa de datos en un mantenimiento:
package com.trifulcas.datos;
import java.util.List;
import java.util.Scanner;
public class AccesoDAO {
public static void main(String[] args) {
try {
// He abstraído la base de datos
// Sólo tengo que crear una instancia de mi capa de Datos
ActorDAO bd = new ActorDAO();
Scanner in = new Scanner(System.in);
int res = 0;
do {
System.out.println(
"1.- Buscar actores\n2.- Añadir actores\n3.- Modificar actores\n4.- Eliminar\n0.- Salir");
res = in.nextInt();
String sql, nombre, apellido;
int actor_id;
switch (res) {
case 1:
System.out.println("Buscar actores");
System.out.println("Dime una parte el apellido");
String cad = in.next();
List<Actor> actores = bd.getActors(cad);
for (Actor actor : actores) {
System.out.println(actor);
}
break;
case 2:
System.out.println("Añadir actores");
System.out.println("Dime el nombre");
nombre = in.next();
System.out.println("Dime el apellido");
apellido = in.next();
if (bd.addActor(new Actor(0, nombre, apellido, null))) {
System.out.println("Registro insertado");
} else {
System.out.println("No se ha insertado el registro");
}
break;
case 3:
System.out.println("Modificar actores");
System.out.println("Dime el id del actor que quieres modificar");
actor_id = in.nextInt();
System.out.println("Dime el nombre");
nombre = in.next();
System.out.println("Dime el apellido");
apellido = in.next();
if (bd.updateActor(new Actor(actor_id, nombre, apellido, null))) {
System.out.println("Registro modificado");
} else {
System.out.println("No se ha modificado el registro");
}
break;
case 4:
System.out.println("Eliminar actores");
System.out.println("Dime el id del actor que quieres eliminar");
actor_id = in.nextInt();
if (bd.deleteActor(actor_id)) {
System.out.println("Registro eliminado");
} else {
System.out.println("No se ha eliminado el registro");
}
break;
}
} while (res != 0);
} catch (Exception ex) {
System.out.println(ex);
}
}
}
package com.trifulcas.datos;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class ActorDAO {
private Connection con;
private int max_records=1000;
public ActorDAO() {
try {
Class.forName("com.mysql.cj.jdbc.Driver");
con = DriverManager.getConnection("jdbc:mysql://localhost:3306/sakila", "root", "");
} catch (Exception ex) {
System.out.println(ex);
}
}
public Actor getActor(int id) {
Actor res = null;
try {
String sql = "select * from actor where actor_id=?" ;
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setInt(1, id);
ResultSet rs = stmt.executeQuery();
if (rs.next()) {
res = new Actor(rs.getInt("actor_id"), rs.getString("first_name"),rs.getString("last_name"),rs.getDate("last_update"));
}
} catch (Exception ex) {
System.out.println(ex);
}
return res;
}
public List<Actor> getActors(int limite){
List<Actor> res=new ArrayList<Actor>();
try {
String sql = "select * from actor limit ?" ;
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setInt(1, limite);
ResultSet rs = stmt.executeQuery();
while (rs.next()) {
Actor temp = new Actor(rs.getInt("actor_id"), rs.getString("first_name"),rs.getString("last_name"),rs.getDate("last_update"));
res.add(temp);
}
} catch (Exception ex) {
System.out.println(ex);
}
return res;
}
public List<Actor> getActors(){
return getActors(max_records);
}
/**
* Devuelve un arraylist de actores cuyo apellido contenga la cadena que le pasamos
* @param cad cadena a buscar
* @return ArrayList de actores
*/
public List<Actor> getActors(String cad) {
List<Actor> res = new ArrayList<Actor>();
try {
String sql = "select * from actor where last_name like ?";
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setString(1, '%'+cad+'%');
ResultSet rs = stmt.executeQuery();
while (rs.next()) {
Actor temp = new Actor(rs.getInt("actor_id"), rs.getString("first_name"), rs.getString("last_name"),
rs.getDate("last_update"));
res.add(temp);
}
} catch (Exception ex) {
System.out.println(ex);
}
return res;
}
public boolean addActor(Actor actor) {
try {
String sql = "insert into actor (first_name, last_name) values (?,?)" ;
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setString(1, actor.getFirst_name());
stmt.setString(2, actor.getLast_name());
int res=stmt.executeUpdate();
return res==1;
} catch (Exception ex) {
System.out.println(ex);
}
return false;
}
public boolean updateActor(Actor actor) {
try {
String sql = "update actor set first_name=?, last_name=? where actor_id=?" ;
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setString(1, actor.getFirst_name());
stmt.setString(2, actor.getLast_name());
stmt.setInt(3, actor.getActor_id());
int res=stmt.executeUpdate();
return res==1;
} catch (Exception ex) {
System.out.println(ex);
}
return false;
}
public boolean deleteActor(Actor actor) {
try {
return deleteActor(actor.getActor_id());
} catch (Exception ex) {
System.out.println(ex);
}
return false;
}
public boolean deleteActor(int actor_id) {
try {
String sql = "delete from actor where actor_id=?" ;
PreparedStatement stmt = con.prepareStatement(sql);
stmt.setInt(1, actor_id);
int res=stmt.executeUpdate();
return res==1;
} catch (Exception ex) {
System.out.println(ex);
}
return false;
}
}
package com.trifulcas.datos;
import java.util.List;
public class AccesoDAO {
public static void main(String[] args) {
// He abstraído la base de datos
// Sólo tengo que crear una instancia de mi capa de Datos
ActorDAO bd=new ActorDAO();
// Trabajo exclusivamente con POJO no con registros de la base de datos
// Que hasta desconozco o no me interesa como están implementados
Actor penelope=bd.getActor(1);
System.out.println(penelope.getFirst_name());
// Obtengo todos los actores en una lista y recorro la lista
List<Actor> actores=bd.getActors(20);
for(Actor actor:actores) {
System.out.println(actor);
}
// Para añadir creo un actor nuevo y después llamo a la capa DAO para añadirlo
Actor nuevo=new Actor(1,"wilfredo","etxevarria",null);
if(bd.addActor(nuevo)) {
System.out.println("Actor "+nuevo+" añadido");
}
// Modifico un actor
penelope.setLast_name("Campofrío");
bd.updateActor(penelope);
// Elimino el actor concreto o por id
Actor w=bd.getActor(320);
bd.deleteActor(w);
bd.deleteActor(321);
}
}