JAVA 26. MEJORANDO INTERFAZ GRAFICA

COLORES DE FONDO Y DE TEXTO

La clase Component proporciona dos métodos para modificar el color de un Componente. A través de los métodos setBackground() y setForeground(), se pueden indicar los colores del fondo y del texto, respectivamente:

Clase:  import java.awt.color;

label1 = new JLabel("Sumar");

text1 = new JTextField("Restar"); 

text1.setBackground( Color.blue );

label1.setForeground( Color.red );

FUENTE

Cambiemos el font de caracteres a Times Roman de 12 puntos

Clase: import java.awt.font;

label1.setFont( new Font( "TimesRoman",Font.PLAIN,12 ) );

label1.setFont( new Font( "TimesRoman",Font.BOLD,24 ) );

label1.setFont( new Font("Helvetica",Font.ITALIC,12) );

IMAGENES

Atributo: ImageIcon imagen = new ImageIcon("C:/holamu.gif");

   

import javax.swing.*;

import java.awt.*;

import java.awt.event.*;

import java.awt.Color;

import java.awt.event.*;

public class Formulario extends JFrame {

      ImageIcon imagen = new ImageIcon("C:/holamu.gif");

         

    private JLabel label1;

    public Formulario() {

        setLayout(null);

        label1=new JLabel(imagen);

        label1.setBounds(10,20,350,350);

        add(label1);

    }

     

        public static void main(String[] ar) {

        Formulario formulario1=new Formulario();

        formulario1.setBounds(0,0,400,500);

        formulario1.setVisible(true);

       

    }

}

VENTANAS Y COLABORACION ENTRE VENTANAS

  

importe:

import javax.swing.WindowConstants;

Ejemplo:

import javax.swing.*;

import java.awt.Window;

import java.awt.event.*;

public class Formulario1 extends JFrame implements ActionListener{

    private JButton boton1,boton2,boton3,boton4;

    private JLabel label1,label2,label3;

    public Formulario1() {

        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("label de la ventana 1");

        label1.setBounds(10,10,200,30);

        label2=new JLabel("label de la ventana 2");

        label2.setBounds(10,10,200,30);

        label3=new JLabel("label de la ventana 3");

        label3.setBounds(10,10,200,30);

        boton4=new JButton("4");

        boton4.setBounds(210,100,90,30);

        boton4.addActionListener(this);

    }

   

    public void actionPerformed(ActionEvent e) {

        if (e.getSource()==boton1) {

            setTitle("boton 1");

            JFrame frame1 = new JFrame("Ventana Emergente 1");

            frame1.setLayout (null);

            frame1.add(label1);

            //frame1.pack();

            frame1.setVisible(true);

            frame1.setSize(400,500);

        }

        if (e.getSource()==boton2) {

            setTitle("boton 2");

            JFrame frame2 = new JFrame("Ventana Emergente 2");

            frame2.setLayout (null);

            frame2.add(label2);

            //frame1.pack();

            frame2.setVisible(true);

            frame2.setSize(400,600);

           

        }

        if (e.getSource()==boton3) {

            setTitle("boton 3");

            JFrame frame3 = new JFrame("Ventana Emergente 2");

            frame3.setLayout (null);

            frame3.add(label3);

            //frame1.pack();

            frame3.setVisible(true);

            frame3.setSize(400,700);

            frame3.add(boton4);

       

        }       

        if (e.getSource()==boton4) {

            setTitle("boton 4");

            JFrame frame4 = new JFrame("Ventana Emergente 4");

            frame4.setLayout (null);

           

            //frame1.pack();

            frame4.setVisible(true);

            frame4.setSize(400,700);

           

       

        }       

       

    }

   

      public static void main(String[] ar){

        Formulario1 formulario2=new Formulario1();

        formulario2.setBounds(0,0,350,200);

        formulario2.setVisible(true);

    }

}

CUADROS DE DIALOGO

//título e icono por defecto

JOptionPane.showMessageDialog(null,"Texto del mensaje.");

//título personalizado, icono de aviso

JOptionPane.showMessageDialog(null,
"Texto del mensaje.",
"Título del marco",
JOptionPane.WARNING_MESSAGE);

//título personalizado, icono de error

JOptionPane.showMessageDialog(null,
"Texto del mensaje.",
"Título del marco",
JOptionPane.ERROR_MESSAGE);

//título personalizado, sin icono

JOptionPane.showMessageDialog(null,
"Texto del mensaje.",
"Título del marco",
JOptionPane.PLAIN_MESSAGE);

JAVA 25. APPLETS EN JAVA

Un applet es una pequeña aplicación accesible en un servidor Internet, que se transporta por la red, se instala automáticamente y se ejecuta in situ como parte de un documento web.

Un applet es una mínima aplicación Java diseñada para ejecutarse en un navegador Web. Por tanto, no necesita preocuparse por un método main() ni en dónde se realizan las llamadas. El applet asume que el código se está ejecutando desde dentro de un navegador. El appletviewer se asemeja al mínimo navegador. Espera como argumento el nombre del fichero html que debe cargar, no se le puede pasar directamente un programa Java.

