JAVA CONCEPTOS BASICOS

Ejercicio 01:

public class jose

{
public static void main(String args[])
//* En cuanto a la palabra String, su inicial debe ir en Mayuscula
{
System.out.println("¡Mi primer programa en Java!");
//* Esto sale cuando se ejecuta
}
}

1) Se guarda en el blog de Notas como: practica 1.txt

2) Se guarda otra copia como: jose.java
3) Se compila con el siguiente comando: javac jose.java
4) Una vez compilado con éxito genera un archivo ejecutable llamado: jose
Es decir, con el comando: java jose ( se ejecuta)

Ejercicio 02:
public class jose02
{
public static void main(String args[])
{
System.out.println("¡Mi nombre es Jose Sanchez Gaona!");
System.out.println("¡Este es mi segundo programa en JAVA!");
System.out.println("son las 20 Horas con 50 minutos");
System.out.println("del 03 de Julio de 2019");

// Esto sale cuando se ejecuta

}
}

Errores:

public class Errores

{
public static void main(String args[])
{
System.out.println("Ejercicio sin una correcta indentacion");
// En apariencia este programa podría contener errores de indentación
// pero en realidad esta bien, unas llaves están mas corridas que las otras
// La falta de indentación, más que errores, es de falta de estica y de orden
}
}

Operadores

El signo + además de usarse para sumar se utiliza como signo de concatenación es decir: resultado =
variable1 + variable2
System.out.println("El resultado es:" + resultado);

Prioridad entre operadores:

1) ( ) paréntesis
 2) ^ potencia (ALT 94)
3) * / (Multiplicacion y Division)
4) + - (Suma y Resta)

EJERCICIOS CON OPERADORES:

Ejercicio: sumabasica:

public class sumabasica

// El nombre de la class puede comenzar en Minusculas ó Mayusculas,
// pero no debe llevar caracteres especiales como: guiones, tildes, etc..
{
public static void main(String args[])

//* En cuanto a la palabra String, su inicial debe ir en Mayuscula

{

int a = 4;
int resultado = 0;

resultado = a + 2;

System.out.println("Resultado = " + resultado);

}
}

Ejercicio: opbasicas1:

public class opbasicas1

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

int a = 4;
int b = 3;
int c = 5;
int d = 6;
int resultado_1 = 0;
int resultado_2 = 0;

resultado_1 = (a+b+c+d) + b - (a+d)/2;

// Resultado_1 = (18) + 3 - (10/2)
// Resultado_1 = (18) + 3 - (5)
// Resultado_1 = 16

System.out.println("Resultado = " + resultado_1);

}
}
Ejercicio: opbasicas2:

public class opbasicas2

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

int a = 4;
int b = 3;
int c = 5;
int d = 6;
int resultado_1 = 0;
int resultado_2 = 0;

resultado_1 = (a+b+c+d) + b - (a+d)/2;

// Resultado_1 = (18) + 3 - (10/2)
// Resultado_1 = (18) + 3 - (5)
// Resultado_1 = 16
resultado_2 = resultado_1 - b*d;
// Resultado_2 = 16-18
// Resultado_2 = -2
System.out.println("Resultado = " + resultado_2);
}
}

Ejercicio: opbasicas3:
public class opbasicas3
{
public static void main(String args[])
{

int a = 4;
int b = 3;
int c = 5;
int d = 6;
int resultado_1 = 0;
int resultado_2 = 0;

resultado_1 = (b+c) + d - (a+d)/2;

// Resultado_1 = 14 - 5
// Resultado_1 = 9

resultado_2 = ((resultado_1+c)/(d+a-8))*15/3;

// Resultado_2 = ((9+5)/(2))*5
// Resultado_2 = 7*5 = 35

System.out.println("Resultado = " + resultado_2);

}
}
Ejercicio: opbasicas4:
public class opbasicas4
{
public static void main(String args[])
{

int a = 4;
int b = 3;
int c = 5;
int d = 6;
int resultado_1 = 0;
int resultado_2 = 0;

resultado_1 = (b+c) + d - (a+d)/2;

// Resultado_1 = 14 - 5
// Resultado_1 = 9

resultado_2 = (resultado_1+c)/(d+a-8)*15/3;

// Resultado_2 = (9+5)/(2)*5
// Resultado_2 = 7*5 = 35

System.out.println("Resultado = " + resultado_2);

}
}

