Ejemplos sencillos de java

Este blog tiene por objetivo ayudar a los que se inician en el
lenguaje Java, con códigos que seguramente les serán de
mucha utilidad.

domingo, 24 de abril de 2011

CRAPS EN JAVA


En este ejemplo se trata de recrear un juego muy conocido llamado CRAPS , el cuál 
consiste  en  lanzar  un  7 u 11  en  el  primer tiro o  de  evitar  un  2 ,  3  ó  12 , si se
 lanza  otra   combinación   se   deberá  lanzar  los  dados  hasta  que  vuelva  a  salir 
ese número , pero sin que salga el 7.

===============================================

import java.io.*;
import java.util.Random;

public class Craps{

    double dinero;
    double apuesta;
    int primerTiro;

    /*CONSTRUCTOR DE LA CLASE DONDE LA VARIABLE DINERO
     DEL JUGADOR SE INICIA*/
    public Craps(double tengo){
        dinero=tengo;
    }

    //METODO QUE LANZA LOS DADOS Y LOS MUESTRA
    public int dados(){

        Random R1=new Random();
        int dado1=1+R1.nextInt(6);
        int dado2=1+R1.nextInt(6);
        int tiro=dado1+dado2;
        System.out.println("Los dados son " + dado1 +" y " + dado2 );
        System.out.println("EL RESULTADO ES: " + tiro);

                return tiro;
    }
    //METODO QUE NOS INDICA LO QUE PASA EN EL PRIMER TIRO
    public int Juego(){

            primerTiro=dados();
            if(primerTiro==7 || primerTiro==11){
                System.out.println("Usted gano");
                dinero=dinero+apuesta;
                System.out.println("Usted tiene " +dinero);
            }
            else if(primerTiro==2 ||primerTiro==3 ||primerTiro==12){
                System.out.println("Usted pierde");
                dinero=dinero-apuesta;
                System.out.println("Usted tiene " + dinero);
            }
            else {
                System.out.println("Lanza otra vez");
                extension();
            }
            return primerTiro;
    }
    //METODO QUE NOS DICE QUE HACER SI NO SE GANA
    //O SE PIERDE EN EL PRIMER TIRO
    public void extension(){

        int Tdados=dados();
      

            if(Tdados==7){
                System.out.println("Usted pierde");
                dinero=dinero-apuesta;
                System.out.println("Usted tiene " +dinero);
            }
            else if(Tdados==primerTiro){
                System.out.println("Usted gana");
                dinero=dinero+apuesta;
                System.out.println("Usted tiene " + dinero);
            }
            else if(Tdados!=primerTiro){
                extension();
            }
      
    }

    //METODO MAIN DONDE SE HACE UN ARREGLO
    //PARA QUE EL JUEGO TENGA UNA MEJOR
    //VISION POR PARTE DEL JUGADOR
    public static void main(String[]args)throws IOException{

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        Craps C1=new Craps(1500);
        String opcion;
        System.out.println("***************CRAPS****************");
        System.out.println("En este juego ganas en el primer tiro");
        System.out.println("si lanzas un 7 u 11 y pierdes si lanzas");
        System.out.println("un 2 , 3  o 12 , en cualquier otro caso ");
        System.out.println("Ese número se convierte en tu número base");
        System.out.println("y tendrás que lanzar de nuevo hasta que ");
        System.out.println("repitas ese número sin antes sacar un 7 con");
        System.out.println("lo cual perderás");
        do{
            System.out.println("Elegir una opcion ");
            System.out.println("Presiona 1 y luego Enter si quieres jugar");
            System.out.println("Presiona 2 y luego Enter si quieres salir");
            System.out.println("==================");
            System.out.println("Usted tiene " + C1.dinero);
            System.out.println("1.-JUGAR");
            System.out.println("2.SALIR");
            opcion=br.readLine();

            switch(Integer.parseInt(opcion)){

                case 1:
                    System.out.println("Cuanto apuesta");
                    System.out.println("==============");
                    C1.apuesta=Integer.parseInt(br.readLine());
                        if(C1.apuesta>C1.dinero || C1.apuesta<0){
                            System.out.println("Apuesta invalida");
                            break;
                    }
                         else{
                            C1.Juego();
                            break;
                    }
                case 2:
                    System.out.println("Usted se retira con: " + C1.dinero);
                    System.exit(0);
            }
        }while(!opcion.equals("2"));

    }

}

