Programa Hades

Simple Simulador de circuitos electrónicos, que incorpora herramientas bastante útiles. Para descargarlo presione AQUI.

¿Qué es una Excepción y qué cuidados debo tener?

El término excepción es un forma corta da la frase "suceso excepcional". Muchas clases de errores pueden utilizar excepciones -- desde serios problemas de hardware, como la avería de un disco duro, a los simples errores de programación, como tratar de acceder a un elemento de un array fuera de sus límites. Cuando
dicho error ocurre dentro de un método Java, el método crea un objeto 'exception' y lo maneja fuera, en el sistema de ejecución. Este objeto contiene información sobre la excepción, incluyendo su tipo y el estado del programa cuando ocurrió el error. El sistema de ejecución es el responsable de buscar algún código para
manejar el error. En terminología java, crear una objeto exception y manejarlo por el sistema de ejecución se llama lanzar una excepción. Después de que un método lance una excepción, el sistema de ejecución entra en acción para buscar el manejador de la excepción. El conjunto de "algunos" métodos posibles para manejar la excepción es el conjunto de métodos de la pila de llamadas del método donde ocurrió el error. El sistema de ejecución busca hacia atrás en la pila de llamadas, empezando por el método en el que ocurrió el error, hasta que encuentra un método que contiene el "manejador de excepción" adecuado. Un manejador de excepción es considerado adecuado si el tipo de la excepción lanzada es el mismo que el de la excepción manejada por el manejador. Así la excepción sube sobre la pila de llamadas hasta que encuentra el manejador
apropiado y una de las llamadas a métodos maneja la excepción, se dice que el manejador de excepción elegido captura la excepción. Si el sistema de ejecución busca exhaustivamente por todos los métodos de la pila de llamadas sin encontrar el manejador de excepción adecuado, el sistema de ejecución finaliza.

Manejo de Errores utilizando Excepciones

Existe una regla de oro en el mundo de la programación: en los programas ocurren errores. Esto es sabido. Pero ¿qué sucede realmente después de que ha ocurrido el error? ¿Cómo se maneja el error? ¿Quién lo maneja?, ¿Puede recuperarlo el programa?
El lenguaje Java utiliza excepciones para proporcionar capacidades de manejo de errores. En esta lección aprenderás qué es una excepción, cómo lanzar y capturar excepciones, qué hacer con una excepción una vez capturada, y cómo hacer un mejor uso de las excepciones heredadas de las clases proporcionadas por el
entorno de desarrollo de Java.

Uso de Exception III

// Demostración de getMessage y printStackTrace de la clase Exception.
public class UsoExcepciones {

   public static void main( String args[] )
   {
      try {
         metodo1(); // llamar a metodo1
      }

      // atrapar las excepciones lanzadas desde metodo1
      catch ( Exception excepcion ) {
         System.err.println( excepcion.getMessage() + "\n" );
         excepcion.printStackTrace();

         // obtener la información de rastreo de la pila
         StackTraceElement[] elementosRastreo = excepcion.getStackTrace();
        
         System.out.println(  "\nRastreo de pila proveniente de getStackTrace:" );
         System.out.println( "Clase\t\tArchivo\t\t\tLinea\tMetodo" );

         // iterar a través de elementosRastreo para obtener descripción de las excepciones
         for ( int i = 0; i < elementosRastreo.length; i++ ) {
            StackTraceElement elementoActual = elementosRastreo[ i ];
            System.out.print( elementoActual.getClassName() + "\t" );
            System.out.print( elementoActual.getFileName() + "\t" );
            System.out.print( elementoActual.getLineNumber() + "\t" );
            System.out.print( elementoActual.getMethodName() + "\n" );
        
         } // fin de la instrucción for

      } // fin de la instrucción catch

   } // fin del método main

   // llamar a metodo2; lanzar excepciones de vuelta hacia main
   public static void metodo1() throws Exception
   {
      metodo2();
   }

   // llamar al método3; lanzar excepciones de vuelta hacia metodo1
   public static void metodo2() throws Exception
   {
      metodo3();
   }