<HTML>

    <APPLET CODE=HolaMundo.class WIDTH=300 HEIGHT=100>

    </APPLET>

</HTML>

CICLO DE VIDA DE UN APPLET

 

Cuando un applet se carga en el appletviewer, comienza su ciclo de vida, que pasaría por las siguientes fases:

• Se crea una instancia de la clase que controla el applet. En el ejemplo de la figura anterior, sería la clase HolaMundo.

• El applet se incializa.

• El applet comienza a ejecutarse.

• El applet empieza a recibir llamadas. Primero recibe una llamada init (inicializar), seguida de un mensaje start (empezar) y paint (pintar). Estas llamadas pueden ser recibidas asíncronamente.

METODOS DE APPLETVIEWER

Vamos a utilizar como excusa la función asociada al appletviewer de los siguientes métodos para adentrarnos en su presentación,  porque también son los métodos propios de la clase Applet.

init()

El método init() se llama cada vez que el appletviewer carga por primera vez la clase. Si el applet llamado no lo sobrecarga, init() no hace nada. Fundamentalmente en este método se debe fijar el tamaño del applet, aunque en el caso de Netscape el tamaño que vale es el que se indique en la línea del fichero html que cargue el applet. También se deben realizar en este método las cargas de imágenes y sonidos necesarios para la ejecución del applet. Y, por supuesto, la asignación de valores a las variables globales a la clase que se utilicen. En el caso de los applet, este método únicamente es llamado por el sistema al cargar el applet.

start()

start() es la llamada para arrancar el applet cada vez que es visitado. La clase Applet no hace nada en este método. Las clases derivadas deben sobrecargarlo para comenzar la animación, el sonido, etc. Esta función es llamada automáticamente cada vez que la zona de visualización en que está ubicado el applet se expone a la visión, a fin de optimizar en uso de los recursos del sistema y no ejecutar algo que no puede ser apreciado (aunque el programador puede variar este comportamiento y hacer que un applet siga activo aun cuando esté fuera del área de visión). Esto es, imaginemos que cargamos un applet en un navegador minimizado; el sistema llamará al método init(), pero no a start(), que sí será llamado cuando restauremos el navegador a un tamaño que permita ver el applet. Naturalmente, start() se puede ejecutar varias veces: la primera tras init() y las siguientes (porque init() se ejecuta solamente una vez) tras haber aplicado el método stop().

stop()

stop() es la llamada para detener la ejecución del applet. Se llama cuando el applet desaparece de la pantalla. La clase Applet tampoco hace nada en este método, que debería ser sobrecargado por las clases derivadas para detener la animación, el sonido, etc. Esta función es llamada cuando el navegador no incluye en su campo de visión al applet; por ejemplo, cuando abandona la página en que está insertado, de forma que el programador puede paralizar los threads que no resulten necesarios respecto de un applet no visible, y luego recuperar su actividad mediante el método start().

destroy()

El método destroy() se llama cuando ya no se va a utilizar más el applet, cuando se necesita que sean liberados todos los recursos dispuestos por el applet, por ejemplo, cuando se cierra el navegador. La clase Applet no hace nada en este método. Las clases derivadas deberían sobrecargarlo para hacer una limpieza final. Los applet multithread deberían utilizar destroy() para detener los threads que quedasen activos.

El appletviewer también contiene la clase Component (componente), que usa dos métodos para ayudas al applet a escribir en el espacio gráfico que el appletviewer le proporciona para su ejecución.

paint( Graphics g )

Es la función llamada cada vez que el área de dibujo del applet necesita ser refrescada. La clase Applet simplemente dibuja un rectángulo gris en el área, es la clase derivada, obviamente, la que debería sobrecargar este método para representar algo inteligente en la pantalla. Cada vez que la zona del applet es cubierta por otra ventana, se desplaza el applet fuera de la visión o el applet cambia de posición debido a un redimensionamiento del navegador, el sistema llama automáticamente a este método, pasando como argumento un objeto de tipo Graphics que delimita la zona a ser pintada; en realidad se pasa una referencia al contexto gráfico en uso, y que representa la ventana del applet en la página web.

update( Graphics g )

Esta es la función que realmente se llama cuando se necesita una actualización de la pantalla. La clase Applet simplemente limpia el área y llama al método paint(). Esta funcionalidad es suficiente para la mayoría de los casos; aunque, de cualquier forma, las clases derivadas pueden sustituir esta funcionalidad para sus propósitos especiales. Es decir, en las situaciones detalladas anteriormente que dañan la zona de exposición del applet, el sistema llama al método paint(), pero en realidad la llamada se realiza al método update(), cuyo comportamiento establecido en la clase Component es llamar al método paint(), tras haber rellenado la zona del applet con su color de fondo por defecto. Pudiera parecer así que se trata de un método de efecto neutro, pero si la función paint() cambiara el color del fondo, podríamos percibir un flick de cambio de colores nada agradable. Por tanto, habrá que cuidarse por lo común, de eliminar este efecto de limpia primero, sobrecargando el método update(), para que llame únicamente a paint(). Otra solución sería insertar el código de pintado en una sobrecarga del método update() y escribir un método paint() que sólo llame a update(). La última solución pasaría por usar el mismo método setBackground( Color ), en el método init() para así evitar el efecto visual sin tener que sobrecargar el método update(). Estas son las mismas razones que aconsejan usar el método resize() inserto en init(), para evitar el mismo desagradable efecto.

