Mensajes

¿Has intentado con algún software que haga screen shots?

Aquí hay uno: ScreenCapturer

[jesus95]

Hola jesus95,

Como dice DiegoS, aquí NO se hacen tareas de ningún tipo. Éste foro tiene la intención de ayudar en dudas puntuales y específicas más no resolver tareas.

Así que:

1) Estudia el lenguaje Java. Tienes muchos libros, te recomiendo Java a fondo.
2) Practica mucho.
3) Cuando tengas alguna duda puntual, coloca el código que has avanzado y con gusto se te ayudará.

Dicho esto, quedamos a la espera que un moderador cierre el tema.

De nada colega. No olvides marcar el tema como solucionado:

Nunca vas a comparar el código que realizas tú en base a un análisis y un previo diseño a el código que te genera un IDE.

Respecto a las tablas, zapatero a sus zapatos. Las tablas están hechas para tablas, y no deben usarse para otra cosa. Con la llegada de HTML5 tienes etiquetas más especificas como: main, section, footer, article, header, nav, etc., para maquetar correctamente una web, ya no tienes que sufrir de "divitis", usa las nuevas etiquetas.

Cierto es que no todas las etiquetas tienen un comportamiento igual, pero no tiene mucho que ver, a mi parecer, con el responsive design, porque éste lo manejas con puro CSS y JS.

Respecto a los IDEs, para eso están, para que seas más productivo como dice @engel, pero no debes nunca depender de éstos. Los que dependen de los interface builders drag and drop, en realidad dudo mucho que puedan hacer un sitio decente. Lo que si no veo mal es comprar plantillas si quieres ahorrarte trabajo, y las modificas.

Sí, a simple vista me parece correcto.

Good job @synthesize, te ganaste 1/2Kg de hierba

A esto deberían de ponerle chincheta. Lectura obligada para los novatos.

PD al staff: Hagan un sencillo script que cuando se detecte las palabras en cualquier orden: "quiero", "ser", "hacker", "como", se le muestre un pop-up donde se le invite a entrar a éste tema. Si cierra el pop-up igual podrá crear por si la intención del autor no es saber "cómo ser hacker". Por ejemplo, una llamada AJAX a un script que cuente el número de palabras "sospechosas" y que de acuerdo al número de concordancias, se muestre el pop-up, caso contrario se envíe la publicación.

Algo así:

Código (php) [Seleccionar] Expandir

$postTitle = $_POST["postTitle"];
$titleTokens = explode(" ", $postTitle);
$warningWords = ["cómo","como","quiero","ser","hacker"];
$warningWordsCounter = 0;

foreach($titleTolens as $token) {
foreach($warningWords as $word) {
if(strtolower($token) == $word)
$warningWordsCounter++;
}
}

echo $warningWordsCounter;

[flowboss16]

Hola flowboss16,

1) Preguntas de Java en la sección Java.
2) JDK es el kit de desarrollo de Java, el lenguaje es Java a secas.

Por como hablas, deduzco que no conoces bien el lenguaje, ¿o me equivoco?. Si estoy en lo cierto, primero aprende bien las bases del lenguaje.

Si ya tienes base, puedes usar la paleta de NetBeans para crear GUIs en Swing, pero el código que te genera es desastrozo. Mejor iníciate con JavaFX, Swing ya quedó en la historia.

Aquí hay un tuto de JavaFX muy bueno que puedes seguir: Tutorial JavaFX 8.

Lol xD. Suele pasar

PD: Puedes aprovechar el autocloseable:

Código (java) [Seleccionar] Expandir

public void exportProducts(List<ProductVO> products) {
 try(ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("D:\\products.obj"))) {
  for(ProductVO product : products)
out.writeObject(product);
 } catch(FileNotFoundException ex) {
ex.printStackTrace();
 } catch(IOException ex2) {
ex2.printStackTrace();
}

}

Así ya no tienes que preocuparte por cerrar flujos o conexiones

1) No. es necesario que el valor devuelto recursivo sea asignado a number. Si no haces, retornará null en lugar de un número correcto porque estás llamando a una réplica del método y este devuelve un valor que debe ser asignado.

2) Bien q hayas preguntado. Si pasas defrente un número real por parámetro éste será tomado como Float. Agregando d al número real indicamos que es Double. En este caso no es necesario.

3) Te felicito, captaste el error oculto

No debe ser static, si ya tenemos un getter para exceptionCounter es completamente innecesario y ademas mal aplicado que sea static. Si lo hacemos y creamos muchos objetos HighestNumberFinder todos ellos compartirán la variable y definitavemente no queremos eso ahora.

Vas aprendiendo. Sigue así. Saludos.

[ENTIDADES]

Usa el API de Java para manejo de XML, JAXB. Con JAXB puedes transformar un objeto a XML y viceversa. Te dejo un ejemplo aplicado a tu caso:

ENTIDADES

Board:

Código (java) [Seleccionar] Expandir


/**
*
* @author Gus
*/
public class Board {
   private String name;
   private int towersNumber;
   
   public Board() {}

