UNIVERSIDAD NACIONAL TECNOLÓGICA DE LIMA SUR

FACULTAD DE INGENIERÍA Y GESTIÓN

CARRERA PROFESIONAL DE INGENIERÍA DE SISTEMAS

ACTIVIDAD SÍNCRONA NÚMERO 5

Trabajo presentado para la asignatura de Lenguaje de la programación I,

dirigida por
Mg. Blas Rebaza, Maruja Emelita

Estudiantes:
Moreno Menacho Facundo Rafael
Chepe Ruiz, Carlos Gerardo Frank
Zegarra Ortega, Xavier Diego
Flores Huaraca Jean Antony

Lima – Perú
 2022
CLASE JFRAME:
Es una clase utilizada en Swing(Es un biblioteca de clases).Este frame nos sirve para generar
ventanas de usuario ,en las cuales se le pueden añadir diferentes objetos con los cuales el
usuario podrá interactuar con el programa.

CLASE JTEXTAREA:
Es un área de varias líneas que muestra texto sin formato. Está destinado a ser un componente
ligero que proporciona compatibilidad de origen con la clase java.awt.TextArea donde pueda
hacerlo de forma razonable.

CLASE JTEXTPANE:
Es otro editor que admite colores, fuentes, tamaños, etc. Admite incluso que le pongamos
directamente iconos pasándole una clase Icon de java o que le añadamos Component de java.

EJEMPLOS:

EJEMPLO 1( ARRAY EN TEXTPANE):

Se crea el proyecto as5( Actividad síncrona 5) y predeterminadamente se crea el paquete con

el mismo nombre.
Creamos la clase JFrame, en el paquete as5, llamada txtpane ya que allí emplearemos esta
clase.

A continuación se verá el JFrame creado, el Panel y TextPane.

 Creamos el panel, el cual está representado con la letra a resaltada ,para poner como
Título de borde “Uso panel de texto”, aclarando que se hará uso del TextPane.

Se crea el panel de texto, el cual está representado con la letra b resaltada, que
será nuestro editor de texto.

Ingresando al código del JFrame :

Importamos :
import java.awt.Cursor;
import java.awt.Insets;
//import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.text.Style;
import javax.swing.text.StyleConstants;
import javax.swing.text.StyleContext;
import javax.swing.text.StyledDocument