repaint

Llamando a este método se podrá forzar la actualización de un applet, la llamada a update(). Pero hay que tener cierto cuidado, porque AWT posee cierta inteligencia (combinación casi siempre nefasta), de forma que si se llama a update() mediante repaint() con una frecuencia muy corta, AWT ignorará las llamadas a update() que estime oportuno, pues considera a esta función como un bien escaso.

Sinopsis

La llamada a appletviewer es de la forma:

 appletviewer [-debug] urls...

El appletviewer toma como parámetro de ejecución, o bien el nombre del un fichero html conteniendo el tag (marca) <APPLET>, o bien un URL hacia un fichero HTML que contenga esa marca.
Si el fichero html no contiene un tag <APPLET> válido, el appletviewer no hará nada. El appletviewer no muestra otras marcas html.
La única opción válida que admite la llamada a appletviewer es -debug, que arranca el applet en el depurador de Java, jdb. Para poder ver el código fuente en el depurador, se tiene que compilar el fichero .java con la opción -g.

Ejemplo de uso

En el ejemplo de llamada al appletviewer siguiente, hacemos que se ejecute el applet básico que crearemos en la sección siguiente y que lanzaremos desde un fichero html del mismo nombre que nuestro fichero de código fuente Java.

%appletviewer HolaMundo.html

Esta llamada lanzaría la ejecución de HolaMundo.class en el appletviewer, abriéndose en pantalla la ventana siguiente:

FUNCIONES DE MENU DE APPLETVIEWER

 

El appletviewer tiene un único menú mostrado en la imagen siguiente y que vamos a explicar en cada una de sus opciones, ya que lo usaremos a menudo cuando vayamos avanzando en nuestros conocimientos de Java.

• Restart

La función Restart llama al método stop() y seguidamente llama de nuevo a start(), que es el método que ha lanzado inicialmente la ejecución del applet. Se puede utilizar Restart para simular el movimiento entre páginas en un documento html.

• Reload

La función Reload llama al método stop() y luego al método destroy() en el applet actual. A continuación carga una nueva copia del applet y la arranca llamando al método start().

• Clone

La función Clone crea una copia del applet actual en una ventana de appletviewer nueva. En realidad es un appletviewer idéntico con el mismo URL.

• Tag

La función Tag muestra en una ventana hija del appletviewer el código html cargado para su ejecución. Es similar a la función View Source que figura en la mayoría de los navegadores, Netscape, Internet Explorer y HotJava incluidos.

• Info

La función Info lee los comentarios de documentación contenidos en el fichero html y muestra la información de los parámetros (si la hay).

• Properties

El appletviewer tiene las funciones básicas de presentación de un navegador y la función Properties (propiedades de la red) permite cambiar o establecer el modo de seguridad o fijar los servidores de proxy o firewall.

• Close

La función Close llama al método destroy() de la ventana actual del appletviewer, teminando su ejecución.

• Quit

La función Quit llama al método destroy() de cada una de las copias del appletviewer que se encuentren lanzadas, concluyendo la ejecución de todas ellas y terminando entonces el appletviewer.

UN APPLET BASICO EN JAVA

 

Vamos a comenzar la creación del código fuente del un applet que satisfaga nuestras necesidades. Recordamos que Java utiliza la extensión .java para designar los ficheros fuente.

 

HolaMundo

A continuación está el código fuente del applet HolaMundo, que es la versión applet de la mínima aplicación Java que antes habíamos escrito. Guardar este código en un fichero fuente Java como HolaMundo.java.

    //

    // Applet HolaMundo de ejemplo

    //

    import java.awt.Graphics;

    import java.applet.Applet;

    public class HolaMundo extends Applet {

        public void paint( Graphics g ) {

            g.drawString( "Hola Mundo!",25,25 ) ;

            }

        }

Componentes Básicos De Un Applet

El lenguaje Java implementa un modelo de Programación Orientada a Objetos. Los objetos sirven de bloques centrales de construcción de los programas Java. De la misma forma que otros lenguajes de programación, Java tiene variables de estado y métodos.

Veamos como se descompone un applet en sus piezas/objetos:

/*

Sección de importaciones

*/

public class NombreDelNuevoApplet extends Applet {

/*

Aquí se declaran las variables de estado (public y private)

*/

/*

Los métodos para la interacción con los objetos se 

declaran y definen aquí

*/

public void MetodoUno( parámetros ) {

/* 

Aquí viene para cada método, el código Java que 

desempeña la tarea.

Qué código se use depende del applet

*/

}

}

Para HolaMundo, se importan las dos clases que necesita. No hay variables de estado, y sólo se tiene que definir un método para que el applet tenga el comportamiento esperado.

Clases incluidas
 

