José Francisco Casales Huerta
Ricardo Betancourt
Esta genial felicidades
Ahora que ya conoces las tags y su uso para documentar, te pongo el siguiente reto que consiste en general la documentación para librería Report, que creamos en el Curso Básico de Java SE el proyecto lo encuentras aquí: https://github.com/anncode1/JavaSEBasico/tree/26.EscribirArchivos
Genera la librería documentada e implementala en el proyecto. Compártenos pantallazos de qué etiquetas usaste y cómo se ve ahora.
José Francisco Casales Huerta
Ricardo Betancourt
Esta genial felicidades
Jose David Garzon
/**
*Report *<p> *Esta es la clase genera reportes en la extension deseada,
*@author david *@version 1.1 *@since 2020
public class Report {
Gilberto A. Guerrero Caballero
/** <b>Report</b>: es una clase publica que permite la generación de un archivo plano (txt), la cual se puede utilizar
Angelica Leung
/**
Danner Adib Uribe
 {```
Carlos Naveda
Holas, Usé un proyecto anterior que tenía terminado de el "Curso de Java"
Coloqué comentarios respectivos para algunas clases y métodos, generé con el siguiente comando la documentación.
Comando:
Packages
Clase Main.java
Clase Interfaz Promotional.java
Clase Movie.java
Clase Documentary.java
Pablo Villegas Palacio
/**
* Librería Report: utilidades para generar reportes (texto/CSV/…),
* escribirlos a disco y reutilizar plantillas.
*
* <p>Incluye clases para:
* <ul>
* <li>{@link com.anncode.report.Report}: modelo inmutable de un reporte.</li>
* <li>{@link com.anncode.report.ReportWriter}: escritura a archivos.</li>
* <li>{@link com.anncode.report.ReportBuilder}: construcción fluida.</li>
* </ul>
*
* @author TuNombre
* @version 1.0
* @since 1.0
*/
package com.anncode.report;
Jesús Alejandro Marrón Legorreta
Daniel Eduardo Espitia Corredor
/** * <h1> Report</h1> * La clase report es utilizada para generar reportes de las peliculas, * capitulos de series y libros que se han visualizado. * <p> * Por ultimo, permite guardar un archivo con la información de los reportes que se hayan * generado. * * @author Daniel Espitia * @version 1.0 * @since 2018 * * */
Yossijaki Jorge Astilleros Chávez
¿Cómo puedo publicar mis capturas?
Yossijaki Jorge Astilleros Chávez
Muchas gracias juandc 😄 sos un crack
Luis David López Berber
Excelente aporte
Yossijaki Jorge Astilleros Chávez
Alessandro Morales
/** * <h1>Reporte</h1> * esta clase es una libreria * <p> * Nos ayuda a poder generar reportes con * extension<strong>.txt</strong> utilizando * el metodo {@code hacerReporte()} * @author Alessandro * @version 1.0 * @since 2018 * */
Jhon Martinez
/** *<h1> Report</h1> * La clase report genera un archivo con los parametros enviados al método {@code makeReport} *<p> * Para la generación del archivo se validan inicialmente los parametros recibidos. *<p> *@param {@code nameFile} Parametro del nombre del archivo del reporte. *@param {@code content} Parametro del contenido del reporte *@param {@code title} Parametro del titulo del reporte *@param {@code extension} Parametro obligatorio del tipo de archivo a crear *@author Jhon Martinez *@version 1.0 *@since 2018 * **/
movigostudio movigostudio
/**
Asi quedo mi libreria documentada
package com.codecasales.makereport; import java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; /** * <h1>Make Report</h1> * Clase que se encarga de escribir archivos de texto * <br> * Escribe documentos de texto a partir de los atributos {@code nameFile}, {@code title} * y {@code content}, donde {@code nameFile} es el nombre del archivo, {@code title} es el titulo del mismo * y {@code content} el contenido de este. * * @author Francisco Casales (codecasales) * @version 1.0 * @since Enero 2019 * */ public class Report { private String nameFile; private String title; private String content; private String extension; /** * Metodo que obtiene el nombre del archivo a generar * * @return nameFile es un objeto {@code String} con el nombre del archivo sin extencion. * */ public String getNameFile() { return nameFile; } /** * Metodo que establece el nombre del archivo sin extencion * * @param nameFile es un objeto de tipo {@code String} que contiene el nombre del archivo sin extencion. * */ public void setNameFile(String nameFile) { this.nameFile = nameFile; } /** * Metodo que obtiene el titulo del archivo. * * @return title es un objeto {@code String} con el titulo del archivo. * */ public String getTitle() { return title; } /** * Metodo que establece el titulo del archivo sin extencion * * @param title es un objeto de tipo {@code String} que contiene el titulo del archivo. * */ public void setTitle(String title) { this.title = title; } /** * Metodo que obtiene el contenido del archivo a generar * * @return content es un objeto {@code String} con el contenido del archivo sin incluir el titulo. * */ public String getContent() { return content; } /** * Metodo que establece el contenido del archivo sin extencion * * @param content es un objeto de tipo {@code String} que tiene el contenido del archivo sin titulo. * */ public void setContent(String content) { this.content = content; } /** * <h1>Metodo makeReport</h1> * Metodo que se encarga de generar los archivos .txt utilizando los datos establecidos por los setters * <br> * Hace una comprobacion, si {@code nameFile}, {@code title} o {@code content} son nulos no genera el archivo * y le pide al usuario proporcionar los datos necesarios. * */ public void makeReport() { if ( (getNameFile() != null) && (getTitle() != null) && (getContent() != null) ) { //Crear el archivo try { File file = new File(getNameFile()+"."+getExtension()); FileOutputStream fos = new FileOutputStream(file); OutputStreamWriter osw = new OutputStreamWriter(fos); BufferedWriter bw = new BufferedWriter(osw); bw.write(getContent()); bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { System.out.println("Ingresa los datos del archivo"); } } /** * Metodo que obtiene la extension del archivo a generar * * @return extension es un objeto {@code String} con la extension del archivo * sin incluir el nombre del archivo. * */ public String getExtension() { return extension; } /** * Metodo que establece la extension del archivo * * @param extension es un objeto de tipo {@code String} que contiene la extension del archivo * sin incluir el nombre del archivo. * */ public void setExtension(String extension) { this.extension = extension; } }
package com.andycode.makereport; import java.io.BufferedWriter; import java.io.File; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter; /** * <h1>Report</h1> * Librería que permite realizar reportes * * <p> * Esta librería nos permite generar reportes de las Movies, Series junto con sus chapters y libros * a excepción de los magazines que tienen la restricción de no poderse visualizar * * @author Andres F.B.S * @version 1.1 * @since 2019 */ public class Report { /** * <h2> Variables </h2> * {@code String nameFile} almacena el nombre del archivo/reporte * {@code String title} contiene el titulo que lleve el archivo/reporte * {@code String content} almacena el contenido del reporte * {@code String extension} contiene la extensión del reporte */ private String nameFile; private String title; private String content; private String extension; public String getNameFile() { return nameFile; } public void setNameFile(String nameFile) { this.nameFile = nameFile; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public String getExtension() { return extension; } public void setExtension(String extension) { this.extension = extension; } /** * <h1>Metodo makeReport</h1> * Este método se encarga de generar reporte de texto plano. * A continuación detallamos sus componentes: * {@code if} valida que {@code getNameFile()} {@code getTitle} {@code getContent()} obtenidos no sean nulos * * Posteriormente creamos el archivo y para ello hicimos lo siguiente * {@code File file = new File(getNameFile() + "." + getExtension())} Creamos un obj file. Recibimos el nombre y extensión seteados * * {@code FileOutputStream fos = new FileOutputStream(file)} Escribimos los caracteres - Va a preparar el archivo para escribir bytes * * {@code OutputStreamWriter osw = new OutputStreamWriter(fos)} Convertir todos los bytes en el archivo - Convertir el String de los bytes en caracteres * * {@code BufferedWriter bw = new BufferedWriter(osw)} Escribimos los elementos de una forma mas eficiente * * {@code bw.write(getContent())} Una vez escrito {@code bw.close()Debemos cerrarlo} */ public void makeReport() { if ((getNameFile() != null) && (getTitle() != null) && (getContent() != null)) { // crear archivo try { File file = new File(getNameFile() + "." + getExtension()); //Manipular el archivo en forma de obj FileOutputStream fos = new FileOutputStream(file); OutputStreamWriter osw = new OutputStreamWriter(fos); BufferedWriter bw = new BufferedWriter(osw); // Escribir elementos mucho mas rapido bw.write(getContent()); bw.close(); // Puede ocasionar errores si se deja abierto } catch (IOException e) { e.printStackTrace(); } } else { System.out.println("Ingresa los datos del archivo"); } } }
package mx.com.ngkntk.makereport;
import java.io.BufferedWriter; import java.io.File; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.OutputStreamWriter;
/**
*/ public class Report {
private String nameFile; private String title; private String content; private String extension; public String getNameFile() { return nameFile; } public void setNameFile(String nameFile) { this.nameFile = nameFile; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public String getExtension() { return extension; } public void setExtension(String extension) { this.extension = extension; } /** * <h1>Método makeReport</h> * Método que se encarga de generar el archivo de tecto a partir de algunas cadenas que proporcionan * el nombre del archivo {@code nameFile}, {@code title} y {@code content} y valida que ninguna sea null. * En caso contrato de qu alguna no cumpla con la condición, no genera el archivo. */ public void makeReport() { if((getNameFile() != null) && (getTitle() != null) && (getContent() != null)) { try { File file = new File(getNameFile() + "." + getExtension()); FileOutputStream fos = new FileOutputStream(file); OutputStreamWriter osw = new OutputStreamWriter(fos); BufferedWriter bw = new BufferedWriter(osw); bw.write(getContent()); bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } }
}
package com.yossi.makereport; import java.io.*; /** * <h1>Report</h1> * <p> * La implementación de esta libreria ayuda a generar reportes en texto plano * para la mejora de sistemas que realizan acciones * * <h2>Variables</h2> * {@code String nameFile} almacena el nombre del archivo a generar * {@code String title} almacena el titulo que se colocara en archivo de texto * {@code String content} almacena el contenido del archivo a generar * {@code String extension} guarda la extensión que tendra el tipo de archivo a generar * * */ public class Report { private String nameFile; private String title; private String content; private String extension; public String getExtension() { return extension; } public void setExtension(String extension) { this.extension = extension; } public String getNameFile() { return nameFile; } public void setNameFile(String nameFile) { this.nameFile = nameFile; } public String getTitle() { return title; } public void setTitle(String title) { this.title = title; } public String getContent() { return content; } public void setContent(String content) { this.content = content; } public void makeReport() { if ((getNameFile() != null) && (getTitle() != null) && (getContent() != null)) { //Crear el archivo try { File file = new File(getNameFile()+"."+getExtension()); FileOutputStream fos = new FileOutputStream(file); OutputStreamWriter osw = new OutputStreamWriter(fos); BufferedWriter bw = new BufferedWriter(osw); bw.write(getContent()); bw.close(); } catch (IOException e) { // TODO Auto-generated catch block e.printStackTrace(); } } else { System.out.println("Ingresa los datos del archivo"); } } }```