==============================================
Aquí unas capturas para que vean el código en ejecución :


viernes, 22 de abril de 2011

FACTORES PRIMOS DE UN NUMERO

En este ejercicio se trata de descomponer un numero en sus factores primos , lo cual
 se puede lograr con un bucle for y dentro de este un bucle while, además se hizo uso
 de un for dentro de este para detener el conteo luego de que el número llegue e ser 
uno , puesto que no tiene sentido seguir dividiendo.


============================================================
import java.io.*;

public class FactoresPrimos {

    int numero;
  
    //CONSTRUCTOR DE LA CLASE
    public FactoresPrimos(int prueba){
        numero=prueba;
    }
    //MÉTODO QUE CALCULARA LOS FACTORES
    public void factores(int numero1){

        for(int i=2;i<numero1;i++){

            while(numero%i==0){
                numero=numero/i;
                System.out.print(i+"  ");
              //Para evitar hacer cálculos innecesarios :
                 if(numero==1){
                    System.exit(0);
                }
            }
        }

    }
    //METODO PRINCIPAL
    public static void main(String[]args)throws IOException{

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingrese el numero: ");
        int num=Integer.parseInt(br.readLine());
        FactoresPrimos FP1=new FactoresPrimos(num);
        System.out.println("Los factores primos son:");
        FP1.factores(num);


    }

}
=========================================================

He aquí la simulación :





viernes, 8 de abril de 2011

INTRODUCCIÓN A OBJETOS PARTE III

En este ejercicio seguiré tratando de introducirlos al tratamiento de objetos en java
sin tocar todavía el tema de herencia , tal vez lo mas importante sea tomar un array
como variable de instancia o como parámetro en un método, como verán el ejercicio
está orientado a dividir un problema en pequeños sub-problemas más sencillos de 
resolver. El ejercicio trata de encontrar los promedios aritméticos , geométricos y 
armónicos de un array con números del tipo double .

======================================================


import java.io.*;

public class Promedios {
    //VARIABLES DE INSTANCIA
    int cantidad_Numeros;
    double matriz[];
    //CONSTRUCTOR
    public Promedios(int cantidad){
        cantidad_Numeros=cantidad;
        matriz=new double[cantidad];
      
    }
    //MÉTODO PARA CALCULAR EL PROMEDIO ARITMÉTICO
    public double Promedio_Aritmetico(double matriz1[]){
        double suma=0;
        double promedio=0;
        for(int i=0;i<=matriz1.length-1;i++){
            suma=suma+matriz1[i];
        }
        promedio=suma/matriz1.length;
        return promedio;
    }
    //MÉTODO PARA CALCULAR EL PROMEDIO GEOMÉTRICO
    public double Promedio_geometrico(double matriz2[]){
        double acumulado=1;
        double promedio=0;
        for(int i=0;i<=matriz2.length-1;i++){
            acumulado=acumulado*matriz2[i];
        }
        promedio=Math.pow(acumulado,1.0/matriz2.length );
        return promedio;
    }
    //MÉTODO PARA CALCULAR EL PROMEDIO ARMÓNICO
    public double Promedio_armonico(double matriz3[]){
      
        double acumulado=0;
        double promedio=0;
        for(int i=0;i<=matriz3.length-1;i++){
            acumulado=acumulado+(1/matriz3[i]);
        }
        promedio=matriz.length/acumulado;
        return promedio;
    }
    public void terminar(){
        System.exit(0);
    }
    //MÉTODO MAIN
    public static void main(String[]args)throws IOException{

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Cuantos numeros va a ingresar");
        int numeros=Integer.parseInt(br.readLine());
        //CREAMOS EL OBJETO, UNA VEZ DEFINIDO EL TAMAÑO DEL 
        //ARRAY 
        Promedios P1=new Promedios(numeros);
        for(int i=0;i<P1.matriz.length;i++){
            System.out.println("Ingrese el numero "+ i );
            P1.matriz[i]=Double.parseDouble(br.readLine());
        }
        //ACCEDEMOS A LOS MÉTODOS MEDIANTE EL OBJETO
        double PA=P1.Promedio_Aritmetico(P1.matriz);
        double PG=P1.Promedio_geometrico(P1.matriz);
        double PH=P1.Promedio_armonico(P1.matriz);
        System.out.println("===============================");
        System.out.println("El promedio aritmetico es: "+ PA);
        System.out.println("===============================");
        System.out.println("El promedio geometrico es: "+ PG);
        System.out.println("===============================");
        System.out.println("El promedio armonico es: " + PH );
        System.out.println("===============================");

    }


}

