Puntos Extras Taller de POO

 http://programacion-orientada-4200.blogspot.com/2011/10/ejercicios-en-sql.html


http://programacion-orientada-4200.blogspot.com/2011/11/ejercicio-de-la-clase-moto.html


http://programacion-orientada-4200.blogspot.com/2011/11/patrones-de-diseno_24.html

Patrones de Diseño

Hola en esta entrada mostrare el ejercicio de las Pruebas de Bebidas en la que se utilizaban partes del código de como preparar un Té y un Café, pero estas son clases incompletas las cuales nosotros tenemos que darles los valores adecuados, y acomodarlas según sea necesario.

Como ya mencioné son clases separadas las cuales debemos implementar, y ¿Como las implementamos si no están completas? Pues en parte tiene que ver mucho el tema de "Superclases" y subclases, las cuales para poder utilizarlas debemos agregar el "abstract" a la "superclase" para que, en este caso java, sepa que no están completas.

Bueno primero especificamos que la superclase se hereda, e implementamos los métodos del tipo abstracto:


public abstract class BebidaCafeinada
{
 public final void prepararReceta()
 {
  hervir();
  poner();
  servir();
  agregaCondimentos();
  System.out.println();
 }

 public abstract void poner();
 public abstract void agregaCondimentos();

 public void hervir()
 {
  System.out.println("Hirviendo el Agua");
 }

 public void servir()
 {
  System.out.println("Sirviendo");
 }
}


Aquí tenemos la superclase, de esta se heredan los metodos "poner" y "agregaCondimentos"

Después tenemos las bebidas que mencionamos hay que darles sus algoritmos, la superclase se encarga de controlar el proceso.


public class Cafe extends BebidaCafeinada
{
 public void poner()
 {
  System.out.println("Poniendo el Cafe");
 }

 public void agregaCondimentos()
 {
  System.out.println("Agregando Azucar y Leche");
 }
}

Esta es la clase Café, que continua con el programa utilizando herencia.


public class Te extends BebidaCafeinada
{
 public void poner()
 {
  System.out.println("Poniendo el Te");
 }

 public void agregaCondimentos()
 {
  System.out.println("Agregando limon");
 }
}

Esta es parecida a la del Café, pero se llama "Te"


public class PruebaBebidas
{
 public static void main(String[] args)
 {
  Te elTe = new Te();
  Cafe elCafe = new Cafe();

  System.out.println("Preparando el Te");
  elTe.prepararReceta();

  System.out.println("Preparando el Cafe");
  elCafe.prepararReceta();
 }
}

Por ultimo esta clase se encarga de hacer la prueba y mostrar los resultados en conjunto.

Bien ahora hacemos la prueba:
Primero vamos al directorio donde tenemos las clases, como son varios archivos ".java", podemos hacer uso del comando "javac *.java" para compilar todos de una sola vez.

Y ahora lo ejecutamos:

Y así es como termina, todo esto es buen motivo para aprender que cualquier código puede reutilizarse e implementarse como tipo abstracto, solo hace falta dar los valores a las variables y demás detalles estéticos.
Utilizando esta manera de programar es mas sencillo implementar otros tipos de clases que se ajusten al método.

Ejercicio de la clase Moto

Hola saludos!!
Haremos un ejemplo:
Bien primero hacemos el pseudocodigo:

Inicia
Numero de Placa:
Motocicleta apagada
Velocidad 0 km/h
Batería al 100%

Si encendemos {
Batería disminuye 1%
}
Si Batería es menor a 1{
No se puede encender! Batería descargada!
}
Apagar detiene Moto y no Disminuye Batería;
Acelerar Disminuye 1% Batería y Aumenta 20 a velocidad;
Frenar Disminuye 1% Batería y Disminuye 20 a velocidad;
Si Velocidad =200 {
Ya no puede acelerar mas!! es la máxima velocidad!!
}
Si Velocidad es =0 {
Ya no puede frenar porque esta detenido!!

Si al Acelerar o Frenar y Batería es menor a 1%{
Motocicleta se Apaga y se detiene
}

Si Batería es Menor a 1%{
Salir de Moto
}
}

