INTERFAZ GRÁFICA DE USUARIO (GUI)

Las interfaces gráficas de usuario(GUI) ofrecen al usuario ventanas, cuadros de diálogo, barras de herramientas, botones, listas desplegables y muchos otros elementos con los que ya estamos muy acostumbrados a tratar. 
Las GUI se construyen a partir de componentes de GUI (llamados widgets). Un componente de GUI es un objeto visual  con el que el usuario puede interactuar a través del teclado o el mouse.  

Existen dos APIs para la programación de interfaces gráficos de usuario AWT(Abstract Windowing Toolkit) y SWING. 


Similitudes entre Swing y AWT

• Por regla general, las clases Swing "equivalentes" a las  de AWT se llaman igual, pero con una J delante: JFrame, JTextField, JLabel,etc. teniendo en cuenta que "no todos los componentes están extendidos: para algunos hay componentes equivalentes (Choise), para otros no (Canvas) y para otros constructores son diferentes (Checkbox, Scrollbar, List)".
• Muchos constructores en Swing tienen los mismos argumentos que en AWT, pero no todos. 

Diferencia entre el Swing y AWT

SWING	AWT
Podemos decir que es la evoluciòn del AWT, la cual al igual que Swing es un conjunto de librerias enfocadas a la construcción de interfaces.	Cada una de las componentes de una ventana en AWT se representa mediante uno o más objetos de la aplicación.
El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir GUIs. Swing abarca componentes como botones, tablas, marcos, etc.	La diferencia de los componentes AWT los Swing se reconocen porque anteponen la letra J antes del nombre.Por ejemplo en AWT se llama Label, mientras que en el Swing se llama JLabel.
Las componentes de Swing utilizan la infraestructura de AWT, incluyendo el modelo de eventos AWT, el cual rige cómo una componente reacciona a eventos tales como, eventos de teclado, mouse, etc.	Permite hacer interfaces gráficas mediante artefactos de interacción con el usuario, como botones, menus, etc.

En sí existe una diferencia, pero al mismo tiempo hay grandes aspectos en común, ambos nos srven para realizar artefactos gráficos y utilizan prácticamente las mismas funciones y componentes, pero la diferencia es que Swing es más avanzado y sus componentes se desarrollan mejor, además AWT necesita tener una plataforma especifica, mientras que desde java Swing podemos utilizarlo y visualizarlo desde diferentes lugares.

AWT

Significa Abstract Windowing Toolkit contiene componentes originales pero no pura interfaz gráfica de usuario que viene con la primera versión de JDK.

• Es una librería que define un conjunto de clases e interfaces java que permiten la construcción de interfaces gráficas de usuario.
• Permite hacer interfaces gráficas mediante artefactos de interacción con el,usuario, como botones, menús, texto, botones, etc.Tambien despiegue gráfico general. 

COMPONENTES Y CONTENEDORES

• COMPONENTES

         *Cualquier elemento gráfico que puede aparecer en una GUI.
         *Lo son todas las clases que derivan de java.awt.Component

         *Ejemplos:

-Botones (java.awt.Button), Campos de texto (java.awt.TextField), etiquetas (java.awt.Label),Listas (java.awt.List), elementos de selección múltiple y exclusiva (java.awt.Checkbox),etc.

• CONTENEDORES

        *Es un elemento gráfico que puede contener dentro a componentes.

        *Lo son todas las clases que derivan de java.awt.Container

        *Ejemplos:

                           -Ventana (java.awt.Frame)

                           -Dialogo (java.awt.Dialog)

                           -Panel (java.awt.Panel)

JERARQUÍA DE AWT

SWING

Swing es la  evolución de AWT, la cuál al igual que Swing es un conjunto de librerias enfocadas a la construcción de interfaces.

• Las clases cuyo nombre comienza por J forman parte de Swing.
• Swing está escrito complementamente en java por lo que es independiente de la plataforma.