El comando import carga otras clases dentro de nuestro código fuente. El importar una clase desde un paquete de Java hace que esa clase importada esté disponible para todo el código incluido en el fichero fuente Java que la importa. Por ejemplo, en el applet HolaMundo se importa la clase java.awt.Graphics, y podremos llamar a los métodos de esta clase desde cualquier método de nuestro programa que se encuentre en el fichero HolaMundo.java. Esta clase define una área gráfica y métodos para poder dibujar dentro de ella. La función paint() declara a g como un objeto de tipo Graphics; luego, paint() usa el método drawString() de la clase Graphics para generar su salida.

La clase Applet

Se puede crear una nueva clase, en este caso HolaMundo, extendiendo la clase básica de Java: Applet. De esta forma, se hereda todo lo necesario para crear un applet. Modificando determinados métodos del applet, podemos lograr que lleve a cabo las funciones que deseamos.

    import java.applet.Applet;

    .  .  .

    public class HolaMundo extends Applet {

Métodos de Applet

La parte del applet a modificar es el método paint(). En la clase Applet, se llama al método paint() cada vez que el método arranca o necesita ser refrescado, pero no hace nada. En nuestro caso, lo que hacemos es:

    public void paint( Graphics g ) {

        g.drawString( "Hola Mundo!",25,25 );

        }

De acuerdo a las normas de sobrecarga, se ejecutará este último paint() y no el paint() vacío de la clase Applet. Luego, aquí se ejecuta el método drawString(), que le dice al applet cómo debe aparecer un texto en el  área de dibujo.

Otros métodos básicos para dibujar son:

    drawLine( int x1,int y1,int x2,int y2 )

    drawRect( int x,int y,int ancho,int alto )

    drawOval( int x,int y,int ancho,int alto )

Tanto para drawRect() como para drawOval(), las coordenadas (x,y) son la esquina superior izquierda del rectángulo (para drawOval, el óvalo es encajado en el rectángulo que lo circunscribe).

 

LA MARCA APPLET DE HTML

Dado que los applets están mayormente destinados a ejecutarse en navegadores Web, había que preparar el lenguaje HTML para soportar Java, o mejor, los applets. El esquema de marcas de HTML, y la evolución del estándar marcado por Netscape hicieron fácil la adición de una nueva marca que permitiera, una vez añadido el correspondiente código gestor en los navegadores, la ejecución de programas Java en ellos.

La sintaxis de las etiquetas <APPLET> y <PARAM> es la que se muestra a continuación y que iremos explicando en párrafos posteriores:

<APPLET CODE=  WIDTH=  HEIGTH= [CODEBASE=] [ALT=] 

[NAME=] [ALIGN=] [VSPACE=] [HSPACE=]>

<PARAM NAME=  VALUE= >

</APPLET>

Atributos obligatorios:

CODE : Nombre de la clase principal
WIDTH : Anchura inicial
HEIGHT : Altura inicial

Atributos opcionales:

CODEBASE : URL base del applet
ALT : Texto alternativo
NAME : Nombre de la instancia
ALIGN : Justificación del applet
VSPACE : Espaciado vertical
HSPACE : Espaciado horizontal

Los applets se incluyen en las páginas Web a través de la marca <APPLET>, que para quien conozca html resultará muy similar a la marca <IMG>. Ambas necesitan la referencia a un fichero fuente que no forma parte de la página en que se encuentran embebidos. IMG hace esto a través de SRC=parámetro y APPLET lo hace a través CODE=parámetro. El parámetro de CODE indica al navegador dónde se encuentra el fichero con el código Java compilado .class. Es una localización relativa al documento fuente.

si un applet reside en un directorio diferente del que contiene a la página en que se encuentra localizado, entonces no se indica un URL a esta localización, sino que se apunta al directorio del fichero .class utilizando el parámetro CODEBASE, aunque todavía se puede usar CODE para proporcionar el nombre del fichero .class.

Al igual que IMG, APPLET tiene una serie de parámetros que lo posicionan en la página. WIDTH y HEIGHT especifican el tamaño del rectángulo que contendrá al applet, se indican en pixels. ALIGN funciona igual que con IMG (en los navegadores que lo soportan), definiendo cómo se posiciona el rectángulo del applet con respecto a los otros elementos de la página. Los valores posibles a especificar son: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM y ABSBOTTOM. Y, finalmente, lo mismo que con IMG, se puede especificar un HSPACE y un VSPACE en pixels para indicar la cantidad de espacio vacío que habrá de separación entre el applet y el texto que le rodea.

APPLET tiene una marca ALT. La utilizaría un navegador que entendiese la marca APPLET, pero que por alguna razón, no pudiese ejecutarlo. Por ejemplo, si un applet necesita escribir en el disco duro de nuestro ordenador, pero en las características de seguridad tenemos bloqueada esa posibilidad, entonces el navegador presentaría el texto asociado a ALT.

ALT no es utilizado por los navegadores que no entienden la marca APPLET, por ello se ha definido la marca </APPLET>, que finaliza la descripción del applet. Un navegador con soporte Java ignorará todo el texto que haya entre las dos marcas <APPLET> y </APPLET>, sin embargo, un navegador que no soporte Java ignorará las marcas y presentará el texto que se encuentre entre ellas.

ATRIBUTOS DE APPLET

 

Los atributos que acompañan a la etiqueta <APPLET>, algunos son obligatorios y otros son opcionales. Todos los atributos, siguiendo la sintaxis de html, se especifican de la forma: atributo=valor. Los atributos obligatorios son:

CODE

Indica el fichero de clase ejecutable, que tiene la extensión .class. No se permite un URL absoluto, como ya se ha dicho, aunque sí puede ser relativo al atributo opcional CODEBASE.

WIDTH

Indica la anchura inicial que el navegador debe reservar para el applet en pixels.

HEIGHT

Indica la altura inicial en pixels. Un applet que disponga de una geometría fija no se verá redimensionado por estos atributos. Por ello, si los atributos definen una zona menor que la que el applet utiliza, únicamente se verá parte del mismo, como si se visualiza a través de una ventana, eso sí, sin ningún tipo de desplazamiento.

Los atributos opcionales que pueden acompañar a la marca APPLET comprenden los que se indican a continuación:

CODEBASE

Se emplea para utilizar el URL base del applet. En caso de no especificarse, se utilizará el mismo que tiene el documento.

ALT

Como ya se ha dicho, funciona exactamente igual que el ALT de la marca <IMG>, es decir, muestra un texto alternativo, en este caso al applet, en navegadores en modo texto o que entiendan la etiqueta APPLET pero no implementen una máquina virtual Java.

NAME

Otorga un nombre simbólico a esta instancia del applet en la página que puede ser empleado por otros applets de la misma página para localizarlo. Así, un applet puede ser cargado varias veces en la misma página tomando un nombre simbólico distinto en cada momento.

ALIGN

Se emplea para alinear el applet permitiendo al texto fluir a su alrededor. Puede tomas los siguientes valores: LEFT, RIGHT, TOP, TEXTTOP, MIDDLE, ABSMIDDLE, BASELINE, BOTTOM y ABSBOTTOM.

VSPACE

Indica el espaciado vertical entre el applet y el texto, en pixels. Sólo funciona cuando se ha indicado ALIGN = LEFT o RIGHT.

HSPACE

Funciona igual que el anterior pero indicando espaciamiento horizontal, en pixels. Sólo funciona cuando se ha indicado ALIGN = LEFT o RIGHT.

Es probable encontrar en algunas distribuciones otras etiquetas para la inclusión de applets, como <APP>. Esto se debe a que estamos ante la tercera revisión de la extensión de HTML para la incrustación de applets y ha sido adoptada como la definitiva. Por ello, cualquier otro medio corresponde a implementaciones obsoletas que han quedado descartadas.

PASO DE PARAMETROS A APPLETS

El espacio que queda entre las marcas de apertura y cierre de la definición de un applet, se utiliza para el paso de parámetros al applet. Para ello se utiliza la marca PARAM en la página HTML para indicar los parámetros y el método getParameter() de la clase java.applet.Applet para leerlos en el código interno del applet. La construcción puede repetirse cuantas veces se quiera, una tras otra.

Los atributos que acompañan a la marca PARAM son los siguientes:

NAME

Nombre del parámetro que se desea pasar al applet.

VALUE

Valor que se desea transmitir en el parámetro que se ha indicado antes.

Texto HTML

Texto HTML que será interpretado por los navegadores que no entienden la marca APPLET en sustitución del applet mismo.

Para mostar esta posibilidad vamos a modificar nuestro applet básico HolaMundo para que pueda saludar a cualquiera. Lo que haremos será pasarle al applet el nombre de la persona a quien queremos saludar. Generamos el código para ello y lo guardamos en el fichero HolaTal.java.

import java.awt.Graphics;

    import java.applet.Applet;

    public class HolaTal extends Applet {

      String nombre;

        public void init() {

            nombre = getParameter( "Nombre" );

            }

        public void paint( Graphics g ) {

            g.drawString( "Hola "+nombre+"!",25,25 );

            }

        }

Si compilamos el ejemplo obtendremos el fichero HolaTal.class que incluiremos en nuestra página Web. Vamos a generar el fichero HolaTal.html, en el que incluiremos nuestro applet, y que debería tener el siguiente contenido:

    <HTML>

    <APPLET CODE=HolaTal.class WIDTH=300 HEIGHT=100>

    <PARAM NAME="Nombre" VALUE="Jairo">

    </APPLET>

  </HTML>

Puedes sustituir mi nombre por el tuyo. Este cambio no afectará al código Java, no será necesario recompilarlo para que te salude a ti el applet.

Los parámetros no se limitan a uno solo. Se puede pasar al applet cualquier número de parámetros y siempre hay que indicar un nombre y un valor para cada uno de ellos.

El método getParameter() es fácil de entender. El único argumento que necesita es el nombre del parámetro cuyo valor queremos recuperar. Todos los parámetros se pasan como Strings, en caso de necesitar pasarle al applet un valor entero, se ha de pasar como String, recuperarlo como tal y luego convertirlo al tipo que deseemos. Tanto el argumento de NAME como el de VALUE deben ir colocados entre dobles comillas (") ya que son String.

 

APPLET EJEMPLO

import java.awt.*;

import java.applet.*;

public class GuiExample extends Applet

{

     Button okButton;

     TextField nameField;

     CheckboxGroup radioGroup;

     Checkbox radio1;

     Checkbox radio2;

     Checkbox option;

     public void init()

     {

  // Tell the applet not to use a layout manager.

        setLayout(null);

  // initialze the button and give it a text.

        okButton = new Button("A button");

  // text and length of the field

        nameField = new TextField("A TextField",100);

  // initialize the radio buttons group

          radioGroup = new CheckboxGroup();

  // first radio button. Gives the label text, tells to which

  // group it belongs and sets the default state (unselected)

          radio1 = new Checkbox("Radio1", radioGroup,false);

  // same but selected

          radio2 = new Checkbox("Radio2", radioGroup,true);

  // Label and state of the checkbox

          option = new Checkbox("Option",false);

  // ubicacion y tamaño de los objetos

 

          okButton.setBounds(20,20,100,30);

          nameField.setBounds(20,70,100,40);

          radio1.setBounds(20,120,100,30);

          radio2.setBounds(140,120,100,30);

          option.setBounds(20,170,100,30);

  // adicionar componentes al frame

      add(okButton);

      add(nameField);

      add(radio1);

      add(radio2);

      add(option);

     }

    }

14-10 Matrices irregulares

Java nos permite crear matrices irregulares. Se dice que una matriz es irregular si la cantidad de elementos de cada fila varía. Luego podemos imaginar una matriz irregular:


 
Como podemos ver la fila cero tiene reservado dos espacios, la fila uno reserva cuatro espacios y la última fila reserva espacio para tres componentes.

Para crear la matriz irregular del gráfico:
La declaración es la misma que para matrices regulares:

int [][] mat;

Primero creamos la cantidad de filas dejando vacío el espacio que indica la cantidad de columnas:

mat=new int[3][];

Luego debemos ir creando cada fila de la matriz indicando la cantidad de elementos de la respectiva fila:

mat[0]=new int[2];
mat[1]=new int[4];
mat[2]=new int[3];

Luego la forma para acceder a sus componentes es similar a las matrices regulares, siempre teniendo en cuenta y validando que exista dicha componente:

mat[0][0]=120;

Dará un error si queremos cargar la tercer componente de la fila cero (esto debido a que no existe):

mat[0][2]=230;

Luego si queremos saber la cantidad de filas que tiene la matriz:

Sytem.out.println(mat.length);

Si queremos saber la cantidad de elementos de una determinada fila:

Sytem.out.println("Cantidad de elementos de la fila 0:"+mat[0].length);
Sytem.out.println("Cantidad de elementos de la fila 1:"+mat[1].length);
Sytem.out.println("Cantidad de elementos de la fila 2:"+mat[2].length);

Problema 1:

Confeccionaremos un programa que permita crear una matriz irregular y luego imprimir la matriz en forma completa.

Programa:

import java.util.Scanner;
public class MatrizIrregular1 {
    private Scanner teclado;
    private int[][] mat;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        mat=new int[filas][];
        for(int f=0;f<mat.length;f++) {
            System.out.print("Cuantas elementos tiene la fila " + f + ":");
            int elementos=teclado.nextInt();
            mat[f]=new int[elementos];            
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void imprimir() {
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }
    
    public static void main(String[] ar) {
        MatrizIrregular1 ma=new MatrizIrregular1();
        ma.cargar();
        ma.imprimir();
    }   
}

Primero creamos la cantidad de filas que tendrá la matriz (en los corchetes para las columnas no disponemos valor):

System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        mat=new int[filas][];

Dentro del primer for pedimos que ingrese la cantidad de elementos que tendrá cada fila y utilizamos el operador new nuevamente, pero en este caso se están creando cada fila de la matriz (Java trata a cada fila como un vector):

for(int f=0;f<mat.length;f++) {
            System.out.print("Cuantas elementos tiene la fila " + f + ":");
            int elementos=teclado.nextInt();
            mat[f]=new int[elementos];            

Dentro del for interno hacemos la carga de las componentes propiamente dicho de la matriz (podemos ir cargando cada fila a medida que las vamos creando):

for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }

Luego imprimimos la matriz en forma completa teniendo cuidado las condiciones que disponemos en cada for.
El primer for se repite tantas veces como filas tiene la matriz: f<mat.length y
el for interno se repite tantas veces como elementos tiene la fila que estamos procesando c<mat [f].length:

for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }

Problemas propuestos

1. Confeccionar una clase para administrar una matriz irregular de 5 filas y 1 columna la primer fila, 2 columnas la segunda fila y así sucesivamente hasta 5 columnas la última fila (crearla sin la intervención del operador)
   Realizar la carga por teclado e imprimir posteriormente.
2. Confeccionar una clase para administrar los días que han faltado los 3 empleados de una empresa.
   Definir un vector de 3 elementos de tipo String para cargar los nombres y una matriz irregular para cargar los días que han faltado cada empleado (cargar el número de día que faltó)
   Cada fila de la matriz representan los días de cada empleado.
   Mostrar los empleados con la cantidad de inasistencias.
   Cuál empleado faltó menos días.

14-9 Matrices y vectores paralelos

Dependiendo de la complejidad del problema podemos necesitar el empleo de vectores y matrices paralelos.

Problema 1:

Se tiene la siguiente información:

· Nombres de 4 empleados.
· Ingresos en concepto de sueldo, cobrado por cada empleado, en los últimos 3 meses.
Confeccionar el programa para:

a) Realizar la carga de la información mencionada.
b) Generar un vector que contenga el ingreso acumulado en sueldos en los últimos 3 meses para cada empleado.
c) Mostrar por pantalla el total pagado en sueldos a todos los empleados en los últimos 3 meses
d) Obtener el nombre del empleado que tuvo el mayor ingreso acumulado