   public Board(String name, int towersNumber) {
       this.name = name;
       this.towersNumber = towersNumber;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getTowersNumber() {
       return towersNumber;
   }

   public void setTowersNumber(int towersNumber) {
       this.towersNumber = towersNumber;
   }

   
   
}


Tower:

Código (java) [Seleccionar] Expandir


package net.elhacker.jaxbexample.model.entities;

/**
*
* @author Gus
*/
public class Tower {
   private String name;
   private int xAxis;
   private int yAxis;
   
   public Tower() {}

   public Tower(String name, int xAxis, int yAxis) {
       this.name = name;
       this.xAxis = xAxis;
       this.yAxis = yAxis;
   }

   public String getName() {
       return name;
   }

   public void setName(String name) {
       this.name = name;
   }

   public int getxAxis() {
       return xAxis;
   }

   public void setxAxis(int xAxis) {
       this.xAxis = xAxis;
   }

   public int getyAxis() {
       return yAxis;
   }

   public void setyAxis(int yAxis) {
       this.yAxis = yAxis;
   }
   
   
}

Disc:

Código (java) [Seleccionar] Expandir


package net.elhacker.jaxbexample.model.entities;

/**
*
* @author Gus
*/
public class Disc {
   private int xAxis;
   private int yAxis;
   
   public Disc() {}

   public Disc(int xAxis, int yAxis) {
       this.xAxis = xAxis;
       this.yAxis = yAxis;
   }

   public int getxAxis() {
       return xAxis;
   }

   public void setxAxis(int xAxis) {
       this.xAxis = xAxis;
   }

   public int getyAxis() {
       return yAxis;
   }

   public void setyAxis(int yAxis) {
       this.yAxis = yAxis;
   }
   
   
}

Ahora veamos a nuestra clase que se transformará en un archivo XML:

Código (java) [Seleccionar] Expandir

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import net.elhacker.jaxbexample.model.entities.Board;
import net.elhacker.jaxbexample.model.entities.Disc;
import net.elhacker.jaxbexample.model.entities.Tower;

/**
*
* @author Gus
*/
@XmlRootElement(name="HanoiTower")
@XmlAccessorType(XmlAccessType.FIELD)
public class HanoiTower {

   @XmlElement
   public Tower tower;
   @XmlElement
   public Board board;
   @XmlElement
   public int playingTowers;
   @XmlElement
   public Disc disc;

   public HanoiTower() {
   }

   public Tower getTower() {
       return tower;
   }

   public void setTower(Tower tower) {
       this.tower = tower;
   }

   public Board getBoard() {
       return board;
   }

   public void setBoard(Board board) {
       this.board = board;
   }

   public Disc getDisc() {
       return disc;
   }

   public void setDisc(Disc disc) {
       this.disc = disc;
   }

   public int getPlayingTowers() {
       return playingTowers;
   }

   public void setPlayingTowers(int playingTowers) {
       this.playingTowers = playingTowers;
   }

}



Como puedes observar, hemos anotado la clase con @XmlRootElement. Esto indica que dicha clase será la raíz de una estructura XML. Ojo, esto no quiere decir que no puedas guardar un objeto anotado así en otro. Su atributo name es para asignarle un nombre a la raíz del XML.

@XmlAccessorType, especifica que tipo de acceso se tendrá la clase, si es por propiedades (campos) o métodos. En nuestro caso, hemos optado por que el acceso sea por medio de las propiedades: XmlAccessType.FIELD.

Las propiedades las hemos anotado con @XmlElement, esto indica que dicha propiedad será una etiqueta, y su valor se desplegará entre dicha etiqueta de apertura y la de su cierre.

Si te das cuenta aunque los objetos Board, Tower y Disc no hayan sido declarados con @XMLElement, JAXB lo hace por nosotros. Observa al final, la salida que genera JAXB.

Ahora veamos quién hace la "magia". En éste caso he creado una clase que actúe de manager para convertir de Objeto a XML y viceversa.

HanoiTowerMarshaller:

Código (java) [Seleccionar] Expandir

import java.io.File;
import java.util.logging.Logger;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Marshaller;
import javax.xml.bind.Unmarshaller;

/**
*
* @author Gus
*/
public class HanoiTowerMarshaller {
   private static JAXBContext jaxbContext;
   private static Logger logger;
           
   public HanoiTowerMarshaller() {
       try {
           jaxbContext  = JAXBContext.newInstance(HanoiTower.class);
           logger = Logger.getLogger(HanoiTowerMarshaller.class.getName());
       } catch(JAXBException ex) {
           logger.warning(ex.getMessage());
       }
   }
   
   public void marshal(HanoiTower hanoiTower) {
       try {
           File file = new File("D:\\hanoi-tower.xml");
           Marshaller jaxbMarshaller = jaxbContext.createMarshaller();
           
           jaxbMarshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
           
           jaxbMarshaller.marshal(hanoiTower, file);
           jaxbMarshaller.marshal(hanoiTower, System.out);

       } catch(JAXBException ex) {
           logger.warning(ex.getMessage());
       }
   }
   