================================================

Aquí una simulación :


jueves, 7 de abril de 2011

INTRODUCCIÓN A OBJETOS PARTE II

En el siguiente ejemplo crearemos una clase llamada Triángulo , el cual utilizará tres
objetos de la clase Punto además de tres objetos de la clase Línea, veremos como
instanciaremos estos seis objetos en nuestro constructor ,ademas utilizaremos dos 
métodos de la clase Linea como son longitud y pendiente , los métodos de la clase
Triángulo que usaremos son esTriángulo( ) y area() .

=======================================================


import java.io.*;

    public class Triangulo{

        Punto P1=null;
        Punto P2=null;
        Punto P3=null;
        Linea L1=null;
        Linea L2=null;
        Linea L3=null;
        //Constructor de la clase Triángulo
        public Triangulo(Punto Punto1,Punto Punto2,Punto Punto3){
            P1=Punto1;
            P2=Punto2;
            P3=Punto3;
            L1=new Linea(P1,P2);
            L2=new Linea(P1,P3);
            L3=new Linea(P2,P3);
        }
         //metodo que reconoce si los tres puntos forman un Triángulo o no
         boolean esTriangulo(){
            boolean triangulo=true;
            double m1=L1.pendiente();
            double m2=L2.pendiente();
            double m3=L3.pendiente();
                if(m1==m2 || m1==m3 || m2==m3){
                    triangulo=false;
                    }
                else{
                    triangulo=true;
                }
            return triangulo;
        }
        //método que calcula el área del Triángulo
         double area(){
            if(esTriangulo()==true){
                double lon1=L1.longitudLinea();
                double lon2=L2.longitudLinea();
                double lon3=L3.longitudLinea();
                double s=(lon1+lon2+lon3)/2;
                double area_T=Math.sqrt(s*(s-lon1)*(s-lon2)*(s-lon3));
                return area_T;
                }
            else{
                return 0;
            }
         }
        public static void main(String[]args)throws IOException{
          
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            System.out.println("========================================");
            System.out.println("Ingrese las coordenadas del primer punto");
            System.out.println("========================================");
            System.out.println("Ingrese la coordenada X");
            double x1=Double.parseDouble(br.readLine());
            System.out.println("Ingrese la coordenada Y");
            double y1=Double.parseDouble(br.readLine());
            System.out.println("=========================================");
            System.out.println("Ingrese las coordenadas del segundo punto");
            System.out.println("=========================================");
            System.out.println("Ingrese la cooordenada X");
            double x2=Double.parseDouble(br.readLine());
            System.out.println("Ingrese la coordenada Y");
            double y2=Double.parseDouble(br.readLine());
            System.out.println("========================================");
            System.out.println("Ingrese las coordenadas del tercer punto");
            System.out.println("========================================");
            System.out.println("Ingrese la coordenada X");
            double x3=Double.parseDouble(br.readLine());
            System.out.println("Ingrese la coordenada Y");
            double y3=Double.parseDouble(br.readLine());
            System.out.println("========================================");

            Punto PA=new Punto(x1,y1);
            Punto PB=new Punto(x2,y2);
            Punto PC=new Punto(x3,y3);

            Triangulo T1=new Triangulo(PA,PB,PC);
            System.out.println("EL AREA DEL TRIANGULO ES: " + T1.area());

          


        }

    }

INTRODUCCIÓN A OBJETOS PARTE I

Es bien sabido que todo el potencial de java radica en la programación orientada a 
objetos,el cual se traduce en crear clases que nos puedan servir de referencia para 
otras clases futuras,es decir reutilizar nuestro código lo cual nos permitirá ser más
eficientes en nuestro trabajo.
En este primer ejemplo, crearemos una clase llamada Punto el cual tendrá dos 
variables de instancia además de un constructor, que nos servirá para las clases
Línea y Triángulo. 