Programa:

import java.util.Scanner;
public class Matriz9 {
    private Scanner teclado;
    private String[] empleados;
    private int[][] sueldos;
    private int[] sueldostot;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        empleados=new String[4];
        sueldos=new int[4][3];
        for(int f=0;f<empleados.length;f++){
            System.out.print("Ingrese el nombre del empleado:");
            empleados[f]=teclado.next();
            for(int c=0;c<sueldos[f].length;c++) {
                System.out.print("Ingrese sueldo:");
                sueldos[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void calcularSumaSueldos() {
     sueldostot=new int[4];
        for(int f=0;f<sueldos.length;f++) {
          int suma=0;
          for(int c=0;c<sueldos[f].length;c++) {
              suma=suma+sueldos[f][c];
          }
          sueldostot[f]=suma;
        }
    }
    
    public void imprimirTotalPagado() {
     System.out.println("Total de sueldos pagados por empleado.");
        for(int f=0;f<sueldostot.length;f++) {
            System.out.println(empleados[f]+" - "+sueldostot[f]);
        }
    }
    
    public void empleadoMayorSueldo() {
        int may=sueldostot[0];
        String nom=empleados[0];
        for(int f=0;f<sueldostot.length;f++) {
            if (sueldostot[f]>may) {
                may=sueldostot[f];
                nom=empleados[f];
            }
        }
        System.out.println("El empleado con mayor sueldo es "+ nom + " que tiene un sueldo de "+may);
    }
    
    public static void main(String[] ar){
        Matriz9 ma=new Matriz9();
        ma.cargar();
        ma.calcularSumaSueldos();
        ma.imprimirTotalPagado();
        ma.empleadoMayorSueldo();
    }
}

Para resolver este problema lo primero que hacemos es definir una matriz donde se almacenarán los sueldos mensuales de cada empleado, un vector de tipo String donde almacenaremos los nombre de cada empleado y finalmente definimos un vector paralelo a la matriz donde almacenaremos la suma de cada fila de la matriz:

private String[] empleados;
    private int[][] sueldos;
    private int[] sueldostot;

En el método de cargar inicializamos el vector con los nombres de los empleados y la matriz paralela donde se almacenan los últimos tres sueldos (previo a cargar procedemos a crear el vector y la matriz):

empleados=new String[4];
        sueldos=new int[4][3];
        for(int f=0;f<empleados.length;f++){
            System.out.print("Ingrese el nombre del empleado:");
            empleados[f]=teclado.next();
            for(int c=0;c<sueldos[f].length;c++) {
                System.out.print("Ingrese sueldo:");
                sueldos[f][c]=teclado.nextInt();
            }
        }

El método sumar sueldos crea el vector donde se almacenará la suma de cada fila de la matriz. Mediante dos for recorremos toda la matriz y sumamos cada fila:

sueldostot=new int[4];
        for(int f=0;f<sueldos.length;f++) {
          int suma=0;
          for(int c=0;c<sueldos[f].length;c++) {
              suma=suma+sueldos[f][c];
          }
          sueldostot[f]=suma;
        }

El método imprimirTotalPagado tiene por objetivo mostrar los dos vectores (el de nombre de los empleados y el que almacena la suma de cada fila de la matriz):

for(int f=0;f<sueldostot.length;f++) {
            System.out.println(empleados[f]+" - "+sueldostot[f]);
        }

Por último para obtener el nombre del empleado con mayor sueldo acumulado debemos inicializar dos variables auxiliares con el primer elemento del vector de empleados y en otra auxiliar guardamos la primer componente del vector sueldostot:

int may=sueldostot[0];
        String nom=empleados[0];
        for(int f=0;f<sueldostot.length;f++) {
            if (sueldostot[f]>may) {
                may=sueldostot[f];
                nom=empleados[f];
            }
        }
        System.out.println("El empleado con mayor sueldo es "+ nom + " que tiene un sueldo de "+may);

Problemas propuestos

1. Se desea saber la temperatura media trimestral de cuatro paises. Para ello se tiene como dato las temperaturas medias mensuales de dichos paises.
   Se debe ingresar el nombre del país y seguidamente las tres temperaturas medias mensuales.
   Seleccionar las estructuras de datos adecuadas para el almacenamiento de los datos en memoria.
   a - Cargar por teclado los nombres de los paises y las temperaturas medias mensuales.
   b - Imprimir los nombres de las paises y las temperaturas medias mensuales de las mismas.
   c - Calcular la temperatura media trimestral de cada país.
   c - Imprimr los nombres de las provincias y las temperaturas medias trimestrales.
   b - Imprimir el nombre de la provincia con la temperatura media trimestral mayor.

14-8 Matrices (cantidad de filas y columnas)

Como hemos visto para definir y crear la matriz utilizamos la siguiente sintaxis:

int[][] mat;

Creación:

mat=new int[3][4];

Como las matrices son objetos en Java disponemos por un lado del atributo length que almacena la cantidad de filas de la matriz:

System.out.println("Cantidad de filas de la matriz:" + mat.length);

También podemos preguntarle a cada fila de la matriz la cantidad de elementos que almacena:

System.out.println("Cantidad de elementos de la primer fila:" + mat[0].length);

Problema 1:

Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir la matriz completa y la última fila.

Programa:

import java.util.Scanner;
public class Matriz5 {
    private Scanner teclado;
    private int[][] mat;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        System.out.print("Cuantas columnas tiene la matriz:");
        int columnas=teclado.nextInt();
        mat=new int[filas][columnas];
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
    
    public void imprimir() {
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }
    
    public void imprimirUltimaFila() {
     System.out.println("Ultima fila");
        for(int c=0;c<mat[mat.length-1].length;c++) {
             System.out.print(mat[mat.length-1][c]+" ");
        }
    }
    
    public static void main(String[] ar) {
        Matriz5 ma=new Matriz5();
        ma.cargar();
        ma.imprimir();
        ma.imprimirUltimaFila();
    }   
}

En este ejemplo cada vez que se ejecute el programa el tamaño de la matriz lo define el usuario, para ello ingresamos por teclado dos enteros y seguidamente procedemos a crear la matriz con dichos valores:

System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        System.out.print("Cuantas columnas tiene la matriz:");
        int columnas=teclado.nextInt();
        mat=new int[filas][columnas];

Ahora las estructuras repetitivas las acotamos preguntando a la misma matriz la cantidad de filas y la cantidad de elementos de cada fila(mat.length almacena la cantidad de filas de la matriz y mat[f].length cuando f vale cero accedemos a la cantidad de elementos de la fila cero y así sucesivamente para cada valor de f):

for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }

El algoritmo de impresión es idéntico al visto anteriormente con la modificación de las condiciones de los for:

public void imprimir() {
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print(mat[f][c]+" ");
            }
            System.out.println();
        }
    }