public class txtpane extends javax.swing.JFrame {

//Método inicial
private void inicio(){
// se crea Array de String para estilo.
 String[] textos = {"Codigo Java - (Texto Normal)." + "\n",
"Utilizando Swing - (Texto Cursiva)." + "\n",
"Programando con Java - (Texto Negrita)" + "\n",
"Utilizando JTextPane - (Texto pequeño)" + "\n",
"Utilizando Style. (Texto grande)" + "\n",
"JTextPane con soporte para insertar objetos." + "\n",
" " + "\n",
"Soporte insertar iconos." + "\n",
" " + "\n",
"JTextPane permite utilizar StyledEditorKit y StyledDocument, " +
"también interactua con diferentes objetos."
};
//Array de String para el nombre de cada estilo "Style"
String[] iniText = {

"normal","cursiva","negrita","peque","grande","boton","normal","icono","normal","normal"
};
//Cramos una variable tipo StyledDocument que manejara los estilos.
StyledDocument sd = txtpane.getStyledDocument();
//Método que se crea más abajo, le pasamos como argumento nuestro StyledDocument.
styleDoc(sd);
//Inicialización de los diferentes estilos a utilizar.
private void styleDoc(StyledDocument sd){
Style def = StyleContext.getDefaultStyleContext().
getStyle(StyleContext.DEFAULT_STYLE);

Style nm = sd.addStyle("normal", def);

StyleConstants.setFontFamily(def, "SansSerif");

Style s = sd.addStyle("cursiva", nm);

StyleConstants.setItalic(s, true);
 s = sd.addStyle("negrita", nm);
StyleConstants.setBold(s, true);

s = sd.addStyle("peque", nm);
StyleConstants.setFontSize(s, 10);

s = sd.addStyle("grande", nm);
StyleConstants.setFontSize(s, 16);

s = sd.addStyle("icono", nm);

CAPTURA DEL COMPILADOR :

JTextArea
-Nos permite redactar un texto de manera más formal en un rango establecido o más.

-Sin esta clase se nos hace muy tedioso poder hacer algo tan sencillo como escribir notas.

Ejemplo

Infraestructura

Comenzamos con las creación de nuestros proyectos dándosele el nombre que más gustemos.

Luego de crear el proyecto procedemos a agregar los palette correspondientes para los que
necesitamos, en nuestro recuadro le damos click derecho, nos vamos a propertiers y por
último nos le damos a las propiedades linewrap y warpstyleword (esto nos permitirá que
cuando escribamos no se nos corten las palabras), nos terminará quedando así.
package art;

public class jtextarea extends javax.swing.JFrame {

public jtextarea() {

initComponents();

//Esto nos permite poder tener el salto de linea automatico

jTextArea1.setLineWrap(true);

jTextArea1.setWrapStyleWord(true);

@SuppressWarnings("unchecked")

private void initComponents() {

jScrollPane1 = new javax.swing.JScrollPane();

jTextArea1 = new javax.swing.JTextArea();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);

jTextArea1.setColumns(20);

jTextArea1.setLineWrap(true);
 jTextArea1.setRows(5);

jTextArea1.setWrapStyleWord(true);

jScrollPane1.setViewportView(jTextArea1);

javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());

getContentPane().setLayout(layout);

layout.setHorizontalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(layout.createSequentialGroup()

.addContainerGap()

.addComponent(jScrollPane1, javax.swing.GroupLayout.DEFAULT_SIZE, 388,

Short.MAX_VALUE)

.addContainerGap())

);

layout.setVerticalGroup(

layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING)

.addGroup(javax.swing.GroupLayout.Alignment.TRAILING,
layout.createSequentialGroup()

.addContainerGap(135, Short.MAX_VALUE)

.addComponent(jScrollPane1, javax.swing.GroupLayout.PREFERRED_SIZE, 140,

javax.swing.GroupLayout.PREFERRED_SIZE)

.addGap(25, 25, 25))

);

pack();

}
 public static void main(String args[]) {

try {

for (javax.swing.UIManager.LookAndFeelInfo info :

javax.swing.UIManager.getInstalledLookAndFeels()) {

if ("Nimbus".equals(info.getName())) {

javax.swing.UIManager.setLookAndFeel(info.getClassName());

break;

} catch (ClassNotFoundException ex) {

java.util.logging.Logger.getLogger(jtextarea.class.getName()).log(java.util.logging.Level.SE
VERE, null, ex);

} catch (InstantiationException ex) {

java.util.logging.Logger.getLogger(jtextarea.class.getName()).log(java.util.logging.Level.SE
VERE, null, ex);

} catch (IllegalAccessException ex) {

java.util.logging.Logger.getLogger(jtextarea.class.getName()).log(java.util.logging.Level.SE
VERE, null, ex);

} catch (javax.swing.UnsupportedLookAndFeelException ex) {

java.util.logging.Logger.getLogger(jtextarea.class.getName()).log(java.util.logging.Level.SE
VERE, null, ex);

java.awt.EventQueue.invokeLater(new Runnable() {
 public void run() {

new jtextarea().setVisible(true);

});

private javax.swing.JScrollPane jScrollPane1;

private javax.swing.JTextArea jTextArea1;

Explicación:

Todo lo que se muestra se puede obtener siguiendo los primero pasos, el unico coidgo
agregado es jTextArea1.setLineWrap(true); y jTextArea1.setWrapStyleWord(true);

Estas líneas de código nos permitirán que al escribir no se nos corten y que el salto sea
automático si no queremos agregarle las funciones que en un principio recomendamos.

JFRAME
 · Tiene muchos métodos para hacer interfaces gráficas.

· Es una clase perteneciente a la biblioteca gráfica de java.swing. Gracias al Jframe se

va poder crear ventanas y objetos, para hacer la interfaz gráfica más agradable.

Ejemplos

Infraestructura

Creamos el proyecto con el nombre “Jframe”, después creamos un paquete con el nombre
“Jframe”, y creamos dos Java Class “jframe y principal” para ejecutar la clase Jframe.

JACA CLASS (jframe)

package Jframe;

import javax.swing.JFrame;(1)

public class jframe extends JFrame{ (2)

public jframe(){ (3)

this.setSize(800,600)( 4)

Análisis del código

(1). Se está importando la librería para que al compilar no me reconozca el error.

(2). En esta línea de código se está realizando la Herencia entre clases con el extends.

(3). En esta línea se está creando un constructor del java class Jframe.

(4). En esta línea de código se está estableciendo el tamaño de la clase “Jframe” con un ancho
de 800 y largo de 600.

❖ Para poder ejecutar el programa se tiene que tener el método “MAIN”, entonces
creamos un Java class “Principal”.

JACA CLASS (principal)

package Jframe;

public class principal {

public static void main(String[] args) {

jframe v1=new jframe()(1)

v1.setVisible(true); (2)

Análisis del código

(1). Para que se puede ver nuestro jframe creamos un objeto de Jframe y ese objeto se le esta
llamando “V1”

(2). Como por defecto toda la ventana del jframe están invisibles entonces lo estamos
haciendo visible, y se le esta colocando “true” para que muestre si se colocaría “False” no se
mostraría.

Compilación del programa

JTEXTAREA

· Tiene muchos métodos para hacer interfaces gráficas.

· Permite al operador del programa ingresar una cadena de caracteres por teclado.

· Ejemplos

· Infraestructura

Creamos el proyecto con el nombre “Jframe”, después creamos un paquete con el

nombre “Jframe”, y creamos dos Java Class “jframe y principal” para ejecutar la clase
Jframe.

JAVA CLASS (jframe)

package Jframe;
import javax.swing.JFrame;(1)

import javax.swing.JPanel;(2)

import javax.swing.JTextArea;(3)

public class jframe extends JFrame{ (4)

public JPanel panel;(5)

public jframe(){ (6)

setSize(500,500) (7)

iniciarCompnentes();

private void iniciarCompnentes(){ (8)

colocarPaneles(); (9)

colocarAreasDeTexto();

private void colocarPaneles(){

panel =new JPanel();

this.getContentPane().add(panel);

private void colocarAreasDeTexto(){ (10)

JTextArea areaTexto = new JTextArea()(11)

areaTexto.setBounds(50, 50, 200, 200) (12)

panel.add(areaTexto);

Análisis del código

(1). Se está importando la librería para que al compilar no me reconozca error.

(2). Se está importando la librería para que al compilar no me reconozca error.

(3). Se está importando la librería para que al compilar no me reconozca error.

(4). En esta línea de código se está realizando la Herencia entre clases con el extends.

(5). En esta línea de código se está creando un constructor “PANEL” para más adelante me
va ayudar.

(6). En esta línea se está creando un constructor del java class Jframe.

(7). En esta línea de código se está estableciendo el tamaño de la clase “Jframe” con un ancho
de 500 y largo de 500.

(8). Se está creando un constructor “iniciarcomponente”.

(9). Se está creando los métodos “colocarPaneles” “colocarAreasDeTexto”

(10). Creamos el método “colocarPaneles” y “colocarAreasDeTexto” con el private.

(11). Para que se puede ver nuestro JTextArea creamos un objeto, y ese objeto se le está
llamando “areaTexto”.

(12). En esta línea de código damos dimensiones al área de texto.

(13). En esta línea de código lo hacemos visible en el panel.

❖ Para poder ejecutar el programa se tiene que tener el método “MAIN”, entonces
creamos un Java class “Principal”.

JACA CLASS (principal)

package Jframe;

public class principal {

public static void main(String[] args) {

jframe v1=new jframe()(1)

v1.setVisible(true); (2)

Análisis del código

(1). Para que se puede ver nuestro jframe creamos un objeto de Jframe y ese objeto se le está
llamando “V1”

(2). Como por defecto toda la ventana del jframe están invisibles entonces lo estamos
haciendo visible, y se le está colocando “true” para que muestre si se colocaría “False” no se
mostraría.

Compilación del código

BIBLIOGRAFÍA:
● ThemeGrill. (2022, 21 de Octubre). Javalist. Programación orientada a objetos.Que Es
Un JFrame - programacion orientado a objetos (epizy.com)