EJERCICIOS CON CONDICIONANTES:

Ejercicio: condicionantes1:

public class condicionantes1

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

int matematicas = 8;
int biologia = 5;
int quimica = 8;
int promedio = 0;
promedio = (matematicas+biologia+quimica)/3;
if(promedio >= 6)
{
System.out.println("El alumno aprobo " + promedio);

}
else
{
System.out.println("El alumno reprobo " + promedio);
}

}
}
Ejercicio: condicionantes2:

public class condicionantes2

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

int matematicas = 5;
int biologia = 5;
int quimica = 4;
int promedio = 0;
promedio = (matematicas+biologia+quimica)/3;
if(promedio >= 6)
{
System.out.println("El alumno aprobo " + promedio);
}
else
{
if(promedio <= 4)
{
System.out.println("El alumno debe repetir" + promedio);
}
else
{
System.out.println("El saco 4" + promedio);
}
}

}
}

EJERCICIOS CON CAPTURA DE DATOS

import java.util.Scanner; // Para captura de datos se requiere la librería útil y la sublibreria Scanner

public class capturadatos1

{
public static void main(String args[])
{
Scanner entrada = new Scanner (System.in); // entrada es el nombre con el cual he nombrado mi objeto que es de
//tipo Scanner
String nombre = " ";
int numero_uno = 0, numero_dos = 0,resultado = 0; // variables de mi objeto llamado: entrada, las inicializo

System.out.println("Indiqueme su nombre: ");

nombre = entrada.nextLine(); // El método nextLine es para captura de texto, acompañado de mi Objeto

System.out.println("Indiqueme el primer valor para la suma: ");

numero_uno = entrada.nextInt(); // El metodo nextInt es para captura de valores numericos, acompañado de mi
// Objeto
System.out.println("Indiqueme el segundo valor para la suma: ");
numero_dos = entrada.nextInt();

resultado = numero_uno + numero_dos;

System.out.println("Hola " + nombre + " el Resultado de la suma es: " + resultado);

}
}
CONDICIONES COMPUESTAS CON OPERADORES LÓGICOS & RELACIONALES
OBSERVACION IMPORTANTE:

Este .equals demanda que los contenidos de las dos variables sean exactos, tanto en mayúsculas como en
minúsculas.

If (nombre_uno.equals("jose ")) Tambien podemos usar la comparación de esta manera.

import java.util.Scanner;
public class practica
{
public static void main(String args[])
{
Scanner entrada = new Scanner (System.in);

String nombre = " ", departamento = " ";

int clave = 0, antiguedad = 0,vacaciones = 0;

System.out.println("****************************************************** ");
System.out.println("* SISTEMA DE INFORMACION DE VACACIONES CIA XY * ");
System.out.println("****************************************************** ");

System.out.println("Indiqueme el nombre: ");

nombre = entrada.nextLine();

System.out.println("Indiqueme la clave del señor: " + nombre);

clave = entrada.nextInt();

// SI CLAVE = 1 DPTO DE MERCADEO

// SI CLAVE = 2 DPTO DE OPERACIONES
// SI CLAVE = 3 DPTO DE RECURSOS HUMANOS

if(clave != 1 && clave != 2 && clave != 3)

{
clave = 0;
System.out.println("Clave incorrecta, igrese 1 2 o 3 ");
System.out.println("Indiqueme Nuevamente la clave del señor: " + nombre);
clave = entrada.nextInt();

}
System.out.println("Indiqueme el tiempo de antiguedad: ");
antiguedad = entrada.nextInt();
// SI CLAVE = 1 DPTO DE MERCADEO:
if(clave == 1)
{
departamento = "MERCADEO";
if(antiguedad == 1)
{
vacaciones = 6;
}
if(antiguedad >= 2 && antiguedad <= 6)
{
vacaciones = 14;
}
if(antiguedad >= 7)
{
vacaciones = 20;
}
}

// SI CLAVE = 2 DPTO DE OPERACIONES:

if(clave == 2)
{
departamento = "OPERACIONES";
if(antiguedad == 1)
{
vacaciones = 10;
}
if(antiguedad >= 2 && antiguedad <= 6)
{
vacaciones = 15;
}
if(antiguedad >= 7)
{
vacaciones = 22;
}
}

// SI CLAVE = 3 DPTO DE R.HUMADOS:

if(clave == 3)
{
departamento = "RECURSOS HUMANOS";
if(antiguedad == 1)
{
vacaciones = 10;
}
if(antiguedad >= 2 && antiguedad <= 6)
{
vacaciones = 20;
}
if(antiguedad >= 7)
{
vacaciones = 30;
}
}
System.out.println("El trabajador: " + nombre);
 System.out.println("perteneciente al Departamento de: " + departamento);
System.out.println("tiene derecho a: " + vacaciones + " dias de vacaciones" );
}
}