======================================================

public class Punto {

    double x=0;
    double y=0;

    public Punto(double CorX,double CorY){
      x=CorX;
      y=CorY;
    }
}
======================================================

Luego crearemos una clase Línea ,el cual como sabemos esta compuesta por dos
puntos , es decir usaremos como variables de instancia dos objetos de la clase
Punto. Aquí el código :

======================================================
import java.io.*;
public class Linea {

    Punto Punto1=null;
    Punto Punto2=null;
    
    //Constructor de la clase Linea, observar como iniciamos los dos puntos que declaramos lineas arriba.
    public Linea(Punto P01,Punto P02 ){
              Punto1=P01;
              Punto2=P02;
    }
   
    //metodo que reconoce si los dos puntos no son los mismos 
    //Si los puntos son iguales no se podra formar una linea
    boolean esLinea(){
        boolean resultado=true;
        if(Punto1.x==Punto2.x && Punto1.y==Punto2.y ){
            resultado=false;
        }
        else{
            resultado=true;
        }
            return resultado;
    }
    //método para calcular la longitud de la linea
    double longitudLinea(){

        double longitud=0;
        if(esLinea()==true){
            longitud=Math.sqrt(Math.pow(Punto2.x-Punto1.x, 2) + Math.pow(Punto2.y -Punto1.y,2) );
        }
        else{
            System.out.println("No es una linea");
            System.exit(0);
        }
        return longitud;
    }

    double pendiente(){

        double m=(Punto2.y-Punto1.y)/(Punto2.x-Punto1.x);
        return m;

    }
    

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

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));

        try {
        System.out.println("Ingrese las coordenadas del punto A: ");
        System.out.println("Ingrese el valor de x");
        double X1=Double.parseDouble(br.readLine());
        System.out.println("Ingrese el valor de y");
        double Y1=Double.parseDouble(br.readLine());
        Punto PA=new Punto(X1,Y1);//creamos el objeto Punto A

        System.out.println("Ingrese las coordenadas del punto B: ");
        System.out.println("Ingrese el valor de x");
        double X2=Double.parseDouble(br.readLine());
        System.out.println("Ingrese el valor de y");
        double Y2=Double.parseDouble(br.readLine());
        Punto PB=new Punto(X2,Y2);//Creamos el objeto Punto B

        //Con los dos puntos podemos crear una linea
        Linea L1=new Linea(PA,PB);

        double longitud= L1.longitudLinea();
        double pendienteLinea=L1.pendiente();
        System.out.println("La longitud de la linea es: " + longitud);
        System.out.println("La pendiente de la linea es: " + pendienteLinea);
    }catch(NumberFormatException e){
        System.out.println("Error en la entrada de datos " + e.getMessage());
    }
    
    }
}

===================================================
Aquí vemos que hemos creado nuestra clase Línea , y hemos usado dos 
objetos de la clase Punto para crear un objeto de la clase Linea, además de 
crear otros métodos como Longitud de la Línea o la pendiente de la misma.

Aquí la simulación:




lunes, 28 de marzo de 2011

CAMBIO DE BASE PARTE II

En este ejercicio , lo que se hizo fue simplemente agregarle un if y algunos else if para los casos en los cuales la base destino es mayor que 10 , si quisieran aumentar las bases disponibles pues simplemente le agregarian otro else if .

=======================================================

import java.io.*;

public class Cambio_base {

    public static void main(String[]args)throws IOException{
        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("Ingresar el numero en base 10 :");
        int numero=Integer.parseInt(br.readLine());
        System.out.println("Ingresar la base numerica a convertir:");
        int base=Integer.parseInt(br.readLine());
        String resultado1="";
        String salida="";
        while(numero>=base){
           int resto=numero%base;
           numero=numero/base;
           if(resto<10){
               resultado1=resultado1+resto;
           }
           else if(resto==10){
               resultado1=resultado1+"A";
           }
           else if(resto==11){
               resultado1=resultado1+"B";
           }
           else if(resto==12){
               resultado1=resultado1+"C";
           }
           else if(resto==13){
               resultado1=resultado1+"D";
           }
           else if(resto==14){
               resultado1=resultado1+"E";
           }
           else if(resto==15){
               resultado1=resultado1+"F";
           }


        }
         resultado1=resultado1+String.valueOf(numero);
         for(int i=resultado1.length()-1;i>=0;i--){
             salida=salida+resultado1.charAt(i);
         }
        System.out.println("El numero en base " + base +" es:");
        System.out.println(salida);
    }

}