Como notaron agregue algunas opciones extras al código como una velocidad limitada a 200 Km/h y que si la batería se acaba la moto se apaga y se detiene.

Bien Ahora el código:


import java.util.*;

public class Motocicleta {

public String Placa;
public boolean EstadoMotor;
public int Velocidad;
public int VidaBateria;

public Motocicleta(String Placa, boolean EstadoMotor, int Velocidad, int VidaBateria)
  {
      this.Placa = Placa;
      this.EstadoMotor = EstadoMotor;
      this.Velocidad = Velocidad;
      this.VidaBateria = VidaBateria;
  }
/**
* @param args
*/
public static void main (String[] args)
  {
Motocicleta casos = new Motocicleta("ELV9550", false, 0, 100);
   
    int opcion = 0;
    Scanner read = new Scanner(System.in);
   
    do {
   
    System.out.println("1.-Datos de Motocicleta");
    System.out.println("2.-Encender");
    System.out.println("3.-Apagar");
    System.out.println("4.-Acelerar");
    System.out.println("5.-Freno");
    System.out.println("6.- Salir\n");                              
    System.out.print("Elija una opcion: ");
    opcion = read.nextInt();
   
    System.out.println("\n");
   
    switch(opcion)
    {
        case 1:
            casos.InfoMoto();
            break;
        case 2:
            casos.encender();
            break;
        case 3:
        casos.apagar();
            break;
        case 4:
        casos.acelerar();
            break;
        case 5:
        casos.frenar();
            break;
 
    }
    }
while(opcion != 6);
}
 
public String MostrarPlaca ()
{
    return Placa;
}

public void encender()
{
    if(EstadoMotor != true && VidaBateria>0){
    EstadoMotor = true;
    if(VidaBateria>1)
    {
        VidaBateria--;
    }
    else{ System.out.println("¡¡La Bateria se descargo por completo!!\n");
    EstadoMotor = false;
    Velocidad = 0;
    }

}
else{
System.out.println("¡¡La Motocicleta ya esta encendida!!\n");
}
   
   
}

public void apagar()
{
if(EstadoMotor != false){
   EstadoMotor = false;
   Velocidad = 0;
}
else{
System.out.println("¡¡La Motocicleta ya esta Apagada!!\n");
}
}

public void acelerar()
{
    if(EstadoMotor = true && Velocidad < 200 && VidaBateria>=0)
    {
        Velocidad = Velocidad + 20;
   
    if(VidaBateria>1)
    {
        VidaBateria--;
    }
else{ System.out.println("¡¡La Bateria se descargo por completo!!\n");
EstadoMotor = false;
Velocidad = 0;
    }
}
else{
System.out.println("No puede acelerar mas!! Velocidad Maxima de Motocicleta:200Km/h\n");
}
}

public void frenar ()
{
    if(EstadoMotor = true && Velocidad != 0 && VidaBateria>=0)
    {
        Velocidad = Velocidad - 20;
    if(VidaBateria>1)
    {
        VidaBateria--;
    }
else{ System.out.println("¡¡La Bateria se descargo por completo!!\n");
EstadoMotor = false;
Velocidad = 0;
    }
    }
    else{
    System.out.println("Ya está detenido!! Velocidad:0 Km/h\n");
    }
}

public void InfoMoto()
{
    System.out.println("La placa es: "+Placa);
    if(EstadoMotor == false){
    System.out.println("Motor Apagado");
    }
    else {
    System.out.println("Motor Encendido");
   }
    System.out.println("Velocidad: "+Velocidad+" Km/h");
    System.out.println("Porcentaje de vida de la bateria: "+VidaBateria+"%"+"\n");

}
}

Bien ahora a probarlo:

Primero Compilamos y ejecutamos el código:

Ahora veamos el estado de la Moto:

Ahora encendemos y mostramos el estado de la moto:

Bien observamos como disminuye la vida de la Batería.

Ahora agregue una opción que nos manda un mensaje si la moto ya esta encendida y la queremos volver a encender:

Ahora probamos el de apagar la moto:

Y también agregué un mensaje si la moto ya esta apagada y tratamos de apagarla de nuevo:

Ahora Aceleramos la moto varias veces:

También como ya mencione la velocidad máxima es de 200Km/h, así que cuando intentamos acelerar mas no nos permite, y por lo tanto no se gasta batería al intentarlo:

Ahora probamos la opción frenar, la cual disminuye la batería y velocidad:

También si ya hemos frenado por completo y queremos volver a frenar nos manda un mensaje:

Y por ultimo probar que pasa cuando la batería se acaba:

Y claro que cada vez que muestra el estado de la moto, muestra el numero de Placa, el Estado del motor, la Velocidad y el estado de la Batería.

Pruebas Unitarias

Hola esto es las pruebas unitarias que resultaron al crearlas, debido a que hay muchas clases mostrare algunas y las demás las subiré para que las puedan descargar.


Prueba de Clase Main:
package proyectofinal;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

public class MainTest {

    public MainTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of main method, of class Main.
     */
    @Test
    public void testMain() {
        System.out.println("main");
        String[] args = null;
        Main.main(args);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

}

Prueba de Clase Seguridad:


package frames;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

public class SeguridadTest {

    public SeguridadTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of main method, of class Seguridad.
     */
    @Test
    public void testMain() {
        System.out.println("main");
        String[] args = null;
        Seguridad.main(args);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

}

Prueba de Clase Menu:



package frames;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

public class MenuTest {

    public MenuTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of main method, of class Menu.
     */
    @Test
    public void testMain() {
        System.out.println("main");
        String[] args = null;
        Menu.main(args);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

}

Prueba de Clase AltaCliente:


package frames;

import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;

public class AltaClienteTest {

    public AltaClienteTest() {
    }

    @BeforeClass
    public static void setUpClass() throws Exception {
    }

    @AfterClass
    public static void tearDownClass() throws Exception {
    }

    @Before
    public void setUp() {
    }

    @After
    public void tearDown() {
    }