COMPONENTE	DESCRIPCIÓN
JButton	Una implementación de un botón "push".
JCheckBox	Una implementación de una casilla de verificación-un elemento que puede activarse o desactivarse, y que muestra su estado al usuario.
JComboBox	Un componente que combina un botón o campo editable y una lista desplegable.
JComponent	La clase base para todos los componentes Swing, excepto contenedoresde Alto nivel.
JDialog	La clase principal para la creación de una ventana de diálogo.
JFileChooser	Proporciona n mecanismo sencillo para que el usuario elija un archivo.
JFrame	Una versión extendida de java.awt.Frame que añade soporte para la arquitectura de componentes JFC/Swing.
JLabel	Un área de visualización de una cadena corta de texto o una imagen, o ambos.
JList	Un componente que muestra una lista de objetos y permite al usuario seleccionar uno o más  elementos
JMenu	Una implementación de un menu-una ventana emergente que contiene JMenusItems que se    muestra cuando el usuario selecciona un elemento en la JMenuBar.
JOptionPane	Hace que sea fácil para que aparezca un cuadro de diálogo estándar que solicita a los   usuarios un valor o les informa algo.
JPanel	Es un contenedor ligero genérico.
JRadioButton	Una implementacion de un boton de radio-un elemento que puede activarse o desactivarse, y que muestra su estado al usuario.
JScrollBar	Una implementación de una barra de desplazamiento.
Jslider	Un componente que permite al usuario seleccionar gráficamente un valor deslizando un botón dentro de un intervalo acotado.
JTextArea	Un JTextArea es un area de varias lineas que muestra texto sin formato.
JTextField	Un JTextField es un componente ligero que permite la edición de una sola línea de texto.
JTree	Un control que muestra un conjunto de datos jerárquicos como un esquema.
JWindow	Un JWindow es un contenedor que se puede mostrar en cualquier lugar en el escritorio del usuario
JApplet	Una versión extendida de java.applet.Applet que añade soporte para la arquitectura de componentes JFC / Swing

JERARQUÍA DE SWING

A continuación se realizara un ejemplo de operaciones: suma, resta, producto y cociente

//A continuación se realizara un ejemplo de operaciones:suma, resta,prodcto y cociente
package Tarea;
import java.awt.event.*;
import javax.swing.*;

public class Calcu extends JFrame{
    
    JLabel jl_var_1;
    JLabel jl_var_2;
    JLabel jl_result;   
    JTextField jtf_var1;
    JTextField jtf_var2;
    JTextField jtf_resultado;
    JButton btn_suma;
    JButton btn_resta;
    JButton btn_producto;
    JButton btn_cociente;
    JButton btn_salir;
    
    public Calcu() {
        
        setLayout(null);
        
        jl_var_1= new JLabel("Variable 1");
        jl_var_1.setBounds(10, 10, 100, 20);
        
        jl_var_2= new JLabel("Variable 2");
        jl_var_2.setBounds(10, 30, 150, 25);
        
        jl_result=new JLabel("Resultado");
        jl_result.setBounds(30, 170, 100, 15);
        
        jtf_var1= new JTextField(50);
        jtf_var1.setBounds(80,10,100,20);
        
        jtf_var2 = new JTextField(50);
        jtf_var2.setBounds(80,40,100,20);
        
        jtf_resultado = new JTextField(50);
        jtf_resultado.setBounds(100, 170, 120, 20);
        
        btn_suma= new JButton("Suma");
        btn_suma.setBounds(150, 70, 100, 20);
        
        btn_resta = new JButton("Resta");
        btn_resta.setBounds(150, 95, 100, 20);
        
        btn_producto = new JButton("Producto");
        btn_producto.setBounds(150, 120, 100, 20);
        
        btn_cociente = new JButton("Cociente");
        btn_cociente.setBounds(150, 145, 100, 20);
        
        btn_salir= new JButton("Salir");
        btn_salir.setBounds(150, 200, 100, 20);
        
        add(jl_var_1);
        add(jl_var_2);
        add(jl_result);
        add(jtf_var1);
        add(jtf_var2);
        add(jtf_resultado);
        add(btn_suma);
        add(btn_resta);
        add(btn_producto);
        add(btn_cociente);
        add(btn_salir);
        
        btn_suma.addActionListener(new evenSuma());
        btn_resta.addActionListener(new evenResta());
        btn_producto.addActionListener(new evenProducto());
        btn_cociente.addActionListener(new evenCociente());
        btn_salir.addActionListener(new evenSalir());

        
        setTitle(" OPERACION ");
        setSize(300,300);
        setVisible(true);
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        
    }
    
    public  class evenSuma implements ActionListener{

        public  void actionPerformed (ActionEvent ee){
            if (ee.getSource()==btn_suma) {
                double a,b,s;
                String n;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                s=a+b;
                n=String.valueOf(s);
                jtf_resultado.setText(n);
            }
            
            
        }
    }
     