========================================================

Aqui una demostracion :


domingo, 27 de marzo de 2011

CAMBIO DE BASE , MENORES QUE 10

En este ejemplo se ingresa un numero en base 10 y luego la base a la que se convertirá , con el limitante que esta debe ser menor que 10 ,aún así este código puede ser de ayuda.

==========================================================
import java.io.*;

public class CambioDeBase {

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

        BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
        System.out.println("*************CAMBIO DE BASE***************");
        System.out.println("==========================================");
        System.out.println("ingrese el numero en base diez: ");
        int numero=Integer.parseInt(br.readLine());
        System.out.println("base numerica final");
        int base=Integer.parseInt(br.readLine());
        String resto2="";
        String salida="";
        while(numero>=base){
            int resto=numero%base;
            numero=numero/base;
            String resto1=String.valueOf(resto);
            resto2=resto2+resto1;
        }
        resto2=resto2+String.valueOf(numero);
      
        for(int i=resto2.length()-1; i>=0 ;i--){
            salida=salida+resto2.charAt(i);
        }
        System.out.println("El numero en base " + base + " es: ");
        System.out.println(salida);
    }
}
=========================================================


sábado, 26 de marzo de 2011

EJEMPLO DE AWT

En este ejemplo , vamos a crear una pequeña aplicación que nos calculara el área y el perímetro de un triangulo , introduciendo primero los tres vértices de un triangulo cualquiera, hemos heredado de Frame
ademas implementando WindowsListener, ActionListener, KeyListener para gestionar los eventos de los
botones.
==================================================================
import java.awt.*;
import java.awt.event.*;

public class DibujoPrueba extends Frame implements WindowListener,ActionListener,KeyListener {

    //ELEMENTOS DE NUESTRO FRAME
    private Label L1,L2,L3,L4,L5=null;
    private Label V1,V2,V3,V4,V5,V6=null;
    private TextField T1,T2,T3,T4,T5,T6,T7,T8=null;
    private Button calculo=null;
    private Button limpio=null;
  
    //CONSTRUCTORES
    public DibujoPrueba(){
        super();
        configurarFrame();
    }
    public DibujoPrueba(String titulo){
        super(titulo);
        configurarFrame();
    }
    public void keyPressed(KeyEvent e){

        Object ob=e.getSource();
        char tecla=e.getKeyChar();
        if(ob.equals(T1)){
            if(tecla=='\n'){
                T2.requestFocus();
            }
        }
        if(ob.equals(T2)){
            if(tecla=='\n'){
                T3.requestFocus();
            }
        }
        if(ob.equals(T3)){
            if(tecla=='\n'){
                T4.requestFocus();
            }
        }
        if(ob.equals(T4)){
            if(tecla=='\n'){
                T5.requestFocus();
            }
        }
        if(ob.equals(T5)){
            if(tecla=='\n'){
                T6.requestFocus();
            }
        }
        if(ob.equals(T6)){
            if(tecla=='\n'){
                calcular();
            }
        }
    }
    public void keyReleased(KeyEvent e){}
    public void keyTyped(KeyEvent e){}

    public void aclarar(){
        T1.setText("");
        T2.setText("");
        T3.setText("");
        T4.setText("");
        T5.setText("");
        T6.setText("");
        T7.setText("");
        T8.setText("");
    }