   // lanzar excepción de vuelta a metodo2
   public static void metodo3() throws Exception
   {
      throw new Exception( "La excepcion se lanzo en metodo3" );
   }

} // fin de la clase UsoExcepciones

Uso de Exception II

// Demostración de la limpieza de la pila.
public class UsoExcepciones {

   public static void main( String args[] )
   {
      // llamar a lanzaExcepcion para demostrar la limpieza de la pila
      try {
         lanzaExcepcion();
      }

      // atrapar excepción lanzada en lanzaExcepcion
      catch ( Exception excepcion ) {
         System.err.println( "La excepcion se manejo en main" );
      }
   }

   // lanzaExcepcion lanza la excepción que no es atrapada en este método
   public static void lanzaExcepcion() throws Exception
   {
      // lanzar una excepción y atraparla en main
      try {
         System.out.println( "El metodo lanzaExcepcion" );
         throw new Exception();      // generar excepción
      }

      // catch es del tipo incorrecto, por lo que la excepción no es atrapada
      catch( RuntimeException excepcionTiempoEjecucion ) {
         System.err.println(
            "La excepcion se manejo en el metodo lanzaExcepcion" );
      }

      // la cláusula finally siempre se ejecuta
      finally {
         System.err.println( "Finally siempre se ejecuta" );
      }

   } // fin del método lanzaExcepcion

}

Uso de Exceptions I

// Demostración del mecanismo try-catch-finally para manejar excepciones.
public class UsoExcepciones {

   public static void main( String args[] )
   {
      try {
         lanzarExcepcion(); // llamar al método lanzarExcepcion
      }

      // atrapar excepciones lanzadas por el método lanzarExcepcion
      catch ( Exception excepcion ) {
         System.err.println( "La excepcion se manejo en main" );
      }

      noLanzaExcepcion();
   }

   // demostrar try/catch/finally
   public static void lanzarExcepcion() throws Exception
   {
      // lanzar una excepción y atraparla inmediatamente
      try {
         System.out.println( "El metodo lanzarExcepcion" );
         throw new Exception();  // generar excepción
      }

      // atrapar la excepción lanzada en el bloque try
      catch ( Exception excepcion ) {
         System.err.println(
            "La excepcion se manejo en el metodo lanzarExcepcion" );
         throw excepcion;  // volver a lanzar para procesarla posteriormente

         // cualquier código aquí no llegaría a ejecutarse
      }

      // este bloque se ejecuta, sin importar lo que ocurra en try/catch
      finally {
         System.err.println( "Finalmente se ejecuto en lanzarExcepcion" );
      }

      // cualquier código aquí no llegaría a ejecutarse

   } // fin del método lanzarExcepcion

   // demostrar finally cuando no ocurre excepción
   public static void noLanzaExcepcion()
   {
      // el bloque try no lanza una excepción
      try {
         System.out.println( "El metodo noLanzaExcepcion" );
      }

      // catch no se ejecuta, porque no se lanzó una excepción
      catch( Exception excepcion ) {
         System.err.println( excepcion );
      }

      // la cláusula this se ejecuta, sin importar lo que ocurra en try/catch
      finally {
         System.err.println(
            "Finalmente se ejecuto en noLanzaExcepcion" );
      }

      System.out.println( "Fin del metodo noLanzaExcepcion" );

   } // fin del método noLanzaExcepcion

} // fin de la clase UsoExcepciones

Juego Marcianitos

Aquí tienen un juego bastante primitivo que me encontré el la web, también les puede servir si revisan el código.

Demostracion Apariencia visual basica

// Cambio de la apariencia visual.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class DemoAparienciaVisual extends JFrame {
   private final String cadenas[] = { "Metal", "Motif", "Windows" };
   private UIManager.LookAndFeelInfo apariencias[];
   private JRadioButton opcion[];
   private ButtonGroup grupo;
   private JButton boton;
   private JLabel etiqueta;
   private JComboBox cuadroCombinado;