    public class evenResta implements ActionListener{
         public  void actionPerformed (ActionEvent e){
             if (e.getSource()==btn_resta) {
                double a,b,r;
                String m;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                r=a-b;
                m=String.valueOf(r);
                jtf_resultado.setText(m);
             }
         }
    }
    
    public class evenProducto implements ActionListener{
        public void actionPerformed (ActionEvent eee){
            if (eee.getSource() == btn_producto) {
                double a,b,p;
                String mm;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                p=a*b;
                mm=String.valueOf(p);
                jtf_resultado.setText(mm);
            }
        }
    }
    
    public class evenCociente implements ActionListener{
        public void actionPerformed(ActionEvent eee){
            if (eee.getSource() == btn_cociente) {
                double a, b, c;
                String nn ;
                a=Double.parseDouble(jtf_var1.getText());
                b=Double.parseDouble(jtf_var2.getText());
                if (b != 0) {
                    c=a/b;
                    nn=String.valueOf(c);
                    jtf_resultado.setText(nn);
                    
                }else{
                    JOptionPane.showMessageDialog(null, "No existe");
                }
            }
        }
    }
    
    public class evenSalir implements ActionListener{
        public void actionPerformed (ActionEvent eeee){
            if (eeee.getSource() == btn_salir) {
                System.exit(0);
            }
        }
    }
    
    public static void main(String[] args) {
        Calcu calcu = new Calcu();
    }
    
}

ARCHIVOS

Los programas usan variables para almacenar información: datos de entrada, los resultados calculados y valores intermedios generados a lo largo del cálculo. Toda esta información es efímera: cuando acaba el programa, todo desaparece. Pero, para muchas aplicaciones, es importante poder almacenar datos de manera permanente, es para esto que se crean archivos o también llamados ficheros ya que nos permite guardar información más allá del tiempo de ejecución. Los archivos nos permite interactuar con los dispositivos de almacenamiento externo para poder mantener la información en el tiempo.

Existen dos tipos de archivos:

1. ARCHIVO DE TEXTO O PLANO

Los archivos de texto plano son aquellos que están compuestos únicamente por texto sin formato, solo caracteres, estos caracteres se pueden codificar de distintos modos dependiendo de la lengua usada. Se les conoce también como archivos de texto llano o texto simple por carecer de información destinada a generar formatos y tipos de letra.

2. ARCHIVO BINARIO

Un archivo binario  es un archivo informático que contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento de ordenadores, como por ejemplo: imágenes, sonido, vídeo, etc.

LA CLASE FILE: Proporciona información acerca de los archivos, de sus atributos, de los directorios, etc. Se usa para crear un archivo.

-Constructores