ESTRUCTURAS DE CONTROL SWITCH-CASE

import java.util.Scanner;

public class switches

{
public static void main(String args[])
{
Scanner entrada = new Scanner (System.in);

int opcion = 0, numero_1 = 0,numero_2 = 0;

int numero_3 = 0,numero_4 = 0, resultado = 0;

System.out.println("************************************************ ");
System.out.println("* EJERCICIO ESTRUCTURAS DE CONTROL SWITCH-CASE * ");
System.out.println("************************************************ ");

// EL PARAMETRO <opcion> SOLO ADMITE DOS TIPOS DE VARIABLES

// VARIABLES INT ó VARIABLES CHAR

System.out.println("Seleccione Opcion: ");

opcion = entrada.nextInt();

if(opcion == 1)
{
System.out.println("Ingrese Numero uno: ");
numero_1 = entrada.nextInt();
}
if(opcion == 2)
{
System.out.println("Ingrese Numero dos: ");
numero_2 = entrada.nextInt();
}
if(opcion == 3)
{
System.out.println("Ingrese Numero tres: ");
numero_3 = entrada.nextInt();
}
if(opcion == 4)
{
System.out.println("Ingrese Numero cuatro: ");
numero_4 = entrada.nextInt();
}

switch(opcion)
{
case 1: resultado = numero_1 + 1;
System.out.println("El resultado de la opcion 1 es: " + resultado);
 break;

case 2: resultado = numero_2 + 2;

System.out.println("El resultado de la opcion 2 es: " + resultado);
break;

case 3: resultado = numero_3 + 3;

System.out.println("El resultado de la opcion 3 es: " + resultado);
break;

case 4: resultado = numero_4 + 4;

System.out.println("El resultado de la opcion 4 es: " + resultado);
break;

default: System.out.println("Opcion No disponible" );

break;
// El default es para evitar que el programa se rompa

}
}

ESTRUCTURAS REPETITIVAS FOR

public class ciclofor

{
public static void main(String args[])
{
for (int i=1; i <= 5; i++) // Notemos que aqui si podemos declarar la varible y su incremento
// mientras que en la estructura While no se puede
{
System.out.print(+ i + " , " ); // El efecto es el mismo con el + antes ó despues

}
System.out.println("Ciclo termino");
for (int i=1; i <= 5; i++)
{
System.out.print(i + " , " ); // El efecto es el mismo con el + antes ó despues

}
System.out.println("Ciclo termino");
}
}

ESTRUCTURAS REPETITIVAS WHILE

Ejercicio 01 (While):

//Este algoritmo genera el resultado siguiente:

//1, 3, 5, 7, 9

package ejecutar;

import javax.swing.JOptionPane;

/**
*
 * @author Jose Sanchez
*/
public class correr {
public static void main(String args[])
{
int i = 1;

while (i<10) // Lo puedo escribir tambien: while( i < 10) y es lo mismo

{
System.out.println(+i);
i = i+2; // El incremento es el mismo **
}

System.out.println( "Otra forma de mostrar el mismo resultado:");

JOptionPane.showMessageDialog(null,"Otra forma de mostrar el mismo resultado:");
i = 1;

while(i < 10)

{
System.out.print(+ i + " , ");
i+=2; // El incremento es el mismo **
}

} Ejecucion

Ejercicio 02 (do-while):

public class ciclodowhile

//Este algoritmo es para generar el resultado siguiente:
//1000, 800, 600, 400, 200,0.

{
public static void main(String args[])
{
 int i = 1000;

while(i>=0)
{
System.out.println(+i);
i = i-200;// El decrecremento es el mismo **
}

System.out.println( "Otra forma de mostrar el mismo resultado:");

i = 1000;

while (i >= 0)
{
System.out.print(+ i + " , ");
i-=200; // El decrecremento es el mismo **
}
// Para dejar dos saltos
System.out.println();
System.out.println();
System.out.println( "** AHORA USANDO EL BUCLE do-while **");
i = 1000;

do
{
System.out.print(+i+" , ");
i-=200;
}
while (i>=0);

}
}
 FUNCION Try-Cath - Excepciones o Sencillamente problemas
Resulta que en la programación se pueden presentar errores mas o menos graves pero que hay que tratar y
gestionar correctamente, es por ello que en JAVA disponemos de un mecanismo que consiste en el uso de
los bloques: try, catch, finally. Esta técnica básica consiste en colocar las instrucciones que podrían provocar
problemas dentro de un bloque try, y colocar a continuación uno o mas bloques catch de tal forma que si se
provoca un error de un determinado tipo, lo que haremos es saltar al bloque catch el cual será capaz de
gestionar ese tipo de error puntual o específico..
Try: significa intenta, en otras palabras lo que el try nos dice es: intenta hacer todo lo que esta encerrado en
este bloque y dado el caso de que suceda una excepción ejecuta el bloque catch. Catch significa capturar la
excepcion
Otro ejemplo de Try Catch - Importantísimo:

Fuente: https://www.youtube.com/watch?v=jYnHBbqHE3A
85. Programación en Java || Tratamiento de Excepciones || try catch para excepciones
verificadas

package pruebaexcepciones;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.swing.JOptionPane;

public class PruebaExcepciones {

public void leerArchivo() throws FileNotFoundException, IOException {
File archivo = new File("D:\\prueba\\texto.txt");
FileReader fr =new FileReader(archivo);
BufferedReader bf = new BufferedReader(fr);
String linea;

while ((linea = bf.readLine()) != null){

System.out.println(linea);
}
}

public void leerArchivo2(){

try{
leerArchivo();
} catch (FileNotFoundException ex){
JOptionPane.showMessageDialog(null, "No se ha encontrado el archivo deseado, por favor verifique
la ruta");
} catch (IOException e){
JOptionPane.showMessageDialog(null, "Ha ocurrido una excepcion verificada");
}

System.out.println("programa terminado");
}

public static void main(String[] args) {

PruebaExcepciones prueba = new PruebaExcepciones();
prueba.leerArchivo2();

}
}
El Try-Catch lo que pretende es que el programa no se frene

Try catch para Expresiones verficadas, lo usamos para Excepciones verificadas, Excepciones, es decir, que
deriven del IOException.

Cuando hay declaraciones en las Excepciones en los Métodos, esto se usa mas que todo cuando en dicho
método donde estamos declarando no la íbamos a capturar los errores y aquí no vamos a tratar de evitarlos.

Con estas declaraciones, le estamos indicando al programa que es muy probable que en este método se
puedan presentar Excepciones del tipo: FileNotFoundException, IOException pero mas nada, aquí estas
excepciones no las podemos tratar.

Este método, lo usaremos en otro método donde aquí si podremos tratar de evitar ese conflicto de
excepciones.
Programa en ejecución:
https://www.youtube.com/watch?v=E3_3bF_q64k&list=PLyvsggKtwbLX9Lr
Dnl1-K6QtYo7m0yXWB&index=24

Curso Java desde cero #24 | Interfaces gráficas (Librería swing)

Código fuente:

/*
Curso Java desde cero #24 | Interfaces gráficas (Librería swing)
*/
package Formulario;
import javax.swing.*;

public class Formulario extends JFrame{

private JLabel label1;

public Formulario(){
setLayout(null);
label1 = new JLabel("prueba Interfaz grafica Jose");
label1.setBounds(10,20,200,300);
add(label1);
}

public static void main(String args[]){

Formulario formulario1 = new Formulario();
formulario1.setBounds(0,0,400,300);
formulario1.setVisible(true);
formulario1.setLocationRelativeTo(null);
}
}

Explicacion:
Inicialmente como lo veníamos haciendo, aquí no vamos a usar de entrada el Método Main (nos lo
saltamos).Lo que hacemos es uso de la herencia con la palabra extends (la cual nos ayuda a importar
clases que han programado previamente otras personas y esas clases están incluidas dentro del
JDK).

Aquí combinamos la librería javax.swing.* junto con una nueva clase la cual vamos a importar y se
llama JFrame (JFrame nos permite crear interfaces graficas) la librería javax.swing.* nos permite
importar los elementos para armar nuestras interfaces, mientras que la clase JFrame lo que hace es
permitirnos crear la interfaz gráfica (es el contenedor donde van a ir todos nuestros elementos).

Entonces al escribir la palabra Extends estamos diciendo que queremos hacer uso de una clase que
ya existe y que esta en el JDK, el cual estamos importando gracias a la librería javax.swing.*

Miremos ahora la etiqueta: private JLabel

Ubiquemonos en el siguiente contexto:

¿Que es lo que hacemos cuando declaramos una variable?

Int num_1 = 0
Int: es el tipo de dato a usar
num_1 = 0: Le asignamos un nombre con su valor inicial

setLayout(null) : este método no va a hacer nada a menos que nosotros le demos una instrucción,
es decir por el momento se quedara observando

Cuando hacemos uso de los elementos que nos provee la librería swing.* hacemos algo muy similar
y uno de estos elementos es una etiqueta que ingresamos de la siguiente manera:
JLabel : Etiqueta, esta nos permite crear o mostrar datos en pantalla sin la necesidad de un
System.out.println ("xxxxx");
label1: Le colocamos cualquier nombre

Ahora bien,

En java existe un concepto llamado: Modificadores de Acceso que son 4 en total, pero vamos a ver
solo dos por el momento:
- Private
 - Public

Nota importante: private JLabel label1

Este tipo de etiquetas o componentes no es necesario inicializarlos (las). Todos los
JLabel por lo general deben de ser de tipo private, ¿porque ?, porque supongamos que
tenemos otra clase, otra interfaz gráfica que también tiene un JLabel que se llama label1
dentro del mismo programa, esto crearía una confusión. Al colocarle que va a ser de tipo
privado, le estamos indicando que únicamente esta clase que estamos programando en
este momento va a tener acceso a este JLabel, por eso le ponemos private.

Estos dos Modificadores actúan como guardias de seguridad, se encargan de decir cuales espacios
son públicos y cuales son privados. Es decir, con los Modificadores de acceso le estamos indicando
al programa que elementos o clases, u objetos van a ser de dominio público y de dominio privado.

Aquí para nuestro ejemplo, nuestros labels van a ser siempre de dominio privado, pues solo los vamos
a utilizar en la interfaz que estamos programando actualmente.

Mientras que el nombre de la clase (Public class Formulario) o la clase en general es de dominio
público, es decir si queremos enlazar una clase A, una clase B y una clase C tienen que ser públicos
porque de lo contrario no se van a encontrar, van a estar escondidas.

Ahora hacemos uso de los siguientes métodos:

 a) Este Método nos permite indicarle al programa a través de coordenadas donde vamos a
colocar los elementos dentro de la interfaz, para evitar que el Metodo setLayaut los coloque
donde quiera le escribimos (null). Es bien importante tener en cuenta que este Metodo lo que
nos permite es crear o poner nuestros componentes a través de coordenadas, si no loponemos
no vamos a poder agregar componentes, no vamos a poder crear nuestros elementos dentro
de nuestra Interfaz grafica.
b) Hacemos uso del label o etiqueta que acabamos de definir o declarar arriba. La inicializamos
como si se tratara de un System.out.println con el mensaje que se ve en las comillas. El
mensaje que queremos que se vea en la interfaz es igual a lo que hace un System.out.println
a excepción de que tiene la forma de un objeto.
c) Una vez que definimos que mensaje queremos que tenga la etiqueta, le damos enseguida las
coordenadas x(10), y(20), ancho:200 y alto:300
d) Por último en esta sección el Método add(agregar), agrega todo lo que creamos previamente
a la etiqueta label1. Este método es imprescindible ya que si no lo colocamos no nos va a
mostrar nada.

Bien!,, hasta aquí todo esta ok, sin embargo nos hace falta crear algo que le diga a nuestro
programa que vamos a crear toda esta sección:

Pues lo acabamos de escribir o dar de alta, pero no le hemos dicho al programa que lo cree. Para
esto existe en Java un concepto llamado Constructores. Un Constructor nos permite crear cosas
PERO No en el lugar donde los estamos programando, sino en un lugar donde lo vamos a invocar.

Para nuestro ejercicio se va a llamar como se ve en la siguiente figura:

Una vez creado nuestro Constructor vamos a proceder ahora si a escribir nuestro Método Main, para
decirle al programa que una vez que ya terminamos por parte de nosotros de crear el diseño de
nuestra etiqueta (1) dentro de un Constructor, lo que vamos a hacer a continuación es arrancarlo de
la siguiente manera:

Observemos que el Método Main (para el arranque de nuestro programa) es el mismo y no cambia.
 a) Hacemos uso de nuestro Objeto que se va a llamar igual que nuestra Clase e igual que nuestro
Constructor. Si nuestra clase se llama jose, debemos llamar de igual forma a nuestra Clase y
nuestro Constructor jose.

Porque un Objeto ?

Lo que hicimos en el bloque Constructor fue crear la Etiqueta que contiene el Mensaje ”xxxxxx” pero
tenemos que crear el Contenedor; es decir, esa pantalla que se ve que es la Interfaz Gráfica.

Entonces vamos a nombrar nuestro Objeto del tipo que queremos que sea, en este caso va a ser un
Objeto de tipo de la Clase que estamos trabajando (Recordemos que nuestra clase se llama:
Formulario)