String s1="";
   // configurar la GUI
   public DemoAparienciaVisual()
   {
      super( "Demo de apariencia visual" );

      Container contenedor = getContentPane();

      // establecer panel para región NORTH de esquema BorderLayout
      JPanel panelNorte = new JPanel();
      panelNorte.setLayout( new GridLayout( 3, 1, 0, 5 ) );

      // establecer etiqueta para panel NORTH
      etiqueta = new JLabel( "Ésta es la apariencia visual Metal seleccionada",
         SwingConstants.CENTER );
      panelNorte.add( etiqueta );

      // establecer botón para panel NORTH
      boton = new JButton( "JButton" );
      panelNorte.add( boton );

      // establecer cuadro combinado para panel NORTH
      cuadroCombinado = new JComboBox( cadenas );
      panelNorte.add( cuadroCombinado );
    
      // crear arreglo para botones de opción
      opcion = new JRadioButton[ cadenas.length ];

      // establecer panel para región SOUTH de esquema BorderLayout
      JPanel panelSur = new JPanel();
      panelSur.setLayout( new GridLayout( 1, opcion.length ) );

      // establecer botones de opción para panel SOUTH
      grupo = new ButtonGroup();
      ManejadorEventos manejador = new ManejadorEventos();

      for ( int cuenta = 0; cuenta < opcion.length; cuenta++ ) {
         opcion[ cuenta ] = new JRadioButton( cadenas[ cuenta ] );
         opcion[ cuenta ].addItemListener( manejador );
         grupo.add( opcion[ cuenta ] );
         panelSur.add( opcion[ cuenta ] );
      }

      // adjuntar paneles NORTH y SOUTH al panel de contenido
      contenedor.add( panelNorte, BorderLayout.NORTH );
      contenedor.add( panelSur, BorderLayout.SOUTH );

      // obtener información de la apariencia visual instalada
      apariencias = UIManager.getInstalledLookAndFeels();

      setSize( 300, 200 );
      setVisible( true );

      opcion[ 0 ].setSelected( true );

   } // fin del constructor de DemoAparienciaVisual

   // usar UIManager para cambiar la apariencia visual de la GUI
   private void cambiarLaAparienciaVisual( int valor )
   {
      // cambiar la apariencia visual
      try {
         UIManager.setLookAndFeel( apariencias[ valor ].getClassName() );
         SwingUtilities.updateComponentTreeUI( this );
         s1= apariencias[ valor ].getClassName();
      }

      // procesar problemas al cambiar la apariencia visual
      catch ( Exception excepcion ) {
         excepcion.printStackTrace();
      }
   }

   public static void main( String args[] )
   {
      DemoAparienciaVisual aplicacion = new DemoAparienciaVisual();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

   // clase interna privada para manejar eventos de botones de opción
   private class ManejadorEventos implements ItemListener {

      // procesar selección de apariencia visual del usuario
      public void itemStateChanged( ItemEvent evento )
      {
         for ( int cuenta = 0; cuenta < opcion.length; cuenta++ )

            if ( opcion[ cuenta ].isSelected() ) {
               etiqueta.setText( "Ésta es la apariencia visual " +
                  s1 + " seleccionada"+cuenta );
               cuadroCombinado.setSelectedIndex( cuenta );
               cambiarLaAparienciaVisual( cuenta );
            }
      }

   } // fin de la clase interna privada ManejadorEventos

} // fin de la clase DemoAparienciaVisual

Uso JTextArea