   public HanoiTower unmarshall(String filePath) {
       HanoiTower hanoiTower = null;
       try {
           File xml = new File(filePath);
           Unmarshaller jaxbUnmarshaller = jaxbContext.createUnmarshaller();
           hanoiTower = (HanoiTower) jaxbUnmarshaller.unmarshal(xml);
       } catch (JAXBException ex) {
           logger.warning(ex.getMessage());
       }
       return hanoiTower;
   }
}

Primero declaramos jaxbContext y logger como propiedades porque las utilizaremos en ambos métodos de la clase.

En el constructor inicializamos jaxbContext con el método newInstance() de JAXBContext al que debemos pasarle por parámetro la clase con la que se trabajará. Como siempre vamos a a trabajar con HanoiTower, se lo indico aquí. Si vamos a trabajar con muchas clases y XML, esto debe ir en el método marshal y unmarshal ya que las clases con las que se va a trabajar son varias.

También inicializamos logger. Logger lo único que hace es crear logs para que los puedas revisar luego en caso de error o algo importante.

En el método marshall, lo primero que hacemos es crear un objeto File con la ruta recibida, esto para saber dónde guardar el XML.

Luego simplemente crea un objeto Marshaller para poder llevar a cabo la conversión. Posteriormente le asignamos una propiedad para que el código esté formateado, esto por cuestiones de legibilidad ).

Por último, utilizamos el método marshal para convertir el objeto a XML y guardarlo en la ruta a la que apunta el objeto File. También lo hacemos con System.out porque quiero ver la salida en la consola también.

El método unmarshall hace lo mismo, la diferencia es que crea un objeto Unmarshaller y utiliza el método unmarshal pasándole el objeto File que apunta a la ruta del XML a leer. Nota el cast, es necesario usarlo.

Ahora, una pequeña prueba:

JAXBExample:

Código (java) [Seleccionar] Expandir

package jaxbexample;

import net.elhacker.jaxbexample.model.entities.Board;
import net.elhacker.jaxbexample.model.entities.Disc;
import net.elhacker.jaxbexample.model.entities.Tower;
import net.elhacker.jaxbexample.model.xml.HanoiTower;
import net.elhacker.jaxbexample.model.xml.HanoiTowerMarshaller;

/**
*
* @author Gus
*/
public class JAXBExample {

   public static void main(String[] args) {
       HanoiTowerMarshaller marshaller = new HanoiTowerMarshaller();
       Board board = new Board();
Tower tower = new Tower();
Disc disc = new Disc();

board.setName("Juego 1");
board.setTowersNumber(5);
tower.setName("Torre 1");
tower.setxAxis(25);
tower.setyAxis(34);
disc.setxAxis(19);
disc.setyAxis(23);
HanoiTower hanoiTower = new HanoiTower();
hanoiTower.setBoard(board);
hanoiTower.setTower(tower);
hanoiTower.setDisc(disc);
hanoiTower.setPlayingTowers(7);
       
       marshaller.marshal(hanoiTower, "D:\\hanoi-tower.xml");
       
       HanoiTower xmlToHanoiTower = marshaller.unmarshall("D:\\hanoi-tower.xml");
       System.out.println("Datos del juego cargado:\n");
       System.out.println("Nombre del juego:");
       System.out.println(xmlToHanoiTower.getBoard().getName());
       System.out.println("Número de torres en el juego:");
       System.out.println(xmlToHanoiTower.getBoard().getTowersNumber());
       System.out.println("Nombre de la torre del jugador:");
       System.out.println(xmlToHanoiTower.getTower().getName());
       System.out.println("Coordenada X de la torre:");
       System.out.println(xmlToHanoiTower.getTower().getxAxis());
       System.out.println("Coordenada Y de la torre:");
       System.out.println(xmlToHanoiTower.getTower().getyAxis());
       System.out.println("Número de torres jugando:");
       System.out.println(xmlToHanoiTower.getPlayingTowers());
       System.out.println("Coordenada X del disco:");
       System.out.println(xmlToHanoiTower.getDisc().getxAxis());
       System.out.println("Coordenada Y del disco:");
       System.out.println(xmlToHanoiTower.getDisc().getyAxis());
   }
   
}


Salida:

Código [Seleccionar] Expandir

<HanoiTower>
   <tower>
       <name>Torre 1</name>
       <xAxis>25</xAxis>
       <yAxis>34</yAxis>
   </tower>
   <board>
       <name>Juego 1</name>
       <towersNumber>5</towersNumber>
   </board>
   <playingTowers>7</playingTowers>
   <disc>
       <xAxis>19</xAxis>
       <yAxis>23</yAxis>
   </disc>
</HanoiTower>
Datos del juego cargado:

Nombre del juego:
Juego 1
Número de torres en el juego:
5
Nombre de la torre del jugador:
Torre 1
Coordenada X de la torre:
25
Coordenada Y de la torre:
34
Número de torres jugando:
7
Coordenada X del disco:
19
Coordenada Y del disco:
23


Enjoy!