Constructores de la clase File	Ejemplo
public File(String pathname) ;	new File("/carpeta/archivo");
public File(String parent, Stringchild) ;	new File("carpeta", "archivo");
public File(File parent, Stringchild) ;	new File(new File("/carpeta"), "archive");
public File(URI uri) ;	new File(new URI(str);

-Métodos

MÉTODOS
canRead()	comprueba si el fichero se puede leer
canWrite()	comprueba siel fichero se puede escribir
delete()	borra dicho fichero
getPath()	devuelve la ruta del fichero
mkdir()	crea un directorio con la ruta del objeto que lo recibe
isDirectory()	comprueba si dicho fichero es un directorio

JERARQUÍA DE FLUJO DE DATOS

Las clases Reader y Writer son clases bases de la jerarquía para los flujos de caracteres es decir se usa para la escritura y lectura de archivos plano o de texto.

Las clases InputStream y OutputStream con las clases bases para leer y escribir archivos binarios.

EJEMPLO DE LECTURA/ESCRITURA DE ARCHIVO PLANO

A continuación se creará, escribirá y leerá un archivo de texto plano:

 package blogger;

import java.io.BufferedReader;
import java.io.File;
import java.io.FileReader;
import java.io.FileWriter;

public class Archivo_de_texto {
    private File f;
    
    public void crearArchivo(){
        try {
            
            f = new File ("Archivos/archivo_plano.txt");
            
            if(!f.exists()){
                f.createNewFile();
            }
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }      
    }
    
    public void escribirArchivo(){
        try {
            FileWriter fw = new FileWriter(f);
            fw.write("Mi primer archivo plano");
            fw.close();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
   
    }
    public void leerArchivo (){
        try {
            FileReader fr = new FileReader(f);
            BufferedReader br = new BufferedReader(fr);
            String linea = null;
            while ((linea=br.readLine()) != null) {                
                System.out.println(linea);
            }
            br.close();
            fr.close();
            
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

EJEMPLO DE LECTURA/ESCRITURA DE ARCHIVO BINARIO

A continuación se creará, escribirá y leerá un archivo de texto plano:

package blogger;

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.util.ArrayList;
import java.util.List;

public class Archivo_Binario {
    private File f;
    
    public void crearArchivoBinario(){
            try {
                f= new File("Archivos/archivo_binario.txt");
               if(!f.exists()){
                f.createNewFile();
            }
            } catch (Exception e) {
                System.out.println(e.getMessage());
            }
    }    
    
    public void escribir_ArchivoBinario(){
        try {
            List  estudiantes = new ArrayList ();
            Estudiante e1 = new Estudiante("Jorge", "75426598", 18, "1234567", "Sistemas");
            Estudiante e2 = new Estudiante("Martha", "7757856", 16, "1745863", "Zootecnia");
            Estudiante e3 = new Estudiante("Martin", "7786626", 22, "1234567", "Ambiental");
           
            estudiantes.add(e1);
            estudiantes.add(e2);
            estudiantes.add(e3);
            
            FileOutputStream fos = new FileOutputStream(f);
            ObjectOutputStream oos= new ObjectOutputStream(fos);
            oos.writeObject(estudiantes);
            oos.close();
            fos.close();
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
    
    public void leerArchivoBinario(){
        try {
            FileInputStream fis = new FileInputStream(f);
            ObjectInputStream ois = new ObjectInputStream(fis);
            ois.close();
            fis.close();
            
        } catch (Exception e) {
            System.out.println(e.getMessage());
        }
    }
}

ARREGLOS UNIDIMENSIONALES

Concepto de Array

También es conocido como tabla, matriz, vector, arreglo, disposición, etc. Java proporciona una clase Array como contenedor básico de objetos y tipos primitivos. Los arrays surgen de la necesidad de tratar conjuntos de datos del mismo tipo relacionados entre sí. (Ing. Jose F. Vélez Serrano, Universidad Rey Juan Carlos).

Los arreglos son una estructura homogénea de datos, de tamaño constante, en la cual se accede a cada uno de sus elementos mediante un identificador común y uno o varios índices.  

Por definición podemos ver:

• Todos los elementos del array son del mismo tipo.
• El número máximo de valores posibles que puede tomar cada índice se denomina rango de esa dimensión o índice. Los valores han de ser consecutivos, por lo que el índice ha de ser de un tipo ordinal. 
• El número de ellos no varía durante la ejecución del programa.

Declarar y Crear un Array

Para declarar un array se escribe:

tipo_de_dato[]  nombre_del_array;  
o
tipo_de_dato  []nombre_del_array;

Ejemplo: Declarar un array  de  enteros.

int numeros[]; 
Para crear un array de 4 números enteros escribimos 

nombre=new tipo[tamaño];

 numeros=new int[4];

La declaración y la creación del array se pueden hacer en una misma línea. Usando el siguiente formato:

tipo[] nombre=new tipo[tamaño]
por ejemplo:  
int[] numeros =new int[4];

Observación:
En la declaración de una variable array no está permitido  poner el tamaño  del arreglo.

EJERCICIO

El siguiente programa lee por teclado 7 números y una posición (0-9). Elimina el número que corresponde a la posición ingresada.

 

public class Ejercicio {

    public static void main(String[] args) {
        int numeros[] = new int[7];
        int posicion;

        Scanner sc = new Scanner(System.in);
        // lee los 7 números
        for (int i = 0; i < numeros.length; i++) {
            System.out.print("Elemento [" + i + "]: ");
            numeros[i] = sc.nextInt();
        }

        System.out.println();
        // lee la posicion a eliminar
        System.out.print("Posición a eliminar: ");
        posicion = sc.nextInt();
        // desplazamos desde el índice a eliminar hasta el final, todos los 
        //elementos un lugar hacia la izquierda, de esta manera el elemento que
        //está en posición se borra.
        for (int i = posicion; i < numeros.length - 1; i++) //llega hasta la penúltima posición
        {
            numeros[i] = numeros[i + 1];
        }
        System.out.println("El vector queda de la siguiente forma: ");
        for (int i = 0; i < numeros.length - 1; i++) //hay un elemento menos en el arreglo
        {
            System.out.println(numeros[i]);
        }
    }
}