// Cómo copiar texto seleccionado de un área de texto a otra.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class DemoAreaTexto extends JFrame
{
   private JTextArea areaTexto1, areaTexto2;
   private JButton botonCopiar;

   // configurar GUI
   public DemoAreaTexto()
   {
      super( "Demostración de JTextArea" );

      Box cuadro = Box.createHorizontalBox();

      String cadena = "Ésta es una cadena de\ndemostración para\n" +
         "ilustrar cómo copiar texto\nde un área de texto a \n" +
         "otra, utilizando un\nevento externo";

      // establecer areaTexto1
      areaTexto1 = new JTextArea( cadena, 10, 15 );
      cuadro.add( new JScrollPane( areaTexto1 ) );

      // establecer botonCopiar
      botonCopiar = new JButton( "Copiar >>>" );
      cuadro.add( botonCopiar );
      botonCopiar.addActionListener(

         new ActionListener() {  // clase interna anónima

            // establecer en areaTexto2 el texto seleccionado de areaTexto1
            public void actionPerformed( ActionEvent evento )
            {
               areaTexto2.append( areaTexto1.getSelectedText() );
            }

         } // fin de la clase interna anónima

      ); // fin de la llamada a addActionListener

      // establecer areaTexto2
      areaTexto2 = new JTextArea( 10, 15 );
      areaTexto2.setEditable( false );
      cuadro.add( new JScrollPane( areaTexto2 ) );

      // agregar cuadro al panel de contenido
      Container contenedor = getContentPane();
      contenedor.add( cuadro );   // colocar en in BorderLayout.CENTER

      setSize( 425, 200 );
      setVisible( true );

   } // fin del constructor de DemoAreaTexto

   public static void main( String args[] )
   {
      JFrame.setDefaultLookAndFeelDecorated(true);
      DemoAreaTexto aplicacion = new DemoAreaTexto();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

} // fin de la clase DemoAreaTexto

Manejo basico del teclado

// Demostración de los eventos de pulsación de tecla.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class DemoTeclas extends JFrame implements KeyListener {
   private String linea1 = "", linea2 = "", linea3 = "";
   private JTextArea areaTexto;

   // configurar GUI
   public DemoTeclas()
   {
      super( "Demostración de eventos de pulsación de tecla" );

      // establecer objeto JTextArea
      areaTexto = new JTextArea( 10, 15 );
      areaTexto.setText( "Oprima cualquier tecla en el teclado..." );
      areaTexto.setEnabled( false );
      areaTexto.setDisabledTextColor( Color.blue );
      getContentPane().add( areaTexto );

      addKeyListener( this );  // permitir al marco procesar eventos de teclas
     
      setSize( 350, 100 );
      setVisible( true );

   } // fin del constructor de DemoTeclas

   // manejar evento de pulsación de cualquier tecla
   public void keyPressed( KeyEvent evento )
   {
      linea1 = "Se oprimió tecla: " + evento.getKeyText( evento.getKeyCode() );
      establecerLineas2y3( evento );
   }

   // manejar evento de liberación de cualquier tecla
   public void keyReleased( KeyEvent evento )
   {
      linea1 = "Se soltó tecla: " + evento.getKeyText( evento.getKeyCode() );
      establecerLineas2y3( evento );
   }

   // manejar evento de pulsación de una tecla de acción
   public void keyTyped( KeyEvent evento )
   {
      linea1 = "Se escribió tecla: " + evento.getKeyChar();
      establecerLineas2y3( evento );
   }

   // establecer segunda y tercera líneas de salida
   private void establecerLineas2y3( KeyEvent evento )
   {
      linea2 = "Esta tecla " + ( evento.isActionKey() ? "" : "no " ) +
         "es una tecla de acción";

      String temp = evento.getKeyModifiersText( evento.getModifiers() );

      linea3 = "Teclas modificadoras oprimidas: " +
         ( temp.equals( "" ) ? "ninguna" : temp );

      areaTexto.setText( linea1 + "\n" + linea2 + "\n" + linea3 + "\n" );
   }

   public static void main( String args[] )
   {
      JFrame.setDefaultLookAndFeelDecorated(true);
      DemoTeclas aplicacion = new DemoTeclas();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

} // fin de la clase DemoTeclas

Manejo basico del mouse

// Demostración de los clics de ratón y cómo diferenciar entre los botones del ratón.
import java.awt.*;
import java.awt.event.*;
import javax.swing.*;
public class DetallesRaton extends JFrame
{
   private int xPos, yPos;
   // establecer cadena barra título; registrar escucha ratón; ajustar tamaño y mostrar ventana
   public DetallesRaton()
   {
      super( "Clics y botones del ratón" );

      getContentPane().addMouseListener( new ManejadorClicsRaton() );

      setSize( 350, 150 );
      setVisible( true );
   }

   // dibujar objeto String en la ubicación donde se hizo clic con el ratón
   public void paint( Graphics g )
   {
      // llamar al método paint de la superclase
      super.paint( g );

      g.drawString( "Se hizo clic en: [" + xPos + ", " + yPos + "]",
         xPos, yPos );
   }

   public static void main( String args[] )
   {
      JFrame.setDefaultLookAndFeelDecorated(true);
      DetallesRaton aplicacion = new DetallesRaton();
      aplicacion.setDefaultCloseOperation( JFrame.EXIT_ON_CLOSE );
   }

   // clase interna para manejar eventos de ratón
   private class ManejadorClicsRaton extends MouseAdapter {

      // manejar evento de clic del ratón y determinar cuál botón se oprimió
      public void mouseClicked(MouseEvent evento)
      {
         xPos = evento.getX();
         yPos = evento.getY();

         String titulo = "Se hizo clic " + evento.getClickCount() + " Veces";
     
         if ( evento.isMetaDown() )  // botón derecho del ratón
            titulo += " con el botón derecho del ratón";
     
         else if ( evento.isAltDown() )  // botón de en medio del ratón
            titulo += " con el botón central del ratón";
     
         else  // botón izquierdo del ratón                      
            titulo += " con el botón izquierdo del ratón";

         setTitle( titulo );  // establecer barra de título de la ventana
         repaint();

      } // fin del método mouseClicked

   } // fin de la clase interna privada ManejadorClicsRaton

} // fin de la clase DetallesRaton

Arbol general

class Nodo {
    int dato;
    Nodo hermanoDer;
    Nodo hijoIzq;
    public Nodo(int dato,Nodo hd, Nodo hi){
        this.dato=dato;
        this.hermanoDer=hd;
        this.hijoIzq=hi;


    }
}

public class ArbolGeneral {
    //Atributos
    private Nodo laRaiz;

    public ArbolGeneral(){
        this.laRaiz=null;
    }

    //Metodos
    public boolean sonIguales(Nodo laRaiz){
        return SonIguales(laRaiz,this.laRaiz);

    }
    public boolean Agregar(String elPath,int elDato){
        if(laRaiz == null) {
            laRaiz = new Nodo(elDato,null,null);
            return true;
        }else{
            Nodo tmp = buscaNodo(elPath);
            if(tmp == null)
                return false;
            else
                return AgregaHermano(tmp,elDato);
        }
    }
    private Nodo buscaNodo(String elPath){
        Nodo tmp1= laRaiz;
        Nodo tmp2 = tmp1;
        StringTokenizer path = new StringTokenizer(elPath,"/");
        int s;
        while(path.hasMoreTokens()){
            s = Integer.parseInt(path.nextToken());
            while(tmp1 !=null){
                if(s== tmp1.dato)
                    break;
                else {
                    tmp2 = tmp1 = tmp1.hermanoDer;
                }
            }
            if(tmp1 == null)
                return tmp1;
            else{
                tmp2 = tmp1;
                tmp1 = tmp1.hijoIzq;
            }
        }
        return tmp2;
    }
    private boolean AgregaHermano(Nodo elPadre, int elDato){
        Nodo tmp = elPadre.hijoIzq;
        if(tmp == null){
            elPadre.hijoIzq = new Nodo(elDato, null, null);
            return true;
        } else{
            elPadre.hijoIzq = new Nodo(elDato, null, elPadre.hijoIzq);
            return true;
        }
    }

    private boolean SonIguales(Nodo a, Nodo b) {
        if(a!=null && b!=null){
            if(a.dato==b.dato){
                SonIguales(a.hermanoDer,b.hermanoDer);
                SonIguales(a.hijoIzq,b.hijoIzq);
                return true;
            }else{
                return false;
            }
        }else{
            return true;
        }
    }
    public static void main(String[] args) {
        ArbolGeneral a= new ArbolGeneral();


    }
}

Hola Mundo

public class HolaMundo{
    public static void main(String [] arg){
        System.out.println("Hola Mundo");
    }
}