Recordemos cuando creamos un Objeto de tipo Scanner:

Aquí estamos haciendo lo mismo con la diferencia de que estamos indicándole a nuestro programa
que vamos a hacer uso de la clase JFrame, por eso estamos creando un Objeto de tipo Formulario
no tanto porque la Clase se llama Formulario sino para referenciar que este Objeto a) Formulario…
tiene que hacer uso de esta Clase extends JFrame.

Entonces al yo nombrar mi Objeto igual que mi clase y mi Constructor todo va a estar enlazado,
todo va a estar dentro de la misma interfaz.

b) Una vez creado el Objeto vamos a mandar a llamar a mi Objeto que recordemos se llama:
Formulaio1 y le vamos a decir que con la ayuda del Método setBounds le indicaremos las
coordenadas y las dimensiones.
c) Nuevamente escribimos nuestro Objeto (Formulario1) y con la ayuda del Método setVisible
determinaremos si mi Interfaz se va a ver o se va a esconder.
(true): para que se vea
(false): para que se esconda
d) Vamos a indicarle al programa que mi Interfaz que se llama Formuario1 con la ayuda del
Método setLocationRelativeto(null) que quiero que mi Interfaz al momento de que se ejecute
aparezca en el centro de mi pantalla.

https://www.youtube.com/watch?v=VOGula26mMM&list=PLyvsggKtwbLX9
LrDnl1-K6QtYo7m0yXWB&index=25
Curso Java desde cero #25 | Interfaces gráficas (swing - JFrame)

Se trata de aprender a manipular el JFrame, que es esta pantalla:

https://www.youtube.com/watch?v=2xLHMUdSPMU&list=PLyvsggKtwbLX9
LrDnl1-K6QtYo7m0yXWB&index=26

Curso Java desde cero #26 | Interfaces gráficas (swing - JLabel)

Se trata de aprender a manipular el JLabel, es decir jugar con las posiciones de los Mensajes:
- "prueba Interfaz grafica Jose"
- "Version 1.0"
Como podemos observar este es un ejercicio con dos etiquetas.

Código fuente:

package Formulario;
import javax.swing.*;