Para imprimir la última fila debemos disponer un valor fijo en el subíndice de la fila (en este caso no podemos disponer un número fijo sino preguntarle a la misma matriz la cantidad de filas y restarle uno ya que las filas comienzan a numerarse a partir de cero: mat[mat.length-1][c])

También la condición del for debemos acceder al atributo length de la última fila mat[mat.length-1].length

for(int c=0;c<mat[mat.length-1].length;c++) {
             System.out.print(mat[mat.length-1][c]+" ");
        }

Problema 2:

Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir el mayor elemento y la fila y columna donde se almacena.

Programa:

import java.util.Scanner;
public class Matriz6 {
    private Scanner teclado;
    private int[][] mat;
    
    public void cargar() {
        teclado=new Scanner(System.in);
        System.out.print("Cuantas fila tiene la matriz:");
        int filas=teclado.nextInt();
        System.out.print("Cuantas columnas tiene la matriz:");
        int columnas=teclado.nextInt();
        mat=new int[filas][columnas];
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                System.out.print("Ingrese componente:");
                mat[f][c]=teclado.nextInt();
            }
        }
    }
        
    public void imprimirMayor() {
     int mayor=mat[0][0];
     int filamay=0;
     int columnamay=0;
        for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                if (mat[f][c]>mayor) {
                    mayor=mat[f][c];
                    filamay=f;
                    columnamay=c;
                }
            }
        }
        System.out.println("El elemento mayor es:"+mayor);
        System.out.println("Se encuentra en la fila:"+filamay+ " y en la columna: "+columnamay);
    }
    
    public static void main(String[] ar) {
        Matriz6 ma=new Matriz6();
        ma.cargar();
        ma.imprimirMayor();
    }   
}

Para obtener el mayor elemento de la matriz y la fila y columna donde se ubica debemos inicializar una variable mayor con el elemento de la fila cero y columna cero (esto lo hacemos suponiendo que en dicha posición se almacena el mayor):

int mayor=mat[0][0];
     int filamay=0;
     int columnamay=0;

Luego mediante dos for recorremos todos los elementos de la matriz y cada vez que encontramos un elemento mayor al actual procedemos a actualizar la variable mayor y la posición donde se almacena:

for(int f=0;f<mat.length;f++) {
            for(int c=0;c<mat[f].length;c++) {
                if (mat[f][c]>mayor) {
                    mayor=mat[f][c];
                    filamay=f;
                    columnamay=c;
                }
            }
        }

Problemas propuestos

1. Crear una matriz de n * m filas (cargar n y m por teclado) Intercambiar la primer fila con la segundo. Imprimir luego la matriz.
2. Crear una matriz de n * m filas (cargar n y m por teclado) Imprimir los cuatro valores que se encuentran en los vértices de la misma (mat[0][0] etc.)