    public void calcular(){
        double x1=0;
        double y1=0;
        double x2=0;
        double y2=0;
        double x3=0;
        double y3=0;

        x1=Double.valueOf(T1.getText()).doubleValue();
        y1=Double.valueOf(T2.getText()).doubleValue();
        x2=Double.valueOf(T3.getText()).doubleValue();
        y2=Double.valueOf(T4.getText()).doubleValue();
        x3=Double.valueOf(T5.getText()).doubleValue();
        y3=Double.valueOf(T6.getText()).doubleValue();

        double area=Math.abs((0.5)*(y1*(x2-x3) + y2*(x3-x1) + y3*(x1-x2)));
        double lado1=Math.sqrt((x1-x2)*(x1-x2) + (y1-y2)*(y1-y2));
        double lado2=Math.sqrt((x2-x3)*(x2-x3) + (y2-y3)*(y2-y3));
        double lado3=Math.sqrt((x1-x3)*(x1-x3) + (y1-y3)*(y1-y3));
        double perimetro=lado1+lado2+lado3;

        T7.setText(String.valueOf(area));
        T8.setText(String.valueOf(perimetro));
              
    }

    public void actionPerformed(ActionEvent e){
        Object ob=e.getSource();
        if(ob.equals(calculo)){
            calcular();
        }
        else if(ob.equals(limpio)){
            aclarar();
        }
    }

    public static void main(java.lang.String[]args){
        DibujoPrueba D1=new DibujoPrueba();
        D1.show();
    }
    private void configurarFrame(){
        this.addWindowListener(this);
        this.setLayout(null);
        this.setBackground(Color.BLUE);
        this.setResizable(true);

        L1=new Label("VERTICE 1");
        L1.setBounds(20,40,70,20);
        add(L1);

        L2=new Label("VERTICE 2");
        L2.setBounds(20,60,70,20);
        add(L2);

        L3=new Label("VERTICE 3");
        L3.setBounds(20,80,70,20);
        add(L3);

        L4=new Label("AREA");
        L4.setBounds(20,120,70,20);
        add(L4);

        L5=new Label("PERIMETRO");
        L5.setBounds(20,140,80,20);
        add(L5);

        V1=new Label("X1");
        V1.setBounds(160,40,100,20);
        add(V1);

        V2=new Label("Y1");
        V2.setBounds(450,40,100,20);
        add(V2);

        V3=new Label("X2");
        V3.setBounds(160,60,100,20);
        add(V3);

        V4=new Label("Y2");
        V4.setBounds(450,60,100,20);
        add(V4);

        V5=new Label("X3");
        V5.setBounds(160,80,100,20);
        add(V5);

        V6=new Label("Y3");
        V6.setBounds(450,80,100,20);
        add(V6);

        T1=new TextField();
        T1.setBounds(270,40,80,20);
        T1.addKeyListener(this);
        add(T1);

        T2=new TextField();
        T2.setBounds(560,40,80,20);
        T2.addKeyListener(this);
        add(T2);

        T3=new TextField();
        T3.setBounds(270,60,80,20);
        T3.addKeyListener(this);
        add(T3);

        T4=new TextField();
        T4.setBounds(560,60,80,20);
        T4.addKeyListener(this);
        add(T4);

        T5=new TextField();
        T5.setBounds(270,80,80,20);
        T5.addKeyListener(this);
        add(T5);

        T6=new TextField();
        T6.setBounds(560,80,80,20);
        T6.addKeyListener(this);
        add(T6);

        T7=new TextField();
        T7.setBounds(140,120,100,20);
        T7.addKeyListener(this);
        add(T7);

        T8=new TextField();
        T8.setBounds(140,140,100,20);
        T8.addKeyListener(this);
        add(T8);

        calculo=new Button("CALCULAR");
        calculo.setBounds(20,160,100,20);
        calculo.addActionListener(this);
        add(calculo);

        limpio=new Button("RESET");
        limpio.setBounds(20,180,100,20);
        limpio.addActionListener(this);
        add(limpio);

        setSize(700,210);
        setLocation(200,200);

    }
    public void windowActivated(WindowEvent e){}
    public void windowClosed(WindowEvent e){}
    public void windowClosing(WindowEvent e){
        Window w=e.getWindow();
        if(w.equals(this)){
            this.dispose();
            System.exit(0);
        }
    }
    public void windowDeactivated(WindowEvent e){}
    public void windowDeiconified(WindowEvent e){}
    public void windowIconified(WindowEvent e){}
    public void windowOpened(WindowEvent e){}
}

============================================================


Aqui , podemos ver el resultado de nuestro pequeño codigo.