diff --git a/src/tutorialJava/capitulo5/ej06_PatronSingleton/Player.java b/src/tutorialJava/capitulo5/ej06_PatronSingleton/Player.java new file mode 100644 index 0000000..c1ad6c9 --- /dev/null +++ b/src/tutorialJava/capitulo5/ej06_PatronSingleton/Player.java @@ -0,0 +1,37 @@ +package tutorialJava.capitulo5.ej06_PatronSingleton; + +public class Player { + + private String nombre; + + private static Player instance = null; // Singleton + + // Singleton + public static Player getInstance() { + if (instance == null) { + instance = new Player("Nave"); + } + return instance; + } + + public Player(String nombre) { + super(); + this.nombre = nombre; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public String toString() { + return "Player [nombre=" + nombre + "]"; + } + + + +} diff --git a/src/tutorialJava/capitulo5/ej06_PatronSingleton/Principal.java b/src/tutorialJava/capitulo5/ej06_PatronSingleton/Principal.java new file mode 100644 index 0000000..80d2e2b --- /dev/null +++ b/src/tutorialJava/capitulo5/ej06_PatronSingleton/Principal.java @@ -0,0 +1,14 @@ +package tutorialJava.capitulo5.ej06_PatronSingleton; + +public class Principal { + + public static void main(String[] args) { + + // Desde un localizador de colisiones + System.out.println("Llamada 1: " + Player.getInstance()); + + System.out.println("Llamada 2: " + Player.getInstance()); + + } + +} diff --git a/src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/KKListener.java b/src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/KKListener.java new file mode 100644 index 0000000..1f113ac --- /dev/null +++ b/src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/KKListener.java @@ -0,0 +1,82 @@ +package tutorialJava.capitulo5.ej07_InterfaceWindowListener; + +import java.awt.event.MouseEvent; +import java.awt.event.MouseListener; +import java.awt.event.WindowEvent; +import java.awt.event.WindowListener; + +public class KKListener implements WindowListener, MouseListener { + + @Override + public void mouseClicked(MouseEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void mousePressed(MouseEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseReleased(MouseEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseEntered(MouseEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void mouseExited(MouseEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowOpened(WindowEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowClosing(WindowEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowClosed(WindowEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowIconified(WindowEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowDeiconified(WindowEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowActivated(WindowEvent e) { + // TODO Auto-generated method stub + + } + + @Override + public void windowDeactivated(WindowEvent e) { + // TODO Auto-generated method stub + + } + +} diff --git a/src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/Principal.java b/src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/Principal.java new file mode 100644 index 0000000..765fbc6 --- /dev/null +++ b/src/tutorialJava/capitulo5/ej07_InterfaceWindowListener/Principal.java @@ -0,0 +1,37 @@ +package tutorialJava.capitulo5.ej07_InterfaceWindowListener; + +import java.awt.event.WindowAdapter; +import java.awt.event.WindowEvent; +import java.awt.event.WindowListener; + +import javax.swing.JFrame; + +public class Principal { + + + + public static void main(String[] args) { + + JFrame ventana = new JFrame("Título de la ventana"); + ventana.setBounds(0, 0, 800, 600); + ventana.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); + + ventana.addWindowListener(new WindowAdapter() { + + @Override + public void windowClosing(WindowEvent e) { + super.windowClosing(e); + }}); + + ventana.setVisible(true); + + } + +} + + + + + + + diff --git a/src/tutorialJava/capitulo5/simulacroExamen01_poker/Baraja.java b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Baraja.java new file mode 100644 index 0000000..74d0fe8 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Baraja.java @@ -0,0 +1,116 @@ +package tutorialJava.capitulo5.simulacroExamen01_poker; + +import tutorialJava.Utils; + +public class Baraja { + + private Carta baraja[] = new Carta[52]; + + public Baraja () { + for (int i = 0; i < 13; i++) { + baraja[i] = new Carta(); + baraja[i].setValor(i + 1); + baraja[i].setPalo("Picas"); + } + for (int i = 0; i < 13; i++) { + baraja[i + 13] = new Carta(); + baraja[i + 13].setValor(i + 1); + baraja[i + 13].setPalo("Diamantes"); + } + for (int i = 0; i < 13; i++) { + baraja[i + 26] = new Carta(); + baraja[i + 26].setValor(i + 1); + baraja[i + 26].setPalo("Tréboles"); + } + for (int i = 0; i < 13; i++) { + baraja[i + 39] = new Carta(); + baraja[i + 39].setValor(i + 1); + baraja[i + 39].setPalo("Corazones"); + } + + // Inicializo id de ordenación de cada carta + for (int i = 0; i < baraja.length; i++) { + baraja[i].setIdOrdenacion(i); + } + } + + + public void pasaCartaDeAbajoHaciaArriba() { + Carta aux = baraja[baraja.length - 1]; + for (int i = (baraja.length - 1); i > 0; i--) { + baraja[i] = baraja[i - 1]; + } + baraja[0] = aux; + } + + public void pasaCartaDeArribaHaciaAbajo() { + Carta aux = baraja[0]; + for (int i = 0; i < (baraja.length - 1); i++) { + baraja[i] = baraja[i + 1]; + } + baraja[baraja.length - 1] = aux; + } + + public void mezclar() { + for (int i = 0; i < baraja.length; i++) { + int indice1 = Utils.obtenerNumeroAzar(0, baraja.length - 1); + int indice2 = Utils.obtenerNumeroAzar(0, baraja.length - 1); + + Carta aux = baraja[indice1]; + baraja[indice1] = baraja[indice2]; + baraja[indice2] = aux; + } + } + + public void ordenar() { + boolean hayIntercambios; + do { + hayIntercambios = false; + for (int i = 0; i < (baraja.length - 1); i++) { + if (baraja[i].getIdOrdenacion() > baraja[i + 1].getIdOrdenacion()) { + Carta aux = baraja[i]; + baraja[i] = baraja[i + 1]; + baraja[i + 1] = aux; + hayIntercambios = true; + } + } + } while (hayIntercambios == true); + } + + public void reparteManoAJugador(Jugador j) { + int cartasDadas = 0; + for (int i = baraja.length - 1; i > -1 && + cartasDadas < j.getMano().length; i--) { + + if (baraja[i] != null) { + j.getMano()[cartasDadas] = baraja[i]; + cartasDadas++; + baraja[i] = null; + } + } + } + + + public Carta[] getBaraja() { + return baraja; + } + public void setBaraja(Carta[] baraja) { + this.baraja = baraja; + } +} + + + + + + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo5/simulacroExamen01_poker/Carta.java b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Carta.java new file mode 100644 index 0000000..4a2f889 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Carta.java @@ -0,0 +1,63 @@ +package tutorialJava.capitulo5.simulacroExamen01_poker; + +public class Carta { + + private int valor; + private String palo; + private int idOrdenacion; + + public Carta () { + } + + public String toString() { + StringBuffer sb = new StringBuffer(); + + switch(valor) { + case 1: + sb.append("As"); break; + case 11: + sb.append("J"); break; + case 12: + sb.append("Q"); break; + case 13: + sb.append("K"); break; + default: + sb.append(valor); + } + + sb.append(":"); + + if (palo.equalsIgnoreCase("Corazones")) sb.append("C"); + else if (palo.equalsIgnoreCase("Tréboles")) sb.append("T"); + else if (palo.equalsIgnoreCase("Diamantes")) sb.append("D"); + else sb.append("P"); + + return sb.toString(); + } + + public int getValor() { + return valor; + } + + public void setValor(int valor) { + this.valor = valor; + } + + public String getPalo() { + return palo; + } + + public void setPalo(String palo) { + this.palo = palo; + } + + public int getIdOrdenacion() { + return idOrdenacion; + } + + public void setIdOrdenacion(int idOrdenacion) { + this.idOrdenacion = idOrdenacion; + } + + +} diff --git a/src/tutorialJava/capitulo5/simulacroExamen01_poker/Jugador.java b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Jugador.java new file mode 100644 index 0000000..5f83834 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Jugador.java @@ -0,0 +1,38 @@ +package tutorialJava.capitulo5.simulacroExamen01_poker; + +import java.util.Arrays; + +public class Jugador { + private String nombre; + private Carta mano[]; + + public Jugador () { + mano = new Carta[5]; + } + + public void obtenManoDeCartas(Baraja baraja) { + + } + + public String toString() { + return "Jugador [nombre=" + nombre + ", mano=" + Arrays.toString(mano) + "]"; + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + public Carta[] getMano() { + return mano; + } + + public void setMano(Carta[] mano) { + this.mano = mano; + } + + +} diff --git a/src/tutorialJava/capitulo5/simulacroExamen01_poker/Poker.java b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Poker.java new file mode 100644 index 0000000..e9d5d49 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Poker.java @@ -0,0 +1,22 @@ +package tutorialJava.capitulo5.simulacroExamen01_poker; + +public class Poker { + // Creo los jugadores y asigno manos a los mismos + private Jugador jugadores[] = new Jugador[5]; + private String nombres[] = new String[] {"Dario", "José Luis", "Carmen", "José", "Alba"}; + private Baraja baraja = new Baraja(); + + /** + * + */ + public Poker () { + baraja.mezclar(); + for (int i = 0; i < jugadores.length; i++) { + jugadores[i] = new Jugador(); + jugadores[i].setNombre(nombres[i]); + baraja.reparteManoAJugador(jugadores[i]); + jugadores[i].obtenManoDeCartas(baraja); + } + System.out.println(); + } +} diff --git a/src/tutorialJava/capitulo5/simulacroExamen01_poker/Principal.java b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Principal.java new file mode 100644 index 0000000..7c2b863 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen01_poker/Principal.java @@ -0,0 +1,21 @@ +package tutorialJava.capitulo5.simulacroExamen01_poker; + +public class Principal { + + public static void main (String args[]) { + Poker poker = new Poker(); + + System.out.println(); + } +} + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Juego.java b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Juego.java new file mode 100644 index 0000000..13eb573 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Juego.java @@ -0,0 +1,99 @@ +package tutorialJava.capitulo5.simulacroExamen02_arkanoid; + +import java.util.Iterator; + +import tutorialJava.Utils; + +public class Juego { + private Ladrillo ladrillos[] = new Ladrillo[20]; + private Pelota pelota = new Pelota(); + private Ladrillo ladrillosDestruidos[] = new Ladrillo[20]; + private int contadorLadrillosDestruidos = 0; + + public Juego() { + for (int i = 0; i < ladrillos.length; i++) { + ladrillos[i] = new Ladrillo(); + ladrillos[i].setNombre("L" + i); + } + } + + /** + * + */ + public void jugar() { + + do { + pelota.mueveAlAzar(); + boolean colisionConLadrillos = false; + for (Ladrillo l : ladrillos) { + if (l.getPuntosVida() > 0) { + if (pelota.chocaConLadrillo(l)) { + l.quitoPuntoDeVida(); + colisionConLadrillos = true; + agregaLadrilloADestruidosSiCorresponde(l); + } + } + } + if (colisionConLadrillos == true) { + muestraArrayLadrillos(); + } + } while (quedanLadrillos()); + // Estadísticas + System.out.println("Primero en ser destruido: " + ladrillosDestruidos[0].toString()); + System.out.println("Último en ser destruido: " + + ladrillosDestruidos[ladrillosDestruidos.length - 1].toString()); + + System.out.println("Orden de destrucción de los ladrillos"); + muestraArrayLadrillosDestruidos(); + } + + + private void agregaLadrilloADestruidosSiCorresponde(Ladrillo l) { + if (l.getPuntosVida() <= 0) { + ladrillosDestruidos[contadorLadrillosDestruidos] = l; + contadorLadrillosDestruidos++; + } + } + + + private void muestraArrayLadrillosDestruidos() { + for (Ladrillo l : ladrillosDestruidos) { + System.out.print(l.toString() + "-"); + } + System.out.println(); + } + + + private void muestraArrayLadrillos() { + for (Ladrillo l : ladrillos) { + if (l.getPuntosVida() > 0) { + System.out.print(l.toString() + "-"); + } + } + System.out.println(); + } + + + private boolean quedanLadrillos() { + for (Ladrillo l : ladrillos) { + if (l.getPuntosVida() > 0) { + return true; + } + } + return false; + } + + + public Ladrillo[] getLadrillos() { + return ladrillos; + } + public void setLadrillos(Ladrillo[] ladrillos) { + this.ladrillos = ladrillos; + } + public Pelota getPelota() { + return pelota; + } + public void setPelota(Pelota pelota) { + this.pelota = pelota; + } +} diff --git a/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Ladrillo.java b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Ladrillo.java new file mode 100644 index 0000000..810dac4 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Ladrillo.java @@ -0,0 +1,114 @@ +package tutorialJava.capitulo5.simulacroExamen02_arkanoid; + +import tutorialJava.Utils; + +public class Ladrillo { + + public static String COLORES[] = new String[] {"rojo", "verde", "azul"}; + + private String nombre; + private String color; + private int x; + private int y, ancho, alto, puntosVida; + + public Ladrillo() { + super(); + x = Utils.obtenerNumeroAzar(0, 800); + y = Utils.obtenerNumeroAzar(0, 500); + ancho = 100; + alto = 50; + puntosVida = Utils.obtenerNumeroAzar(1, 3); + asignaColor(); + } + + private void asignaColor() { + switch(puntosVida) { + case 1: + color = COLORES[Utils.obtenerNumeroAzar(0, COLORES.length - 1)]; + break; + case 2: + color = "Plateado"; + break; + default: + color = "Dorado"; + } + } + + public void quitoPuntoDeVida() { + puntosVida -= 1; + } + + public String getColor() { + return color; + } + + public void setColor(String newColor) { + color = newColor; + } + + public int getX() { + return x; + } + + public void setX(int x) { + this.x = x; + } + + public int getY() { + return y; + } + + public void setY(int y) { + this.y = y; + } + + public int getAncho() { + return ancho; + } + + public void setAncho(int ancho) { + this.ancho = ancho; + } + + public int getAlto() { + return alto; + } + + public void setAlto(int alto) { + this.alto = alto; + } + + public int getPuntosVida() { + return puntosVida; + } + + public void setPuntosVida(int puntosVida) { + this.puntosVida = puntosVida; + } + + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + public String toString() { + return nombre + ":" + puntosVida; + } + + +} + + + + + + + + + + + diff --git a/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Pelota.java b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Pelota.java new file mode 100644 index 0000000..db2a698 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Pelota.java @@ -0,0 +1,55 @@ +package tutorialJava.capitulo5.simulacroExamen02_arkanoid; + +import tutorialJava.Utils; + +public class Pelota { + private int x; + private int y; + + public Pelota() { + super(); + } + + /** + * + * @param l + * @return + */ + public boolean chocaConLadrillo(Ladrillo l) { + if (x >= l.getX() && x <= (l.getX() + l.getAncho()) && + y >= l.getY() && y <= (l.getY() + l.getAlto())) { + return true; + } + return false; + } + + /** + * + */ + public void mueveAlAzar() { + x= Utils.obtenerNumeroAzar(0, 800); + y = Utils.obtenerNumeroAzar(0, 500); + } + + /////// GETTERS Y SETTER + + public String toString() { + return "Pelota [x=" + x + ", y=" + y + "]"; + } + + public int getX() { + return x; + } + public void setX(int x) { + this.x = x; + } + public int getY() { + return y; + } + public void setY(int y) { + this.y = y; + } + + + +} diff --git a/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Principal.java b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Principal.java new file mode 100644 index 0000000..100fd77 --- /dev/null +++ b/src/tutorialJava/capitulo5/simulacroExamen02_arkanoid/Principal.java @@ -0,0 +1,21 @@ +package tutorialJava.capitulo5.simulacroExamen02_arkanoid; + +import java.util.Scanner; + +public class Principal { + + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + String respuestaUsuario; + + do { + System.out.println("\n\n Juego del ARKANOID\n"); + Juego juego = new Juego(); + juego.jugar(); + + System.out.println("¿Quieres volver a jugar? (S -> Sí N -> No): "); + respuestaUsuario = sc.nextLine(); + } while (respuestaUsuario.equalsIgnoreCase("s")); + } + +} diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/Ejemplo01_ListasConInteger.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/Ejemplo01_ListasConInteger.java new file mode 100644 index 0000000..938e3b4 --- /dev/null +++ b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/Ejemplo01_ListasConInteger.java @@ -0,0 +1,51 @@ +package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo01_ListYArrayList; + +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; + +public class Ejemplo01_ListasConInteger { + + public static void main(String[] args) { + // Declarado la lista de Integers + List numeros = new ArrayList(); + + // Inicializar con 10 elementos de tipo Integer + for (int i = 0; i < 10; i++) { + numeros.add(new Integer(100 + i)); + numeros.add(Integer.valueOf(100 + i)); + numeros.add(100 + i); + } + + // Agrego un elemento + numeros.add(1000); + + // Elimino un elemento + numeros.remove(2); + + // Inserto un elemento en una posición concreta + numeros.add(1, 5000); + + // Crear una nueva lista + List numerosNegativos = new ArrayList(); + + // Inicializo la nueva lista + for (int i = 0; i < 3; i++) { + numerosNegativos.add(-1000 + i); + } + + // Agrego la nueva lista en cualquier posición de la antigua lista + numeros.addAll(4, numerosNegativos); + + // Primera forma de eliminar un elemento concreto sin conocer su posición + // Tengo que recorrer todos los elementos de la lista + for (int i = 0; i < numeros.size(); i++) { + if (numeros.get(i).intValue() == 5000) { + numeros.remove(i); + } + } + + System.out.println(""); + } + +} diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/CromoBaloncesto.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/CromoBaloncesto.java new file mode 100644 index 0000000..e8fbaa0 --- /dev/null +++ b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/CromoBaloncesto.java @@ -0,0 +1,33 @@ +package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo01_ListYArrayList.cromosBaloncesto; + +public class CromoBaloncesto { + private int id; + private String nombre; + /** + * @param id + * @param nombre + */ + public CromoBaloncesto(int id, String nombre) { + this.id = id; + this.nombre = nombre; + } + @Override + public String toString() { + return "CromoBaloncesto [id=" + id + ", nombre=" + nombre + "]"; + } + public int getId() { + return id; + } + public void setId(int id) { + this.id = id; + } + public String getNombre() { + return nombre; + } + public void setNombre(String nombre) { + this.nombre = nombre; + } + + + +} diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/EjemploListasCromos.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/EjemploListasCromos.java new file mode 100644 index 0000000..cb77720 --- /dev/null +++ b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo01_ListYArrayList/cromosBaloncesto/EjemploListasCromos.java @@ -0,0 +1,44 @@ +package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo01_ListYArrayList.cromosBaloncesto; + +import java.util.ArrayList; +import java.util.List; + +public class EjemploListasCromos { + + public static void main (String args[]) { + CromoBaloncesto c1 = new CromoBaloncesto(100, "Felipe Reyes"); + CromoBaloncesto c2 = new CromoBaloncesto(200, "Lebron"); + CromoBaloncesto c3 = new CromoBaloncesto(300, "Pau Gasol"); + + List lista = new ArrayList(); + lista.add(c1); + lista.add(c2); + lista.add(10, c3); + + for (CromoBaloncesto c : lista) { + System.out.println(c.getNombre()); + } + + + +// CromoBaloncesto c4 = new CromoBaloncesto(4, "Cristina Castro"); +// CromoBaloncesto c5 = new CromoBaloncesto(5, "María Jesús Joyanes"); +// CromoBaloncesto c6 = new CromoBaloncesto(6, "Alazne Ruiz"); +// +// List lista2 = new ArrayList(); +// lista2.add(c4); +// lista2.add(c5); +// lista2.add(c6); +// +// lista.addAll(1, lista2); +// +// lista.removeAll(lista); +// +// System.out.println("VAcía: " + lista.isEmpty()); +// +// for (CromoBaloncesto c : lista) { +// System.out.println(c.toString()); +// } + + } +} diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/EjemploHashMap.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/EjemploHashMap.java new file mode 100644 index 0000000..624d090 --- /dev/null +++ b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/EjemploHashMap.java @@ -0,0 +1,75 @@ +package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashMap; + +import java.util.HashMap; +import java.util.Iterator; + +public class EjemploHashMap { + + /** + * + */ + private static void ejemploHashMapGeneral () { + // Creaci�n de un HashMap general + HashMap hm = new HashMap(); + + // Inserci�n de datos en un HashMap general + hm.put("1", new Persona ("11111111A", "P�rez P�rez", "Jos�")); + hm.put("2", new Persona ("22222222A", "Mu�oz Mu�oz", "Rafael")); + hm.put("3", new Persona ("33333333A", "Cuenca Cuenca", "Juan")); + hm.put("4", new Persona ("44444444A", "Torralbo Torralbo", "Patricia")); + hm.put("5", new Persona ("55555555A", "L�rida L�rida", "Luc�a")); + + + // Recuperaci�n de datos en un HashMap general + System.out.println("Objeto con id 1: " + hm.get("1")); // Recuperaci�n de un solo objeto + + // Inserci�n de un objeto con un tipo de identificador diferente + hm.put(Integer.valueOf(6), new Persona ("66666666A", "Ram�rez Ram�rez", "Ramiro")); + + + // Recuperaci�n de todas las claves de objetos en el HM + System.out.println("\nRecorrido del HashMap:"); + Object claves[] = hm.keySet().toArray(); + for (int i = 0; i < claves.length; i++) { + System.out.println("Identificador: " + claves[i] + + " - Objeto obtenido: " + hm.get(claves[i])); + } + } + + + /** + * + */ + private static void ejemploHashMapEspecifico () { + // Creaci�n de un HashMap general + HashMap hm = new HashMap(); + + // Inserci�n de datos en un HashMap general + hm.put("1", new Persona ("11111111A", "P�rez P�rez", "Jos�")); + hm.put("2", new Persona ("22222222A", "Mu�oz Mu�oz", "Rafael")); + hm.put("3", new Persona ("33333333A", "Cuenca Cuenca", "Juan")); + hm.put("4", new Persona ("44444444A", "Torralbo Torralbo", "Patricia")); + hm.put("5", new Persona ("55555555A", "L�rida L�rida", "Luc�a")); + + // Eliminaci�n de alg�n elemento en el HM + hm.remove("5"); + + // Recuperaci�n de todos los objetos en el HM + System.out.println("\nRecorrido de los objetos del HashMap:"); + Iterator personas = hm.values().iterator(); + while (personas.hasNext()) { + System.out.println("Objeto obtenido: " + personas.next()); + } + } + + + + /** + * + * @param args + */ + public static void main (String args[]) { + ejemploHashMapGeneral(); + //ejemploHashMapEspecifico(); + } +} diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/Persona.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/Persona.java new file mode 100644 index 0000000..a363010 --- /dev/null +++ b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashMap/Persona.java @@ -0,0 +1,55 @@ +package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashMap; + +public class Persona { + + private String Dni; + private String Apellidos; + private String Nombre; + + + public Persona(String dni, String apellidos, String nombre) { + super(); + Dni = dni; + Apellidos = apellidos; + Nombre = nombre; + } + + + public String getDni() { + return Dni; + } + + + public void setDni(String dni) { + Dni = dni; + } + + + public String getApellidos() { + return Apellidos; + } + + + public void setApellidos(String apellidos) { + Apellidos = apellidos; + } + + + public String getNombre() { + return Nombre; + } + + + public void setNombre(String nombre) { + Nombre = nombre; + } + + + @Override + public String toString() { + return "Persona [Dni=" + Dni + ", Apellidos=" + Apellidos + ", Nombre=" + Nombre + "]"; + } + + + +} diff --git a/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashTable/EjemploHashTable.java b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashTable/EjemploHashTable.java new file mode 100644 index 0000000..cbadf48 --- /dev/null +++ b/src/tutorialJava/capitulo6_ColeccionesDeDatos/ejemplo02_HashTable/EjemploHashTable.java @@ -0,0 +1,36 @@ +package tutorialJava.capitulo6_ColeccionesDeDatos.ejemplo02_HashTable; + +import java.util.Enumeration; +import java.util.Hashtable; + +public class EjemploHashTable { + + public static void main(String[] args) { + + Hashtable ht = new Hashtable(); + ht.put("st01", "String 01"); + ht.put("st02", "String 02"); + ht.put("st03", "String 03"); + ht.put("st04", "String 04"); + + ht.remove("st04"); + + ht.size(); + + Enumeration en = ht.elements(); + while (en.hasMoreElements()) { + Object obj = en.nextElement(); + System.out.println("Elemento: " + obj.toString()); + } + + + en = ht.keys(); + while (en.hasMoreElements()) { + System.out.println("Elemento id: " + en.nextElement() + + " - Obj: " + ht.get(en.nextElement())); + } + + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/EjemploDateCalendar.java b/src/tutorialJava/capitulo7_Recursos/EjemploDateCalendar.java new file mode 100644 index 0000000..5b4571a --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/EjemploDateCalendar.java @@ -0,0 +1,213 @@ +package tutorialJava.capitulo7_Recursos; + +import java.text.ParseException; +import java.text.SimpleDateFormat; +import java.util.Arrays; +import java.util.Calendar; +import java.util.Date; +import java.util.GregorianCalendar; +import java.util.Locale; +import java.util.TimeZone; + +public class EjemploDateCalendar { + + /** + * + */ + private static void ejemploCreacionNormalDate () { + // El constructor por defecto de java.util.Date nos permite crear un objeto con la fecha actual + Date fechaActual = new Date(); + System.out.println("Fecha actual: " + fechaActual.toString()); + // getTime() nos permite acceder a los millis que representan al objeto Date, muy importante conocer esto + System.out.println("Milisegundos actuales: " + fechaActual.getTime()); + } + + /** + * + */ + private static void ejemploFormateoFecha () { + Date ahora = new Date(); + + // El formateo de fechas se puede realizar a trav�s de SimpleDateFormat, de una forma sencilla. + // Consulta Javadoc SimpleDateFormat para más detalles + SimpleDateFormat sdf = new SimpleDateFormat ("EEE, MMM d, ''yy 'at' hh:mm:ss a z"); + System.out.println("Fecha actual: " + sdf.format(ahora)); + + SimpleDateFormat sdf2 = new SimpleDateFormat ("dd/MM/yyyy HH:mm:ss"); + System.out.println("Fecha actual: " + sdf2.format(ahora)); + + Date fechaParseada = null; + // El parseo de fechas debe obligatoriamente ser inspeccionado con un bloque de manejo de excepciones + try { + fechaParseada = sdf2.parse("19/03/1977 15:33:00"); + } catch (ParseException e) { + System.out.println ("Error en el parseo de la fecha"); + e.printStackTrace(); + } + System.out.println("Fecha parseada: " + sdf.format(fechaParseada)); + } + + + /** + * + */ + private static void ejemploCalendarBasico () { + // Otra forma muy habitual de manejar fechas es a través de los objetos de tipo Calendar + Calendar fechaCalendar = new GregorianCalendar(1918, Calendar.APRIL, 01, 22, 05, 23); + System.out.println("Millis: " + fechaCalendar.getTimeInMillis()); + // Es f�cil y muy habitual convertir un Calendar en Date + Date fechaAPartirDeCalendar = new Date(fechaCalendar.getTimeInMillis()); + System.out.println("Fecha a partir de Calendar : " + fechaAPartirDeCalendar); + } + + + + private static void ejemploCalendarConCamposIndividualizados () { + Calendar fechaCalendar = Calendar.getInstance(); // Instanciación por patrón Factory (Recuerda como funciona) + + fechaCalendar.set(Calendar.YEAR, 2018); + // Sobre el mes, recuerda que Enero corresponde al valor int 0 y Diciembre al int 11. Mejor usa las variables estáticas + fechaCalendar.set(Calendar.MONTH, Calendar.APRIL); + fechaCalendar.set(Calendar.DAY_OF_MONTH, 01); + + // Ejemplo de manejo de horas en formato AM/PM + fechaCalendar.set(Calendar.HOUR, 10); + fechaCalendar.set(Calendar.AM_PM, Calendar.PM); + // Puedes preferir el formato 24 horas + fechaCalendar.set(Calendar.HOUR_OF_DAY, 22); + + fechaCalendar.set(Calendar.MINUTE, 05); + fechaCalendar.set(Calendar.SECOND, 23); + fechaCalendar.set(Calendar.MILLISECOND, 123); + + // Conversión a date y formateo + Date fechaAPartirDeCalendar = new Date(fechaCalendar.getTimeInMillis()); + System.out.println("Fecha a partir de Calendar con campos individualizados: " + + new SimpleDateFormat ("dd/MM/yyyy HH:mm:ss").format(fechaAPartirDeCalendar)); + + } + + + /** + * + */ + private static void ejemploLecturaCamposIndividualizadosYLocaleEnImpresion () { +// Locale locale = Locale.getDefault(); + Locale locale = Locale.ITALIAN; + Calendar ahora = Calendar.getInstance(locale); + + System.out.println("Año: " + ahora.get(Calendar.YEAR)); + System.out.println("Mes (0 es Enero): " + ahora.get(Calendar.MONTH)); + ahora.set(Calendar.MONTH, Calendar.JANUARY); + System.out.println("Month (String): " + ahora.getDisplayName(Calendar.MONTH, Calendar.SHORT, locale)); + System.out.println("D�a del mes: " + ahora.get(Calendar.DAY_OF_MONTH)); + System.out.println("D�a de la semana (0 es Domingo): " + ahora.get(Calendar.DAY_OF_WEEK)); + System.out.println("D�a de la semana (String): " + + ahora.getDisplayName(Calendar.DAY_OF_WEEK, Calendar.LONG, locale)); + System.out.println("Semana del año: " + ahora.get(Calendar.WEEK_OF_YEAR)); + System.out.println("Semana del mes: " + ahora.get(Calendar.WEEK_OF_MONTH)); + System.out.println("Día del año: " + ahora.get(Calendar.DAY_OF_YEAR)); + System.out.println("Hora en formato 24H: " + ahora.get(Calendar.HOUR_OF_DAY)); + System.out.println("Hora en formato 12H: " + ahora.get(Calendar.HOUR)); + System.out.println("AM/PM: " + ahora.get(Calendar.AM_PM)); + System.out.println("AM/PM: " + ahora.getDisplayName(Calendar.AM_PM, Calendar.LONG, locale)); + System.out.println("Minutos: " + ahora.get(Calendar.MINUTE)); + System.out.println("Segundos: " + ahora.get(Calendar.SECOND)); + System.out.println("MiliSegundos: " + ahora.get(Calendar.MILLISECOND)); + + // DST_Offset + System.out.println("DST_OFFSET: " + ahora.get(Calendar.DST_OFFSET)); + } + + + + /** + * + */ + private static void ejemploSumaRestaFechas () { + Calendar ahora = Calendar.getInstance(); + ahora.add(Calendar.DAY_OF_MONTH, 20); + System.out.println("Ahora más 20 días : " + ahora.getTime()); + + ahora = Calendar.getInstance(); + ahora.add(Calendar.DAY_OF_MONTH, -20); + System.out.println("Ahora menos 20 días : " + ahora.getTime()); + } + + + /** + * + */ + private static void ejemploComparacionFechas () { + Calendar ahora = Calendar.getInstance(); + Calendar despues = Calendar.getInstance(); + despues.add(Calendar.HOUR_OF_DAY, 2); + + Calendar antes = Calendar.getInstance(); + antes.add(Calendar.HOUR_OF_DAY, -5); + + System.out.println("Ahora es después que después: " + ahora.after(despues)); + System.out.println("Ahora es antes que después: " + ahora.before(despues)); + System.out.println("Ahora es después que antes: " + ahora.after(antes)); + System.out.println("Ahora es antes que antes: " + ahora.before(antes)); + } + + + + /** + * + */ + private static void ejemploDiasEntreDosFechas () { + Calendar unDiaDeMarzo = Calendar.getInstance(); + unDiaDeMarzo.set(Calendar.MONTH, Calendar.MARCH); + + Calendar unDiaDeFebrero = Calendar.getInstance(); + unDiaDeFebrero.set(Calendar.MONTH, Calendar.FEBRUARY); + + long milis = unDiaDeMarzo.getTimeInMillis()-unDiaDeFebrero.getTimeInMillis(); + long diasEntreFechas = milis/1000/60/60/24; + System.out.println("Days : " + diasEntreFechas); + } + + + + /** + * + */ + private static void ejemploZonasHorarias () { + Calendar ahoraEnEspania = Calendar.getInstance(TimeZone.getDefault()); + Calendar ahoraEnCanada = Calendar.getInstance(TimeZone.getTimeZone("Canada/Central")); + Calendar ahoraEnNewYork = Calendar.getInstance(TimeZone.getTimeZone("America/New_York")); + + System.out.println("Hora espa�ola: " + ahoraEnEspania.get(Calendar.HOUR_OF_DAY)); + System.out.println("Hora canadiense: " + ahoraEnCanada.get(Calendar.HOUR_OF_DAY)); + System.out.println("Hora en New York: " + ahoraEnNewYork.get(Calendar.HOUR_OF_DAY)); + + // Podemos obtener todos las zonas horarias disponibles + String zonasHorarias[] = TimeZone.getAvailableIDs(); + for (String str : zonasHorarias) + System.out.println("Zona horaria: " + str); +// System.out.println("Zona horaria disponible: " + Arrays.toString(zonasHorarias)); + + // También podemos fabricarnos una zona horaria determinada, si no hallamos la que buscamos + // Cuidado con los horarios de verano!!! + Calendar unaZona= Calendar.getInstance(TimeZone.getTimeZone("GMT+8:00")); + Calendar otraZona= Calendar.getInstance(TimeZone.getTimeZone("GMT-4:00")); + System.out.println("GMT+8:00: " + unaZona.get(Calendar.HOUR_OF_DAY)); + System.out.println("GMT-4:00: " + otraZona.get(Calendar.HOUR_OF_DAY)); + } + + + public static void main(String[] args) { +// ejemploCreacionNormalDate(); +// ejemploFormateoFecha(); +// ejemploCalendarBasico(); +// ejemploCalendarConCamposIndividualizados(); +// ejemploLecturaCamposIndividualizadosYLocaleEnImpresion(); +// ejemploSumaRestaFechas(); +// ejemploComparacionFechas(); + //ejemploDiasEntreDosFechas(); + ejemploZonasHorarias(); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/EjemploFicheroPropiedades.java b/src/tutorialJava/capitulo7_Recursos/EjemploFicheroPropiedades.java new file mode 100644 index 0000000..32e4bcb --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/EjemploFicheroPropiedades.java @@ -0,0 +1,89 @@ +package tutorialJava.capitulo7_Recursos; + +import java.io.File; +import java.io.FileInputStream; +import java.io.FileNotFoundException; +import java.io.FileReader; +import java.io.IOException; +import java.util.Properties; + +public class EjemploFicheroPropiedades { + + private static Properties propiedades = null; + + public EjemploFicheroPropiedades () { + super(); + } + + /** + * + * @return + */ + private static Properties getPropiedades() { + if (propiedades == null) { + propiedades = new Properties(); + + try { + // Una forma de leer el fichero de propiedades +// propiedades.load(propiedades.getClass().getResourceAsStream("/tutorialJava/capitulo6_Recursos/ejemplo.properties")); + + // Otra forma de leer el fichero de propiedades + File file = new File("./src/tutorialJava/capitulo7_Recursos/ejemplo.properties"); + System.out.println("Fichero encontrado: " + file.exists()); + propiedades.load(new FileReader(file)); + + } catch (FileNotFoundException e) { + e.printStackTrace(); + } catch (IOException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + + } + return propiedades; + } + + /** + * + * @param nombrePropiedad + * @return + */ + public static String getProperty(String nombrePropiedad) { + return getPropiedades().getProperty(nombrePropiedad); + } + + + /** + * + * @param nombrePropiedad + * @return + */ + public static int getIntProperty (String nombrePropiedad) { + return Integer.parseInt(getPropiedades().getProperty(nombrePropiedad)); + } + + + /** + * + * @param nombrePropiedad + * @return + */ + public static Float getFloatProperty (String nombrePropiedad) { + return Float.parseFloat(getPropiedades().getProperty(nombrePropiedad)); + } + + + /** + * + * @param args + */ + public static void main (String args[]) { + String usuario = EjemploFicheroPropiedades.getProperty("USUARIO"); + String password = EjemploFicheroPropiedades.getProperty("PASSWORD"); + int id = EjemploFicheroPropiedades.getIntProperty("ID_USUARIO"); + + System.out.println("Usuario leído del fichero de propiedades: " + usuario); + System.out.println("Password leído del fichero de propiedades: " + password); + System.out.println("Id de usuario leído del fichero de propiedades: " + id); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/EjemploMath.java b/src/tutorialJava/capitulo7_Recursos/EjemploMath.java new file mode 100644 index 0000000..aafc0a4 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/EjemploMath.java @@ -0,0 +1,39 @@ +package tutorialJava.capitulo7_Recursos; + +public class EjemploMath { + + public static void main(String[] args) { + // La clase Math tiene una cantidad importante de métodos que podemos utilizar en cálculos muy diversos + + // Respecto a las propiedades encontramos dos propiedades estáticas + System.out.println("Valor de PI: " + Math.PI); + System.out.println("Valor de E: " + Math.E); + + // Métodos de interés + System.out.println("\nMétodos básicos:\nMáximo de dos números: " + Math.max(3, 4.5)); + System.out.println("Mínimo de dos números: " + Math.min(3.5, 4)); + System.out.println("Valor absoluto de -3: " + Math.abs(-3)); + System.out.println("Redondeo del número 3.5: " + Math.round(3.5)); + System.out.println("Número al azar entre 0 y 1: " + Math.random()); + + System.out.println("\nPotenciación:\nPotencia de base 25 y exponente 0.5 (raiz cuadrada de 25): " + Math.pow(25, 0.5f)); + System.out.println("Raiz cuadrada de 9: " + Math.sqrt(9)); + System.out.println("Raiz cúbica de 27: " + Math.cbrt(27)); + System.out.println("Potencia del número E con exponente 10: " + Math.exp(10)); + System.out.println("Hipotenusa de un triángulo rectángulo, dados dos de los catetos del mismo: " + Math.hypot(3, 4)); + System.out.println("Logaritmos:\nLogaritmo en base 10 del número 100: " + Math.log10(100)); + System.out.println("Logaritmo en base E de la potencia de base E y exponente 2: " + Math.log(Math.pow(Math.E, 2))); + + System.out.println("\nTrigonometría:\nPaso de 90 grados a radianes: " + Math.toRadians(90)); + System.out.println("Paso de 1 radián a grados: " + Math.toDegrees(1)); + System.out.println("Seno del ángulo de 1 radián: " + Math.sin(1)); + System.out.println("Coseno del ángulo de 2 radianes: " + Math.cos(2)); + System.out.println("Tangente del ángulo de 45 grados: " + Math.tan(Math.toRadians(45))); + System.out.println("Arcoseno del ángulo de 0.85 radianes: " + Math.asin(0.85)); + System.out.println("Arcocoseno del ángulo de 0.15 radianes: " + Math.acos(0.15)); + System.out.println("Arcotangente del ángulo de 45 grados: " + Math.atan(Math.toRadians(45))); + + // Existen otros pocos métodos más en la clase Math, si quieres puedes descubrirlos a través de Javadoc Math. + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/EjemploRecursividad_Factorial.java b/src/tutorialJava/capitulo7_Recursos/EjemploRecursividad_Factorial.java new file mode 100644 index 0000000..86e99e8 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/EjemploRecursividad_Factorial.java @@ -0,0 +1,26 @@ +package tutorialJava.capitulo7_Recursos; + +public class EjemploRecursividad_Factorial { + + public static void main(String[] args) { + System.out.println("Mediante no recursividad: " + factorialNoRecursivo(6)); + System.out.println("Mediante recursividad: " + factorialRecursivo(6)); + } + + + public static int factorialRecursivo(int n) { + if (n == 1) { + return 1; + } + return n * factorialRecursivo(n - 1); + } + + + public static int factorialNoRecursivo(int n) { + for (int i = n-1; i > 1; i--) { + n *= i; + } + return n; + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/EjemploString.java b/src/tutorialJava/capitulo7_Recursos/EjemploString.java new file mode 100644 index 0000000..f399438 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/EjemploString.java @@ -0,0 +1,51 @@ +package tutorialJava.capitulo7_Recursos; + +public class EjemploString { + + public static void main(String[] args) { + String str = "Cadena de texto de tamaño mediano"; + str = new String("Cadena de texto de tamaño mediano"); + str = new String(new char[] {'C', 'a', 'd', 'e', 'n', 'a', ' ', 'd', 'e', ' ', 't', 'e', 'x', 't', 'o'}); + str = new String(new StringBuffer("Cadena de texto de tamaño mediano")); + + System.out.println("Carácter en la posición 4: " + str.charAt(4)); + System.out.println("Comparación con la cadena \"Hola\": " + str.compareTo("Hola")); + System.out.println("Concatenación con la cadena \" para practicar\": " + str.concat(" para practicar")); + System.out.println("Búsqueda booleana de la cadena \"texto\": " + str.contains("texto")); + System.out.println("Respuesta booleana a la terminación de la cadena con respecto a la cadena \"mediano\": " + str.endsWith("mediano")); + System.out.println("Comparación de cadena ignorando mayúsculas: " + str.equalsIgnoreCase("CADENA DE TEXTO DE TAMAÑO MEDIANO")); + System.out.println("Índice en el que se encuentra la cadena \"texto\" (-1 si no se encuentra la cadena): " + str.indexOf("texto")); + System.out.println("Está la cadena vacía?: " + str.isEmpty()); + System.out.println("Índice de la última aparición del carácter 'a': " + str.lastIndexOf("a")); + System.out.println("Longitud de una cadena de texto: " + str.length()); + System.out.println("Reemplazar todas las apariciones de 'a' por el carácter 'o': " + str.replace('a', 'o')); + System.out.println("Remplazo de todas las vocales a través de expresión regular: " + str.replaceAll("[aeiou]", "í")); + + // Ejemplo de separación de cadena en cadenas a través de split() + System.out.println("Separación de una cadena en otras cadenas a través de un espacio en blanco"); + String[] palabras = str.split("[ ]{1,}"); + for (int i = 0; i < palabras.length; i++) { + System.out.println("Palabra " + (i + 1) + ": " + palabras[i]); + } + + // Uso de split() con una expresión regular + System.out.println("Separación de una cadena en otras cadenas a través de la expresión regular [adt]"); + palabras = str.split("[adt]"); + for (int i = 0; i < palabras.length; i++) { + System.out.println("Palabra " + (i + 1) + ": " + palabras[i]); + } + + // Uso de split() con una expresión regular + System.out.println("Separación de una cadena en otras cadenas a través de la expresión regular \" {2,}\", \" \""); + palabras = new String("Cadena con 2 espacios en medio").split(" {2,}"); + for (int i = 0; i < palabras.length; i++) { + System.out.println("Palabra " + (i + 1) + ": " + palabras[i]); + } + + System.out.println("Subcadena de texto a partir de los índices de inicio y fin: " + str.substring(4, 15)); + System.out.println("Paso a minúsculas: " + str.toLowerCase()); + System.out.println("Paso a mayúsculas: " + str.toUpperCase()); + System.out.println("Eliminación de los espacios en blanco iniciales: " + new String(" Cadena de texto de tamaño mediano").trim()); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/EjemploWrappersTiposPrimitivos.java b/src/tutorialJava/capitulo7_Recursos/EjemploWrappersTiposPrimitivos.java new file mode 100644 index 0000000..ea0f9fa --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/EjemploWrappersTiposPrimitivos.java @@ -0,0 +1,64 @@ +package tutorialJava.capitulo7_Recursos; + +public class EjemploWrappersTiposPrimitivos { + + public static void main (String args[]) { + + // Wrapper para el tipo de datos "int" + Integer integer = new Integer(15); + System.out.println("\nForma rápida de creación de un Integer: " + Integer.valueOf(15)); + System.out.println("Valor entero de 15: " + integer.intValue()); + System.out.println("Valor long de 15: " + integer.longValue()); + System.out.println("Valor short de 15: " + integer.shortValue()); + System.out.println("Valor float de 15: " + integer.floatValue()); + System.out.println("Valor double de 15: " + integer.doubleValue()); + System.out.println("Valor máximo para un Integer: " + Integer.MAX_VALUE); + System.out.println("Valor mínimo para un Integer: " + Integer.MIN_VALUE); + System.out.println("Tamaño en bits complemento a 2 para Integer: " + Integer.SIZE); + System.out.println("Decodificicación base decimal 255: " + Integer.decode("255")); + System.out.println("Decodificicación base hexadecimal 0xFF: " + Integer.decode("0xFF")); + System.out.println("Decodificicación base hexadecimal 0XFF: " + Integer.decode("0XFF")); + System.out.println("Decodificicación base hexadecimal #FF: " + Integer.decode("#FF")); + System.out.println("Decodificicación base octal O377: " + Integer.decode("0377")); + System.out.println("Parseo de una cadena de caracteres \"123456789\": " + Integer.parseInt("123456789")); + System.out.println("Otra forma de parsear cadenas de caracteres a Integer: " + Integer.valueOf("12345678")); + + + // Wrapper para el tipo de datos "long" + System.out.println("\nValor máximo para un Long: " + Long.MAX_VALUE); + System.out.println("Valor mínimo para un Long: " + Long.MIN_VALUE); + System.out.println("Tamaño en bits complemento a 2 para Long: " + Long.SIZE); + + // Wrapper para el tipo de datos "short" + System.out.println("\nValor máximo para un Short: " + Short.MAX_VALUE); + System.out.println("Valor mínimo para un Short: " + Short.MIN_VALUE); + System.out.println("Tamaño en bits complemento a 2 para Short: " + Short.SIZE); + + // Wrapper para el tipo de datos "boolean" + System.out.println("\nForma rápida de creación de un Boolean: " + Boolean.valueOf(true)); + System.out.println("Parseo de una cadena de caracteres \"true\" a Boolean: " + Boolean.parseBoolean("true")); + + // Wrapper para el tipo de datos "float" + System.out.println("\nValor máximo para un Float: " + Float.MAX_VALUE); + System.out.println("Valor mínimo para un Float: " + Float.MIN_VALUE); + System.out.println("Tamaño en bits complemento a 2 para Float: " + Float.SIZE); + + // Wrapper para el tipo de datos "double" + System.out.println("\nValor máximo para un Double: " + Double.MAX_VALUE); + System.out.println("Valor mínimo para un Double: " + Double.MIN_VALUE); + System.out.println("Tamaño en bits complemento a 2 para Double: " + Double.SIZE); + + // Wrapper para el tipo de datos "Character" + char cadenaTexto[] = new char[] {'H', 'o', 'l', 'a', ' ', 'A', 'm', 'i', 'g', 'o', ' ', '2', '5', '5', '\n'}; + System.out.println ("\nAnalizaré el array de caracteres: " + cadenaTexto.toString()); + for (int i = 0; i < cadenaTexto.length; i++) { + System.out.println("'" + cadenaTexto[i] + "' es dígito: " + Character.isDigit(cadenaTexto[i])); + System.out.println("'" + cadenaTexto[i] + "' es letra: " + Character.isLetter(cadenaTexto[i])); + System.out.println("'" + cadenaTexto[i] + "' es letra o dígito: " + Character.isLetterOrDigit(cadenaTexto[i])); + System.out.println("'" + cadenaTexto[i] + "' es minúscula: " + Character.isLowerCase(cadenaTexto[i])); + System.out.println("'" + cadenaTexto[i] + "' es mayúscula: " + Character.isUpperCase(cadenaTexto[i])); + System.out.println("'" + cadenaTexto[i] + "' es un caracter similar a espacio en blanco: " + Character.isWhitespace(cadenaTexto[i])); + } + + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemplo.properties b/src/tutorialJava/capitulo7_Recursos/ejemplo.properties new file mode 100644 index 0000000..66c6675 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemplo.properties @@ -0,0 +1,6 @@ +# Ejemplo de comentario en fichero de propiedades + +# Propiedades +USUARIO=RafaelMunoz77 +PASSWORD=1DAWlosmejores +ID_USUARIO=1523 diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Madre.java b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Madre.java new file mode 100644 index 0000000..e323f94 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Madre.java @@ -0,0 +1,14 @@ +package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener; + +public class Madre implements PersonaEntraListener { + + public Madre() { + Principal.addPersonaEntraListener(this); + } + + @Override + public void entraPersona(PersonaEntraEvent e) { + System.out.println("Soy una madre y ha entrado " + e.getNombrePer()); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Padre.java b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Padre.java new file mode 100644 index 0000000..d7835cd --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Padre.java @@ -0,0 +1,14 @@ +package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener; + +public class Padre implements PersonaEntraListener { + + public Padre() { + Principal.addPersonaEntraListener(this); + } + + @Override + public void entraPersona(PersonaEntraEvent e) { + System.out.println("Soy un padre y ha entrado " + e.getNombrePer()); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraEvent.java b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraEvent.java new file mode 100644 index 0000000..539f085 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraEvent.java @@ -0,0 +1,22 @@ +package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener; + +public class PersonaEntraEvent { + private String nombrePer; + + + + public PersonaEntraEvent(String nombrePer) { + super(); + this.nombrePer = nombrePer; + } + + public String getNombrePer() { + return nombrePer; + } + + public void setNombrePer(String nombrePer) { + this.nombrePer = nombrePer; + } + + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraListener.java b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraListener.java new file mode 100644 index 0000000..c0e661b --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/PersonaEntraListener.java @@ -0,0 +1,6 @@ +package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener; + +public interface PersonaEntraListener { + + public void entraPersona(PersonaEntraEvent e); +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Principal.java b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Principal.java new file mode 100644 index 0000000..51d6cce --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploEntraPersonaListener/Principal.java @@ -0,0 +1,42 @@ +package tutorialJava.capitulo7_Recursos.ejemploEntraPersonaListener; + +import java.util.ArrayList; +import java.util.List; + +import tutorialJava.Utils; + +public class Principal { + + private static List listeners = new ArrayList(); + + public static void addPersonaEntraListener (PersonaEntraListener p) { + listeners.add(p); + } + + public static void removePersonaEntraListener (PersonaEntraListener p) { + listeners.remove(p); + } + + private static void fireEntraPersona(String nombrePer) { + for (PersonaEntraListener l : listeners) { + l.entraPersona(new PersonaEntraEvent(nombrePer)); + } + } + + public static void main(String[] args) { + + Padre p = new Padre(); + Madre m = new Madre(); + + do { + String nombrePer = Utils.obtenerCadenaConDescripcion("Quién ha entrado?: "); + + if (nombrePer.equalsIgnoreCase("maría") || nombrePer.equalsIgnoreCase("jesús")) { + // Lanzo notificació a la lista de listeners + fireEntraPersona(nombrePer); + } + + } while(true); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/IntroduccionNumeros.java b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/IntroduccionNumeros.java new file mode 100644 index 0000000..aba8396 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/IntroduccionNumeros.java @@ -0,0 +1,63 @@ +package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener; + +import java.util.ArrayList; +import java.util.List; +import java.util.Scanner; + +public class IntroduccionNumeros { + + private static List listNumeroImparListeners = + new ArrayList(); + + /** + * + * @param l + */ + public static void addNumeroImparListener(NumeroImparListener l) { + listNumeroImparListeners.add(l); + } + + /** + * + * @param l + */ + public static void removeNumeroImparListener(NumeroImparListener l) { + listNumeroImparListeners.remove(l); + } + + /** + * + */ + private static void fireNumeroImparListener(int numeroImparIntroducido) { + NumeroImparEvent event = new NumeroImparEvent(numeroImparIntroducido); + for (int i = listNumeroImparListeners.size() - 1; i >= 0; i--) { + listNumeroImparListeners.get(i).numeroImparIntroducido(event); + } + } + + + public static void main(String[] args) { + int num = 0; + Scanner sc = new Scanner(System.in); + + // doy de alta los listeners que quieren saber que se ha introducido un número impar + Mesa mesa1 = new Mesa(); + addNumeroImparListener(mesa1); + Perro perro1 = new Perro(); + addNumeroImparListener(perro1); + Mesa mesa2 = new Mesa(); + addNumeroImparListener(mesa2); + + do { + System.out.println("Introduzca un número, por favor: "); + num = sc.nextInt(); + System.out.println("\tEl número introducido es " + num); + + if (num % 2 == 1) { + fireNumeroImparListener(num); + } + + } while (num != 0); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Mesa.java b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Mesa.java new file mode 100644 index 0000000..0abce25 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Mesa.java @@ -0,0 +1,13 @@ +package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener; + +public class Mesa implements NumeroImparListener { + + + + @Override + public void numeroImparIntroducido(NumeroImparEvent e) { + System.out.println("Soy una mesa y me han notificado que el usuario ha introducido " + + "un número impar: " + e.getNumeroIntroducido()); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparEvent.java b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparEvent.java new file mode 100644 index 0000000..31f6041 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparEvent.java @@ -0,0 +1,23 @@ +package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener; + +public class NumeroImparEvent { + private int numeroIntroducido; + + /** + * @param numeroIntroducido + */ + public NumeroImparEvent(int numeroIntroducido) { + super(); + this.numeroIntroducido = numeroIntroducido; + } + + public int getNumeroIntroducido() { + return numeroIntroducido; + } + + public void setNumeroIntroducido(int numeroIntroducido) { + this.numeroIntroducido = numeroIntroducido; + } + + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparListener.java b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparListener.java new file mode 100644 index 0000000..8cb9149 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/NumeroImparListener.java @@ -0,0 +1,6 @@ +package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener; + +public interface NumeroImparListener { + + public void numeroImparIntroducido(NumeroImparEvent e); +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Perro.java b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Perro.java new file mode 100644 index 0000000..35eb208 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploNumeroImparListener/Perro.java @@ -0,0 +1,14 @@ +package tutorialJava.capitulo7_Recursos.ejemploNumeroImparListener; + +public class Perro implements NumeroImparListener { + + + + @Override + public void numeroImparIntroducido(NumeroImparEvent e) { + System.out.println("Soy un perro y me han notificado la introducción de un número " + + "impar: " + e.getNumeroIntroducido()); + IntroduccionNumeros.removeNumeroImparListener(this); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/CorrectorOrtografico.java b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/CorrectorOrtografico.java new file mode 100644 index 0000000..9702489 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/CorrectorOrtografico.java @@ -0,0 +1,41 @@ +package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener; + +public class CorrectorOrtografico implements PalabraRepetidaListener { + + String nombre; + + public CorrectorOrtografico(String nombre) { + super(); + this.nombre = nombre; + Principal.addPalabraRepetidaListener(this); + } + + + + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + + + + @Override + public void palabraRepetidaEncontrada(PalabraRepetidaEvent e) { + System.out.println("Soy " + this.nombre + " y hay una " + + "palabra repetida: " + e.getPalabra()); + } + + +} + + + + + + + diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Informatica.java b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Informatica.java new file mode 100644 index 0000000..4b95e4d --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Informatica.java @@ -0,0 +1,32 @@ +package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener; + +public class Informatica implements PalabraRepetidaListener { + + String nombre; + + public Informatica(String nombre) { + super(); + this.nombre = nombre; + Principal.addPalabraRepetidaListener(this); + } + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + @Override + public void palabraRepetidaEncontrada(PalabraRepetidaEvent e) { + System.out.println("Soy " + this.nombre + " y hay una palabra " + + "repetida: " + e.getPalabra()); + } + + +} + + + + diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaEvent.java b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaEvent.java new file mode 100644 index 0000000..2ebcd7b --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaEvent.java @@ -0,0 +1,19 @@ +package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener; + +public class PalabraRepetidaEvent { + String palabra; + + public PalabraRepetidaEvent(String palabra) { + super(); + this.palabra = palabra; + } + + public String getPalabra() { + return palabra; + } + + public void setPalabra(String palabra) { + this.palabra = palabra; + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaListener.java b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaListener.java new file mode 100644 index 0000000..f85eb61 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/PalabraRepetidaListener.java @@ -0,0 +1,6 @@ +package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener; + +public interface PalabraRepetidaListener { + + public void palabraRepetidaEncontrada(PalabraRepetidaEvent e); +} diff --git a/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Principal.java b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Principal.java new file mode 100644 index 0000000..fe59f6f --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/ejemploPalabraRepetidaEnFraseListener/Principal.java @@ -0,0 +1,68 @@ +package tutorialJava.capitulo7_Recursos.ejemploPalabraRepetidaEnFraseListener; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Scanner; + +public class Principal { + + private static List listeners = + new ArrayList(); + + + private static void firePalabraRepetidaEncontrada(String palabra) { + PalabraRepetidaEvent event = new PalabraRepetidaEvent(palabra); + for (PalabraRepetidaListener listener : listeners) { + listener.palabraRepetidaEncontrada(event); + } + } + + + public static void addPalabraRepetidaListener(PalabraRepetidaListener l) { + listeners.add(l); + } + + public static void removePalabraRepetidaListener(PalabraRepetidaListener l) { + listeners.remove(l); + } + + + public static void main(String[] args) { + Scanner sc = new Scanner(System.in); + String frase = ""; + + CorrectorOrtografico alejandro = new CorrectorOrtografico("Alejandro"); + CorrectorOrtografico sergio = new CorrectorOrtografico("Sergio"); + Informatica carmen = new Informatica("Carmen"); + + + do { + System.out.println("Dame una frase: "); + frase = sc.nextLine(); + String palabras[] = frase.split("[ ]+"); + List listaPalabras = Arrays.asList(palabras); + + for (int i = 0; i < palabras.length; i++) { + String palabra = palabras[i]; + if (listaPalabras.subList(0, i).contains(palabra)) { + System.out.println("La palabra " + palabra + " está " + + "repetida"); + firePalabraRepetidaEncontrada(palabra); + } + } + + } while (!frase.equals("")); + + } + +} + + + + + + + + + diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/EjemploExcepcionesBasico.java b/src/tutorialJava/capitulo7_Recursos/excepciones/EjemploExcepcionesBasico.java new file mode 100644 index 0000000..67671f4 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/EjemploExcepcionesBasico.java @@ -0,0 +1,208 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +import java.lang.reflect.Field; +import java.lang.reflect.InvocationTargetException; +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.List; + +public class EjemploExcepcionesBasico { + + /** + * Ejemplo de Exception general + */ + private static void ejemploExceptionGeneral () { + String str = null; + + try { + System.out.println ("Contenido de str: " + str.toLowerCase()); + } + catch(Exception e) { + System.out.println(e.getMessage()); + e.printStackTrace(); + } + + System.out.println("Terminando"); + } + + + /** + * + */ + private static void ejemploNullPointerException () { + Persona persona = new Persona (null, new Pierna(Pierna.IZQUIERDA)); + + try { + System.out.println ("Pierna izquierda de la persona: " + persona.getPiernaIzquierda().toString()); + System.out.println ("Pierna derecha de la persona: " + persona.getPiernaDerecha().toString()); + String cadenas[] = new String[2]; + System.out.println("cadena: " + cadenas[3]); + } + catch (NullPointerException ex) { + System.out.println("Exception NullPointer recogida"); + } + catch (IndexOutOfBoundsException ex) { + System.out.println("Exception IndexOutOfBoundsException recogida"); + } + catch (Exception ex) { + System.out.println("Exception general recogida"); + } + + System.out.println("Fuera del catch"); + } + + + /** + * + */ + private static void ejemploArithmeticException () { + try { + int divisor = 0; + System.out.println ("Divisi�n: " + (50/divisor)); + } + catch (ArithmeticException ex) { + System.out.println("Error aritmético"); + System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n"); + ex.printStackTrace(); + } + } + + + + + /** + * + */ + private static void ejemploClassCastException () { + try { + Object persona = new Object(); + Pierna pierna = (Pierna) persona; + } + catch (ClassCastException ex) { + System.out.println("Error de casting"); + System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n"); + ex.printStackTrace(); + } + } + + + + + /** + * + */ + private static void ejemploIndexOutOfBoundsException () { + try { + List piernas = new ArrayList(); + piernas.add(new Pierna(Pierna.DERECHA)); + + System.out.println ("Pierna en array: " + piernas.get(1).toString()); + } + catch (IndexOutOfBoundsException ex) { + System.out.println("Error de índice de acceso a un elemento en un array"); + System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n"); + ex.printStackTrace(); + } + } + + + + + /** + * + */ + private static void ejemploNumberFormatException () { + try { + System.out.println("Parseo de n�mero: " + Integer.parseInt("rafa")); + } + catch (NumberFormatException ex) { + System.out.println("Error de parseo a un número"); + System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n"); + ex.printStackTrace(); + } + } + + + + + /** + * + */ + private static void ejemploClassNotFoundException () { + try { + // Ejemplo de instanciaci�n de un objeto + Persona persona = (Persona) Class.forName("tutorialJava.capitulo7_Recursos.excepciones.Persona").newInstance(); + System.out.println("Objeto instanciado: " + persona); + + // Ejemplo de obtenci�n de las propiedades de un objeto + Field propiedades[] = persona.getClass().getDeclaredFields(); + System.out.println("\nListado de propiedades del objeto: "); + for (int i = 0; i < propiedades.length; i++) { + System.out.println("Campo: " + propiedades[i].getName()); + } + + // Ejemplo de obtenci�n de los m�todos de un objeto + Method metodos[] = persona.getClass().getMethods(); + System.out.println("\nListado de métodos del objeto: "); + for (int i = 0; i < metodos.length; i++) { + System.out.println("Método: " + metodos[i].getName() + "()"); + } + + // Ejemplo de invocaci�n de un m�todo de un objeto + System.out.println("\nInvocación pierna derecha: " + Persona.class.getMethod("getPiernaDerecha", null).invoke(persona, null)); + + } + catch (ClassNotFoundException ex) { + System.out.println("Error por no encontrar una clase"); + System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n"); + ex.printStackTrace(); + } catch (InstantiationException e) { + System.out.println("Error de instanciaci�n de una clase"); + System.out.println("Mensaje de error: " + e.getMessage() + "\n\n"); + e.printStackTrace(); + } catch (IllegalAccessException e) { + System.out.println("Error de acceso ilegal a una clase"); + System.out.println("Mensaje de error: " + e.getMessage() + "\n\n"); + e.printStackTrace(); + } catch (IllegalArgumentException e) { + System.out.println("IllegalArgumentException Error en la invocación de un método"); + System.out.println("Mensaje de error: " + e.getMessage() + "\n\n"); + e.printStackTrace(); + } catch (InvocationTargetException e) { + System.out.println("InvocationTargetException Error en la invocación de un método"); + System.out.println("Mensaje de error: " + e.getMessage() + "\n\n"); + e.printStackTrace(); + } catch (NoSuchMethodException e) { + System.out.println("NoSuchMethodException Error en la invocación de un método"); + System.out.println("Mensaje de error: " + e.getMessage() + "\n\n"); + e.printStackTrace(); + } catch (SecurityException e) { + System.out.println("SecurityException Error en la invocación de un método"); + System.out.println("Mensaje de error: " + e.getMessage() + "\n\n"); + e.printStackTrace(); + } catch(Exception ex) { + System.out.println("Exception no controlada"); + System.out.println("Mensaje de error: " + ex.getMessage() + "\n\n"); + ex.printStackTrace(); + } + + } + + + + + /** + * + * @param args + */ + public static void main (String args[]) { + +// ejemploExceptionGeneral(); +// ejemploNullPointerException(); +// ejemploArithmeticException(); + //ejemploClassCastException(); + //ejemploIndexOutOfBoundsException(); + //ejemploNumberFormatException(); + ejemploClassNotFoundException(); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/EjemploLanzamientoExcepcionPropia.java b/src/tutorialJava/capitulo7_Recursos/excepciones/EjemploLanzamientoExcepcionPropia.java new file mode 100644 index 0000000..f6b0f35 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/EjemploLanzamientoExcepcionPropia.java @@ -0,0 +1,63 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +public class EjemploLanzamientoExcepcionPropia { + + /** + * + * @param persona + * @return + * @throws PersonaNulaException + * @throws PiernaNulaException + */ + private static String personaToString (Persona persona) throws PersonaNulaException, PiernaNulaException { + StringBuffer sb = new StringBuffer(); + // A partir de una persona, vamos a construir un StringBuffer que recorra sus dos piernas + if (persona == null) { + throw new PersonaNulaException("El objeto persona es null"); + } + else { + sb.append("El objeto persona tiene dos piernas: "); + + if (persona.getPiernaDerecha() == null) { + throw new PiernaNulaException("La pierna derecha del objeto persona es null"); + } + else { + sb.append("la derecha "); + + if (persona.getPiernaIzquierda() == null) { + throw new PiernaNulaException("La pierna izquierda del objeto persona es null"); + } + else { + sb.append("y la izquierda."); + } + } + } + + return sb.toString(); + } + + + + + /** + * + * @param args + */ + public static void main(String[] args) { + + try { +// Persona persona = new Persona(new Pierna(Pierna.DERECHA), new Pierna(Pierna.IZQUIERDA)); + Persona persona = null; +// Persona persona = new Persona(null, new Pierna(Pierna.IZQUIERDA)); +// Persona persona = new Persona(new Pierna(Pierna.DERECHA), null); + System.out.println(personaToString(persona)); + } catch (PersonaNulaException e) { + System.out.println("Existen valores nulos en el objeto persona: " + e.getMessage()); + e.printStackTrace(); + } catch (PiernaNulaException e) { + System.out.println("Existen valores nulos en el objeto persona: " + e.getMessage()); + } + + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/MartesException.java b/src/tutorialJava/capitulo7_Recursos/excepciones/MartesException.java new file mode 100644 index 0000000..4361ba0 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/MartesException.java @@ -0,0 +1,29 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +public class MartesException extends Exception { + + public MartesException() { + // TODO Auto-generated constructor stub + } + + public MartesException(String message) { + super(message); + // TODO Auto-generated constructor stub + } + + public MartesException(Throwable cause) { + super(cause); + // TODO Auto-generated constructor stub + } + + public MartesException(String message, Throwable cause) { + super(message, cause); + // TODO Auto-generated constructor stub + } + + public MartesException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) { + super(message, cause, enableSuppression, writableStackTrace); + // TODO Auto-generated constructor stub + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/Persona.java b/src/tutorialJava/capitulo7_Recursos/excepciones/Persona.java new file mode 100644 index 0000000..5cd27b1 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/Persona.java @@ -0,0 +1,34 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +public class Persona { + protected Pierna piernaDerecha; + protected Pierna piernaIzquierda; + + public Persona() { + System.out.println("Constructor Persona sin argumentos"); + this.piernaDerecha = new Pierna(Pierna.DERECHA); + this.piernaIzquierda = new Pierna(Pierna.IZQUIERDA); + } + + public Persona(Pierna piernaDerecha, Pierna piernaIzquierda) { + super(); + this.piernaDerecha = piernaDerecha; + this.piernaIzquierda = piernaIzquierda; + } + + public Pierna getPiernaDerecha() { + return piernaDerecha; + } + + public void setPiernaDerecha(Pierna piernaDerecha) { + this.piernaDerecha = piernaDerecha; + } + + public Pierna getPiernaIzquierda() { + return piernaIzquierda; + } + + public void setPiernaIzquierda(Pierna piernaIzquierda) { + this.piernaIzquierda = piernaIzquierda; + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/PersonaNulaException.java b/src/tutorialJava/capitulo7_Recursos/excepciones/PersonaNulaException.java new file mode 100644 index 0000000..90e7b13 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/PersonaNulaException.java @@ -0,0 +1,8 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +public class PersonaNulaException extends Exception { + + public PersonaNulaException(String msg) { + super(msg); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/Pierna.java b/src/tutorialJava/capitulo7_Recursos/excepciones/Pierna.java new file mode 100644 index 0000000..d636b0d --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/Pierna.java @@ -0,0 +1,24 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +public class Pierna { + + public static int DERECHA = 0; + public static int IZQUIERDA = 1; + + protected int tipo; + + public Pierna(int tipo) { + super(); + this.tipo = tipo; + } + + public int getTipo() { + return tipo; + } + + public void setTipo(int tipo) { + this.tipo = tipo; + } + + +} diff --git a/src/tutorialJava/capitulo7_Recursos/excepciones/PiernaNulaException.java b/src/tutorialJava/capitulo7_Recursos/excepciones/PiernaNulaException.java new file mode 100644 index 0000000..5e267aa --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/excepciones/PiernaNulaException.java @@ -0,0 +1,8 @@ +package tutorialJava.capitulo7_Recursos.excepciones; + +public class PiernaNulaException extends Exception { + + public PiernaNulaException(String msg) { + super(msg); + } +} diff --git a/src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/PalabraRepetidaException.java b/src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/PalabraRepetidaException.java new file mode 100644 index 0000000..3731859 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/PalabraRepetidaException.java @@ -0,0 +1,13 @@ +package tutorialJava.capitulo7_Recursos.palabraRepetidaException; + +public class PalabraRepetidaException extends Exception { + + public PalabraRepetidaException() { + super(); + } + + public PalabraRepetidaException(String message) { + super(message); + } + +} diff --git a/src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/Principal.java b/src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/Principal.java new file mode 100644 index 0000000..685de23 --- /dev/null +++ b/src/tutorialJava/capitulo7_Recursos/palabraRepetidaException/Principal.java @@ -0,0 +1,65 @@ +package tutorialJava.capitulo7_Recursos.palabraRepetidaException; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.Scanner; + +public class Principal { + + + /** + * @throws PalabraRepetidaException + * + */ + private static void pideFrases() throws PalabraRepetidaException { + Scanner sc = new Scanner(System.in); + String frase = ""; + + + do { + System.out.println("Dame una frase: "); + frase = sc.nextLine(); + String palabras[] = frase.split("[ ]+"); + List listaPalabras = Arrays.asList(palabras); + + for (int i = 0; i < palabras.length; i++) { + String palabra = palabras[i]; + if (listaPalabras.subList(0, i).contains(palabra)) { + System.out.println("La palabra " + palabra + " está " + + "repetida"); + throw new PalabraRepetidaException("La palabra " + + palabra + " está repetida en la frase: " + + frase); + } + } + + } while (!frase.equals("")); + + } + + + + /** + * + * @param args + */ + public static void main(String[] args) { + try { + pideFrases(); + } catch (PalabraRepetidaException e) { + // TODO Auto-generated catch block + e.printStackTrace(); + } + } + +} + + + + + + + + + diff --git a/src/tutorialJava/examenes/examen20241213/Animal.java b/src/tutorialJava/examenes/examen20241213/Animal.java new file mode 100644 index 0000000..224e724 --- /dev/null +++ b/src/tutorialJava/examenes/examen20241213/Animal.java @@ -0,0 +1,50 @@ +package tutorialJava.examenes.examen20241213; + +import tutorialJava.Utils; + +public abstract class Animal { + protected String nombre; + protected float peso; + + public Animal() { + super(); + } + + public Animal(String nombre) { + super(); + this.nombre = nombre; + this.peso = Utils.obtenerNumeroAzar(1, 600); + } + + public Animal(String nombre, float peso) { + super(); + this.nombre = nombre; + this.peso = peso; + } + + public abstract float calcularEspacio(); + + public String getNombre() { + return nombre; + } + + public void setNombre(String nombre) { + this.nombre = nombre; + } + + public float getPeso() { + return peso; + } + + public void setPeso(float peso) { + this.peso = peso; + } + + @Override + public String toString() { + return "Animal [nombre=" + nombre + ", peso=" + peso + "]"; + } + + + +} diff --git a/src/tutorialJava/examenes/examen20241213/Ave.java b/src/tutorialJava/examenes/examen20241213/Ave.java new file mode 100644 index 0000000..760d003 --- /dev/null +++ b/src/tutorialJava/examenes/examen20241213/Ave.java @@ -0,0 +1,38 @@ +package tutorialJava.examenes.examen20241213; + +import tutorialJava.Utils; + +public class Ave extends Animal { + + private float envergaduraAlas; + + public Ave() { + super(); + } + + public Ave(String nombre) { + super(nombre); + this.envergaduraAlas = Utils.obtenerNumeroAzar(15, 200); + } + + @Override + public float calcularEspacio() { + return (float) (this.peso * 1.5 + this.envergaduraAlas * 2); + } + + public float getEnvergaduraAlas() { + return envergaduraAlas; + } + + public void setEnvergaduraAlas(float envergaduraAlas) { + this.envergaduraAlas = envergaduraAlas; + } + + @Override + public String toString() { + return "Ave [envergaduraAlas=" + envergaduraAlas + ", nombre=" + nombre + ", peso=" + peso + + ", calcularEspacio()=" + calcularEspacio() + "]"; + } + + +} diff --git a/src/tutorialJava/examenes/examen20241213/Mamifero.java b/src/tutorialJava/examenes/examen20241213/Mamifero.java new file mode 100644 index 0000000..51e9712 --- /dev/null +++ b/src/tutorialJava/examenes/examen20241213/Mamifero.java @@ -0,0 +1,52 @@ +package tutorialJava.examenes.examen20241213; + +import tutorialJava.Utils; + +public class Mamifero extends Animal { + + private String tipoAlimentacion; + + public Mamifero() { + super(); + } + + public Mamifero(String nombre) { + super(nombre); + + if (Utils.obtenerNumeroAzar(0, 1) == 0) { // Carnívoro + this.tipoAlimentacion = "Carnívoro"; + } + else { // Herbívoro + this.tipoAlimentacion = "Herbívoro"; + } + } + + + @Override + public float calcularEspacio() { + return this.peso * 3; + } + + public String getTipoAlimentacion() { + return tipoAlimentacion; + } + + public void setTipoAlimentacion(String tipoAlimentacion) { + this.tipoAlimentacion = tipoAlimentacion; + } + + @Override + public String toString() { + return "Mamifero [tipoAlimentacion=" + tipoAlimentacion + ", nombre=" + nombre + ", peso=" + peso + + ", calcularEspacio()=" + calcularEspacio() + "]"; + } + + +} + + + + + + + diff --git a/src/tutorialJava/examenes/examen20241213/Principal.java b/src/tutorialJava/examenes/examen20241213/Principal.java new file mode 100644 index 0000000..86541d0 --- /dev/null +++ b/src/tutorialJava/examenes/examen20241213/Principal.java @@ -0,0 +1,141 @@ +package tutorialJava.examenes.examen20241213; + +import tutorialJava.Utils; +import tutorialJava.examenes.examen20241211.Producto; + +public class Principal { + + private static Animal[] animales = new Animal[Utils.obtenerNumeroAzar(10, 20)]; + + /** + * + * @param args + */ + public static void main(String[] args) { + + // Inicializo objetos en Array + for (int i = 0; i < animales.length; i++) { + if (i < (animales.length / 2)) { + animales[i] = new Mamifero("Mamífero_" + i); + } + else { + animales[i] = new Ave("Ave_" + i); + } + } + + muestraAnimales(); + ordenaBurbuja(animales); + System.out.println("\nAnimales ordenados"); + muestraAnimales(); + + System.out.println("\nEspacios necsarios"); + System.out.println("Total espacio necesario: " + calcularEspacioTotal()); + System.out.println("Total espacio mamíferos carnívoros: " + + calcularEspacioMamiferosCarnivoros()); + + System.out.println("\nEstadísticas"); + System.out.println("Animal que más ocupa: " + animales[0].toString()); + System.out.println("Animal que menos ocupa: " + + animales[animales.length - 1].toString()); + System.out.println("Total mamíferos herbívoros: " + contadorMamiferosHerbivoros()); + System.out.println("Total aves gran envergadura: " + + contadorAvesGranEnvergadura()); + } + + /** + * + */ + private static void muestraAnimales() { + for (int i = 0; i < animales.length; i++) { + System.out.println(animales[i].toString()); + } + } + + + private static float calcularEspacioTotal() { + float espacio = 0; + for (int i = 0; i < animales.length; i++) { + espacio += animales[i].calcularEspacio(); + } + return espacio; + } + + + private static float calcularEspacioMamiferosCarnivoros() { + float espacio = 0; + for (int i = 0; i < animales.length; i++) { + if (animales[i] instanceof Mamifero) { + Mamifero m = (Mamifero) animales[i]; + if (m.getTipoAlimentacion().equalsIgnoreCase("Carnívoro")) { + espacio += animales[i].calcularEspacio(); + } + } + } + return espacio; + } + + /** + * + * @return + */ + private static int contadorMamiferosHerbivoros() { + int cont = 0; + for (int i = 0; i < animales.length; i++) { + if (animales[i] instanceof Mamifero) { + Mamifero m = (Mamifero) animales[i]; + if (m.getTipoAlimentacion().equalsIgnoreCase("Herbívoro")) { + cont++; + } + } + } + return cont; + } + + /** + * + * @return + */ + private static int contadorAvesGranEnvergadura() { + int cont = 0; + for (int i = 0; i < animales.length; i++) { + if (animales[i] instanceof Ave) { + Ave a = (Ave) animales[i]; + if (a.getEnvergaduraAlas() > 100) { + cont++; + } + } + } + return cont; + } + + /** + * + * @param a + */ + public static void ordenaBurbuja(Animal a[]) { + boolean hayIntercambios = false; + do { + hayIntercambios = false; + for (int i = 0; i < a.length - 1; i++) { + if (a[i].calcularEspacio() < a[i + 1].calcularEspacio()) { + Animal aux = a[i]; + a[i] = a[i + 1]; + a[i + 1] = aux; + hayIntercambios = true; + } + } + } while (hayIntercambios == true); + + } + + + + +} + + + + + + +