Dibujar en Java con la Clase Graphics
Cargado por
Fernando PinedaDibujar en Java con la Clase Graphics
Cargado por
Fernando PinedaComo Dibujar Figuras en Java Utilizando la Clase
Graphics
Posted by p_geek On enero 24, 2019 In Lenguajes No comments
Afortunadamente java ofrece un gran soporte para gráficos e incluso existe una clase Graphics2D para
dibujos bidimensionales. Sin embargo, en este articulo hablaremos solamente de graphics y ciertos
elementos que deberás conocer para dibujar.
Primero debes saber que Graphics funciona con un sistema de coordenadas (todas las herramientas y
lenguajes que soporten dibujo lo tienen). La coordenada X indica la posición horizontal del elemento y
este se dibuja de izquierda a derecha, la coordenada Y funciona de arriba a abajo dibujando los
elementos de esta forma. A diferencia de las coordenadas en matemáticas en Java Y se desplaza hacia
abajo cuando su valor es positivo.
Ademas, la parte superior izquierda siempre tendrá las coordenadas(x, y) con valor (0, 0). Tomando
esta como referencia para posicionar tus dibujos, podrás apreciar lo explicado a continuación:
La clase Graphics permite establecer colores y fuentes a sus dibujos, es posible dibujar: texto, imágenes,
círculos, rectángulos, arcos, lineas y poligonos (fillPolygon, este metodo permite crear multiples dibujos
como: triángulos, hexágonos y otros. Pues por parámetro debes pasar un arreglo de posiciones en X y Y
logrando diversas figuras).
¿Como dibujar?
Para poder comenzar a crear nuestros primeros dibujos, debemos crear un marco y agregar un panel. El
panel es nuestra hoja (literal) que permite aplicar los dibujos de la clase Graphics (el contexto grafico es
nuestro panel). Ya creado nuestro marco con panel ahora debemos establecer el método para dibujar:
1 public void paintComponent(Graphics g) {
2 [Link](g);
3 }
Con el método anterior seremos capaces de dibujar, es importante llamar al método padre utilizando
super, pues con esto indicamos que pinte nuevamente el contexto, si usted no hace el llamado es posible
que se dibuje una vez o no dibuje nada. El código completo con el marco y panel (contexto grafico) es:
1
2 package contextografico;
3
4 import [Link];
5
public class PrimerDibujo {
6
7 public static void main(String[] args) {
8 JFrame f = new JFrame("Ventana con Contexto Grafico");
9 PanelDibujo panel=new PanelDibujo();
10 [Link](panel);
[Link](280, 150, 500, 400);
11 [Link](JFrame.EXIT_ON_CLOSE);
12 [Link](true);
13 }
14
15 }
16
1
package contextografico;
2
3
import [Link].*;
4 import [Link].*;
5
6 public class PanelDibujo extends JPanel {
7
8 @Override
9 public void paintComponent(Graphics g) {
[Link](g);
10 }
11
12 }
13
Aplicando métodos para dibujar
setColor(Color c): este método hace posible establecer diferentes colores a las figuras, recibe por
parámetro un objecto de tipo color. La clase Color contiene una serie de constantes que indican el valor
de cada color, tras escribir Color y un punto se mostraran los diferentes nombres de colores.
1
2 public class PanelDibujo extends JPanel {
3
@Override
4 public void paintComponent(Graphics g) {
5 [Link](g);
6 [Link]( 40, 35, 80, 80, 0, 360);
7 [Link](160, 75, 200, 75);
[Link]([Link]);
8 [Link]( 40, 150, 80, 70, 0, 360);
9 }
10
11 }
12
Cabe mencionar que los métodos que al comienzo tienen fill tiene un comportamiento de dibujo especial
y es que estos crean el dibujo relleno con el color establecido (en la imagen anterior se dibuja un arco
relleno de color naranja).
Un método util conocido como translate, recibe por parámetro dos valores y son las posiciones X y Y.
Al establecer el valor de coordenadas cambia el punto de origen. Por ende, los dibujos serán dibujados a
partir de los valores establecidos como punto de origen, ejemplo:
1
2 public class PanelDibujo extends JPanel {
3
@Override
4 public void paintComponent(Graphics g) {
5 [Link](g);
6 [Link]([Link]);
7 [Link]([Link]()/2, [Link]()/2);
8 [Link](40, 10, 50, 50);
[Link](-40, -80, 50, 50);
9 [Link](-5, -5, 10, 10);
10 }
11
12 }
13
La posición donde se encuentra el circulo dibujado, es el nuevo punto de origen y a partir de este serán
dibujadas las figuras. Para obtener el centro del marco, obtienes el ancho y alto del Panel y lo divides
entre 2 (podrás observar que el circulo esta centrado).
¿Dibujar una figura dentro de otra?
Algo realmente sencillo de hacer, puedes apreciar el siguiente ejemplo:
1
2 public class PanelDibujo extends JPanel {
3
@Override
4 public void paintComponent(Graphics g) {
5 [Link](g);
6 [Link]([Link]);
7 [Link]([Link]()/2, [Link]()/2);
8 [Link](40, 10, 50, 50);//dibujo de rectangulo
[Link]([Link]);
9 [Link](40, 10, 50, 50); //dibujo de circulo
10 }
11
12 }
13
Usted simplemente deberá poner las mismas posiciones X, Y. Pues los dibujos se realizan de izquierda a
derecha, con esto se asegura de dibujar figuras «anidadas».
Los métodos utilizados en los ejemplos no son todos. Para mi punto de vista los métodos mencionados,
te facilitaran la creación de dibujos. Si deseas conocer los demás métodos puedes revisar el API de
JAVA.
Como crear Hilos (Thread) en Java
Posted by p_geek On enero 5, 2019 In Programación Concurrente No comments
Programación concurrente, tambien se puede conocer con el termino de ejecución en paralelo y esta
hace referencia a la ejecución de multiples tareas al mismo tiempo.
Anteriormente en sistemas operativos antiguos no era posible ejecutar multiples tareas al mismo tiempo.
Sin embargo, se tuvo la necesidad de realizar esto para un mayor aprovechamiento de recursos del
sistema. Ademas el termino paralelismo anteriormente no era posible, debido a que los procesadores
solo tenian un nucleo por lo que simplemente a simple vista parecia que ejecutaba programas al mismo
tiempo pero en realidad lo que sucede a nivel de sistema es que el gestor de procesos se encargaba de
repartir un tiempo a cada proceso.
Sin embargo, actualmente con el avance de la tecnologia existen procesadores con multiples nucleos y
aqui realmente ocurre el paralelismo. Afortunadamente JAVA tiene su propia maquina virtual
encargada de administrar la ejecucion de procesos creados por el propio lenguaje, esto facilita la tarea de
creación. Pero la cosa no solo termina aqui, ya que pueden surgir varios problemas con la programacion
concurrente una de ellas es la incongruencia de datos.
Ejemplo:
Tenemos una variable contador = 0, imagina que estas lanzando multiples hilos para incrementar en uno
el valor de la variable. Entonces entra en juego el hilo 1 e incrementa contador = 1 (pero aun no escribe
ese valor en la variable), entonces el gestor del sistema operativo le dice: oye hilo 1, espera que te voy a
suspender y ahora entra en juego el hilo 2, la variable contador aun tiene el valor cero, por lo que el hilo
2 toma ese valor lo incremente en uno y este escribe el valor siendo contador = 1.
El gestor del sistema operativo decide retomar el hilo 1 y este vuelve a escribir el numero 1 y se supone
que la variable contador debe ser igual a 2.
Este es un problema muy comun al utilizar Thread (hilos), por lo que debes solucionar el problema
sincronizando la ejecución de estos. Sin embargo, en este articulo no explicare el procedimiento (lo
menciono para que tengas una idea de lo que puede suceder).
Comencemos a crear hilos, primero explicare a crearlos utilizando la clase Thread (heredando de esta).
1
2 package hilos;
3
public class HiloUtilizandoThread extends Thread {
4
5 public HiloUtilizandoThread(String tarea) {
6 [Link] = tarea;
7 }
8
9 @Override
10 public void run() {
[Link](tarea);
11 }
12
13 private String tarea;
14
15 }
16
El metodo run() es el corazón del subproceso encargado de ejecutar la acción (aqui debemos poner el
código a ejecutar). Sin embargo, no debe ejecutar los hijos mediante este metodo, pues no estaria
aplicando programación concurrente (mas adelante mencionare como lanzar hilos).
Otra forma de implementar Hilos es utilizando la clase Runnable, existen dos formas de crear hilos.
Debido a que, si una clase donde quieras crear hilos ya este heredando de otra clase (por lo cual no
podras heredar de Thread pues sabemos que Java no permite herencia multiple). Sin embargo, JAVA
permite interfaces multiples y es por ese motivo que se pueden implementar hilos en 2 formas. El código
para implementar hilos utilizando Runnable es el siguiente:
1 package hilos;
2
public class HiloUtilizandoRunnable implements Runnable {
3
4
public HiloUtilizandoRunnable(String tarea) {
5 [Link] = tarea;
6 }
7
8 @Override
9 public void run() {
[Link](tarea);
10 }
11
12 private String tarea;
13
14 }
15
16
Ahora debemos lanzar los hilos creados, podemos hacerlo con el código mostrado a continuación:
1
2 package hilos;
3
4 public class HilosMain {
5
6 public static void main(String[] args) {
//Creacion de hilos utilizando la clase Thread
7 HiloUtilizandoThread hilo1 = new HiloUtilizandoThread("Tarea 1 con Thread");
8 HiloUtilizandoThread hilo2 = new HiloUtilizandoThread("Tarea 2 con Thread");
9 [Link]();
10 [Link]();
11 //Creacion de hilos utilizando la interfaz Runnable
Thread hiloR1 = new Thread(new HiloUtilizandoRunnable("Tarea 1 con Runnable"
12 Thread hiloR2 = new Thread(new HiloUtilizandoRunnable("Tarea 2 con Runnable"
13 [Link]();
14 [Link]();
15 }
16
17 }
18
El sistema operativo tiene una cola encargada de gestionar los procesos en ejecución, el
metodo start() pone los hilos creados en la cola del sistema operativo y este se encarga de gestionar la
ejecución (el orden de ejecución de hilos, depende del sistema operativo).
Crear Menú Emergente en Java con JPopupMenu
Posted by p_geek On mayo 14, 2019 In Lenguajes No comments
JPopupMenu es una clase que permite crear un menú emergente, gracias a esta clase nosotros
podemos desplegar un menú al presionar clic derecho.
Esto puede ser útil si usted se encuentra desarrollando una aplicación como: editor de texto, editor de
imagenes, entre otros.
Sin embargo, aveces suele ser complicado crear este tipo de menú. Afortunadamente, explicare de
manera breve una forma sencilla de implementarlo. Cabe mencionar, que solo mencionare los métodos
necesarios para poder llevar acabo el menú emergente y no hablare a fondo sobre esta clase.
El único método a utiliza es:
setComponentPopupMenu(JPopupMenu component); este método se encarga de establecer el menú
emergente. Sobre el objeto donde fue utilizado.
Antes de comenzar a crear el menu emergente, usted debe tener conocimiento previo de como crear
menus en java, debido a que estos son utilizado para crear el menu emergente.
Primero comenzaremos creando nuestra ventana, esto se realiza siempre para poder agregar nuestro
JPanel.
1
2 package menuemergente;
3
4 import [Link];
5
public class MenuEmergente {
6
7 public static void main(String[] args) {
8 PanelMenuEmergente panel = new PanelMenuEmergente();
9 JFrame f = new JFrame("Evento Menu Emergente");
10 [Link](panel);
[Link](150, 100, 500, 400);
11 [Link](JFrame.EXIT_ON_CLOSE);
12 [Link](true);
13 }
14
15 }
16
La siguiente clase es nuestro JPanel con el menú previamente creado, tiene una clase interna anónima
encargada de gestionar eventos. Se realizo de esta forma para facilitar el código a ustedes y sea
entendible para aquellos usuarios que apenas comienzan.
Mencionado lo anterior, el siguiente ejemplo es:
Escribir un programa que permita cambiar el color del panel mediante un menú emergente, el menú
emergente debe desplegarse al presionar clic derecho.
1 package menuemergente;
2
import [Link];
3 import [Link].*;
4 import [Link].*;
5
6 public class PanelMenuEmergente extends [Link] {
7
8 private JMenuItem colorVerde;
9 private JMenuItem colorAmarillo;
private JMenuItem colorRojo;
10 private JMenuItem colorNegro;
11
12 public PanelMenuEmergente() {
13 initComponents();
14 addMenuEmergente();
addEventos(new ControladorMenus(this));
15 }
16
private final void addEventos(ControladorMenus controlador) {
17 [Link](controlador);
18 [Link](controlador);
19 [Link](controlador);
20 [Link](controlador);
21 }
22
private final void addMenuEmergente() {
23 JPopupMenu menuEmergente = new JPopupMenu();
24
25 colorVerde = new JMenuItem("Verde");
26 colorAmarillo = new JMenuItem("Amarillo");
27 colorRojo = new JMenuItem("Rojo");
28
29 JMenu otroColores = new JMenu("Otros Colores");
colorNegro = new JMenuItem("Negro");
30 [Link](colorNegro);
31
32 [Link](colorVerde);
33 [Link](colorAmarillo);
34 [Link](colorRojo);
[Link](otroColores);
35
36
[Link](menuEmergente);
37 }
38
39 private class ControladorMenus implements ActionListener {
40
41 private JPanel panel;
42
43 public ControladorMenus(JPanel panel) {
[Link] = panel;
44 }
45
46 @Override
47 public void actionPerformed(ActionEvent e) {
48 switch ([Link]()) {
49 case "Amarillo":
[Link]([Link]);
50 break;
51 case "Verde":
52 [Link]([Link]);
53 break;
case "Rojo":
54 [Link]([Link]);
55 break;
56 case "Negro":
57 [Link]([Link]);
58 }
}
59
60 }
61
62
63
64
65
66
67
68 private void initComponents() {
69 setLayout(new [Link]());
70 }
71
72 }
73
74
75
76
77
El primer paso es crear el menu, para ello creamos diferentes opciones de menú (JMenuItem) indicando
mediante texto el color de fondo que establecerán.
Adicionalmente, se crea un menu (JMenu). Esto se realiza con el fin de crear una opción llamada
«Otros» que muestre mas colores, en otras palabras es un menú dentro de otro menú.
El segundo paso fue crear un objeto de la clase JPopupMenu llamado menuEmergente. Esta clase
cuenta con el método add(), el cual me permite agregar las opciones de menu (JMenuItem) y menú
adicional (JMenu). Adicionando estos objetos nos permite crear un menu emergente, solo falta indicar
donde debe ser visible.
Finalmente debemos indicar el componente que queremos agregarle nuestro menú emergente, en este
caso lo haremos al JPanel. Como nuestra clase hereda de JPanel, usamos la palabra reservada
thisindicando que usaremos la propia clase, escribimos un punto delante y mostrara los metodos
disponibles.
Usaremos el método setComponentPopupMenu y pasamos por parámetro el objeto JPopupMenu
creado.
El método usado, por defecto se encarga de gestionar eventos de mouse. Pues detecta cuando se ha
presionado clic derecho y muestra el menú emergente. De esta forma ahorramos escribir mas lineas de
código.
Ejecutamos nuestro proyecto y ahora cada que presionamos clic derecho sobre el contexto, se despliega
nuestro menú emergente.
Ademas, las opciones de menu pueden usar la interfaz ActionListener. Por este motivo se creo la
clase ControladorMenus encargada de gestionar este tipo de eventos de acción.
Tiene un constructor que recibe por parámetro un objeto de tipo JPanel, esto se hace para lograr cambiar
el color de fondo. Obteniendo como resultado lo siguiente al presionar la opción de menú con el color
deseado:
Espero sea de utilidad este breve ejemplo, puedes realizar cosas mas interesantes teniendo estas bases
mencionadas. Solo debes imaginar todas las posibilidades.
Como Utilizar Evento en JSlider, Recupera el Valor
Seleccionado
Posted by p_geek On mayo 12, 2019 In Lenguajes No comments
Crear una barra de valores utilizando JSlider no tiene algún sentido, pues esta no tiene funcionalidad por
defecto. Si usted desea conocer el valor seleccionado, deberá gestionar eventos.
Al gestionar eventos usted podrá obtener los valores cuando el usuario se encuentre manipulado el
JSlider.
Para comenzar, primero debe saber que existe una interfaz nombrada ChangeListener, permite saber el
cambio de estado de la barra.
Esta interfaz es realmente sencilla, solo cuenta con un metodo llamado:
stateChanged(ChangeEvent e); se activa cuando el usuario comienza a mover la flecha del JSlider,
gracias a esto podemos obtener el valor seleccionado.
Teniendo en claro esta función de la interfaz, ahora realizaremos un ejemplo sencillo. A continuación
explicaremos los requisitos del ejemplo:
Escribir un programa que tenga una barra de valores del 0 al 100, el valor seleccionado deberá escribirse
en un botón.
1
2 package eventosjslider;
3
4 import [Link];
5
public class EventosJSlider {
6
7 public static void main(String[] args) {
8 PanelSlider panel = new PanelSlider();
9 JFrame f = new JFrame("Evento en JSlider");
10 [Link](panel);
[Link](150, 100, 300, 400);
11 [Link](JFrame.EXIT_ON_CLOSE);
12 [Link](true);
13 }
14
15 }
16
En nuestro panel, hemos agregado nuestro JSlider y JButton, para ello utilizamos el administrador de
diseño GridLayot para dividir el contenido en dos columnas. Ademas, creamos una clase interna
anónima para gestionar los eventos de JSlider.
1 package eventosjslider;
2
import [Link];
3 import [Link];
4
5 public class PanelSlider extends [Link] {
6
7 public PanelSlider() {
8 initComponents();
9 [Link](new ControladorJSlider());
}
10
11 private class ControladorJSlider implements ChangeListener {
12
13 @Override
14
15
16 public void stateChanged(ChangeEvent e) {
17 [Link]("Valor: " + [Link]());
18 }
19
20 }
21
22 // <editor-fold defaultstate="collapsed" desc="Generated
23 Code">
private void initComponents() {
24
25 barraValores = new [Link]();
26 botonValores = new [Link]();
27
28 setLayout(new [Link](1, 2));
29
30 [Link](10);
[Link](1);
31 [Link]([Link]);
32 [Link](true);
33 [Link](true);
34 add(barraValores);
35
36 [Link]("Valor 50");
add(botonValores);
37 }// </editor-fold>
38
39
40 // Variables declaration - do not modify
41 private [Link] barraValores;
42 private [Link] botonValores;
// End of variables declaration
43
}
44
45
46
Como la clase ControladorJSlider se encargara de gestionar los eventos, esta debe implementar la
interfaz ChangeListener. Posteriormente debemos registrar el evento a nuestro JSlider, esto podemos
hacerlo mediante el metodo:
addChangeListener(ChangeListener object); este recibe por parametro un objeto de tipo
ChangeListener, por este motivo le pasamos por parametro la clase ControladorJSlider.
Cuando tu desplaces la flecha de la barra el valor del botón se actualiza de forma automática, como se
muestra en la siguiente imagen:
Esto es posible, gracias al evento utilizado en nuestra barra. El ejemplo realizado es muy sencillo. Sin
embargo, tu puedes crear cosas mas complejas mediante los valores obtenidos. Otro ejemplo seria:
modificar el factor de transparencia de un dibujo utilizando Graphics2D.
Como Crear Eventos en Cuadros de Texto
Utilizando DocumentListener
Posted by p_geek On mayo 12, 2019 In Lenguajes No comments
Crear eventos a tus campos de texto es realmente útil, te permite realizar muchas cosas. Un ejemplo de
estas es crear un buscador, al escribir cada letra podrás buscar de manera inmediata en tu base de datos.
Ademas, manejar este tipo de eventos resulta realmente sencillo. Es importante conocer este tipo de
eventos, pues te ayudaran a brindar mejor funcionalidad a tu software.
Comencemos hablando de la interfaz DocumentListener, cuenta con 3 métodos sencillos. Los cuales
son:
changedUpdate(DocumentEvent e); este método notifica cuando se ha realizado un cambio al
documento. Este metodo realmente se ocupa pocas veces. Los siguientes métodos que mencionare son
los mas usados al momento de codificar.
insertUpdate(DocumentEvent e); este método se invoca cuando el usuario comienza a insertar texto
dentro del campo de texto.
removeUpdate(DocumentEvent e); a diferencia del método anterior, este hace lo contrario. Se activa
cuando el usuario comienza a remover o eliminar texto del campo de texto.
Una vez comprendido el funcionamiento de cada método, realizaremos el siguiente ejemplo:
Escribiremos un programa que solo permita insertar como máximo 10 caracteres y mínimo 8, cuando se
exceda el limite, el campo se pondrá en color rojo y cuando se encuentre dentro del rango se pondrá en
verde.
Primero comenzaremos creando nuestra ventana, lo podemos realizar mediante el siguiente código:
1
2 package eventoscampos;
3
4 import [Link];
5
public class EventosCampos {
6
7 public static void main(String[] args) {
8 PanelCampos panel = new PanelCampos();
9 JFrame f = new JFrame("Eventos a campo de texto");
10 [Link](panel);
[Link](150, 100, 800, 600);
11 [Link](JFrame.EXIT_ON_CLOSE);
12 [Link](true);
13 }
14
15 }
16
Ahora el siguiente paso es crear nuestro panel con el campo de texto, en este caso hemos creado un
panel utilizando el administrador de diseño BorderLayout. Ademas, se creo una clase interna
llamada ControladorCampos encargada de gestionar los eventos de tipo DocumentListener, debido a
que esta clase implementa la interfaz nosotros sabemos que se encarga de gestionar los métodos de este
tipo de eventos.
1 package eventoscampos;
2
import [Link];
3 import [Link];
4 import [Link];
5 import [Link];
6
7 public class PanelCampos extends [Link] {
8
public PanelCampos() {
9 initComponents();
10 addEventos(new ControladorCampos());
11 }
12
13 public void addEventos(ControladorCampos oyente) {
14 Document documento = [Link]();
[Link](oyente);
15 }
16
17 private class ControladorCampos implements DocumentListener {
18
19 private int numeroCaracteres;
20
21 @Override
22 public void insertUpdate(DocumentEvent e) {
numeroCaracteres++;
23 if(numeroCaracteres >= 8 && numeroCaracteres <= 10) {
24 [Link]([Link]);
25 }else {
26 [Link]([Link]);
}
27
}
28
29 @Override
30 public void removeUpdate(DocumentEvent e) {
31 numeroCaracteres--;
32 if(numeroCaracteres < 8 || numeroCaracteres > 10) {
[Link]([Link]);
33 }else {
34 [Link]([Link]);
35 }
36 }
37
38 @Override
public void changedUpdate(DocumentEvent e) {
39
40 }
41
42 }
43
44 private void initComponents() {
45 campoCaracteres = new [Link]();
setLayout(new [Link]());
46 add(campoCaracteres, [Link]);
47 }
48
49 private [Link] campoCaracteres;
50 }
51
52
53
54
55
56
57
58
Tomando en cuenta la descripción del ejercicio que se tenia que realizar, dentro del
método insertUpdate si el método se encuentra dentro del rango de 8 a 10 caracteres se pintara de color
verde. En caso contrario se pintara de color rojo.
Dentro del método removeUpdate, indicamos que si el método es menor a 8 o mayor a 10 se pinte de
color rojo, indicando que no cuenta con los caracteres suficientes. En caso contrario, debe pintarse de
verde.
Ahora ya sabes manejar eventos de tipo DocumentEvent, esto te sera de gran utilidad incluso al validar
una contraseña o un correo electrónico.
Incluso, si deseas realizar cálculos de cambio al realizar una venta. Podrás simular el calculo del cambio
en tiempo real.
Manejo de Eventos de Acción (ActionListener) en
Java
Posted by p_geek On febrero 5, 2019 In Lenguajes No comments
El manejo de eventos de accion es uno de los eventos mas sencillos de implementar. Debido a que
solamente consta de un metodo. Sin embargo, es uno de los mas usados, pues permite agregar eventos de
tipo accion (al presionar) en algunos componentes.
Algunos componentes donde puede aplicarse el evento de tipo accion son: los botones, JTextField. Para
los botones el metodo se invoca al momento de presionar, en JTextField funciona de manera diferente y
este metodo se llama cuando el usuario hace un enter.
Para aplicar este evento realizare un ejemplo sencillo, consta de un boton. Sin embargo, cuando el
usuario presiona este boton el color de fondo se cambia. Ademas, si presiona nuevamente el boton, el
fondo cambia a un color diferente.
Primero crearemos nuestro marco y panel. Dentro del panel agregaremos el boton:
1
2 package eventoaccion;
3
import [Link];
4
5
public class EventoAccion {
6
7 public static void main(String[] args) {
8 JFrame f = new JFrame("Evento de Accion");
9 [Link](new PanelAccion());
10 [Link](100, 200, 500, 400);
[Link](JFrame.EXIT_ON_CLOSE);
11 [Link](true);
12 }
13
14 }
15
1 package eventoaccion;
2
import [Link];
3 import [Link];
4 import [Link];
5
6 public class PanelAccion extends JPanel {
7
8 public PanelAccion() {
9 addComponentes();
}
10
11 public void addComponentes() {
12 setLayout(new BorderLayout());
13
14 JButton cambiarColorFondo = new JButton("Cambiar Color de Fondo");
15 [Link](new OyenteAccion(this));
16 add(cambiarColorFondo, [Link]);
17 }
18
}
19
20
Para agregar el evento (poner a la escucha) lo hacemos con el metodo addActionListener, por
parametro recibe un objeto de tipo ActionListener.
ActionListener es una interfaz, solo contiene un metodo. A diferencia de las demas interfaces de
eventos, este tipo de evento no contiene una clase adaptadora pues tan solo tiene un metodo y no tendria
sentido. El metodo es:
actionPerformed: este metodo es llamado cuando se realiza una accion (se presiona un boton o
presionan enter dentro de un campo de texto).
A continuacion debemos crear la siguiente clase, donde se implementa la interfaz y el metodo invocado
del evento. Dentro del metodo agregaremos el codigo necesario para cambiar el fondo de pantalla con
diferentes colores:
1
2 package eventoaccion;
3
4 import [Link];
5 import [Link];
6 import [Link];
7
public class OyenteAccion implements ActionListener {
8
9 private PanelAccion panel;
10
11 public OyenteAccion(PanelAccion panel) {
12 [Link] = panel;
13 }
14
15 @Override
public void actionPerformed(ActionEvent e) {
16 int r = (int) ([Link]() * 256);
17 int g = (int) ([Link]() * 256);
18 int b = (int) ([Link]() * 256);
19 [Link](new Color(r, g, b));
20 }
21
}
22
23
Sabemos que el codigo de colores RGB, tiene un rango de valores de 0 a 255. Por este motivo se crean
tres variables de tipo entero.
¿Por que se multiplica por 256?
Cuando realizamos un casting a entero, siempre se toma en cuenta solo la parte entera. Ejemplo:
Supongamos que [Link] genera el numero 0.9999 y este valor se multiplica con 255. El resultado
es: 254.9745 y haciendo el casting a entero el resultado final es: 254.
Podras observar que nunca tomaremos en cuenta el valor 255 si realizamos la multiplicacion por el
mismo. Por este motivo, multiplicamos por 256, si haces las operaciones correspondientes mostradas
anteriormente podras notar que el resultado final es 255.
Lo explicado acerca de los colores, no es realmente el tema. Pero, me parece interesante y algo
importante que conozcas este tipo de cosas, pues a futuro pueden ser de gran ayuda.
Manejo de Eventos de Ventana
(WindowListener/WindowAdapter) en Java
Posted by p_geek On febrero 3, 2019 In Lenguajes No comments
El Manejo de Eventos de Ventana puede ser útil en distintos aspectos. Permite crear software con
funciones especificas. Supongamos que usted desea conectar una base de datos al momento de abrir la
ventana por primera vez, podrá lograr este comportamiento gracias a los eventos de ventana.
Otro uso de los eventos de ventana, es en un programa de reloj. Este debe mostrar la hora al momento de
iniciar por primera vez. Sin embargo, tan solo son algunas aplicaciones de este tipo de evento, pues seras
capaz de crear software realmente interesante.
Debes saber que java ofrece una interfaz y clase adaptadora, en esta ocasión usaremos la interfaz.
Primero comencemos creando nuestro método main encargado de crear y ejecutar las instancias.
1
2 package eventoventana;
3
import [Link];
4
5
public class MainVentana {
6
7 public static void main(String[] args) {
8 Ventana ventana = new Ventana();
9 [Link](JFrame.DO_NOTHING_ON_CLOSE);
10 [Link](new OyenteVentana(ventana));
[Link](500, 200, 500, 400);
11 [Link](true);
12 }
13
14 }
15
Ahora el siguiente paso es crear nuestra ventana y agregarle el evento. El código es:
1 package eventoventana;
2
3 import [Link];
4
5 public class Ventana extends JFrame {
6
7 public void addEventos(OyenteVentana oyente) {
8 [Link](oyente);
}
9
10 }
11
El ultimo paso es crear nuestra clase que implemente la interfaz WindowListener. Sin embargo, antes
mencionare el funcionamiento de cada método.
Descripción de los Métodos
windowActivated: Este método se activa cuando la ventana tiene el foco, con esto me refiero a cuando
la ventana esta sobre todas las demás. Por ejemplo: cuando en windows tenemos dos ventanas abiertas,
una estará con un color mas transparente (esto quiere decir que no estamos trabajando sobre esa
ventana). Sin embargo, cuando la ventana tiene un color fijo es porque estamos trabajando (copiando,
guardando o creando archivos) sobre esta.
windowDeactivated: Funciona de manera contraria al método anterior, cuando la ventana no esta activa
(no tiene el foco o no se esta trabajando sobre esta) se invoca el método.
windowClosed: Se activa cuando la ventana se ha cerrado.
windowClosing: Cuando usted cierra la ventana presionando el botón de cerrar este método se activa.
Por lo que, para aprovechar este método primero debe desactivar la función del botón cerrar. El código
creado como ejemplo te mostrara como aprovechar esta función.
windowIconified: Al minimizar (ocultar) la ventana, esta función se invoca.
windowDeiconified: Lo contrario al método anterior, cuando la ventana se encuentra minimizada y es
maximizada se invoca el método.
windowOpened: Es llamado cuando la ventana se ejecuta (abre) por primera vez.
Explicación del Ejemplo
El siguiente ejemplo te ayudara a comprender el funcionamiento de los métodos. Ademas, agregue una
característica que podrá servirte en un futuro con el método windowClosing.
1 package eventoventana;
2
import [Link];
3 import [Link];
4 import [Link];
5 import [Link];
6
7 public class OyenteVentana implements WindowListener {
8
9 private Ventana ventana;
10
public OyenteVentana(Ventana ventana) {
11 [Link] = ventana;
12 }
13
14 @Override
15 public void windowOpened(WindowEvent e) {
16 [Link](ventana, "Ventana iniciada por primera vez");
}
17
18
@Override
19 public void windowClosing(WindowEvent e) {
20 int opcion = [Link](ventana, "¿Quieres salir del prog
21 JOptionPane.YES_NO_OPTION);
22 if(opcion==JOptionPane.YES_OPTION) {
[Link](0);
23
24
25
26
}
27 }
28
29 @Override
30 public void windowClosed(WindowEvent e) {
31 [Link]("La ventana se ha cerrado");
}
32
33
@Override
34 public void windowIconified(WindowEvent e) {
35 [Link]("la ventana se a minimizado ");
36 }
37
38 @Override
public void windowDeiconified(WindowEvent e) {
39 [Link]("La ventana se a maximizado");
40 }
41
42 @Override
43 public void windowActivated(WindowEvent e) {
44 [Link]("La ventana esta activa (tienes el foco)");
[Link]().setBackground([Link]);
45 }
46
47 @Override
48 public void windowDeactivated(WindowEvent e) {
49 [Link]("La ventana no esta activa (no tienes el foco)");
[Link]().setBackground([Link]);
50 }
51
52 }
53
54
55
56
Explicare detenidamente como aprovechar windowClosing. Para lograr que el método funcione, primero
debe desactivar la función del botón cerrar que ofrece la ventana. Esto podemos hacerlo con el siguiente
código:
1 [Link](JFrame.DO_NOTHING_ON_CLOSE);
Con el código anterior le decimos que por mas que presionen el botón cerrar, la ventana no sera cerrada.
Sin embargo, tras presionar el botón, se activa el método windowClosing (se lanza un evento). Dentro de
este podemos poner cualquier código. Por ejemplo: preguntar si realmente desea salir de la ventana.
Ademas, cuando la ventana tiene el foco (La ventana esta sobre todas las demás) se activa
windowActivated, dentro del método agregue el código necesario para cambiar el color de fondo a rojo.
Podrá comprender de lo que hablo con la siguiente imagen:
Sin embargo, cuando usted no tiene el foco (la ventana esta detrás de otra) se invoca windowDeactivated
y el color del fondo se cambia a negro.
Los demas metodos se comprenden de manera facil. Por lo que, no es necesario explicarlos, ademas olo
imprimen un mensaje en consola
Manejo de Eventos de Mouse
(MouseListener/MouseAdapter) con Java
Posted by p_geek On febrero 1, 2019 In Lenguajes No comments
Crear eventos de ratón puede tener grandes utilidades, mas aun cuando se trata de desarrollar algún
videojuego. Pues, permite crear diferentes funciones de acuerdo al comportamiento especifico del
usuario tras utilizar el mouse.
El manejo de eventos de mouse se implementa mediante dos formas diferentes, la primera es utilizando
clases de interfaz. Otra opción es utilizando las clases adaptadoras.
Los eventos de mouse son varios, afortunadamente he preparado un ejemplo que permitirá comprender
de manera sencilla el funcionamiento de cada método. Para ello, primero mencionaremos los métodos a
continuación:
Métodos pertenecientes a la interfaz
MouseListener o clase MouseAdapter
mouseClicked: Se activa cuando se presiona y dejas de presionar el botón, sin mover el mouse. Por lo
que, si mantienes presionado, mueves el mouse y sueltas el botón se activara otro método
nombrado mouseDragged.
mouseEntered: Cuando se encuentra dentro del área de un componente, este método se invoca. Por
ejemplo: tenemos un panel al cual agregamos este tipo de evento, este método me permite saber cuando
se encuentra el cursor dentro del panel (componente).
mouseExited: Se lanza cuando el cursor sale del área de un componente, retomando el ejemplo del
panel del método anterior. Funciona de manera contraria, pues el método se activa cuando el cursor esta
dentro del panel y este sale del área conformada por el componente.
mousePressed: Se activa cuando el botón del mouse se mantiene presionado.
mouseReleased: Cuando el botón del mouse deja de ser presionado, se invoca el método.
Métodos pertenecientes a la interfaz
MouseMotionListener o clase MouseMotionAdapter
mouseDragged: Cuando mantienes presionado el botón del mouse y lo mueves, se activa el método.
mouseMoved: Este método se invoca cuando el cursor (mouse) se mueve.
Ejemplo para el Manejo de Eventos de Mouse
Los temas nuevos, se entienden mejor con un ejemplo. Las funciones del ejemplo son:
Cuando se mantiene presionado el botón del mouse, el fondo cambia de color. Esto es gracias al metodo
mousePressed, pues se invoca al realizar este comportamiento.
Y si al mismo tiempo se arrastra el cursor se dibujara un circulo que lo siga. Cabe mencionar que esto es
posible gracias a que el metodo mouseDragged que es invocado.
Ademas, si usted presiona y deja de presionar sin mover el cursor se dibuja un rectángulo alrededor del
circulo en las coordenadas donde se presiono. Y ahora podra apreciar una apariencia distinta como se ve
a continuación:
Si usted deja de presionar el botón del mouse, el color de fondo es eliminado. Estos son los
comportamientos mas destacados, los demás solo imprimen mensajes en consola.
Como es costumbre, comencemos creando nuestro marco (JFrame) con las instancias necesarias:
1
2 package eventomouse;
3
4 import [Link];
5
6 public class EventoRaton {
7
public static void main(String[] args) {
8 JFrame f = new JFrame("Eventos de Mouse");
9 PanelRaton panel = new PanelRaton();
10 OyenteRaton oyente = new OyenteRaton(panel);
11 [Link](oyente);
[Link](panel);
12 [Link](JFrame.EXIT_ON_CLOSE);
13 [Link](true);
14 [Link](300, 200, 500, 400);
15 }
16
17 }
18
Ahora creamos el panel, este componente nos permite dibujar dentro y agregar mas componentes.
Dentro de este, realizare los métodos necesarios para dibujar de acuerdo al comportamiento del usuario
con el mouse.
1
2
3
package eventomouse;
4
5 import [Link].*;
6 import [Link];
7
8 public class PanelRaton extends JPanel {
9
10 private int x = 0;
private int y = 0;
11 private boolean band = false;
12
13 public void addEventos(OyenteRaton e) {
14 [Link](e);
15 [Link](e);
16 }
17
public void setCoordenadas(int x, int y) {
18 this.x = x;
19 this.y = y;
20 }
21
22 public void setBandera(boolean band) {
[Link] = band;
23
}
24
25 @Override
26 public void paintComponent(Graphics g) {
27 [Link](g);
28 [Link](x, y);
[Link](-10, -10, 20, 20);
29 if(band) {
30 [Link]([Link]);
31 [Link](-25, -20, 50, 40);
32 // band = false;
33 }
}
34
35 }
36
37
38
Hasta ahora hemos creado nuestra ventana y panel. El paso final es crear nuestro OyenteRaton, dentro de
esta clase agregare todos los métodos necesarios para implementar este tipo de evento. Ademas, me
tome la molestia de escribir una pequeña descripción en cada método indicando el comportamiento.
1 package eventomouse;
2
import [Link];
3 import [Link].*;
4
5
6 public class OyenteRaton implements MouseListener, MouseMotionListener {
7
8 private PanelRaton panel;
9
public OyenteRaton(PanelRaton panel) {
10 [Link] = panel;
11 }
12
13 @Override
14 public void mouseClicked(MouseEvent e) {
//se invoca cuando presionas y dejas de presionar el boton sin mover el cur
15 [Link]([Link](), [Link]());
16 [Link](true);//se activa la bandera, permitiendo dibujar un recta
17 PanelRaton.
18 }
19
20 @Override
public void mousePressed(MouseEvent e) {
21 //se llama cuando se mantiene presionado el boton.
22 [Link]([Link]);
23 }
24
25 @Override
26 public void mouseReleased(MouseEvent e) {
//se llama cuando has dejado de presionar el boton del mouse.
27 [Link](null);
28 }
29
30 @Override
31 public void mouseEntered(MouseEvent e) {
//se llama cuando el mouse entra a los limites del componente.
32 //Cuando sale y entra de la ventana (en este caso).
33 [Link]("Acabas de entrar al area del componente");
34 }
35
36 @Override
37 public void mouseExited(MouseEvent e) {
//se llama cuando el cursor sale de los limites del componente.
38 [Link]("Acabas de salir del area del componente");
39 }
40
41 //Los siguientes metodos pertenecen a MouseMotionListener
42 @Override
public void mouseDragged(MouseEvent e) {
43
//es llamado cuando mantienes presionado el boton y mueves el cursor.
44 [Link]([Link](), [Link]());
45 [Link]();
46 }
47
48 @Override
public void mouseMoved(MouseEvent e) {
49 //Se llama al moveerse el cursor.
50 /*recomiendo comentar la siguiente linea, para apreciar mejor el mensaje de
51 // [Link]("estas moviendo el cursor");
52
53
54
55
}
56
57 }
58
59
60
61
Manejo de Eventos de Teclas (KeyListener) con
Java
Posted by p_geek On enero 29, 2019 In Lenguajes No comments
Implementar eventos de teclado no es complicado como algunos piensan. Sin embargo, deben realizar
algunos pasos para hacerlo funcionar correctamente. Agregar este tipo de evento te permite crear una
interfaz mas compleja con atajos. Permitiendo al usuario ejecutar otras funciones del programa
rápidamente.
Ademas, si deseas crear juegos a futuro. Es importante conocer este tipo de eventos, pues son
primordiales para darle movimiento al personaje y asignarle diferentes acciones con determinada
combinación de teclas.
Los eventos generados solamente son tres, podrás implementarlos utilizando la clase KeyListener o
KeyAdapter.
KeyListener: es una interfaz, por lo que obliga a re-escribir todos los métodos. Cada método con una
acción especifica para detectar el evento.
KeyAdapter: esta clase ya implementa la interfaz, por este motivo no es necesario re-escribir todos los
métodos. Solo re-escribirás los métodos que pienses utilizar.
Descripción de los Métodos
keyPressed: invocado cuando el usuario presiona cualquier tecla.
keyReleased: invocado cuando se ha dejado de pulsar la tecla (mas abajo mostrare un evento que dejara
claro cuando se invoca este método).
keyTyped: es lo misma función del método keyPressed, la única diferencia, es que el método solo
funciona cuando se presionan teclas que no son de acción (es decir: teclas como fin, alt, f6, entre otras.
No son reconocidas por este método).
EL evento que usare para dejar claro el funcionamiento de estos métodos, consiste en un panel al cual
cambiaremos el color de fondo. Primero comencemos creando nuestro marco (JFrame):
1
2
3
4
5
6
package eventoteclado;
7
8 import [Link];
9
1 public class EventoTeclado {
0
1 public static void main(String[] args) {
1 JFrame f = new JFrame("Eventos de Teclado");
PanelTeclado panel = new PanelTeclado();
1
OyenteTeclado oyente = new OyenteTeclado(panel);
2 [Link](oyente);
1 [Link](panel);
3 [Link](JFrame.EXIT_ON_CLOSE);
1 [Link](true);
[Link](300, 200, 500, 400);
4 }
1
5 }
1
6
1
7
1
8
1 package eventoteclado;
2
import [Link];
3
4
public class PanelTeclado extends JPanel {
5
6 public void addEventos(OyenteTeclado e) {
7 /*Cuando usamos un evento de teclado, es necesario indicarle donde se
8 tendrá el foco,
9 sino indica el foco, nunca funcionara el evento.*/
[Link](true);
1 [Link](e);
0 }
1
1 }
1
2
1
3
1
4
Si trabajamos con eventos de teclado, es importante indicar quien tendrá el foco (con esto me refiero, a
la parte donde se usaran los eventos de teclado). Esto lo hacemos con el método: setFocusable(). Sino
indica quien tendrá el foco, los eventos de teclado no funcionaran, podrás observar que dentro del
código anterior se pasa por parámetro el valor true al método, indicando que tiene el foco.
addKeyListener: indica que usara eventos de teclado, por parámetro recibe un objeto de tipo
KeyListener.
Implementando métodos para Evento de Teclado
Creamos nuestra clase con los métodos para gestionar el evento de teclado:
1 package eventoteclado;
2
import [Link];
3 import [Link].*;
4
5 public class OyenteTeclado implements KeyListener {
6
7 private PanelTeclado panel;
8
9 public OyenteTeclado(PanelTeclado panel) {
10 [Link] = panel;
}
11
12
@Override
13 public void keyTyped(KeyEvent e) {
14 [Link]("Solo funciona cuando presiona teclas que no son Fin, AL
15 otros.");
16 }
17
@Override
18 public void keyPressed(KeyEvent e) {
19 [Link]("color");
20 switch ([Link]()) {
21 case KeyEvent.VK_R://cambia fondo a color rojo
[Link]([Link]);
22 break;
23 case KeyEvent.VK_G://cambia fondo a color verde
24 [Link]([Link]);
25 break;
26 case KeyEvent.VK_B://cambia fondo a color azul
[Link]([Link]);
27 }
28 [Link]("Se activa al presionar cualquier tipo de telcla.");
29 }
30
31 @Override
public void keyReleased(KeyEvent e) {
32
33
34
35 [Link](null);
[Link]("Se lanzara msg cuando se deja de pulsar la telcla.");
36 }
37
38 }
39
40
41
El código anterior funciona de manera sencilla, con el objetivo de mostrarte la función de cada método
de manera fácil.
Dentro del metodo keyPressed agregue el codigo para cambiar el color de fondo, si usted mantiene
presionada la tecla R, G o B. Cambia el color de fondo al correspondiente:
Sin embargo, en el momento cuando dejas de presionar la tecla, el color de fondo vuelve a la
normalidad. Cabe mecionar, que al metodo keyTyped no se agrego codigo extra, pues funciona similar
al keyPressed.
Como Crear Pestañas con JTabbedPane en Java
Posted by p_geek On enero 26, 2019 In Lenguajes No comments
Crear pestañas con java utilizando la clase JTabbedPane brinda mejor aspecto a las interfaces.
Ademas, crea un diseño amigable en cuanto a usabilidad.
Ofrece múltiples ventajas, pues para crear (agregar) pestañas recibe por parámetro objetos
Component lo cual incrementa posibilidades de agregar múltiples elementos. Por ejemplo:
usted podrá agregar distintos paneles y dentro de los paneles agregar mas elementos que
conformen formularios, entre otros. Ademas, ofrece gran facilidad de implementación.
Para comenzar a crear nuestras primeras pestañas, como de costumbre primero debemos
crear nuestra ventana (marco) con un panel.
1 package paneles;
2
import [Link].*;
3
4
public class Paneles {
5
6 public static void main(String[] args) {
7
8 JFrame f = new JFrame("Ventana con Pestañas y paneles");
9 [Link](new PanelMezclado());
10 [Link](500, 400);
[Link](150, 100);
11 [Link](JFrame.EXIT_ON_CLOSE);
12 [Link](true);
13 }
14
15 }
16
Ahora crearemos la instancia a la clase JTabbedPane y agregaremos pestañas con diferentes
componentes. Realmente es fácil implementar pestañas y se logra haciéndolo con el siguiente
código:
1 //Panel con etiquetas
2 JTabbedPane pVista = new JTabbedPane();
3 add(pVista, [Link]);//Agregamos al panel nuestro objeto JTabbedPane
4 [Link]("Panel con malla", addPanelConMalla());
[Link]("Panel con bordes", addPanelConBorder());
5 [Link]("Mezcla de paneles", addMezclaPaneles());
6
Para una implementación sencilla, basta con utilizar el método addTab(). Y este tiene una
sobre carga de métodos, algunos ofrecen la posibilidad de agregar un icono a la pestaña. Sin
embargo, el utilizado en el código permite agregar un texto a la pestaña y obviamente el
contenido.
Los objetos Comoponent pasados por parámetro son:
1
2 private Component addPanelConMalla() {
JPanel panel = new JPanel();
3 GridLayout grid = new GridLayout(2, 2);
4 [Link](grid);
5 JButton boton1 = new JButton("Primer Botón");
6 JButton boton2 = new JButton("Último Botón");
7 [Link](boton1);
[Link](new JButton("Otro Botón"));
8 [Link](boton2);
9 return panel;
10 }
11
Este método y los demás son de tipo Component, con el código anterior utilizamos el
administrador de diseño GridLayout y se agregamos tres botones.
1
2 private Component addPanelConBorder() {
JPanel panel = new JPanel();
3 BorderLayout layout = new BorderLayout();
4 [Link](layout); //&amp;lt;=Asignar el Layout
5 [Link](new JButton("Norte"), "North");
6 [Link](new JButton("Sur"), "South");
7 [Link](new JButton("Este"), "East");
[Link](new JButton("Oeste"), "West");
8 [Link](new JButton("Centro"), "Center");
9 return panel;
10 }
11
Ahora hacemos uso de BorderLayout y agregamos varios botones, podrás notar que existe la
posibilidad de crear pestañas con diferentes componentes cada una.
1
2 private Component addMezclaPaneles() {
3 JPanel panel = new JPanel();
4 BorderLayout layout = new BorderLayout();
[Link](layout);
5
6 JPanel panelNorte = new JPanel();
7 [Link]([Link]);
8 [Link](BorderFactory.
9 createLineBorder([Link], 5));
[Link](panelNorte, [Link]);
10 [Link](new JButton("Aceptar"));
11 [Link](new JButton("Cancelar"));
12 [Link](new JButton("Botón"), "Center");
13
14 return panel;
15 }
16
Finalmente usamos el mismo administrador de diseño que el código anterior, pero agregamos
botones y un border dando un aspecto diferente.
Como podrás notar, este tipo de pestañas da mejor aspecto y utilidad a nuestras aplicaciones.
Ademas, el método utilizado para lograr este funcionamiento solamente es uno. Sin embargo,
si deseas agregar funciones extras recomiendo visitar el API de JAVA (pues solo mencione el
método necesario para lograr esta función).
Como Abrir y Guardar Archivos con JFileChooser
en Java
Posted by p_geek On enero 25, 2019 In Lenguajes No comments
Regularmente cuando se comienza a crear interfaces graficas, llega un momento en donde necesitamos
crear diferentes programas para manipular archivos. Sin embargo, los usuarios aveces necesitan guardar,
editar y abrir archivos de manera fácil.
Ademas crear un cuadro de dialogo que permita abrir y guardar archivos, da un aspecto mas
profesional a la interfaz. Por esta y mas razones se recomienda implementar esta clase conocida como
JFIleChooser.
En este articulo nos limitaremos a enseñar como manipular archivos, pues crearemos un articulo especial
sobre el tema. Para comenzar a crear nuestro cuadro de dialogo, creare una ventana con menú (aunque
esto no es necesario, puede implementarlo de diferentes formas):
1
2 package menus;
3
4 import [Link];
5
6 public class Menus {
7
public static void main(String[] args) {
8 JFrame f = new JFrame("Ventana con menus");
9 BarraMenu barra = new BarraMenu();
10 [Link](new OyenteMenu());
11 [Link](barra);
[Link](400, 300);
12 [Link](120, 100);
13 [Link](JFrame.EXIT_ON_CLOSE);
14 [Link](true);
15 }
16
17 }
18
1 package menus;
2
import [Link].*;
3
4
public class BarraMenu extends JMenuBar {
5
6 private JMenu archivo;
7 private JMenuItem abrir;
8 private JMenuItem guardar;
9 private JMenuItem salir;
10
public BarraMenu() {
11 addMenus();
12
13
14 }
15
16 public final void addMenus() {
17 archivo = new JMenu("Archivo");
18 add(archivo);
19 abrir = new JMenuItem("Abrir");
[Link](abrir);
20 guardar = new JMenuItem("Guardar");
21 [Link](guardar);
22 [Link]();
23 salir = new JMenuItem("Salir");
[Link](salir);
24 }
25
26 public void addEventos(OyenteMenu e) {
27 [Link](e);
28 [Link](e);
29 [Link](e);
}
30
31 }
32
33
34
Explicare de forma breve que hace el código anterior, el primer cuadro de código simplemente se
encarga de crear el marco (JFrame) e instancias para usar las demás clases, el segundo bloque crea el
menú, el tercero es donde se gestiona los eventos de tipo ActionListener.
Dentro de la clase donde se gestionan los eventos, se agregara el código para crear cuadros de dialogo.
La clase JFileChooser ofrece varios métodos con funciones diferentes. Sin embargo, mencionare los
básicos (los mas utilizados).
Para crear a comenzar nuestro primer cuadro de dialogo, primero debemos crear una instancia a la clase
JFileChooser y después debemos hacer uso de los siguientes métodos:
Cuadro de Dialogo para Abrir Archivos
showOpenDialog(Component parent): se encarga de crear el cuadro de dialogo que permite abrir
archivos, este método es de tipo entero. Por lo que, devuelve diferentes valores enteros y son los
siguientes:
JFileChooser.CANCEL_OPTION
JFileChooser.APPROVE_OPTION
JFileChooser.ERROR_OPTION
Lo anterior son constantes de clase (son valores enteros), si deseas conocer el valor de las constantes
recomiendo visitar el API de java. Mencionaremos especialmente la
constante APPROVE_OPTION este valor es devuelto cuando seleccionan el archivo y se presiona el
botón de abrir:
Código:
1 int opcion = [Link](null);
2 if (opcion == JFileChooser.APPROVE_OPTION) {
3 String ruta = [Link]().getAbsolutePath();
}
4
Sabemos que el metodo showOpenDialog devuelve valores de tipo entero, por esta razón debemos
almacenar los valores en una variable. Con el condicional le decimos que si el archivo se aprueba nos
devuelva la ruta. Sabiendo la ruta usted sera capaz de leer el contenido dentro del archivo mediante otras
clases (del tema hablaremos en otro articulo).
Ademas, el método recibe por parámetro un objeto de tipo Component. Debe pasar el componente padre,
por ejemplo: una ventana o simplemente indicarle null (diciendo que no existe un componente padre).
Esto simplemente asegura centrar el cuadro de dialogo respecto al componente padre.
Cuadro de Dialogo para Guardar Archivos
showSaveDialog(Component parent): funciona igual que el método anterior, la única diferencia el
botón. Solo permite guardar archivos y no abrir. Devuelve las mismas constantes y el código es igual:
1 int opcion = [Link](null);
2 if (opcion == JFileChooser.APPROVE_OPTION) {
3 String ruta = [Link]().getAbsolutePath();
}
4
setFileFilter(FileFilter filter): Si deseas filtrar el tipo de archivo a mostrar puedes hacerlo utilizando
este método, solo recibe por parámetro un objeto de tipo FileFilter y puedes hacerlo con la
clase FileNameExtensionFilter, esta clase recibe por parámetro el nombre a mostrar en el cuadro de
dialogo y el tipo de archivo a filtrar como se muestra a continuación:
1 [Link](new FileNameExtensionFilter("Archivo de Texto", "txt"));
getSelectedFile(): este metodo solo devuelve un objecto de tipo file.
Para terminar, este todo lo mencionado sobre FileChooser puede ser implementado de la siguiente
forma:
1 package menus;
2
import [Link];
3 import [Link];
4 import [Link];
5 import [Link];
6
7
8
9
10 public class OyenteMenu implements ActionListener {
11
12 private JFileChooser seleccion;
13
14 public OyenteMenu() {
15 seleccion = new JFileChooser();
16 }
17
@Override
18 public void actionPerformed(ActionEvent e) {
19 String tipo = [Link]();
20 switch (tipo) {
21 case "Abrir":
opcionAbrir();
22
break;
23 case "Guardar":
24 opcionGuardar();
25 break;
26 case "Salir":
[Link](0);
27 }
28 }
29
30 //Codigo para crear cuadro de dialogo con JFileChooser
31 public void opcionAbrir() {
32 [Link](new FileNameExtensionFilter("Archivo de Texto", "*")
int opcion = [Link](null);
33 if (opcion == JFileChooser.APPROVE_OPTION) {
34 String ruta = [Link]().getAbsolutePath();
35 }
36 }
37
38 public void opcionGuardar() {
int opcion = [Link](null);
39 if (opcion == JFileChooser.APPROVE_OPTION) {
40 String ruta = [Link]().getAbsolutePath();
41 }
42 }
//Fin de codigo JFileChooser
43
44
}
45
46
47
48
El codigo agrega eventos y permite detectar las opciones pulsadas del usuario. El resultado final puede
ser apreciado en la primer imagen del post. Espero sea de gran utilidad lo explicado y tengan curiosidad
de implementar lo aprendido en mas proyectos GUIs.
Como Dibujar Figuras en Java Utilizando la Clase
Graphics
Posted by p_geek On enero 24, 2019 In Lenguajes No comments
Afortunadamente java ofrece un gran soporte para gráficos e incluso existe una clase
Graphics2D para dibujos bidimensionales. Sin embargo, en este articulo hablaremos
solamente de graphics y ciertos elementos que deberás conocer para dibujar.
Primero debes saber que Graphics funciona con un sistema de coordenadas (todas las
herramientas y lenguajes que soporten dibujo lo tienen). La coordenada X indica la posición
horizontal del elemento y este se dibuja de izquierda a derecha, la coordenada Y funciona de
arriba a abajo dibujando los elementos de esta forma. A diferencia de las coordenadas en
matemáticas en Java Y se desplaza hacia abajo cuando su valor es positivo.
Ademas, la parte superior izquierda siempre tendrá las coordenadas(x, y) con valor (0, 0).
Tomando esta como referencia para posicionar tus dibujos, podrás apreciar lo explicado a
continuación:
La clase Graphics permite establecer colores y fuentes a sus dibujos, es posible dibujar: texto,
imágenes, círculos, rectángulos, arcos, lineas y poligonos (fillPolygon, este metodo permite
crear multiples dibujos como: triángulos, hexágonos y otros. Pues por parámetro debes pasar
un arreglo de posiciones en X y Y logrando diversas figuras).
¿Como dibujar?
Para poder comenzar a crear nuestros primeros dibujos, debemos crear un marco y agregar
un panel. El panel es nuestra hoja (literal) que permite aplicar los dibujos de la clase Graphics
(el contexto grafico es nuestro panel). Ya creado nuestro marco con panel ahora debemos
establecer el método para dibujar:
1 public void paintComponent(Graphics g) {
2 [Link](g);
3 }
Con el método anterior seremos capaces de dibujar, es importante llamar al método padre
utilizando super, pues con esto indicamos que pinte nuevamente el contexto, si usted no hace
el llamado es posible que se dibuje una vez o no dibuje nada. El código completo con el marco
y panel (contexto grafico) es:
1
2 package contextografico;
3
4 import [Link];
5
public class PrimerDibujo {
6
7 public static void main(String[] args) {
8 JFrame f = new JFrame("Ventana con Contexto Grafico");
9 PanelDibujo panel=new PanelDibujo();
10 [Link](panel);
[Link](280, 150, 500, 400);
11 [Link](JFrame.EXIT_ON_CLOSE);
12 [Link](true);
13 }
14
15 }
16
1
package contextografico;
2
3
import [Link].*;
4 import [Link].*;
5
6 public class PanelDibujo extends JPanel {
7
8 @Override
9 public void paintComponent(Graphics g) {
[Link](g);
10 }
11
12 }
13
Aplicando métodos para dibujar
setColor(Color c): este método hace posible establecer diferentes colores a las figuras, recibe
por parámetro un objecto de tipo color. La clase Color contiene una serie de constantes que
indican el valor de cada color, tras escribir Color y un punto se mostraran los diferentes
nombres de colores.
1
2 public class PanelDibujo extends JPanel {
3
@Override
4 public void paintComponent(Graphics g) {
5 [Link](g);
6 [Link]( 40, 35, 80, 80, 0, 360);
7 [Link](160, 75, 200, 75);
[Link]([Link]);
8 [Link]( 40, 150, 80, 70, 0, 360);
9 }
10
11 }
12
Cabe mencionar que los métodos que al comienzo tienen fill tiene un comportamiento de
dibujo especial y es que estos crean el dibujo relleno con el color establecido (en la imagen
anterior se dibuja un arco relleno de color naranja).
Un método util conocido como translate, recibe por parámetro dos valores y son las posiciones
X y Y. Al establecer el valor de coordenadas cambia el punto de origen. Por ende, los dibujos
serán dibujados a partir de los valores establecidos como punto de origen, ejemplo:
1
2 public class PanelDibujo extends JPanel {
3
@Override
4 public void paintComponent(Graphics g) {
5 [Link](g);
6 [Link]([Link]);
7 [Link]([Link]()/2, [Link]()/2);
8 [Link](40, 10, 50, 50);
[Link](-40, -80, 50, 50);
9 [Link](-5, -5, 10, 10);
10 }
11
12 }
13
La posición donde se encuentra el circulo dibujado, es el nuevo punto de origen y a partir de
este serán dibujadas las figuras. Para obtener el centro del marco, obtienes el ancho y alto del
Panel y lo divides entre 2 (podrás observar que el circulo esta centrado).
¿Dibujar una figura dentro de otra?
Algo realmente sencillo de hacer, puedes apreciar el siguiente ejemplo:
1
2 public class PanelDibujo extends JPanel {
3
@Override
4 public void paintComponent(Graphics g) {
5 [Link](g);
6 [Link]([Link]);
7 [Link]([Link]()/2, [Link]()/2);
8 [Link](40, 10, 50, 50);//dibujo de rectangulo
[Link]([Link]);
9 [Link](40, 10, 50, 50); //dibujo de circulo
10 }
11
12 }
13
Usted simplemente deberá poner las mismas posiciones X, Y. Pues los dibujos se realizan de
izquierda a derecha, con esto se asegura de dibujar figuras «anidadas».
Los métodos utilizados en los ejemplos no son todos. Para mi punto de vista los métodos
mencionados, te facilitaran la creación de dibujos. Si deseas conocer los demás métodos
puedes revisar el API de JAVA.
Como Crear Menús Utilizando Marcos en JAVA
Posted by p_geek On enero 23, 2019 In Lenguajes No comments
Los menús son prácticos al momento de crear GUIs pues reducen la creación de nuevos componentes
que puedan saturar nuestra interfaz dando un aspecto no amigable. Por este y otros motivos debes
aprender a crear menús utilizando marcos (aunque también puedes hacerlo con paneles).
Para crear un menu se requieren tres clases, mencionadas a continuación:
JMenuBar: esta clase hereda de JComponent siendo una subclase y permite guardar componentes de
tipo JMenu actuando como una piel, el mismo nombre lo indica pues actúa como una barra en la cual se
colocan componentes JMenu.
JMenu: esta clase permite escribir el nombre de nuestro menu (menu padre) y en esta colocaremos
submenus. Al momento de presionar desplegara los submenus contenidos. Ademas, esta clase permite
agregar un JMenu a otro objeto JMenu permitiendo crear menús y submenus anidados.
JMenuItem: esta clase es un componente que debe agregarse a un JMenu y sera nuestra lista que se
despliegue al presionar el menu (menu padre). Ademas, tras presionar nuestro submenu (JMenuItem)
este lanza un evento el cual podremos manipular utilizando los métodos ofrecidos por la clase.
Para comenzar a crear nuestro primer menu, debemos crear un marco (ventana). Podemos hacerlo
creando una instancia directamente de la clase como se muestra a continuación:
Código para Crear Marco
1
2 package menus;
3
4 import [Link];
5
public class Menus {
6
7
public static void main(String[] args) {
8 JFrame f = new JFrame("Ventana con menus");
9 BarraMenu barra=new BarraMenu();
10 [Link](barra);
11 [Link](800,600);
[Link](120,100);
12 [Link](JFrame.EXIT_ON_CLOSE);
13 [Link](true);
14 }
15
16 }
17
El metodo protagonista en esta ocasión es setJMenuBar. Este metodo permite establecer el menu a
nuestra ventana (marco). Por lo que, pide por parámetro un objecto de tipo JMenuBar.
Para crear el menu, debemos hacer uso de pocos metodos que entenderás de forma inmediata.
Código para Crear Menu
1 package menus;
2
import [Link].*;
3
4
public class BarraMenu extends JMenuBar {
5
6 public BarraMenu() {
7 addMenus();
8 }
9
10 public final void addMenus() {
JMenu archivo = new JMenu("Archivo");
11 add(archivo);
12 add(new JMenu("Editar"));
13 add(new JMenu("Ayuda"));
14
15 [Link](new JMenuItem("Abrir"));
16 [Link](new JMenuItem("Guardar"));
17
18
19 [Link](new JMenuItem("Cerrar"));
[Link]();
20
21 JMenu propiedades = new JMenu("Propiedades");
22 [Link](new JMenuItem("Propiedad 1"));
23 [Link](new JMenuItem("Propiedad 2"));
24 [Link](new JMenuItem("Propiedad 3"));
25
26 [Link](propiedades);//aqui se aprecian dos componentes JMenu anidados.
[Link]();
27 [Link](new JMenuItem("Salir"));
28 }
29
30 }
31
32
Aplicando un poco los conocimientos obtenidos con POO, heredo directamente de JMenuBar
estableciendo mi barra para colocar los demás componentes.
El siguiente paso es crear una instancia de la clase JMenu y posteriormente hacer uso del metodo add().
Este permite agregar componentes de tipo JMenuItem y JMenu, usted debe pasar por parámetro el texto
que desea mostrar.
addSeparator(): este metodo crea una linea que permite una mejor visión (algo estético para mejorar el
diseño del menu).
Tipos de Eventos Comunes de la GUI (Interfaz
Grafica de Usuario)
Posted by p_geek On enero 19, 2019 In Lenguajes No comments
¿Que son los eventos?
Definiremos de manera breve este concepto, un evento es el resultado de una acción realizada por el
usuario dentro de una interfaz grafica.
Sin embargo, nosotros hablaremos sobre los eventos que maneja java. En java debemos saber que todo
es orientado 100% a objetos, con esto podemos entender que es realmente un evento. Es un objeto
encargado de guardar la información por ejemplo: el nombre del origen de evento, el tipo de evento.
Ademas, los eventos pueden ser generados de diversas formas: al presionar una tecla, escribir texto
dentro de un campo, al desplazar o hacer clic con el mouse, al maximizar, minimizar y cerrar la ventana,
entre otros. Sin embargo, hablare de los mas comunes dentro de aplicaciones GUI.
Diseño del manejo de eventos
Para aplicar eventos se necesita llevar acabo un esquema, compuesto por objetos creados de acuerdo a la
acción.
Objeto origen: como decía anteriormente, este objeto puede ser un componente por ejemplo: botones,
ventanas, opciones de menu, entre otros.
Cuando presionan dicho objeto se crea un evento (objeto origen) en cargado de guardar información
sobre la acción realizada.
Objeto evento: se encarga de guardar la información necesaria para identificar el tipo de evento, ademas
puede guardar el nombre del origen.
Objeto oyente: este objeto siempre sera de tipo Listener y es encargado de estar a la escucha (de
chismoso) de cuando un evento (objeto origen) es creado. Este ejecuta la acción asociada al evento. Sin
embargo, cada oyente debe tener su registro al origen correspondiente pues dependiendo el origen tendra
una serie de metodos.
Para que tengas una mejor idea del esquema para aplicar a una GUI te dejo la siguiente imagen:
Clasificación de Eventos
Debemos saber que cada objeto origen genera un tipo especifico de evento que debe ser representada
con su clase adecuada.
Tipos de Oyentes
Son clases que deben representar los tipos de eventos que escuchan, estas clases deben implementar una
o varias interfaces para ejecutar metodos de acuerdo al tipo de evento.
Sin embargo, la mayoría de interfaces tienen mas de un metodo que tal vez no debas usar. Debido a este
motivo han creado una serie de clases adaptadoras encargadas de cumplir la misma función, pero la
ventaja es que solo usas los metodos que necesites (son clases que ya implementan las interfaces
mencionadas anteriormente y estas tambien se utilizan para crear oyentes).
Los eventos permiten incrementar la funcionalidad del programa, permitiendo al usuario interactuar de
manera facil. Pues tu como desarrollador, puedes hacer que un boton por ejemplo: cambie el color de
fondo o ejecute funciones mas complejas. En este articulo solo doy una breve introducción, en futuros
artículos explicare como implementar los diferentes tipos de eventos.
Como Funcionan los Administradores de Diseño
(Esquemas) en Java
Posted by p_geek On enero 5, 2019 In Lenguajes No comments
Los administradores de esquemas o diseño ofrecen una gran serie de ventajas, ya que
permite colocar los componentes de manera facil siempre que conozca el funcionamiento de
los administradores de diseño. Sin embargo, el administrador por defecto en una ventana
(JFrame) es BorderLayout y para el JPanel el administrador de esquema usado es FlowLayout.
El metodo usado setLayout(): permite establecer el administrador de diseño, recibe por
parametro un objeto de tipo LayoutManager (es una interfaz), los administradores de diseño
implementan LayoutManager por este motivo es posible pasar por parametro al metodo. Si
pasas por parametro null se indica que no tendra ningún administrador de diseño y todos los
componentes agregados se hacen de forma absoluta es decir un valor de posición fijo X y Y.
FlowLayout
Este es uno de ls administradores de esquema mas simple, pues todos los componentes
agregados al JPanel que establezca este comportamiento se agregan de izquierda a derecha
y cuando los componentes llegan al limite de la ventana los componentes pasan a una
segunda linea ordenando de la misma forma.
Ademas permite alinear los componentes al centro, izquierda o derecha.
El código para crear la ventana de la imagen anterior es el siguiente:
1 class ProbandoEsquemas extends JPanel {
2
private JButton[] botones;
3
4
public ProbandoEsquemas() {
5 addComponentes();
6 }
7
8
9 public final void addComponentes() {
10 /*No hace falta decir que usara FlowLayout, JPanel lo usa por defecto*/
11 setLayout(new FlowLayout());
12 botones = new JButton[10];
for (int i = 0; i&lt;10; i++) {
13 botones[i] = new JButton("Boton " + i);
14 add(botones[i]);
15 }
16 }
17
}
18
19
BorderLayout
Este administrador de esquemas ofrece 5 regiones donde poner los componentes y estos se
adaptan al tamaño de las regiones. Sin embargo, como comentaba anteriormente es posible
agregar un JPanel dentro de otro y en cada region usted sera capaz de agregar un Panel de
tipo FlowLayout o GridLayout, puede quedar mas claro el funcionamiento con la siguiente
imagen:
El código creado es:
1 class ProbandoEsquemas extends JPanel {
2
public ProbandoEsquemas() {
3 addComponentes();
4 }
5
6
7
public final void addComponentes() {
8 setLayout(new BorderLayout());
9 JButton botonNorte = new JButton("Norte");
10 JButton botonSur = new JButton("Sur");
11 JButton botonEste = new JButton("Este");
12 JButton botonOeste = new JButton("Oeste");
JButton botonCentro = new JButton("Centro");
13 add(botonNorte, [Link]);
14 add(botonSur, [Link]);
15 add(botonEste, [Link]);
16 add(botonOeste, [Link]);
add(botonCentro, [Link]);
17 }
18
19 }
20
21
Existe una diferencia entre FlowLayout al agregar elementos, en BorderLayout debemos
especificar la posición donde agregar nuestro componente:
add(botonSur, [Link]);
Como podrás observar al metodo add() se le pasa un segundo parametro indicando la
posición del componente.
Algo importante que no he mencionado, todos los componentes creados ya sea un boton,
panel, entre otros (cualquier componente) debe ser agregado al panel (JPanel) mediante el
metodo mencionado anteriormente.
GridLayout
Hasta ahora hemos visto FlowLayout, BorderLayout y en breve GridLayout, todos estos
administradores de diseño tienen una sobre carga de constructores. Pero en la mayoría de los
casos GridLayout(numeroFilas, numeroColumnas) recibe por parametro el numero de filas y
columnas creando una especie de tabla o matriz (como gustes verlo).
Los componentes se agregan de acuerdo al orden de filas, los componentes se colocan en la
primer fila de izquierda a derecha cubriendo el numero de columnas y al terminar la fila se
pasa con la siguiente realizando el mismo procedimiento. La siguiente imagen te ayuda a
comprender lo explicado:
El código para utilizar GridLayout es:
1
2 class ProbandoEsquemas extends JPanel {
3
4 private JButton[] botones;
5
6 public ProbandoEsquemas() {
addComponentes();
7 }
8
9 public final void addComponentes() {
10 setLayout(new GridLayout(2, 5));
11 botones = new JButton[10];
for (int i = 0; i<10; i++) {
12 botones[i] = new JButton(i + "");
13 add(botones[i]);
14 }
15 }
16
17 }
18
Finalmente usted podrá poner a prueba todos estos JPanel utilizando una ventana:
1 public class AdministradoresDeDiseño {
2
public static void main(String[] args) {
3 JFrame f = new JFrame("Administrador de Esquemas");
4 [Link](300, 200, 400, 300);
5 [Link](new ProbandoEsquemas());
6 [Link](true);
7
[Link](JFrame.EXIT_ON_CLOSE);
8 }
9
10 }
11
Como Utilizar JSlider en Java
Posted by p_geek On enero 5, 2019 In Lenguajes No comments
La clase JSlider, permite crear una barra donde nosotros seremos capaces de seleccionar un valor
entero. Permitiendo al usuario tomar el valor dentro de un rango de valores definidos por el
programador, cabe mencionar que esta clase hereda de JComponent.
JSlider por defecto muestra una barra horizontal pero permite cambiar la orientación, ademas tiene
algunos metodos encargados de poner el indicador al valor más cercado de la barra (estos metodos seran
mencionados a continuación).
Primero comenzamos creando una ventana (ya explique como hacerlo):
1
2 package jslider;
3
import [Link];
4
5
public class JSliderMain {
6
7 public static void main(String[] args) {
8 JFrame f = new JFrame("Slider");
9 [Link](300, 100, 500, 200);
10 [Link](new PanelSlider());
[Link](JFrame.EXIT_ON_CLOSE);
11 [Link](true);
12 }
13
14 }
15
El segundo paso es crear una clase que herede de JPanel, un panel es como una bolsa que permite
guardar componentes dentro de ella, ademas usted sera capas de meter una bolsa dentro de otra (osea un
JPanel dentro de otro JPanel) esto permite crear interfaces graficas mas complejas y de mejor
usabilidad. Creamos la clase PanelSlider:
1 package jslider;
2
import [Link].*;
3 import [Link].*;
4
5 public class PanelSlider extends JPanel {
6
7
8
9 private JSlider radioSlider;
10
11 public PanelSlider() {
12 addComponentes();
}
13
14
public final void addComponentes() {
15 setLayout(new BorderLayout());
16 radioSlider = new JSlider(100, 200, 150);
17 [Link](5);
18 [Link](25);
[Link](true);
19 [Link]([Link]);
20 [Link](true);
21 add(radioSlider, [Link]);
22 }
23
}
24
25
Me tome la molestia de agregar los metodos mas utilizados, sin embargo si usted desea implementar mas
funciones a su barra podrá consultar la API de JAVA.
La clase JSlider tiene sobrecarga de constructores, el constructor utilizado en el ejemplo recibe por
parametro un valor minimo, maximo y uno por defecto donde colocara la flecha (indicador) que nosotros
podemos desplazar dentro de ese rango, en otras palabras el minimo y maximo establecen un rango de
numero de inicio a fin.
Ejemplo: En el código anterior pasamos por parametro los valores JSlider(100, 200, 150); indicando
que nuestro valor inicial es 100 y final 200. El tercer valor pasado por parametro indica la posición del
indicador (flecha) donde debe colocarse por defecto.
setMajorTickSpacing(25): con este metodo estamos diciendo que cada 25 valores va a colocar una
etiqueta indicando el valor debajo o al lado (Cuando la orientación esta en vertical).
setMinorTickSpacing(5): este simplemente divide los valores cada 5, pero estos se colocan dentro del
espacio dejado por el metodo anterior, podrás observar el cambio con la siguiente imagen:
setPaintLabels(true): este metodo se encarga de dibujar los valores numéricos, por lo cual debes pasar
un valor de tipo boolean.
setPaintTicks(true): dibuja las lineas encargadas de dividir los espacios dejados con los metodos
setMajorTickSpacing() y setMinorTickSpacing().
setOrientation([Link]): Recibe por parametro constantes de clase (son valores
enteros) los cuales permiten determinar la posición de la barra.
Como Crear una Ventana JFrame en Java
Posted by p_geek On enero 5, 2019 In Lenguajes No comments
Crear una ventana en java sin necesidad de usar el asistente es una buena practica que muchos novatos
deben tener en cuenta, pues una elaboración desde cero les permite comprender mejor el funcionamiento
de los metodos ofrecidos por el API Java.
Por ejemplo, para poder utilizar una calculadora se recomienda saber resolver las operaciones de suma,
resta, multiplicacion, division de manera que el usuario sepa lo que esta haciendo. Sucede lo mismo al
momento de crear una ventana en Java ya que podrías elaborar una sin mucho trabajo utilizando el
asistente que ofrece el compilador (por ejemplo: netbeans) pero no tendras idea del código detrás de
esto. Es por ello que a continuación te explicare los códigos para realizar una ventana:
1 package ventana;
2
import [Link];
3
4
public class Ventana {
5
6 public static void main(String[] args) {
7 JFrame v=new JFrame("Primera Ventana");
8 //[Link](100, 100);
9 //[Link](600, 400);
[Link](JFrame.EXIT_ON_CLOSE);
10 [Link](true);
11 [Link](new Panel());
12 [Link](100, 100, 600, 400);
13 [Link]("x=" + [Link]() + ", y=" + [Link]());
14 [Link]("ancho=" + [Link]() + ", alto=" + [Link]());
}
15
16 }
17
18
19
Utilizando la clase JFrame se crea una ventana, esta clase tiene una serie de metodos de los cuales
hablare.
setLocation(x, y): este metodo permite determinar la ubicación de la ventana de acuerdo a las
dimensiones de nuestra pantalla y recibe por parametro dos valores que son las posiciones en X y Y.
setSize(ancho, alto): permite determinar el tamaño que tendra la ventana. Sin embargo, para ahorrar los
2 metodos mencionados hasta el momento existe un metodo que incluye la funcion de ambos conocido
como:
setBounds(x, y, ancho, alto);
Todo va bien, pero aun falta algo importante ya que la ventana por si sola no se muestra. Debemos hacer
uso del siguiente metodo:
setVisible(true): recibe por parametro un dato de tipo boolean y puede ser false o true, si pones false la
ventana no sera visible y por ende sabes que sucede al pasar por parametro el valor true.
Prácticamente nuestra ventana esta terminada, pero ¿que pasa al cerrar nuestra ventana? esta no
cierra completamente y podremos observar como el compilador aun dice que la ventana esta en
ejecución. Para solucionar este problema debemos usar el metodo:
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE): recibe por parametro constantes de clase
(simplemente son valores de tipo entero) dentro del API podemos observar los valores de cada constante
y saber el comportamiento que recibe. En este caso la constante que pasamos por parametro le indica
que al momento de pulsar en la X de la ventana esta debe salir y terminar el «proceso».
Finalmente el metodo:
add(panel): permite agregar un componente, siempre debemos pasar por parametro un objecto de tipo
JPanel.
Las ventanas van acompañadas de uno o varios JPanel, los cuales tienen administradores de diseño que
tienen un comportamiento distinto al insertar componentes, este tema sera tratado en otro articulo.
[Link]/
Ejemplo de Relación Productor/Consumidor con
Sincronización en Java
Posted by p_geek On enero 26, 2019 In Programación Concurrente No comments
La relación productor/consumidor es interesante pues ambos comparten un buffer. Sin embargo,
ambos funcionan de manera distinta teniendo una relación entre ellos. Esta estrategia tiene muchas
aplicaciones en diversos ámbitos de la vida real.
Por ejemplo: las impresoras, estas funcionan con esta estrategia, pues debe esperar a que el productor
almacene los documentos a imprimir y el consumidor debe comenzar a vaciar dichos archivos e
imprimirlos.
El ejemplo que plantearemos en código es sobre una pastelería implementando la estrategia
productor/consumidor.
Digamos que existen 10 rebanas de pastel sobre la mesa, entonces los clientes (consumidor) toman una
rebana hasta acabarse. Cuando esto sucede, el cliente debe notificarle al productor (cocinero) que
produzca mas rebanas y las coloque sobre la mesa. Entonces, al terminar de producir, ahora el productor
debe notificarle al consumidor que ya existen mas rebanadas.
Como primer paso, vamos a crear y lanzar hilos. Ademas se declaran las variables necesarias.
1 import static [Link];
2
public class ProductorConsumidorMain implements Runnable {
3
4
public static void main(String[] args) {
5 Thread[] hilos = new Thread[8];
6 Runnable runnable = null;
7 for (int i = 0; i &lt; [Link]; i++) {
if (i == 0) {
8 runnable = new ProductorConsumidorMain(true);//productor
9 } else {
10 runnable = new ProductorConsumidorMain(false);//consumidor
11 }
12 hilos[i] = new Thread(runnable);
hilos[i].start();
13 }
14
15 /*Aqui le indicamos, que el hilo principal del main debe esperar a que fina
16 creados*/
17 try {
18 for (int i = 0; i &lt; [Link]; i++) {
hilos[i].join();
19 }
20 } catch (Exception e) {
21 }
22
23 }
24
/*como esta variable se esta compartiendo, todos los hilos trabajan con ella.
25 Y esto es debido a que ninguno tiene una copia propia de la variable*/
26 private static int rebanadas;
27 private boolean productor;
28 //Tambien es importante que el cerrojo se comparta con todos los hilos
29 private static Object lock = new Object();
30
public ProductorConsumidorMain(boolean productor) {
31 [Link] = productor;
32 }
33
34 @Override
35 public void run() {
36 while (true) {
if (productor) {//es productor
37 productor();
38 } else {//es consumidor
39 consumidor();
40 }
}
41 }
42
43 public void esperar() {
44 try {
45 [Link]();
46 } catch (InterruptedException ex) {
[Link]("Error de interrupcion");
47 }
48 }
49
50
51
52
53
54
55
56
La variable de tipo boolean llamada productor, indica que si el valor es true es productor y si es false
entonces es consumidor.
¿Como detectar la sección critica?
No profundizare sobre el tema. Sin embargo, para detectar fácilmente nuestra sección critica debemos
identificar el problema. Por ejemplo: en esta ocasión deseamos controlar la producción y consumo de
rebanadas, esta variable debe ser manipulada constantemente mediante hilos incrementando y
decrementando su valor. Con esto, sabemos que al manipular este dato debemos asegurarnos de que solo
un hilo tome su valor y no dos al mismo tiempo (ya que esto podría llevar a incongruencia de datos).
Teniendo esto en mente debemos sincronizar hilos protegiendo nuestra sección critica.
¿Como proteger la sección critica?
Podemos hacerlo implementando distintas soluciones que ofrece java. Sin embargo, hablaremos sobre
la palabra reservada synchronized, recibe por parámetro cualquier objeto y este actúa como nuestro
cerrojo (es importante declarar como static nuestro objeto que funcionara como cerrojo).
Funciona de la siguiente forma: supongamos que lanzamos 5 hilos, entonces estos en una especie de
concurso luchan para ver quien llega primero, tenemos los hilos: h1, h2, … , h5.
h2 llega primero y le pregunta al cerrojo: ¿esta ocupado el cerrojo? este le dice, no, adelante. Ahora el
h2 se encuentra activo, después llega h1 y hace la misma pregunta ¿esta ocupado el cerrojo? este le dice,
si, así que te mandare a la espera.
Activo: h2 – Espera: h1, h3, … , h5
Cuando h2 termina de realizar su tarea, despierta a todos los hilos produciendo una especie de concurso
para que solamente un hilo entre nuevamente a la sección critica.
El código anterior no incluye los métodos productor y consumidor, ahora toca hablar de ellos. Primero
comenzare:
Creando el productor
1 public void productor() {
synchronized (lock) {
2 if (rebanadas == 0) {
3 rebanadas = 10;
4 [Link]();
5
6 [Link]("Productor ha terminado de cocinar " + rebanadas + "
}
7 esperar();
8 }
9 }
10
Simplemente preguntamos, si productor es igual a cero entonces produces diez rebanadas. Ahora con el
objeto utilizado como cerrojo debemos notificar a todos los hilos que despierten (con esto indicamos que
aquellos hilos que sean consumidores, pueden comenzar a tomar rebanadas). Después de notificarle a
todos los hilos, nuestro hilo actual (hilo productor) debe dormir y esperar a que el consumidor lo
despierte (le notifique que no hay rebanadas).
Creando el consumidor
1
2 public void consumidor() {
3 synchronized (lock) {
4 if (rebanadas > 0) {
5 [Link]("Consumidor tiene la rebanada numero: " + rebanadas);
rebanadas--;
6 try {
7 sleep(1000);
8 } catch (InterruptedException ex) {
9 [Link]("Error de interrupcion");
}
10 } else {
11 [Link]();
12 esperar();
13 }
14 }
}
15
16
Con el código, primero nos aseguramos de tener rebanadas. Mientras rebanadas sea mayor a cero podrán
tomar una rebanada.
Si no existen rebanadas, debemos notificar al productor (realmente se notifican todos los hilos que están
a la espera) que ya no existen rebanadas. El hilo actual (hilo consumidor) debe esperar hasta que el
productor le notifique que ha terminado de cocinar.
Si analizas detenidamente lo explicado y el código, haces pruebas comentando partes del código. Podras
entender facilmente la relacion productor consumidor.
Manejo de Eventos de Ventana
(WindowListener/WindowAdapter) en Java
Posted by p_geek On febrero 3, 2019 In Lenguajes No comments
El Manejo de Eventos de Ventana puede ser útil en distintos aspectos. Permite crear software con
funciones especificas. Supongamos que usted desea conectar una base de datos al momento de abrir la
ventana por primera vez, podrá lograr este comportamiento gracias a los eventos de ventana.
Otro uso de los eventos de ventana, es en un programa de reloj. Este debe mostrar la hora al momento de
iniciar por primera vez. Sin embargo, tan solo son algunas aplicaciones de este tipo de evento, pues seras
capaz de crear software realmente interesante.
Debes saber que java ofrece una interfaz y clase adaptadora, en esta ocasión usaremos la interfaz.
Primero comencemos creando nuestro método main encargado de crear y ejecutar las instancias.
1
2 package eventoventana;
3
import [Link];
4
5
public class MainVentana {
6
7 public static void main(String[] args) {
8 Ventana ventana = new Ventana();
9 [Link](JFrame.DO_NOTHING_ON_CLOSE);
10 [Link](new OyenteVentana(ventana));
[Link](500, 200, 500, 400);
11 [Link](true);
12 }
13
14 }
15
Ahora el siguiente paso es crear nuestra ventana y agregarle el evento. El código es:
1 package eventoventana;
2
3 import [Link];
4
5 public class Ventana extends JFrame {
6
7 public void addEventos(OyenteVentana oyente) {
8 [Link](oyente);
}
9
10 }
11
El ultimo paso es crear nuestra clase que implemente la interfaz WindowListener. Sin embargo, antes
mencionare el funcionamiento de cada método.
Descripción de los Métodos
windowActivated: Este método se activa cuando la ventana tiene el foco, con esto me refiero a cuando
la ventana esta sobre todas las demás. Por ejemplo: cuando en windows tenemos dos ventanas abiertas,
una estará con un color mas transparente (esto quiere decir que no estamos trabajando sobre esa
ventana). Sin embargo, cuando la ventana tiene un color fijo es porque estamos trabajando (copiando,
guardando o creando archivos) sobre esta.
windowDeactivated: Funciona de manera contraria al método anterior, cuando la ventana no esta activa
(no tiene el foco o no se esta trabajando sobre esta) se invoca el método.
windowClosed: Se activa cuando la ventana se ha cerrado.
windowClosing: Cuando usted cierra la ventana presionando el botón de cerrar este método se activa.
Por lo que, para aprovechar este método primero debe desactivar la función del botón cerrar. El código
creado como ejemplo te mostrara como aprovechar esta función.
windowIconified: Al minimizar (ocultar) la ventana, esta función se invoca.
windowDeiconified: Lo contrario al método anterior, cuando la ventana se encuentra minimizada y es
maximizada se invoca el método.
windowOpened: Es llamado cuando la ventana se ejecuta (abre) por primera vez.
Explicación del Ejemplo
El siguiente ejemplo te ayudara a comprender el funcionamiento de los métodos. Ademas, agregue una
característica que podrá servirte en un futuro con el método windowClosing.
1 package eventoventana;
2
import [Link];
3 import [Link];
4 import [Link];
5 import [Link];
6
7 public class OyenteVentana implements WindowListener {
8
9 private Ventana ventana;
10
public OyenteVentana(Ventana ventana) {
11 [Link] = ventana;
12 }
13
14 @Override
15 public void windowOpened(WindowEvent e) {
16 [Link](ventana, "Ventana iniciada por primera vez");
}
17
18
19
20
21
@Override
22 public void windowClosing(WindowEvent e) {
23 int opcion = [Link](ventana, "¿Quieres salir del prog
24 JOptionPane.YES_NO_OPTION);
25 if(opcion==JOptionPane.YES_OPTION) {
[Link](0);
26
}
27 }
28
29 @Override
30 public void windowClosed(WindowEvent e) {
31 [Link]("La ventana se ha cerrado");
}
32
33
@Override
34 public void windowIconified(WindowEvent e) {
35 [Link]("la ventana se a minimizado ");
36 }
37
38 @Override
public void windowDeiconified(WindowEvent e) {
39 [Link]("La ventana se a maximizado");
40 }
41
42 @Override
43 public void windowActivated(WindowEvent e) {
[Link]("La ventana esta activa (tienes el foco)");
44
[Link]().setBackground([Link]);
45 }
46
47 @Override
48 public void windowDeactivated(WindowEvent e) {
49 [Link]("La ventana no esta activa (no tienes el foco)");
[Link]().setBackground([Link]);
50 }
51
52 }
53
54
55
56
Explicare detenidamente como aprovechar windowClosing. Para lograr que el método funcione, primero
debe desactivar la función del botón cerrar que ofrece la ventana. Esto podemos hacerlo con el siguiente
código:
1 [Link](JFrame.DO_NOTHING_ON_CLOSE);
Con el código anterior le decimos que por mas que presionen el botón cerrar, la ventana no sera cerrada.
Sin embargo, tras presionar el botón, se activa el método windowClosing (se lanza un evento). Dentro de
este podemos poner cualquier código. Por ejemplo: preguntar si realmente desea salir de la ventana.
Ademas, cuando la ventana tiene el foco (La ventana esta sobre todas las demás) se activa
windowActivated, dentro del método agregue el código necesario para cambiar el color de fondo a rojo.
Podrá comprender de lo que hablo con la siguiente imagen:
Sin embargo, cuando usted no tiene el foco (la ventana esta detrás de otra) se invoca windowDeactivated
y el color del fondo se cambia a negro.
Los demas metodos se comprenden de manera facil. Por lo que, no es necesario explicarlos, ademas olo
imprimen un mensaje en consola.
Como Crear Metodos Recursivos con Ejemplo en
Java
Posted by p_geek On enero 5, 2019 In Recursividad No comments
Recursividad, algo realmente interesante y complejo para aquellos usuarios que comienzan con este
paradigma. La recursividad se puede definir como: Un metodo que se llama asi mismo.
Sin embargo, para realizar esto debes de cumplir ciertas «restricciones» pues de no hacerlo, el llamado
podría realizarse de manera infinita y este se ejecutaría hasta consumir todos los recursos de la memoria.
Por este motivo siembre se debe tener un caso base.
¿Que es un caso base?
El caso base (con la palabra podrías darte una idea) es el punto donde sabes que debes detenerte (en este
caso el propio metodo debe saber cuando detener las llamadas que se hace a el mismo).
Se recomienda aplicar la recursividad a problemas pequeños o problemas complejos en los cuales
realmente facilite el análisis del funcionamiento en comparación a otro tipo de implementación. Ademas,
la recursividad en algunos casos puede simplificar el código reduciendo varias lineas.
A continuación te mostrare un ejemplo comun en recursividad, el factorial:
Primero lo implementaremos utilizando recursividad:
1 public int calculaFactorial(int num) {
2 if (num == 0) {
3 return 1;
4 } else {
5 return num * calculaFactorial(num - 1);
}
6 }
7
Ahora sin utilizar recursividad:
1
2 public int calculaFactorialCiclo(int num) {
3
4 int fact_acum = 0;
5
if (num == 0) {
6 return 1;
7 } else {
8
9 while (num != 0) {
10 fact_acum = fact_acum * num;
num--;
11 }
12
13 return fact_acum;
14
15 }
16
17 }
18
El caso base para el factorial es cuando la variable num es igual a cero. Esto debe ser asi ya que en
matemáticas sabemos que el factorial de cero es uno.
Explicare de manera breve como funciona el metodo recursivo y dejare una imagen que te ayudara a
comprender. Para ello realizamos la siguiente llamada al metodo y le pasamos por parametro el numero
5.
calculaFactorial(5);
El metodo recursivo lo primero que hace es preguntar si num es igual a cero, en este caso num vale 5 por
lo tanto no se cumple y en caso de no cumplirse la condición debe retornar un valor, analicemos
detenidamente la siguiente linea:
return num * calculaFactorial(num – 1);
devuelve 5 * calculaFactorial(5-1);
Sabemos que el metodo devuelve un dato de tipo entero y como se esta llamando asi mismo hace lo
siguiente:
return 5 * 4!;
La llamada recursiva del metodo, podemos observarla de manera facil de esta forma. Sin embargo, se
podría decir que aun no ejecuta la operación, debido a que las operaciones son realizadas cuando se ha
llegado al caso base. Por lo que, una vez que num sea igual a cero se cumple la primera condición y
devuelve uno.
Como ahora no se hace un llamado recursivo, se sabe que a llegado a su fin (caso base) y debe comenzar
a realizar todas las operaciones pendientes. Esto se podrá observar mejor en la siguiente imagen:
Finalmente podrás observar que la diferencia entre el metodo recursivo y no recursivo es notable, no se
tú pero a mi me parece mas complejo la creación del metodo sin recursividad ademas de tener mas lineas
de codigo.
Como Crear una Lista Enlazada Dinamica Desde
Cero con JAVA
Posted by p_geek On enero 5, 2019 In Estructura de Datos No comments
La definición que daremos sobre una lista enlaza es muy breve y puede ser la siguiente: Una lista
enlazada es una colección de datos que hacen referencia a una clase. Ya que los datos almacenados
pueden ser de una clase en especial que usted a creado para diferentes propósitos.
Por ejemplo: usted estará creando una clase que solamente se encargue de almacenar números enteros o
una clase «generica» mediante la cual usted pueda guardar información del usuario, ya sea una clase de
tipo: empleado, persona, entre otros.
Crear nuestra listas enlazadas de manera personalizada ofrece una gran serie de ventajas en diversos
aspectos, pues usted seria capaz de implementar funciones que por defecto la clase ArrayList<> de java
no tiene. Una de esas funciones podría ser: devolver el numero anterior y siguiente del numero buscado.
Ejemplo:
usted tiene una lista enlazada con los siguientes datos: 1–>2–>8–>5–>
desea buscar el numero 8, los números (nodos) serian los siguientes:
anterior=2 y siguiente=5, esto solo es un ejemplo sencillo ya que usted podría realizar cosas más
interesantes.
Comencemos creando un nuevo proyecto, puede ponerle cualquier nombre. Posteriormente creamos
una clase NodoLista, esta clase permite definir el tipo de información que usted desea almacenar en su
lista enlazada, como decía anteriormente esta información puede ser de tipo: entero (en este ejemplo se
muestra asi) o incluso usted sera capaz de pasar por parametro una clase creada (personalizada).
1 package default;
2
3
public class NodoLista {
4
5 NodoLista sig;
6 int dato;
7
8 public NodoLista(int dato) {
9 [Link]=dato;
sig=null;
10 }
11
12 }
13
Realmente esta clase no tiene nada complejo, solo recibe por parametro el tipo de dato que desea recibir
y el «puntero» (en java no existe ese termino, para fines prácticos lo llamaremos asi). El «puntero» o
referencia simplemente se encarga de apuntar la información creando una colección en forma de lista
enlazada, en realidad esta variable hace referencia a la ubicación del nodo a apuntar.
El «puntero» en este caso es la variable siguiente, esta debe ser igual a null ya que no esta haciendo
referencia a ningún dato.
La siguiente clase Lista, debe contener toda la logica que cumpla con el comportamiento de una lista
enlazada, aqui nosotros nos encargaremos de crear los metodos necesarios para que todo funcione de
acuerdo a nuestras necesidades.
A diferencia de la cola y pila una lista no tiene una regla que seguir al insertar datos, una lista
enlazada permite insertar al frente, final o en cierto punto especifico.
1 package default;
2
public class Lista {
3
4
NodoLista ini, fin;
5 int tamanio;
6
7 public Lista() {
8 ini=fin=null;
9 }
10
public boolean estaVacia() {
11 return ini==null;
12 }
13
14 public void insertarFinal(int dato) {
15 NodoLista nuevo=new NodoLista(dato);
16 if(estaVacia()) {
ini=nuevo;
17 }else {
18 [Link]=nuevo;
19 }
20 fin=nuevo;
tamanio++;
21 }
22
23 public void insertarInicio(int dato) {
NodoLista nuevo=new NodoLista(dato);
24 if(estaVacia()) {
25 fin=nuevo;
26 }else {
27 [Link]=ini;
28 }
ini=nuevo;
29 tamanio++;
30 }
31
32 public int borrarDelInicio() {
33
34 int elemento = [Link];
35
36 if(inicio==fin) {
inicio=null;
37 fin=null;
38 }else {
39 inicio=[Link];
40 }
41
return elemento;
42
43
}
44
45 public int borrarDelFinal() {
46
47 int elemento = [Link];
48
49 if(inicio==fin) {
50 inicio=null;
fin=null;
51 }else {
52 Nodo temporal=inicio;
53
54 while([Link]!=fin) {
55 temporal=[Link];
56 }
57
fin=temporal;
58 [Link]=null;
59 }
60
61 return elemento;
62
63 }
64
public void mostrarLista() {
65 NodoLista recorrer=ini;
66 [Link]();
67 while(recorrer!=null) {
68 [Link]("[" + [Link] + "]------>;");
69
70
71
72
73
74
75 recorrer = [Link];
}
76 }
77
78 }
79
80
81
82
83
84
El código de esta clase solo contiene las funciones principales de insertar, borrar y mostrar. Sin embargo,
usted sera capaz de personalizar o agregar nuevos metodos.
Finalmente creamos una clase donde nos encargaremos de llamar a nuestros metodos creados y poner en
marcha todo el código:
1 package default;
2
import [Link];
3
4
public class ListaSimpleEnlazada {
5
6 public static void main(String[] args) {
7
8 Lista mylista=new Lista();
9
10 int select=0;
11 int dato_inicio;
12
do {
13
14
try {
15 select = [Link]([Link](null,
16 "1=Agregar elemento al inicio de la lista"
17 + "\n2=Agregar elemento al final de la lista"
18 + "\n3=Eliminar un elemento del inicio de la lista"
+ "\n4=Eliminar un elemento del Final de la lista"
19 + "\n5=Mostrar los datos de la lista"
20 + "\n6=Salir", "Menu de Opciones", 3));
21
22 switch(select) {
23
24 case 1:
25 try {
dato_inicio = [Link]([Link](null, "Inserta un elemen
26 "Insertando al inicio", 3));
27 [Link](dato_inicio);
28 }catch(NumberFormatException e) {
29 [Link](null, "Error" + [Link]());
30 }
break;
31
32
case 2:
33 try {
34 dato_inicio = [Link]([Link](null, "Inserta un elemen
35 "Insertando al final", 3));
36 [Link](dato_inicio);
}catch(NumberFormatException e) {
37 [Link](null, "Error" + [Link]());
38 }
39 break;
40
41 case 3:
dato_inicio = [Link]();
42 [Link](null, "El elemento eliminado es: " + dato_inicio,
43 "Eliminando nodo del inicio", JOptionPane.INFORMATION_MESSAGE);
44 break;
45
46 case 4:
47 dato_inicio = [Link]();
[Link](null, "El elemento eliminado es: " + dato_inicio,
48 "Eliminando nodo del Final", JOptionPane.INFORMATION_MESSAGE);
49 break;
50
51 case 5:
52 [Link]();
53 break;
54
case 6:
55 break;
56
57 default:
58 [Link](null, "Opcion Incorrecta");
59 }
60
}catch(NumberFormatException e) {
61 [Link](null, "Error" + [Link]());
62 }
63
64 }while(select!=6);
65
66 }
67
68 }
69
70
71
72
73
74
75
76
77
78
Si usted tiene un buen conocimiento en java le resultara facil entender el código, sino es asi ¡animo! siga
practicando y estudiando, pronto vera la luz al final del tunel.
Como Funciona el Polimorfismo con Ejemplo en
Java
Posted by p_geek On enero 5, 2019 In Programación Orientada a Objetos 4 Comments
Polimorfismo, esta palabra al principio puede sonar algo difícil pero realmente no es asi. El
polimorfismo se define como la capacidad de comportarse a un metodo de acuerdo a la instancia creada,
para que entiendas te explicare con un ejemplo en la vida cotidiana.
El metodo se comporta de manera diferente dependiendo de la clase con la cual esta interactuando,
debido a que cada clase implementa un comportamiento distinto.
Ejemplo:
supongamos que existe un metodo visitante(), este visitante tiene una serie de llamadas. Cuando te marca
tu madre o padre te vas a comportar de manera educada al contestar el telefono. Sin embargo, cuando un
amigo te marca te comportas de una manera no educada hablando no formal.
Digamos que tu madre y padre conforman una clase Padres y tu amigo esta dentro de una clase
Amigos. El metodo visitante() se comporta de manera diferente de acuerdo a la clase referenciada.
Ahora te mostrare otro ejemplo en código para que esto quede mas claro:
1
package polimorfismo;
2
3
public abstract class Operaciones {
4
5 protected int num1;
6 protected int num2;
7
8 public Operaciones() {
9 num1 = 10;
num2 = 5;
10 }
11
12 public abstract void operaciones();
13
14 }
15
La clase operación es nuestra superclase, dentro de ella definimos el metodo operaciones() como
abstracto al definir un metodo de esta forma le indicamos que va a tener diferente comportamiento,
importante mencionar que no siempre se utiliza abstract para hacer polimorfismo ya que puede estar
presente simplemente utilizando herencia y re-escribiendo los metodos.
1
package polimorfismo;
2
3 public class Suma extends Operaciones {
4
5 @Override
6 public void operaciones() {
7 int suma = num1 + num2;
[Link]("suma: " + suma);
8 }
9
10 }
11
Nuestra clase suma debe heredar de Operaciones, aqui aplicamos la frase «es un«. ¿La suma es un? es
una operación lo cual permite heredar de operaciones, cuando nosotros heredamos de esta clase
automaticamente el compilador marca error y aparece debido a que en la clase padre se ha definido un
metodo abstracto obligando a siempre re-escribir el metodo en nuestra subclase.
Lo explicado anteriormente puede aplicarse a una nueva clase en este caso llamada Multiplicación,
podrás observar que sucede lo mismo que la clase Suma.
1 package polimorfismo;
2
public class Multiplicacion extends Operaciones {
3
4
5 @Override
6 public void operaciones() {
7 int multiplicacion = num1 * num2;
8 [Link]("multiplicacion: " + multiplicacion);
}
9
10
}
11
Debemos poner en uso lo creado anteriormente, para ello debemos hacerlo utilizando la
claseMainOperaciones y haciendo referencia a las clases creadas:
1
2 package polimorfismo;
3
public class MainOperaciones {
4
5 public static void main(String[] args) {
6 Operaciones operacion;
7 operacion = new Suma(); // aqui se esta aplicando el polimorfismo
8 [Link](); //operacion suma
operacion = new Multiplicacion(); //polimorfismo
9 [Link](); //operacion multiplicacion
10 }
11
12 }
13
Es importante mencionar que una clase abstracta e interfaz no pueden ser instanciadas. Por este motivo
se ha creado una variable operación de tipo Operaciones (me refiero a la clase).
¿Como es posible crear una instancia?
Se puede lograr gracias al polimorfismo, como podrás observar la variable operación se comporta de
manera diferente, debido a la referencia realizada con distintas clases.
operacion = new Suma();
La linea anterior le dice al metodo operaciones que va tener un comportamiento para realizar
simplemente una suma. La instancia es posible, debido a que una Suma es una Operacion (Suma es de
tipo operación porque hereda de esta clase).
operacion = new Multiplicacion();
Ahora se indica a la variable operación que tendra un comportamiento de tipo multiplicación y gracias a
esto el metodo operaciones realiza dicha operación.
Como las variables num1 y num2 se han iniciado con valores 10 y 5, al ejecutar el metodo main nos
muestra los siguientes resultados:
suma: 15
multiplicacion: 50
Al principio el polimorfismo puede sonar algo complejo, pero mediante practica y entendiendo el porque
de las cosas veras lo facil de su implementación.
Como Crear una Pila Dinamica Desde Cero con
Java
Posted by p_geek On enero 5, 2019 In Estructura de Datos 3 Comments
Pila, se podría decir que es como una lista enlazada pero a diferencia una pila tiene restricciones al igual
que una cola. Una pila funciona de manera contraria a una cola, sabemos que una cola funciona de
acuerdo a la siguiente frase: Primero en entrar, primero en salir. Entonces, ya podrías imaginar como
funciona una pila «Ultimo en entrar, primero en salir«.
Podrás crear una pila reutilizando el código de una lista enlazada aplicando herencia. Sin embargo, para
no complicar las cosas realizaremos el código desde cero.
Las pilas tienen una gran serie de aplicaciones, usted sera capaz de convertir expresiones regulares a
infija, posfija y prefija. Ademas, esta presente en todos los sistemas operativos ya que gracias a su gran
potencial permiten gestionar las llamadas de metodos que realizan los programas en ejecución.
Como es costumbre, el código que mostraremos mas adelante contiene los metodos básicos de una pila,
ejemplo: empujar, sacar, mostrar.
Debemos comenzar creando una clase que nombraremos NodoPila
1
package [Link];
2
3
public class NodoPila {
4
5 String elemento;
6 NodoPila siguiente;
7
8 public NodoPila(String elemento) {
9 [Link] = elemento;
siguiente = null;
10 }
11
12 }
13
Lo que esta haciendo es crear el nodo, sera utilizado para almacenar los valores que vayan agregando a
nuestra lista. La variable siguiente se encarga de hacer una referencia y apuntar los nuevos valores para
que estos no se pierdan (aclaro que se realiza en la clase donde se encuentra la logica sobre como
funciona una pila).
Lo siguiente es crear una clase Pila, aqui pondremos la logica de la pila.
1 package [Link];
2
public class PilaDinamica {
3
4
NodoPila cima;
5 int tamanio;
6
7 public boolean estaVacia() {
8 return cima == null;
9 }
10
public void Empujar(String elemento) {
11 NodoPila nuevo = new NodoPila(elemento);
12 [Link] = cima;
13 cima = nuevo;
14 tamanio++;
15 }
16
public String SacarPila() {
17 String auxiliar = [Link];
18 cima = [Link];
19 tamanio--;
20 return auxiliar;
}
21
22
23
24
25 public void mostrarPila() {
26 NodoPila recorre=cima;
27 while(recorre!=null) {
[Link]("<---[" + [Link] + "]");
28 recorre = [Link];
29 }
30 }
31
32 }
33
34
La variable tamanio, simplemente funciona como contador y esta permite determinar el numero de
elementos que han insertado.
El metodo mostrarPila():
Este metodo no es complejo, lo que hacemos es crear una variable auxiliar (en este caso llamada
recorrer).
¿Por que debemos crear una variable auxiliar?
Echaremos a volar nuestra imaginación, entonces supongamos que tienes 5 globos los cuales obviamente
estas sujetando. Si tú, sueltas los globos obviamente se pierden (esto sucede con nuestra variable cima,
debido a que tiene las referencias originales a nuestros nodos. Entonces, al momento de recorrer estarias
perdiendo los nodos ya que estas diciendo que cima sea igual a cima de siguiente).
La variable auxiliar (recorrer) vendría siendo un amigo el cual te ayuda a detener los globos. Ahora
ambos estan agarrando los globos pero como tu amigo es la variable recorrer y suelta los globos «el ya
los perdio» pero tú aun estas sujetando.
Espero este ejemplo te ayude a entender de manera facil, realmente practicando y analizando el código
es como se aprende.
Las pilas son muy utilizadas por compiladores, pues estas permiten evaluar las expresiones aritméticas y
generar código a nivel de maquina. Realmente la estructura de datos es importante para aquellos que
estan empezando a desarrollar aplicaciones, ahora ya sabes como divertirte.
Finalmente, cabe mencionar que deberas crear un menu para utilizar los metodos.
Como Crear una Cola Dinamica Desde Cero con
Java
Posted by p_geek On enero 5, 2019 In Estructura de Datos No comments
Colas, otra estructura de datos muy interesante la cual tiene una gran serie de aplicaciones en el ambito
computacional, aunque esta tambien se implemente en la vida real y podemos notarlo en la fila que
hacemos al comprar tortillas o dentro de un super mercado. Una cola funciona mediante FIFO (primero
en entrar, primero en salir).
La cola en estructura de datos funciona de manera similar a una cola dentro de un super mercado,
cajero, banco, entre otros. A diferencia de una lista enlazada la cola no puede introducir datos en
cualquier punto, una cola siempre inserta los datos nuevos al final y elimina al inicio.
Ejemplo: cuando hacemos fila para comprar tortillas (tal vez no todos lo hacen pero creo la mayoría), si
la cola esta vacía obviamente usted sera el primero en llegar (aqui es donde entra en juego la variable
inicio que sera utilizada en el codigo), supongamos que rapidamente llega un cliente, este no puede ser
atendido primero que usted por ende espera al final de la cola y asi sucesivamente los nuevos clientes
que van llegando se colocan al final de la cola (se crea una variable fin que estará cambiando siempre
haciendo referencia al ultimo cliente que a llegado).
Le han despachado las tortillas ¿que pasa?, sale de la fila dando lugar al cliente que esta detrás de usted
(la variable inicio hacia referencia a usted antes de salir, al momento de salir ahora la variable inicio
debe hacer referencia al cliente que esta detrás de usted).
Como podrás observar, este tipo de estructura de datos tiene una gran serie de aplicaciones. Espero no
confundirlos con este ejemplo, pero he tratado de poner un ejemplo de la vida cotidiana esperando
entiendan de manera facil.
Primero comenzaremos creando nuestra clase Nodo:
1 package [Link];
2
public class NodoCola {
3
4
int elemento;
5 NodoCola siguiente;
6
7 public NodoCola(int elemento) {
8
9 [Link] = elemento;
siguiente = null;
10 }
11
12 }
13
Esta clase se encarga de iniciar los valores de nuestras variables a esta altura todos debemos saber como
crear un constructor. Podemos pasar cualquier tipo de dato como parametro, usted puede adaptar el
código de acuerdo al problema.
La clase Colas, para facilitar la lectura del código siempre se recomienda crear clases que contengan
diferentes partes del código. Esta clase contiene los metodos necesarios con las funciones de una cola.
1 package [Link];
2
public class Colas {
3
4
int tamanio;
5 NodoCola inicio, fin;
6
7 public Colas() {
8 inicio = fin = null;
9 }
10
public boolean estaVacia() {
11 return inicio == null;
12 }
13
14 public void insertarCola(int elemento) {
15 NodoCola nuevo = new NodoCola(elemento);
16 if (estaVacia()) {
inicio = nuevo;
17 } else {
18 [Link] = nuevo;
19 }
20 fin = nuevo;
tamanio++;
21 }
22
23 public int sacarCola() {
24 int auxiliar = [Link];
25 inicio = [Link];
26 tamanio--;
return auxiliar;
27 }
28
29 public void mostrarCola() {
30 NodoCola aux = inicio;
31 [Link]();
32 while (aux != null) {
[Link]("[" + [Link] + "]--->");
33 aux = [Link];
34
35
36
37
38 }
39 }
40
41 public int inicioCola() {
return [Link];
42 }
43
44 public int tamanioCola() {
45 return tamanio;
46 }
47
48 }
49
50
51
Realmente usted sera capaz de entender la logica detrás de esto, contiene el metodo sacarCola():
este se encarga de eliminar al primer dato, tomando como base el ejemplo de la cola al comprar tortillas,
el primero que esta en la fila sera eliminado.
inicio = [Link]
esta linea muestra lo que mencionaba anteriormente, supongamos que eres el primero en la fila y te han
despachado las tortillas, antes de salir la variable inicio esta haciendo referencia a ti. Pero al momento de
salir la variable inicio hace referencia al cliente que estaba detrás de ti (tomando tu lugar y siendo el
primero en la fila).
Con lo explicado anteriormente usted sera capaz de entender el metodo insertarCola().
Para facilitarte aun mas las cosas, ahora te mostrare el código para usar los metodos mencionados
anteriormente:
1 package [Link];
2
import [Link];
3
4
public class MainColas {
5
6 public static void main(String[] atrgs) {
7
8 int opcion = 0, elemento;
9
10 Colas cola = new Colas();
11
12 try {
13
14 do {
15
opcion = [Link]([Link](null,
16 "1=Insertar un elemento a la cola"
17 + "\n2=Sacar un elemento de la cola"
18 + "\n3=¿La cola esta vacia?"
19 + "\n4=¿Que elemento esta en el inicio de la cola?"
20 + "\n5=Tamaño de la cola"
+ "\n6=Limpiar la cola"
21 + "\n7=Mostrando la colas"
22 + "\n8=Salir", "Menu de Opciones", 3));
23
24 switch (opcion) {
25
26 case 1:
27 elemento = [Link]([Link](nu
"Insertando al final", JOptionPane.INFORMATION_MES
28
29 [Link](elemento);
30 break;
31
32 case 2:
33 if (![Link]()) {
elemento = [Link]();
34
35
[Link](null, "El elemento sacad
36 "Sacando elemento de la cola", [Link]
37 } else {
38 [Link](null, "La cola esta vaci
39 "Cola vacia", JOptionPane.INFORMATION_MESSAGE)
}
40 break;
41
42 case 3:
43 if ([Link]()) {
44 [Link](null, "La cola esta vaci
45 "Cola vacia", JOptionPane.INFORMATION_MESSAGE)
} else {
46 [Link](null, "La Cola no esta v
47 "Cola contiene datos", [Link]
48 }
49 break;
50
case 4:
51 if (![Link]()) {
52 elemento = [Link]();
53 [Link](null, "El elemento que e
54 elemento,
55 "Mostrando elemento del inicio de la cola", JO
} else {
56 [Link](null, "La cola esta vaci
57 "Cola Vacia", JOptionPane.INFORMATION_MESSAGE)
58 }
59 break;
60
61 case 5:
elemento = [Link]();
62 [Link](null, "El tamaño de la cola
63 "Mostrando tamaño de la cola", [Link]
64 break;
65
66 case 6:
67 /*if(![Link]()) {
[Link]();
68 [Link](null, "La pila se ha vac
69 "vaciando pila", JOptionPane.INFORMATION_MESSA
70 }else {
71 [Link](null, "La pila esta vaci
72 "Pila Vacia", JOptionPane.INFORMATION_MESSAGE)
}*/
73 break;
74
75 case 7:
76 if (![Link]()) {
77 [Link]();
} else {
78 [Link](null, "La pila esta vaci
79 "Pila Vacia", JOptionPane.INFORMATION_MESSAGE)
80 }
81 break;
82
83 case 8:
[Link](null, "Aplicacion Finalizada
84 "Finalizando", JOptionPane.INFORMATION_MESSAGE);
85 break;
86
87 default:
88 [Link](null, "La opcion no esta en
89 "Incorrecta", JOptionPane.INFORMATION_MESSAGE);
}
90
91 } while (opcion != 8);
92
93 } catch (NumberFormatException e) {
94 [Link](null, "Error: " + [Link]());
95 }
96
}
97
98
}
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
Como Funciona la Herencia con Ejemplo en Java
Posted by p_geek On enero 5, 2019 In Programación Orientada a Objetos No comments
La herencia, es una de las características mas importantes en la programación orientada a objetos debido
a que esta permite ahorrar código de manera considerable. Ademas, permite realizar el desarrollo de
software de una manera mas organizada.
Herencia, esta palabra dice de lo que trata y es que extends es una palabra reservada en java y me
permite heredar de otras clases. Sin embargo, no se puede heredar de cualquier clase ya que debe
aplicarse una regla (realmente solo es una frase). Antes de heredar usted debe preguntarse lo siguiente
«es un» y «tiene un«.
Ejemplo: Supongamos que se tiene la clase coche, aqui entran en juego las dos frase mencionadas
anteriormente.
¿El coche es un?
Asi es, espero hayas pensado lo mismo que yo. El coche es un vehículo y es aqui donde te das cuenta de
la utilidad de estas frases. Ahora que ya sabemos que el coche es un vehículo podemos aplicar la
siguiente frase.
¿El vehículo tiene un?
El vehículo, tiene un volante, asientos, llantas, velocidades. Realmente esta pregunta te permite saber
que atributos debes agregar a tu clase.
En este caso la clase vehículo es nuestra superclase y la clase coche que hereda de vehículo es
nuestra subclase. Ahora pondre un ejemplo para aclarar el tema:
Primero creamos una clase nombrada Padre:
1
2
package herencia;
3
4
public class Padre {
5
6 public Padre(String apellido) {
7 [Link] = apellido;
8 setCasa("Casa");
9 }
10
public String getApellido() {
11 return apellido;
12 }
13
14 public void setCasa(String casa) {
15 [Link] = casa;
16 }
17
public String getCasa() {
18 return casa;
19 }
20
21 public String mensaje() {
22 return "Apellido: " + apellido;
23 }
24
private String casa;
25 private String apellido;
26
27 }
28
29
El padre es nuestra superclase y este tiene como atributo (propiedad) una casa la cual va a heredar su
hijo (en este caso la clase hereda de padre). A continuación se crea la clase hijoDePadre este hijo hereda
la casa de su padre, ademas ahora el hijo puede tener sus propios atributos (propiedades o cosas
materiales, como lo quieras ver).
El hijo se ha comprado un coche, por ende esta propiedad se agrega a la clase.
1
2
package herencia;
3
4
public class hijoDePadre extends Padre {
5
6 public hijoDePadre(String apellido, int edad) {
7 super(apellido);
8 [Link] = edad;
9 setCoche("Coche");
}
10
11 public void setCoche(String coche) {
12 [Link] = coche;
13 }
14
15 public String getCoche() {
return coche;
16 }
17
18 @Override
19 public String mensaje() {
20 return [Link]() + " Edad: " + edad;
21 }
22
private String coche;
23 private int edad;
24
25 }
26
27
Sin embargo, como la clase padre recibe por parametro un apellido (se puede decir que el hijo esta
heredando el apellido) por lo cual debemos especificar en nuestra clase hijoDePadre un constructor que
pase por parametro el apellido (el cual heredo del padre) mas otros valores que deseemos agregar (en
este caso la edad).
La palabra reservada super me permite llamar al constructor o metodos de clase que estoy heredando, en
este caso nosotros vamos a llamar el metodo mensaje y al constructor de la clase Padre.
Podemos observar que cuando ponemos un punto delante de super (ejemplo: [Link]()) le
indicamos que estamos llamando al metodo de la clase que estamos heredando y si solamente ponemos
la palabra super acompañada de parentesis indicamos la llamada al constructor de la clase Padre
(ejemplo: super(apellido)).
Por un lado la llamada al constructor padre me permite iniciar los valores de las variables (en este caso la
variable apellido, permitiendo llamar al metodo mensaje de la clase padre (esto hace que nuestra variable
apellido no devuelva un valor nulo). Sino llamas al constructor padre el propio compilador te indicara un
error).
Ahora creamos la clase HijoDeHijoDePadre, podría sonar raro. Pero traduciendo un poco al español, la
clase padre se convierte en abuelo, la clase hijoDePadre se convierte en padre, espero no confundirte
(pero podrías pensarlo como en la vida real y entenderas).
1
2 package herencia;
3
4 public class hijoDeHijoDePadre extends hijoDePadre {
5
6 public hijoDeHijoDePadre(String nombre, int edad) {
super(nombre, edad);
7 setXbox("Xbox");
8 }
9
10 public void setXbox(String xbox) {
11 [Link] = xbox;
}
12
13
public String getXbox() {
14 return xbox;
15 }
16
17 private String xbox;
18
19 }
20
Esto podrás entenderlo con las explicaciones que he realizado hasta el momento, finalmente solo
creamos la clase para usar los metodos creados:
1
2 package herencia;
3
public class HerenciaMain {
4
5 public static void main(String[] args) {
6
7 hijoDeHijoDePadre heredo = new hijoDeHijoDePadre("Ramirez", 20);
8
9 [Link]("El hijo de apellido " + [Link]() +
10 "heredo del abuelo una: " + [Link]() + ", del padre un: "
+ [Link]() + " y la unica pertenencia propia es: " + heredo
11 [Link]("Mensaje=> " + [Link]());
12
13 }
14
15 }
16
Me olvidaba de decir que la palabra reservada extends hace posible la herencia, ya que permite
extender los atributos de una clase.
[Link]/
Cómo Instalar Librería de Java3D con su
Documentación en NetBeans
Posted by p_geek On mayo 11, 2019 In Tutoriales No comments
En esta ocasión explicare como instalar las librerías de java 3d en nuestro IDE NetBeans, existen
diferentes formas de instalar estas librerías. En windows es relativamente sencillo pues ofrece un
instalador, pero en linux y macos no existe instalador de java 3d.
Sin embargo, la manera que explicare sobre como instalar java 3d funciona para cualquier sistema
operativo y ademas explicare como instalar la documentación.
Como primer paso, debemos descargar las librerías y documentación de java 3d mediante los siguientes
enlaces:
Debemos descargar la versión 1.5.1 de Java 3D: Ver Link
La versión de la documentación disponible para la versión mencionada de java 3d es la
1.4.0_01: Ver Link
Al descargar todo lo necesario, debe extraer el archivo java3d-1_5_1_X (la letra x, representa el tipo de
sistema operativo), quedara un carpeta y ahora dentro de esa carpeta extraemos un nuevo archivo
llamado j3d-jre, nos dejara una carpeta llamada lib, abrimos la carpeta lib y ext. Ahora, dentro de la
ultima carpeta usted encontrara los archivos .JAR que nos importan.
Recomiendo crear una carpeta nombrada Java3D dentro de su proyecto donde usara estas librerías, copie
los archivos .JAR dentro de la carpeta y de igual forma agregue el archivo java3d-1_4_0-[Link] (sin
descomprimir).
Teniendo listo lo mencionado anteriormente, ahora debemos ejecutar netbeans y abrimos las librerías
siguiendo la siguiente ruta de menus: Tools (herramientas) – Libraries (Librerías). Se abrira la siguiente
ventana.
Presionamos el botón «Nueva Libreria (New Library…)» y abrira otra ventana donde escribiremos el
nombre de nuestra nueva librería:
Ahora podemos observar que aparece una nueva librería llamada Java3D, seleccionamos esta librería y
presionamos la pestaña «Classpath«, presionaremos el botón «Add JAR/Folder…» y seleccionamos
los archivos .JAR.
El ultimo paso es muy similar a como agregar los .JAR, en este caso nos posicionamos en la pestaña
«Javadoc» y agregamos el archivo .zip que contiene la documentación.
Para poder visualizar la documentación al codificar, es importante tener el plugin nb-javac
Library instalado. Para instalarlo, debe abrir:
Tools (herramientas) – Plugins
Se abrira una nueva ventana, aquí debemos seleccionar la pestaña «Available Plugins (plugins
disponibles)» marcamos el plugin nb-javac Library y presionamos «install (instalar)«.
PD, como ya lo he instalado no me aparece en la pestaña plugins disponibles, pero si aparece en la
pestaña de instalados:
Para poder usar esta nueva librería en nuestros proyectos, nosotros debemos agregarla de forma manual.
Podemos abrir cualquier proyecto y sobre la carpeta «Libraries (librerías)» presionar clic derecho y
«Add Library (Agregar libreria)»
Se abrira una ventana donde se mostraran todas las librerías existentes, aquí solo debemos buscar la que
hemos creado «Java3D» y presionar el botón «Add Library (Agregar libreria)«.
Listo, ahora puedes comenzar a utilizar todas las clases disponibles en java 3d.
Como Instalar Apache NetBeans 11.0 Final IDE en
MacOS Fácil y Rapido
Posted by p_geek On mayo 11, 2019 In Tutoriales No comments
Debido a que hace tiempo me surgió la necesidad de instalar netbeans en macos, me di cuenta de la poca
información (por no decir ninguna) que existe sobre como realizar la instalación de apache netbeans
sobre macos.
Sabemos que la pagina de netbeans nos ofrece un instalar .DMG en fase experimental, por esta razón no
recomiendo realizar la instalación de esta forma. Otra de las opciones, es descargar el archivo bin el cual
simplemente debe ser extraído y podrá ejecutar netbeans sin problemas.
Sin embargo, esto puede resultar molesto si usted trabajo frecuentemente con netbeans. Ya que debe
ejecutar el archivo bin para iniciar el IDE.
Afortunadamente existe otra manera y una de las mejores para instalar netbeans actualmente tanto en
mac como en linux. Este proyecto es conocido como NetBeans MacOS Bundle y cuenta con una serie
de archivos con extensión .SH que permiten realizar la instalación de netbeans de manera realmente
sencilla. Cabe mencionar, que mediante los archivos usted descargara el instalador netbeans en su
versión final de la web oficial y automáticamente sera instalado. Ademas, podrá ver la [Link] en
su carpeta de aplicaciones.
Antes de instalar la ultima versión de netbeans, recomiendo desinstalar versiones antiguas e incluso
recomiendo eliminar la carpeta nombrada «netbeans» que se encuentra dentro de la carpeta aplicaciones
de MacOS.
El primer paso es descargar los archivos del proyecto NetBeans MacOS Bundle mediante el siguiente
enlace (estos archivos me permitirán descargar e instalar la ultima versión de netbeans):
Ver Link
Una vez descargado el archivo, debes descomprimirlo. Posteriormente dejara una carpeta, recomiendo
mover esta carpeta al escritorio para que sea fácil acceder mediante el terminal. Tras mover la carpeta a
una ruta de acceso fácil, ahora debemos ejecutar el terminal y cambiarnos al directorio del proyecto.
En mi caso yo moví la carpeta al escritorio, por lo que aplique los siguientes comandos para acceder a la
carpeta (el comando ls muestra los archivos que contiene la carpeta):
Ahora que nos hemos posicionado sobre el directorio, podemos observar que existe un archivo llamado:
[Link], nosotros ejecutaremos este archivo y la descarga e instalación se realizaran de manera
automática. Debemos ejecutarlo, mediante el siguiente comando:
Como podrás observar, al ejecutar el comando comenzara a descargar el instalador de netbeans en su
versión final. Debemos esperar a que la descarga finalice, al terminar de descargar el archivo nos pedira
la contraseña para poder comenzar con la instalación (la contraseña a ingresar es la de su usuario).
Ingresamos la contraseña y esperamos a que termine de instalarse. La instalación dura muy poco, al
terminar de instalarse podrás verificar que existe una carpeta llamada netbeans en la carpeta de
aplicaciones en macos.
Pensaras que ya todo esta listo, pero no. Aun queda un paso muy breve, debemos activar las
siguientes herramientas en netbeans para poder comenzar a crear y ejecutar proyectos. no hace falta
descargar las herramientas, debido a que netbeans las tiene por defecto. Como mencione anteriormente,
solo debe activarlas.
Se me olvidaba comentar, también puede modificar el archivo [Link]. Y cambiar el link de descarga
de netbeans (usar algún otro ofrecido por la pagina oficial).
Los beneficios de cambiar dicho enlace, es que podrás asegurarte de descargar la ultima versión.
Ademas, puede ocurrir que algún link deje de funcionar. Por lo que, viene bien saber modificar el enlace
para descargar.
Espero te sea de gran ayuda e instales apache netbeans sin problemas en tu sistema operativo macos.
También podría gustarte
- Creación de GUI en Java con EclipseAún no hay calificacionesCreación de GUI en Java con Eclipse18 páginas
- Introducción a Java y POO en Desarrollo WebAún no hay calificacionesIntroducción a Java y POO en Desarrollo Web25 páginas
- Taller de Programación en Java BásicoAún no hay calificacionesTaller de Programación en Java Básico29 páginas
- Tutorial API REST con Spring BootAún no hay calificacionesTutorial API REST con Spring Boot76 páginas
- Ejercicios Java: JCheckBox, JRadioButton y JList100% (4)Ejercicios Java: JCheckBox, JRadioButton y JList607 páginas
- Manejo de Eventos en Swing con NetBeansAún no hay calificacionesManejo de Eventos en Swing con NetBeans49 páginas
- PDF. Desarrollo de Interfaces. Tema 4Aún no hay calificacionesPDF. Desarrollo de Interfaces. Tema 417 páginas
- Guía de Programación Orientada a ObjetosAún no hay calificacionesGuía de Programación Orientada a Objetos123 páginas
- Desarrollo de Interfaces en Java SwingAún no hay calificacionesDesarrollo de Interfaces en Java Swing5 páginas
- Prácticas de Programación en JavaAún no hay calificacionesPrácticas de Programación en Java16 páginas
- Creación de Formularios en NetBeansAún no hay calificacionesCreación de Formularios en NetBeans37 páginas
- Ejercicios Resueltos de Argumentos en Java67% (3)Ejercicios Resueltos de Argumentos en Java113 páginas
- Introducción a Programas en JavaScriptAún no hay calificacionesIntroducción a Programas en JavaScript7 páginas
- Ejercicios de JavaScript para PrincipiantesAún no hay calificacionesEjercicios de JavaScript para Principiantes24 páginas
- Introducción a Plataformas MóvilesAún no hay calificacionesIntroducción a Plataformas Móviles25 páginas
- Guía Completa del Diagrama de ClasesAún no hay calificacionesGuía Completa del Diagrama de Clases77 páginas
- Taller de Java: Introducción a POOAún no hay calificacionesTaller de Java: Introducción a POO25 páginas
- CRUD en Java Web con JSP y ServletAún no hay calificacionesCRUD en Java Web con JSP y Servlet20 páginas
- Ejercicios Resueltos de Programación en Java80% (5)Ejercicios Resueltos de Programación en Java5 páginas
- Ejercicios de Java: Estructuras If y Switch100% (1)Ejercicios de Java: Estructuras If y Switch13 páginas
- Herencia en Programación Orientada a ObjetosAún no hay calificacionesHerencia en Programación Orientada a Objetos26 páginas
- Ejercicios de If y Switch en JavaAún no hay calificacionesEjercicios de If y Switch en Java7 páginas
- Fundamentos de Programación en JavaAún no hay calificacionesFundamentos de Programación en Java20 páginas
- Objetos Predefinidos en JavaScriptAún no hay calificacionesObjetos Predefinidos en JavaScript38 páginas
- Introducción a JavaFX y sus ControlesAún no hay calificacionesIntroducción a JavaFX y sus Controles40 páginas
- Instalación y Configuración de EclipseAún no hay calificacionesInstalación y Configuración de Eclipse12 páginas
- Imagen de fondo en JFrame con NetBeansAún no hay calificacionesImagen de fondo en JFrame con NetBeans8 páginas
- Hilos en Java: Guía y Ejemplo PrácticoAún no hay calificacionesHilos en Java: Guía y Ejemplo Práctico8 páginas
- Actividades de Programación en Java 304AAún no hay calificacionesActividades de Programación en Java 304A9 páginas
- Lenguajes Formales y Autómatas en JavaAún no hay calificacionesLenguajes Formales y Autómatas en Java6 páginas
- Importancia del Administrador de ServidoresAún no hay calificacionesImportancia del Administrador de Servidores4 páginas
- Requerimientos Software Control LaboratorioAún no hay calificacionesRequerimientos Software Control Laboratorio36 páginas
- Comandos Esenciales de Linux UbuntuAún no hay calificacionesComandos Esenciales de Linux Ubuntu7 páginas
- Cómo crear un archivo PST en OutlookAún no hay calificacionesCómo crear un archivo PST en Outlook6 páginas
- Definición de barra de título en ExcelAún no hay calificacionesDefinición de barra de título en Excel7 páginas
- Características de Sistemas OperativosAún no hay calificacionesCaracterísticas de Sistemas Operativos9 páginas
- Auto aprovisionamiento WR744G y BackupAún no hay calificacionesAuto aprovisionamiento WR744G y Backup2 páginas
- Manual de Prosicar TPV Comercio FullAún no hay calificacionesManual de Prosicar TPV Comercio Full89 páginas
- Guía del Agente OCS Inventory NG en WindowsAún no hay calificacionesGuía del Agente OCS Inventory NG en Windows39 páginas
- Implementación de DLP con Endpoint ProtectorAún no hay calificacionesImplementación de DLP con Endpoint Protector3 páginas
- Manual de Uso de CofoProvincia en SIGCATAún no hay calificacionesManual de Uso de CofoProvincia en SIGCAT7 páginas
- Informe Técnico: Análisis Forense IIIAún no hay calificacionesInforme Técnico: Análisis Forense III54 páginas
- Instalación y activación de Petrel 2017Aún no hay calificacionesInstalación y activación de Petrel 20171 página
- Actualización Dumpper v.91.3 y WPSAún no hay calificacionesActualización Dumpper v.91.3 y WPS11 páginas
- Gestión de Proyectos en Primavera P6Aún no hay calificacionesGestión de Proyectos en Primavera P664 páginas
- Recuperación de Receptores Azbox BravooAún no hay calificacionesRecuperación de Receptores Azbox Bravoo8 páginas
- Bitacora-Desfragmentación de DiscoAún no hay calificacionesBitacora-Desfragmentación de Disco3 páginas
- Guía de Instalación de Windows 10 USBAún no hay calificacionesGuía de Instalación de Windows 10 USB23 páginas
- Cómo formatear Windows XP paso a pasoAún no hay calificacionesCómo formatear Windows XP paso a paso11 páginas
- Informe Técnico de Mantenimiento de LaptopAún no hay calificacionesInforme Técnico de Mantenimiento de Laptop1 página
- Evolución de los Sistemas OperativosAún no hay calificacionesEvolución de los Sistemas Operativos35 páginas
- Funciones y gestión de sistemas operativos Windows80% (5)Funciones y gestión de sistemas operativos Windows8 páginas
- Planeación y Tipos de Discos de AlmacenamientoAún no hay calificacionesPlaneación y Tipos de Discos de Almacenamiento11 páginas