    /**
     * Test of main method, of class AltaCliente.
     */
    @Test
    public void testMain() {
        System.out.println("main");
        String[] args = null;
        AltaCliente.main(args);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtRFC method, of class AltaCliente.
     */
    @Test
    public void testSetTxtRFC() {
        System.out.println("setTxtRFC");
        String id = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtRFC(id);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtRFC method, of class AltaCliente.
     */
    @Test
    public void testGetTxtRFC() {
        System.out.println("getTxtRFC");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtRFC();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtNombre method, of class AltaCliente.
     */
    @Test
    public void testSetTxtNombre() {
        System.out.println("setTxtNombre");
        String nombre = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtNombre(nombre);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtNombre method, of class AltaCliente.
     */
    @Test
    public void testGetTxtNombre() {
        System.out.println("getTxtNombre");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtNombre();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtCalle method, of class AltaCliente.
     */
    @Test
    public void testSetTxtCalle() {
        System.out.println("setTxtCalle");
        String calle = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtCalle(calle);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtCalle method, of class AltaCliente.
     */
    @Test
    public void testGetTxtCalle() {
        System.out.println("getTxtCalle");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtCalle();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtColonia method, of class AltaCliente.
     */
    @Test
    public void testSetTxtColonia() {
        System.out.println("setTxtColonia");
        String colonia = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtColonia(colonia);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtColonia method, of class AltaCliente.
     */
    @Test
    public void testGetTxtColonia() {
        System.out.println("getTxtColonia");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtColonia();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtCiudad method, of class AltaCliente.
     */
    @Test
    public void testSetTxtCiudad() {
        System.out.println("setTxtCiudad");
        String ciudad = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtCiudad(ciudad);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtCiudad method, of class AltaCliente.
     */
    @Test
    public void testGetTxtCiudad() {
        System.out.println("getTxtCiudad");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtCiudad();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtTel method, of class AltaCliente.
     */
    @Test
    public void testSetTxtTel() {
        System.out.println("setTxtTel");
        String tel = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtTel(tel);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtTel method, of class AltaCliente.
     */
    @Test
    public void testGetTxtTel() {
        System.out.println("getTxtTel");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtTel();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtEstado method, of class AltaCliente.
     */
    @Test
    public void testSetTxtEstado() {
        System.out.println("setTxtEstado");
        String estado = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtEstado(estado);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtEstado method, of class AltaCliente.
     */
    @Test
    public void testGetTxtEstado() {
        System.out.println("getTxtEstado");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtEstado();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of setTxtCP method, of class AltaCliente.
     */
    @Test
    public void testSetTxtCP() {
        System.out.println("setTxtCP");
        String cp = "";
        AltaCliente instance = new AltaCliente();
        instance.setTxtCP(cp);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of getTxtCP method, of class AltaCliente.
     */
    @Test
    public void testGetTxtCP() {
        System.out.println("getTxtCP");
        AltaCliente instance = new AltaCliente();
        String expResult = "";
        String result = instance.getTxtCP();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of validacion method, of class AltaCliente.
     */
    @Test
    public void testValidacion() {
        System.out.println("validacion");
        AltaCliente instance = new AltaCliente();
        boolean expResult = false;
        boolean result = instance.validacion();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of validacionCP method, of class AltaCliente.
     */
    @Test
    public void testValidacionCP() {
        System.out.println("validacionCP");
        AltaCliente instance = new AltaCliente();
        boolean expResult = false;
        boolean result = instance.validacionCP();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of validacionTel method, of class AltaCliente.
     */
    @Test
    public void testValidacionTel() {
        System.out.println("validacionTel");
        AltaCliente instance = new AltaCliente();
        boolean expResult = false;
        boolean result = instance.validacionTel();
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

    /**
     * Test of SP method, of class AltaCliente.
     */
    @Test
    public void testSP() {
        System.out.println("SP");
        boolean a = false;
        AltaCliente instance = new AltaCliente();
        boolean expResult = false;
        boolean result = instance.SP(a);
        assertEquals(expResult, result);
        // TODO review the generated test code and remove the default call to fail.
        fail("The test case is a prototype.");
    }

}

Bien las demás las dejo en el siguiente link:
Pruebas Unitarias zip

Sistemas Distribuidos

Nombre del Proyecto: Sistema de Administración de Almacén.

Objetivo: Diseñar y desarrollar un Sistema de Información que gestione todas las operaciones en un Departamento de  Almacén de Artículos.

Justificación: La idea de desarrollar un Sistema de Información, que gestione las operaciones de un departamento de almacén, está dada por la actual problemática de las pequeñas y medianas empresas, donde no existe un control automatizado para gestionar dichas operaciones. Normalmente en dichas organizaciones, se utilizan métodos tradicionales, que a un mediano y largo plazo, se  generan problemas por el volumen de documentos que se llegaran a manejar.

Este Sistema, tiene como principal finalidad:

-Automatizar todas las tareas que se efectúan en el departamento de almacén.

-Llevar un registro histórico, de todos los movimientos efectuados en el departamento, es decir: compas de artículos, altas, existencias, salidas de material, bajas de material, modificaciones, consultas de información.

-Reducir las pérdidas y extravió de material en la empresa.

-Reducir los tiempos en todas las operaciones antes mencionadas.

Alcance: El alcance de este Sistema, abarca cualquier tipo de Organización, es decir tanto pública como privada, así como instituciones, en donde se requieran metodologías, para automatizar y controlar todas las operaciones en un almacén, donde el personal que labora puede ser susceptible a cometer errores, si realiza su trabajo de forma manual y mecánica.

El diseño de este Sistema de Información, se adecua perfectamente a las necesidades cualquier Pequeña o Mediana Empresa, por lo que su alcance puede repercutir aun más, ya que si se requiere implementar a otro tipo de negocio, solo se realizan mínimas modificaciones al diseño original y así adecuarlo a las necesidades de cada empresa.

Documentación Técnica

Hola saludos, en esta entrada mostrare como generar documentación técnica con javadoc, que fue el que yo utilice.

Existen varias herramientas que nos permiten auto-generar la documentación técnica, están: Javadoc, Doxygen, Sandcastle, Sphinx entre otros.

Bien yo utilizare javadoc, primero desde el símbolo del sistema buscamos el directorio donde tenemos el proyecto, después una vez encontrado tecleamos javadoc *.java y damos enter.
Escribir *.java quiere decir que incluiremos todos los archivos con dicha extensión.

Después nos vamos al directorio donde están los archivos y abrimos el documento html que se llama "index" el cual nos mostrara toda la información generada con esta herramienta.

Subí la documentación completa del proyecto para descargar:
Documentación Técnica

Les dejo también estos links muy buenos sobre la documentación:

Subestimada Javadoc
Javadoc

Patrones de diseño

Hola, en esta entrada hablare de los Patrones de diseño.

Primero ¿que es un patrón de diseño?
Es una solución ya especificada para resolver problemas de programación comunes.
Esto hace el código mas flexible, también es una buena manera de implementar organización en el código, si existen uniones entre clases esto lo hace mas diferenciable y fácil de encontrar.

Algunos patrones de diseño son (pueden dar clic en cada uno son enlaces):

Algunos patrones de diseño

Delegado
Compuesto
Decorador
Mediador
Iterador
Observador
Modelo-vista-controlador
Factoria
Data Access Object (DAO)
Proxy

Los patrones de diseño describen las clases y las instancias colaboran entre si. Cada patron puede ser adaptado a algún problema, para describir alguno debemos especificar:

• El nombre
• Cual es el propósito
• Si existen algunos otros que coincidan
• Cual problema se esta aplicando
• El diagrama de clases
• Diagrama de interacciones
• Algunas notas extras
• Otros patrones con los que pudiera estar relacionado.

Un Patrón de diseño es un esquema que se supone puede o debe resolver el problema ya que se muestra de manera mas simple toda  la información de las clases osea el programa en si. Pero un patrón es en escala pequeña y sirve para resolver problemas, no confundirlo con los esquemas que se elaboran para diseñar el programa, ya que estos son en escala mucho mayor.

Aqui un ejemplo del Patrón que queremos seguir para nuestro proyecto, es la clase Seguridad de la cual ya mostre su funcionamiento anteriormente:

Aquí utilizamos el patrón Observador y el Decorador, trataremos de seguirlos usando en todo lo demás, solo muestro esta parte por ahora porque seguimos puliendo las demás.


Referencias:
Patrones de Diseño PDF
Descripcion de patrones

Eventos y excepciones

Hola saludos, en esta entrada hablare de eventos que ocurren y errores que se pueden presentar en el programa.

Primero que es un evento o excepción, un evento puede ser algún problema que se puede presentar debido a que el usuario de alguna manera no ha ejecutado correctamente el programa, o lo ha llevado hasta los extremos que puede tolerar este.
Un error es cuando el programa en si, ha tenido problemas al iniciar, ejecutarse o para finalizar debido a que algún archivo fue eliminado, movido de directorio o editado incorrectamente. Cuando esto pasa el usuario puede encontrarse con que ha descubierto un error irreparable por el, amenos que sepa exactamente la causa, por estas razones debemos especificar al usuario mediante cuadros de dialogo que algo pasa, para que el usuario no se espante y tenga alguna idea de que pudo haber ocurrido al menos.

En mi proyecto también manejamos eventos y excepciones aquí algunos ejemplos:

En la primera ventana la cual le pedimos al usuario que ingrese su cuenta y contraseña:

Si el usuario es incorrecto el programa lo detectará entonces le mandara un mensaje para que el usuario sepa que se ha equivocado al teclear su cuenta:

También hay un mensaje si el usuario introduce una contraseña invalida, para que se entere que se ha equivocado:

Y aquí el código que es el responsable de que esto ocurra y evite que el usuario se desespere al no poder acceder y no saber que esta tecleando mal los datos:

Cuando el usuario ingresa correctamente sus datos y presiona aceptar el programa abrirá la ventana del menú para que pueda acceder a trabajar.
Si no es así, el código podemos apreciar como hay una parte donde declaramos un cuadro de mensaje que le avisa al usuario su error.


Material de Apoyo:


Información sobre eventos y excepciones