public class Formulario extends JFrame{

private JLabel label1;
private JLabel label2;
 public Formulario(){
setLayout(null);
label1 = new JLabel("prueba Interfaz grafica Jose");
label1.setBounds(10,20,300,30);
add(label1);
label2 = new JLabel("Version 1.0");
label2.setBounds(10,100,100,30);
add(label2);

public static void main(String args[]){

Formulario formulario1 = new Formulario();
formulario1.setBounds(0,0,300,200);
formulario1.setResizable(false);
formulario1.setVisible(true);
formulario1.setLocationRelativeTo(null);
}
}

Ejecución:

Breve explicación del Algoritmo:

https://www.youtube.com/watch?v=6PMMn62pf78&list=PLyvsggKtwbLX9Lr
Dnl1-K6QtYo7m0yXWB&index=27
Curso Java desde cero #27 | Interfaces gráficas (Swing - JButton)
Componente JButton

Código fuente:

package Formulario;
import javax.swing.*;
import java.awt.event.*;

public class Formulario extends JFrame implements ActionListener{

JButton boton1;
@SuppressWarnings("LeakingThisInConstructor")
public Formulario(){
setLayout(null);
boton1 = new JButton ("Cerrar");
boton1.setBounds(300,250,100,30);
add(boton1);
boton1.addActionListener(this);
}

public void actionPerformed(ActionEvent e){

if(e.getSource() == boton1){
System.exit(0);
}
}

public static void main(String args[]){

Formulario formulario1 = new Formulario();
formulario1.setBounds(0,0,450,350);
 formulario1.setVisible(true);
formulario1.setResizable(false);
formulario1.setLocationRelativeTo(null);
}
}

Este componente (JButton) nos permite agregar botones a nuestras Interfaces graficas. Cuando
programamos un botón en Java lo tenemos que programar en dos partes totalmente diferentes:

- Primero, debemos crear el diseño, es decir, darle las dimensiones y el texto que queremos que
contenga nuestro botón.
- Segundo, tenemos que programar la funcionalidad del botón, a esta funcionalidad se le va a
conocer como Evento.

Ejecución:

Explicación del Algoritmo:

https://www.youtube.com/watch?v=oJl8inUGzGY&list=PLyvsggKtwbLX9Lr
Dnl1-K6QtYo7m0yXWB&index

Curso Java desde cero #28 | Interfaces gráficas (Manejo de botones & etiquetas)
Código fuente:

package Formulario;
import javax.swing.*;
import java.awt.event.*;

public class Formulario extends JFrame implements ActionListener{

private JButton boton1, boton2, boton3;
private JLabel label1;

/* Diseño de los componentes */

@SuppressWarnings("LeakingThisInConstructor")
public Formulario(){
setLayout(null);
boton1 = new JButton ("1");
boton1.setBounds(10,100,90,30);
add(boton1);
boton1.addActionListener(this);

boton2 = new JButton ("2");

boton2.setBounds(110,100,90,30);
add(boton2);
boton2.addActionListener(this);

boton3 = new JButton ("3");

boton3.setBounds(210,100,90,30);
add(boton3);
boton3.addActionListener(this);

label1 = new JLabel("En espera...");

label1.setBounds(10,10,300,30);
 add(label1);
}

/* Captura de los eventos de cada boton */

public void actionPerformed(ActionEvent e){
if(e.getSource() == boton1){
label1.setText("Has presionado el boton 1");
}
if(e.getSource() == boton2){
label1.setText("Has presionado el boton 2");
}
if(e.getSource() == boton3){
label1.setText("Has presionado el boton 3");
}
}

/* Creación del diseño de nuestra Interfaz grafica */

/* Metodo Main */
public static void main(String args[]){
Formulario formulario1 = new Formulario();
formulario1.setBounds(0,0,350,200);
formulario1.setVisible(true);
formulario1.setResizable(false);
formulario1.setLocationRelativeTo(null);
}
}

Ejecución:
https://www.youtube.com/watch?v=Rs4gz77Ap0g&list=PLyvsggKtwbLX9Lr
Dnl1-K6QtYo7m0yXWB&index=29

Curso Java desde cero #29 | Interfaces gráficas (Swing - JTextField)

Componente JTextField.

Nos permite integrar pequeñas cajas de texto a nuestras Interfaces graficas,con la finalidad de
poderle solicitar al usuario datos desde teclado y así poder interactuar con los programas.
Vamos a hacer un programa que integre los siguientes tres componentes:

Una vez le de Aceptar el texto que acabo de digitar va a quedar en la parte superior de la Interfaz,
es decir en su Titulo.
Código fuente: