Manual de Tópicos Avanzados de Programación con JAVA Netbeans (página 2)

Hasta el momento ya tenemos creado y llenado el archivo de propiedades, ahora veremos cómo utilizarlo.8. Crea una nueva clase, llámala jcProperties.java

PROGRAMA 2

Esta clase, te permite leer el archivo .Properties que esta contenido dentro del JAR de la aplicación, también puede utilizarse archivos externos sin ningún problema.9. Para implementar este clase, por el momento solo desde consola, el código para la clase MAIN es:

package jcproperties_sample;

import java.util.Properties;

/**

*  @web http://jc-mouse.blogspot.com/

* @author Mouse

*/

public class Main {

    public staticvoid main(String[] args) {

        //se crea una instancia a nuestra clase

        Properties mispropiedades = newjcProperties().getProperties();

        //se leen las propiedades indicando el KEY (identificador) y se imprime

        System.out.println(mispropiedades.getProperty("Description"));

        System.out.println(mispropiedades.getProperty("Question"));

        System.out.println(mispropiedades.getProperty("Warning"));

        System.out.println(mispropiedades.getProperty("Important"));

        //si no existe la KEY que indicamos, este devolvera NULL

        System.out.println();

        System.out.println("Key no existe devuelve: " + mispropiedades.getProperty("keynoexiste"));

    }

}

10. Ejecuta el proyecto, si hiciste todo bien, podras ver el siguiente resultado

PROGRAMA 3

Vamos ahora a crear la aplicación que muestra las imágenes en una carpeta…

Crearemos un nuevo JFrame form, desde netbeans y le damos de nombre MainFrame, o como le quieran llamar. Luego nos vamos al a pestaña de diseño y agregamos de la paleta de componentes un Menú bar al JFrame.

Agregamos al menú File 2 Menú Items y les cambiamos el texto para que digan algo así como esto:

Primero editaremos el código del menú salir, que cerrará la aplicación. Para esto damos clic derecho en el menú salir y le damos en Events > Action > actionPerformed.

Nos manda al código de Java y vamos a borrar lo que dice //TODO y ponemos algo como esto

System.exit (0);

Vamos a agregar de la paleta de netbeans al JFrame un JPanel. Lo centramos, y agregamos 2 botones así como en la figura:

Les cambiaremos el nombre a los botones en el Inspector de Netbeans:

Vamos al código de Java del MainFrame y en el constructor que dice algo como:

/** Creates new form MainFrame */public MainFrame() {initComponents();}

Vamos a agregar la linea despues de initComponents();

this.centrar();

Que es un método que nos centrará la ventana en la pantalla al crearse el JFrame.

Ahora aquí está el método, lo pegan ahí abajo del constructor o donde quieran:

PROGRAMA 4

Private void centrar(){Dimension pantalla = this.getToolkit().getScreenSize();this.setLocation(pantalla.width / 2 – this.getWidth() / 2, pantalla.height / 2 – this.getHeight() / 2);}

private void mostrarImagen(File file){ImagePanel imgPanel = new ImagePanel(file, this.pnlImagen.getWidth(), this.pnlImagen.getHeight());this.pnlImagen.add(imgPanel);this.repaint();}

Este método lo usaremos cuando abramos una imagen desde el menú Archivo > Abrir.

Vamos a la pestaña de diseño y vamos Archivo, Abrir click derecho, Events > Action > ActionPerformed, igual que como lo hicimos con el menú salir, y en el código vamos a poner esto:

JFileChooser fc = new JFileChooser();fc.setFileFilter(new FileNameExtensionFilter("Archivos de imagen", "jpg", "jpeg", "png", "gif"));int opcion = fc.showDialog(this, "Abrir");if (opcion == JFileChooser.APPROVE_OPTION){File file = fc.getSelectedFile();this.mostrarImagen(file);this.cargaDirectorio(file.getParent());}

Lo que hace este fragmento de código es llamar a un FileChooser, que nos va proporcionar el archivo que seleccionemos, le vamos a dar un "filtro" para que solamente nos muestre los archivos de imágenes (extensiones "jpg", "jpeg", "png", "gif"), ahí pueden agregar más extensiones de archivo… Entonces llamamos this.mostrarImagen mandándole el objeto File que seleccionamos, luego inmediatamente, se llama un método aun no creado, llamado this.cargaDirectorio, y le enviamos el directorio del archivo con file.getParent(), en forma de String.

Lo que va a hacer este método va a ser, cargar en el arreglo de File[] todas las imágenes que se encuentren en la carpeta, para después poder ir cambiando de imagen con los botones "<" y ">". Aquí está el método que carga el directorio:

private void cargaDirectorio(String folder){File dir = new File(folder);if (dir.isDirectory()){this.fotos = dir.listFiles(new FilenameFilter(){

public boolean accept(File file, String nombre){if (nombre.endsWith(".jpg") ||nombre.endsWith(".jpeg") ||nombre.endsWith(".gif") ||nombre.endsWith(".png")){return true;}return false;}});}}

if (this.fotos != null){PanelImagen tmp = (PanelImagen) this.pnlImagen.getComponent(0);this.contador++;if (this.contador == this.fotos.length){this.contador = 0;}tmp.setImagenFromFile(this.fotos[this.contador]);}

Lo que se hace aquí es preguntar primero si el arreglo de fotos no es nulo, esto

if (this.fotos != null){PanelImagen tmp = (PanelImagen) this.pnlImagen.getComponent(0);if (this.contador == -1){this.contador = this.fotos.length -1;}tmp.setImagenFromFile(this.fotos[this.contador–]);}

Casi lo mismo…

Formateamos el códifo con ctrl+alt+F en netbeans para que se acomode.

Bueno entonces ya tenemos un pequeño visor de imágenes, esta bastante sencillo, se puede mejorar mucho, pero aquí nada más dejo las bases, bueno AQUI dejo link para el

PROGRAMA 5

El proyecto:1. Crea un nuevo proyecto en netbeans, JAVA – JAVA APLICATION, llamalo "javaapplet".

2. En el proyecto que se crea, elimina el archivo MAIN, ya que no lo necesitamos.

3. Crea un nuevo JAppletForm, clic derecho sobre el paquete "javaapplet" y NEW – JAppletForm… llama a esta nueva clase "interfaz".

Si no encuentras esa opción, debes escoger NEW – OTHER… y en la ventana que te aparece, escoges SWING GUI FORMS – JAPPLET FORM.4. Al nuevo jAppletForm: Interfaz, añade los siguientes controles:

5. Crea una nueva clase; New – Java Class…, y llámalo "imagenNET.java" añade el siguiente código:

package javaapplet;

import java.awt.Dimension;

import java.awt.image.BufferedImage;

import java.io.IOException;

import java.net.URL;

import java.util.logging.Level;

import java.util.logging.Logger;

import javax.imageio.ImageIO;

import javax.swing.ImageIcon;

/**

 * @web http://jc-mouse.blogspot.com/

 * @author Mouse

 */

public class imagenNET extends javax.swing.JLabel {

   String imagen;

   BufferedImage _image;    

    public imagenNET(String i,Dimension d){

        this.imagen=i;

        this.setBounds(0, 0, (int) d.getWidth(),(int) d.getHeight());

        cargar_imagen();

    }    

    /* carga la imagene de la pagina en memoria */  

    public void cargar_imagen(){    

            try {

                URL _url = new URL(this.imagen);

                _image = ImageIO.read(_url);

            } catch (IOException ex) {

                Logger.getLogger(imagenNET.class.getName()).log(Level.SEVERE, null, ex);

            }

            ImageIcon imagenFondo = new ImageIcon(_image);

            this.setIcon(imagenFondo);

            this.repaint();

    }      

}

PROGRAMA 6

Esta clase, que se extiende de un JLabel,  lo unico que hace, es añadir una imagen desde internet a este objeto.6. Ya solo queda añadir un evento al JButton de la clase interfaz y colocar el siguiente evento:

El proyecto ya está terminado, y lo ejecutamos desde netbeans para ver que este todo bien. Para generar los .class y el. JAR, debemos hacer clic derecho sobre el proyecto y elegir "Clean and build".

Luego cuando genero los class necesarios, para ejecutar el applet, clic derecho sobre la clase principal que tenga el método runable, en este caso nuestra clase "interfaz" y escogemos "Run File".

El applet se ejecuta desde el AppletViewer de java, como se ve en la imagen de abajo.

Implementar el applet en un navegador web.Cuando utilizamos la opcion "Clean And Build", netbeans géneros todos los archivos necesarios para implementar el applet en navegadores web. Si se fija en la pestaña Files, podrá ver que los archivos principal que necesitamos es el "javaapplet.jar", y el IDE,  también genero el archivo HTML correspondiente.

En estos dos archivos que utilizaremos, cópialos a una misma carpeta y abre el archivo HTML con el bloc de notas. Modifica el código HTML de la siguiente forma:

Aquí tenemos el applet firmado y ejecutándose desde un navegador web (Firefox)

.

PROGRAMA 8

Algo realmente bueno en la versión 6.1 de NetBeans es que viene configurado nativamente para conectarse al servidor MySQL.

Podemos crear una base de datos desde esa opción. Por ejemplo, creemos la base de datos "sistema". Ni bien se crea, nos pedirá crear una nueva conexión a esta base de datos (usuario, y contraseña). Al finalizar, podemos ver que se creó una nueva conexión en el árbol de "databases".

Creemos una tabla llamada "usuarios" y que tenga los campos:

• id usuario

• contraseña

• nombre

Podemos hacerlo desde la opción de NetBeans "create table" y ejecutando un comando SQL:

Create table usuarios(

Id_usuario varchar(20) not null primary key,

Contraseña varchar(100),

Nombre varchar(100))

Refrescamos el árbol, y veremos la tabla recién creada:

Insertemos unos cuantos valores a nuestra tabla

insert into usuarios values ('diego','diesil','Diego Silva'), ('juanpe','perez','Juan Perez').

PROGRAMA 9

• Mostrar el formulario de inicio de sesión

• Validar los datos ingresados en el formulario.

UNIDAD 2

Interfaz grafica para usuarios

2.1. Creación de interfaz grafica para usuarios.

2.2. Computación Grafica

Como es primer vez que creamos un Servlet tenemos que irnos a otro, y saldrá este menú.

Luego buscamos web y buscamos servlet. y le ponemos nombre al servlet y le damos terminar al siguiente menú ya que no lo iniciaremos con ningún valor .Ya creado nos saldrá esto:

Veamos la imagen para entender como esta formado un servlet.

Bien ahora para usarlos es el mismo lenguaje de java así que no habrá mucho problema.Librerías de Clases en Java y Netbeans

El operador instanceof sirve para consultar si un objeto es una instancia de una clase determinada, o de su padre. Pareciera absurdo tratar de conocer cuál es la clase que da lugar a una instancia específica, sin embargo es de mucha utilidad cuando se trabaja con interfaces y herencia a la vez. Veamos un ejemplo:public classprimo {private intnumero;private intvectorPrimos[];private inttamañoV;publicprimo(){this.tamañoV=25;this.vectorPrimos= new int [this.tamañoV];this.numero=0;}}public class Main {public static void main(String[] args) {primo p = new primo();if (esPrimo(p)){System.out.println("ES INSTANCIA DE PRIMO");}}public static boolean esPrimo(primo p) {return (p instanceof primo);}}Lo que realiza este sencillo ejemplo es comprobar si la instancia llamada "p" corresponde a la clase primo, definida anteriormente, con la ayuda del método

PROGRAMA 3

Lograr abstraer las clases y crear objetos que funcionen de una manera adecuada.Para crear nuestra librería, debemos crear un nuevo proyecto Java en Netbeans, escogiendo la opción de Java Class Library:

Como pueden leer en la descripción dentro de la imagen, una Class Library no contiene una clase Main para que se pueda correr o implementar las clases que se escriban dentro de la misma. Recuerde que la librería dará insumos a sus aplicaciones para realizar tareas a otras aplicaciones o programas.Crearemos una librería que nos servirá para encontrar algunas familias o sucesiones de números. Empezaremos con la sucesión de números Fibonacci y los famosos números Primos. Se crearán clases para encontrar dichas sucesiones de números, conocer el Fibonacci que desee el usuario, evaluar si un número es primo o no, entre otras operaciones. Además, la clase para los fibonacci debe de facilitar métodos y atributos para encontrar los fibonacci que a la vez son primos.A medida que el programador vaya escribiendo y concibiendo sus clases, la librería debe lucir de la siguiente manera:

Para implementar esta librería, basta con construir el proyecto, para generar un Jar que contenga las clases. Luego creamos una nueva aplicación Java que llamaremos ImplementarNumeros:

Ahora, con el proyecto creado, hacemos click derecho sobre el nombre del proyecto en el apartado de proyectos de Netbeans y nos dirigimos a las propiedades del mismo:

Nos dirigimos a la categoría de Librerias. Dentro de ella, agregamos un compilado, que puede ser un proyecto de Netbeans, un folder, una Class Libraryo un Jar. En este caso, agregaremos un Jar, así que presionamos el botón de Add JAR/Folder y buscamos el Jar de nuestra Class Library (Se encuentra en la carpeta dist dentro del folder del proyecto creado por Netbeans).

Al agregarlo, luego dentro del Main del proyecto, importamos las librerías de esta manera:

import numeros.fibonacci;import numeros.primo;

Y ya podremos utilizar toda la funcionalidad de nuestras clases dentro de un proyecto e implementarlas.

PROGRAMA 4

NumberAdditionUI El IDE crea el NumberAdditionUI forma y el NumberAdditionUI clase dentro de la NumberAddition aplicación, y abre la NumberAdditionUI se forman en el GUI Builder. El my.NumberAddition paquete reemplaza el paquete por defecto. La adición de componentes: Hacer el Front End 

• Haga clic en la ficha Diseño en la parte superior de su área de trabajo para volver al formulario de diseño.

• Haga clic con el botón Agregar ( jButton2 ). Desde el menú pop-, seleccione Eventos> Acción> actionPerformed

• Vamos a añadir un código que nuestro trabajo botón Añadir. El código fuente terminado deberá tener el siguiente aspecto:

•  private void jButton2ActionPerformed(java.awt.event.ActionEvent evt){ private void jButton2ActionPerformed (evt java.awt.event.ActionEvent) (

•      / / Primero definimos las variables float.

•      float num1, num2, resultado;

•      / / Tenemos que analizar el texto a un tipo float.

•       num1 = Float.parseFloat (jTextField1.getText ());

•      num2 = Float.parseFloat (jTextField2.getText ());

•      / / Ahora podemos realizar la suma.

•      resultado = num1 + num2;

•      / / Ahora vamos a pasar el valor de resultado que jTextField3.

•       / / Al mismo tiempo, vamos a

•       / / Cambiar el valor del resultado de un flotador en una cadena.

•      jTextField3.setText (String.valueOf (resultado));

PROGRAMA 4

Paso 1:

Observa el siguiente tutorial

Paso 3:

Ahora vamos a agregar algunos componentes al JFrame. Selecciona un label en la paleta haciendo click y luego agrégalo al JFrame haciendo click sobre esta donde quieres que aparezca. De la misma manera agrega un text field y un button. Al terminar tu ventana debe verse de la siguiente manera:

Ahora vamos a cambiar el nombre de nuestros componentes para que sean más fáciles de identificar. De la misma manera que antes, a pesar de que los nombres no son importantes para Java, por convención debemos elegir nombres representativos que nos indicen para qué sirve cada uno de los componentes. Además de eso se utiliza que por convención las primeras tres letras indiquen el tipo de componente de la siguiente manera:

De esta manera vamos a seleccionar nombres para nuestros controles. Para cambiar los nombres debes utilizar la ventana Inspector como se ve en el video. Puedes seleccionar un control y presionar F2 para cambiarle el nombre. Utiliza los siguientes nombres para tus controles:

PROGRAMA 5

Paso 1:

Ahora lo que vamos a hacer es cambiar el texto de los componentes para que sea más claro.

Para encontrar más fácilmente las propiedades podemos seleccionar la caja de propiedades y comenzar a escribir, si hacemos esto aparece la ventana Quick Search que nos permite escribir algo y lo busca por nosotros. Vamos a cambiar el texto de los componentes de la siguiente manera:

Nota que borramos el texto de txtName para que aparezca vacío.

Dentro de esta pantalla vamos a escribir la siguiente línea:

Logramos poniendo la siguiente línea en el constructor, el método que se llama MainFrame():

Por último debes regresar a la clase Main utilizando el explorador de proyectos y agregar la siguiente línea en el método main(), recuerda que el método main() es el punto de inicio de la aplicación, es decir, la primera parte del código que se ejecuta.

¿Recuerdas esta sintaxis? Lo único que estamos diciendo es que queremos construir un nuevo (new) objeto de la clase MainFrame (nuestra ventana).

PROGRAMA 6

Abrimos nuestro IDE y vamos al Menu File o Archivo > New Project o Nuevo Proyecto.

En la siguiente ventana, elegimos :Categoría o Categories > Java y Proyecto o Projects : Java Application

En la siguiente ventana ingresamos el nombre de nuestro proyecto, en nuestro caso minitienday si queremos cambiamos la ruta donde se va a crear el proyecto.

  Presionamos en Finalizar o Finish y en tendremos la pestaña de Proyectos algo como esto:

Y en nuestra ventana editor algo similar a :

Netbeans por defecto no usa este esquema de colores, mas adelante les explicaré como hacer esto.Ahora incluimos las librerías con las que vamos a trabajar, para este caso vamos a insertar solo los jar que necesitamos.

  Elegimos el archivo que queremos :

  Con esto tendremos que se ha agregado a las librerías de nuestro proyecto.

  Esto es lo que a veces van a encontrar con el termino agregar al CLASSPATH del proyecto

 Todas estas librerías son Open Source y las puede encontrar en internet, les dejo algunos enlaces.

Programa 8

AHORA A LA ACCIÓN!

? Abrimos el NetBeans 6.8 y vamos a "Archivo/Proyecto nuevo", como se muestra en la imagen:

Crear nuevo Proyecto

  El siguiente paso es seleccionar en la parte categorías la carpeta "Java Web" después seleccionamos en el espacio de Proyectos "Web Application" y terminamos presionando el botón "Siguiente>" tal cual se muestra resaltado con rojo en la imagen:

Seleccionar Proyecto

El siguiente paso es el dos y se puede apreciar en el cuadro rojo "2.-Name y Location" en este paso le damos el nombre al proyecto que estamos creando nosotros le dimos el nombre de "aprendiendoJavaEERichFaces"ustedes le pueden dar el que ustedes quieran, la localización del proyecto automáticamente NetBeans la completa por ustedes, para finalizar este paso le damos click al botón "Siguiente>", como mostramos en la imagen:

Nombre y localización del proyecto

El siguiente paso corresponde a "3.- Server and Settings" donde elegimos el Servidor que utilizaremos para nuestro proyecto, nosotros ya le hemos dicho que el que se tiene que utilizar es "GlassFish Domain v3?NetBeans lo seleccionara solo si es que no has instalado otro server en tu NetBeans, luego presionas"Siguiente>",te tiene que quedar como en la imagen:

Server and Settings

El último y siguiente paso es "4.- Frameworks" NetBeans les mostrara una lista de los Frameworks que tiene disponibles nosotros seleccionamos "JavaServer Faces" seleccionada esa opción se les activara la pestaña de configurar JavaServer Faces, seleccionen la opción "use default library which comes with Server (JSF 2.0)" Es la que NetBeans muestra por defecto, luego hacen click en el botón "Terminar" y el proceso de creación del proyecto termina, como se muestra en la imagen:

Framework- JavaServer Faces

Programa 9

Si hicieron los pasos que les señalamos tendrían que tener un resultado como la imagen:

Resultado de creación de proyecto

Ahora ya estamos en condiciones para poder implementar la librería de RichFaces para esto tenemos que seguir una serie de pasos que daremos a continuación:

Se acuerdan de las librerías de RichFaces que enumeramos en la parte de arriba, bueno ahora las utilizaremos, para que recuerden las librerías las enumeramos a continuación recuerden que tienen que tener TODAS:

• richfaces-api-3.3.3.Final

• richfaces-impl-jsf2-3.3.3.Final

• richfaces-ui-3.3.3.Final

• commons-beanutils-1.7.0.jar

• commons-collections-3.2.jar

• commons-digester-1.8.jar

• commons-logging-1.0.4.jar

• jhighlight-1.0.jar

Ahora vamos a la carpeta donde se aloja nuestro proyecto en mí caso es la siguiente:

C:UsersGerardoDocumentsNetBeansProjectsaprendiendoJavaEERichFaces.

En el interior de la carpeta creamos una nueva carpeta con el nombre "lib" y en su interior pegamos todas las librerías que son de RichaFaces, como se muestra en la imagen:

Librerías RichaFaces

Una vez creado la carpeta lib en nuestro proyecto y copiado todas las librerías solicitadas por RichFaces en su interior, vamos de nuevo al NetBeans 6.8, en el proyecto que hemos creado hacemos un click izquierdo encima de la carpeta "librerías" para seleccionarla y luego un click derecho y le hacemos click a "Agregar archivo JAR/Carpeta…", como se ve en la imagen:

Agregar Archivo JAR

A continuación se abrirá una ventana y tenemos que ir a la carpeta "lib" que hemos creado en nuestro proyecto y seleccionar TODAS las librerías y hacer click en abrir, con esto recién estaremos adjuntando las librerías que el proyecto necesita para usar RichFaces.

Programa 10

Una vez creado la carpeta lib en nuestro proyecto y copiado todas las librerías solicitadas por RichFaces en su interior, vamos de nuevo al NetBeans 6.8, en el proyecto que hemos creado hacemos un click izquierdo encima de la carpeta "librerías" para seleccionarla y luego un click derecho y le hacemos click a "Agregar archivo JAR/Carpeta …", como se ve en la imagen:

Agregar Archivo JAR

A continuación se abrirá una ventana y tenemos que ir a la carpeta "lib" que hemos creado en nuestro proyecto y seleccionar TODAS las librerías y hacer click en abrir, con esto recién estaremos adjuntando las librerías que el proyecto necesita para usar RichFaces:

Cargar Librerías al proyecto

Ahora su proyecto tiene que mostrar las librerías respectivas cargadas, como se puede ver en la imagen:

Librerías RichFaces cargadas

Ahora que ya tenemos las librerías cargadas tenemos que cambiar la configuración del proyecto para que este reconozca las librerías de RichFaces, entonces vamos a "configuration files" le hacemos doble click al archivo"web.xml", después que se habrá este archivo le hacemos click a "Operador XML", como se muestra en la imagen:

Configuración web.XML

Se le abrirá la ventana con código XML, ese código tiene que ser reemplazado por completo por el que mostraremos a continuación, recomendación es borrar todo el código que tenía el archivo y copiarlo por completo por el siguiente:

Tal cual como esta arriba les tiene que quedar el archivo "web.xml" , después procedemos a guardar el proyecto. La tecnología que usaremos no es compatible con el formato que trae "index.xhtml", por lo que tenemos que eliminar este archivo que se encuentra en la carpeta "Web Pages", en la imagen se muestra clara su ubicación y de la forma que tienen que eliminarlo:

Unidad 3

Programas 1-10

 La tecnología que usaremos no es compatible con el formato que trae "index.xhtml", por lo que tenemos que eliminar este archivo que se encuentra en la carpeta "Web Pages", en la imagen se muestra clara su ubicación y de la forma que tienen que eliminarlo:

Suprimir index.xhtml

Ahora que ya lo hemos eliminado necesitamos crear nuestro archivo "index" que sea compatible con la tecnología que estamos utilizando, para crearlo le hacemos click izquierdo en la carpeta "Web Pages" y click derecho vamos a "Nuevo" y después "JSP", como muestra la imagen:

Crear index.jsp

Luego se nos abrirá una ventana donde escogeremos el nombre del archivo JSP creado, como este archivo es el que reemplazara a "index.xhtml" le pondremos el nombre de "index" por resultado se creara un archivo"index.jsp":

index.jsp

Una vez creado el "index.jsp" nos tiene que quedar de esta forma nuestro proyecto, como se ve en la imagen:

index.jsp

Tenemos que preocuparnos de que el archivo "web.xml" tenga que tener configurado la ruta hacia el "index.jsp" para hacerlo buscamos estas líneas de código y vemos que se encuentren de la siguiente forma:

Después de haber copiado el código tal cual, procedemos a compilar y a ejecutar nuestro proyecto para compilar el proyecto presionamos < Mayúscula + F11> la idea es que haga un Clean and Build , después para ejecutar el proyecto presionamos F6 y el proyecto comenzara a ejecutarse, el resultado que tienen que tener se muestra a continuación:

Resultado Final

De esta forma hemos logrado solo implementar RichFaces en JavaServer Faces, este Framework posee un sin fin de componentes que hacen mas amigable la interfaz de nuestros programas, en su pagina oficial hay un Live Demo , que muestra los componentes con sus respectivos codigos, es muy interactiva y ayuda de mucho el link es este. Espero que les haga gustado el post e implementado RichFaces, espero sus comentarios, se despide Gerardo, Adios.

UNIDAD 3

Definir una variable local

Lo que diferencia a esta de las demás es el lugar en donde se colocan. Toda variable local debe colocarse dentro de un método y fuera de cualquier bloque que se defina dentro de este.

Las variables globales: son accesibles desde cualquier parte de la clase y por tanto por cualquier método que este contenido en esta, la imagen nos muestra las variables Globales en el bloque numerado con 1 y 3. Dado que la parte en la cual fueron definidas es la clase y fuera de cualquier método. La palabra static significa que la variable pertenece a la clase y no a las instancias de la misma aunque esta es teoría orientada a objetos aplica para un mejor entendimiento.

Las variables locales: son accesibles solo para el método en el cual han sido definidas en este caso las encerradas en el bloque 2. Dos variables de ámbitos distintos pueden llamarse igual, esto no se aconseja dado que hace necesario ingresar un elemento que se denomina resolución de ambigüedad this, con fines prácticos evitaremos que esto suceda. 

Las variables de bloque: son las que se definen dentro de los bloques como el si él mientras y otros que más adelante trabajaremos en el curso.

Las formas de conversión de textos a numéricos son las siguientes: 

Integer.parseInt(texto); //convierte el texto dado a enteroLong.parseLong(texto);//convierte el texto dado a un enteroDouble.parseDouble(texto);//convierte el texto dado a decimal

5. Operadores aritméticos de java.Asignación = 

Suma  +

Resta   –

Multiplicación  *

División             /

Modulo             %

Potenciación  Math.pow(base,exponente)

Raiz cuadrada Math.sqrt(radicando)

Incremento de uno ++

Decremento de uno —

6. Operadores relacionales que aplica solo para los números no para los textos

mayor que  >

menor que  <</font>

mayor o igual que >=

menor o igual que <=

igual que ==

diferente que !=

COMO HACER UN RADIO BUTTON

Primero creas un proyecto y le das nombre

Luego te vas a proyectos y en paquetes le das click derecho y creas un nuevo jframe

Le das un nombre al jframe

Luego te vas a contenedores swing y jalas el radio button

Le das click derecho al radio button seleccionas actipon performed y generas tu código

COMO HACER UN DESLIZADOR

Primero creas un proyecto y le das nombre

Luego te vas a proyectos y en paquetes le das click derecho y creas un nuevo jframe

Le das un nombre al jframe

Luego te vas a contenedores swing y jalas el deslizador

Le das click derecho al deslizador seleccionas action performed y generas tu código

COMO HACER UN MENU

Primero creamos un nuevo proyecto en netbeans

En los paquetes creamos un jfrane

Agragamos un nombre a nustrojfrane

Ela parte superior nos vamos a swing containers

Extraemos un menú para nuestro jfrane

Realizamos un actionevent para nustro menú

Nos vamos a nuestro código y empezamos a desarróllalo

Y como vemos en nustro programa llaesta listo para que se modifique solo los primeros pasos

Creamos un nuevo panel para que nos aparescanustro mensaje

Asi es como nos queda nuestro proyecto solo es darle nuestro mensaje

COMO HACER UNA LISTA

Primero creas un nuevo proyecto y le das un nombre

Luego te vas al lado izquierdo y te vas a tu proyecto a paquetes le das click derecho y le das new jframe

Le das un nombre a tu jframe

De el lado derecho te vas a tus controles swing

Jalas tu opción de lista y le das click derecho , propiedades y donde dice ITEM1,ITEM2, etc le pones los nombres que quieres que lleve tu lista.

Una vez que lo hayas hecho le das click derecho en eventos, action performed y generas tu código te aparecerá una ventana así.

EJEMPLO USO DEL TOGGLE BUTTON

1.- creamos una Nueva Java Application, y le damos el nombre appEjemploSWING, luego en los "SourcePackages" agregamos un nuevo package llamado ejemplo.

2.-Finalmente agregamos una JFrameForm al package recién creado, y lo llamados frmEjemplo.Al realizar esto agregamos una JFrame que corresponde a un formulario de nivel superior en SWING.Después de realizado lo anterior se debería ver como sigue:

3.-En la ventana anterior se puede apreciar el DiseñadorMatisse, que trae incoporadoNetBeans, además de la Paleta de Controles y la Ventana de Propiedades.4.-En la ventana de propiedades, cambiamos las propiedades title (título del JFrame), por "Ejemplo con SWING" (sin comillas), y también podemos desmarcar la propiedad Resizable, para que no podamos modificar el tamaño del JFrame en tiempo de ejecución.5.-Luego, arrastramos desde la Paleta de Controles SWING los siguientes controles: 1 Label (jLabel), 1 TextField (jTextField), y un Button (jButton). Como es un ejemplo básico no entraré en muchos detalles, ni tampoco estableceré sus respectivas propiedades Name.Lo siguiente sería cambiar las propiedades text de cada uno de ellos para que el formulario quede de la siguiente forma:

6.-El siguiente paso será escribir cierto código que nos permita 2 cosas: mejorar la apariencia del JFrame, y realizar el saludo cuando presionemos el Button.7.-Entonces nos vamos a la ventana de código, presionándo el ToggleButton "Source", que se encuentra al lado izquierdo de Design.Bajo package ejemplo, incorporamos:

importjavax.swing.*;

y bajo la declaracion: publicvoidrun() {, incorporamos:JFrame.setDefaultLookAndFeelDecorated(true);JDialog.setDefaultLookAndFeelDecorated(true);

8.-Volvemos a la vista de Diseño (Design), y hacemos doble click sobre el Button, se vuelve a abrir la vista de código, y en lugar en que aparece el cursor, escribimos:JOptionPane.showMessageDialog(this, "Hola " + jTextField1.getText(),"saludos",JOptionPane.INFORMATION_MESSAGE);

Lo probamos, y el programa corriendo queda…

9.-El código del programa, incluyendo el código generado por NetBeans es el siguiente.

package ejemplo;import javax.swing.*;public class frmEjemplo extends javax.swing.JFrame {public frmEjemplo() {initComponents();}@SuppressWarnings("unchecked")// private void initComponents() {jLabel1 = new javax.swing.JLabel();jTextField1 = new javax.swing.JTextField();jButton1 = new javax.swing.JButton();setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);setTitle("Ejemplo con SWING");setResizable(false);jLabel1.setText("Ingresesunombre:");jButton1.setText("Saludar");jButton1.addActionListener(new java.awt.event.ActionListener() {public void actionPerformed(java.awt.event.ActionEventevt) {jButton1ActionPerformed(evt);}});javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane());getContentPane().setLayout(layout);layout.setHorizontalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(layout.createSequentialGroup().addGap(28, 28, 28).addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(layout.createSequentialGroup().addGap(10, 10, 10).addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE, 257,javax.swing.GroupLayout.PREFERRED_SIZE).addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED).addComponent(jButton1)).addComponent(jLabel1)).addContainerGap(30, Short.MAX_VALUE)));layout.setVerticalGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING).addGroup(layout.createSequentialGroup().addGap(42, 42, 42).addComponent(jLabel1).addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED).addGroup(layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASELINE).addComponent(jTextField1, javax.swing.GroupLayout.PREFERRED_SIZE,javax.swing.GroupLayout.DEFAULT_SIZE,javax.swing.GroupLayout.PREFERRED_SIZE).addComponent(jButton1)).addContainerGap(81, Short.MAX_VALUE)));pack();}// private void jButton1ActionPerformed(java.awt.event.ActionEventevt) {// TODO add your handling code here:JOptionPane.showMessageDialog(this, "Hola " + jTextField1.getText(),"saludos",JOptionPane.INFORMATION_MESSAGE);}public static void main(String args[]) {java.awt.EventQueue.invokeLater(new Runnable() {public void run() {JFrame.setDefaultLookAndFeelDecorated(true);JDialog.setDefaultLookAndFeelDecorated(true);new frmEjemplo().setVisible(true);}});}private javax.swing.JButton jButton1;private javax.swing.JLabel jLabel1;private javax.swing.JTextField jTextField1;}

CREAMOS UN NUEVO PROYECTO LLAMADO SEPARADOR

Agregamos un nombre y damos finish

Listo tenemos nuetro proyecto

Creamos nuestro jfrane para implementar los conceptos

Esta clase contiene el método estático main (método vinculado a la clase y no a sus instancias u objetos) necesario para arrancar, a través de la máquina virtual de Java, el proyecto. ¿Qué hace exactamente el método main?. Pues llamar

Vemos pues que el JFrame, contiene

• Un panel (JPanel) principal que ocupa todo el JFrame

• Un menu principal (JMenuBar) con dos opciones fileMenu y helpMenu (los dos son componentes JMenuItem y los dos tienen a su vez una opción de menú, son los llamados JMenuItem).

Listo lla tenemos nustro pequeño separador en netbeans

UNIDAD 4

Hilos

4.1. Concepto de hilo.

4.2. Comparación de un programa de flujo único contra uno de flujo múltiple

4.3. Creación y control de hilos

4.4. Sincronización de hilos

COMO GENERAR UN PROYECTO DE HILOS RAPIDAMENTE

Primero creas un proyecto y le das nombre

Para hacer un código en hilos tienes que gregarle extends Thread después de tu primer public class

PROGRAMA DE HILOS EN JAVA

Programa de hilos de cómo se van haciendo los nombres de cada hilo

Programa que realiza calcula los grados de temperatura

Crear un nuevo proyecto ICEfaces

• vamos a crear un proyecto llamado procomponentesicefaces

• tal y como creamos el proyecto projspservlets en el apartado Crear un nuevo proyecto Web

En este proyecto indicamos en el combo Server: que el servidor es GlassFish V2 y seguidamente hacemos clic soble el botón 

En el apartado Frameworks indicamos lo siguiente

• ICEfaces

• lo seleccionamos

Para terminar de crear el proyecto hacemos clic sobre el botón 

4.2. Comparación de un programa de flujo único contra uno de flujo múltiple

4.3. Creación y control de hil4.4. Sincronización de hilos

Una ventana splash es una ventana de presentación ; sin los botones clásicos y que va a servir para darle una mejor presentación a nuestro proyecto.

Esta ventana se debe colocar al principio de nuestra aplicación; para empezar debemos diseñar la que será nuestra imagen de presentación la cual por motivos de tiempo elegí la de NetBeans ; y a esta le vamos a agregar una barra de progreso :

• Abrimos el NetBeans y creamos un nuevo proyecto , el cual lo desmarcamos para que no cree la clase main :

• Creamos el folder en donde irá nuestra imagen; para ello clic derecho en Source Package ? New ? Other por lo que saldrá una ventana en la cual debemos elegir  Other ? Folder   y finalmente le damos el nombre que queramos

Ahora creamos un paquete Splash en el cual vamos a agregar un JFrame y también creamos una clase para el hilo que vamos a usar , por lo que les debe quedar así :

• Vamos a trabajar en nuestro Frame, al cual le hacemos clic derecho ? SetLayout y le damos BorderLayout hecho esto colocamos dos paneles : uno en el sur y otro en el centro (seguir el orden para no tener complicaciones). Después de haber agregado los paneles a cada uno le vamos a dar BorderLayout al igual que al frame. Hecho esto vamos a colocar en el panel del sur un JProgressBar al que le vamos a llamar progreso y en el panel central una etiqueta; nos debe quedar así :

• Para cambiar el nombre del JProgresBar podemos darle clic derecho a la barra y elegimos "Change Variable name" a continuación nos saldrá la siguiente ventana en la cual debemos colocar el nombre de la barra

• En el panel central vamos a colocar una etiqueta al cual le vamos  a colocar una imagen, ver esta entrada para ver cómo colocar una imagen :

• En el diseñador del JFrame nos vamos a agregar código , para ello hacemos clic en en boton source ;  y ya en la clase del JFrame (al cual llame Principal) le agregamos un objeto Hilo :

import java.awt.Color;public class Principal extends javax.swing.JFrame{ HiloProgreso hilo;

• Vamos a el constructor y le agregamos el siguiente código : 

public Principal() { //Método por defecto initComponents(); iniciarSplash(); //Creamos un objeto HiloProgreso al cual //le pasamos por parámetro la barra de progreso hilo=new HiloProgreso(progreso); //Iniciamos el Hilo hilo.start(); //Le damos tamaño y posición a nuestro Frame this.setLocation(200,200); this.setSize(472,249); //Liberamos recursos hilo=null; }

• Creamos un método get para nuestro JProgressBar , para ello o bien lo agregamos directamente o bien hacemos que el NetBeans lo genere , para ello clic derecho sobre el atributo ? seleccionamos Refactor ? Seleccionamos Encapsule Fields  y en la ventana que aparece simplemente seleccionamos los métodos set y get que deseamos que NetBeans genere:

• Hecho esto aparecerá la siguiente línea de código : 

public javax.swing.JProgressBar getjProgressBar1() { return progreso; }

• Ahora si podemos crera nuestro método iniciar Splash : 

public void iniciarSplash() { this.getjProgressBar1().setBorderPainted(true); this.getjProgressBar1().setForeground(new Color(50, 50, 153, 100)); this.getjProgressBar1().setStringPainted(true); }

• NetBeans nos debe estar marcando un error , esto se da porque aún no hemos creado nuestra clase HiloProgreso ; para ello clic en el paquete Splash ? New ? Java Class y a la clase le damos de nombre HiloProgreso y la vamos hacer que extienda de Thread ; en esta clase debemos crear una referencia a la barra de progreso que vamos a pasar por parámetros para lo cual declaramos un JProgressBar progreso : 

package Splash;import javax.swing.JProgressBar;public class HiloProgreso extends Thread{ JProgressBar progreso;

• Ahora vamos a crear nuestro método constructor el cual va a tener como parámetros una barra de progreso1 , se debe observar como se da la relación de asociación ; es decir la referencia del objeto que pasó por parámetro la asigno a la referencia que cree anteriormente y con esto puedo usar todos sus métodos (el super es para llamar al método constructor de la clase Thread y por ley debe ser la primera línea en el método constructor de la clase hija) : 

public class HiloProgreso extends Thread{ JProgressBar progreso; public HiloProgreso(JProgressBar progreso1) { super(); this.progreso=progreso1; }

• Hecho esto vamos a crear el método run que va a servir para correr el hilo : 

• public void run() { for(int i=1;i<=100;i++) { progreso.setValue(i); pausa(100); } }

• Y por último creamos nuestro método pausa , que como el nombre indica nos va a dar una pausa para que la barra de progreso no llegue al 100% n bien corramos la aplicación : 

public void pausa(int mlSeg) { try { // pausa para el splash Thread.sleep(mlSeg); }catch(Exception e){} }

• Hecho esto presionamos F6 y veremos algo como esto :

Para crear la calculadora de la imágen anterior debemos tener en cuenta la interfaz y los eventos. Lo ideal es mantener el código que permite los cálculos en una clase separada, pero aqui todo se realizará en una única clase.Para comenzar a trabajar con componentes gráficos y eventos debemos agregar al inicio del archivo de la clase las siguientes inclusiones:

Con esto importamos todas las clases awt, events y swing.Estructura del programa

Nuestra clase se llamará Main y nuestro archivo main.class. Este es su esqueleto:

Como se puede ver, nuestra clase extiende JFrame e implementa la interface ActionListener que nos obliga a implementar el método actionPerformed (click en botón).Se tienen atributos privados, el primero un cuadro de texto, los demas contadores y variables de control.Luego tenemos el constructor de la clase, que nos servirá para crear la interfaz y asignar eventos a los controles correspondientes (lo veremos ahora mismo). Luego tenemos un método estatico especial llamado main (en minúsculas) que nos permite ejecutar la calculadora.Y por último un evento para capturar los clicks del usuario sobre los diferentes botones de la calculadora.

Creando la interfaz

Dentro del constructor podemos ver este código:

Primero asignamos el título de la ventana y creamos un vector con los caracteres de los botones. Si lo notaron tiene un orden algo extraño, esto se debe al algoritmo que se usa luego para crear los controles recorriendo el vector.Posteriormente creamos un JPanel y le asignamos un layout tipo grid de 4 columnas, entonces al recorrer el vector vamos agregando a este panel objetos JButton creados con la etiqueta que obtenemos del item actual del vector y de paso ya le asignamos el controlador del evento (el mismo objeto, this, hace referencia a esta misma instancia de la clase Main).Al salir del ciclo ya tenemos todos los botones, pero nos falta un poco para terminar el diseño. Creamos un cuadro de texto y le fijamos alineación de texto a la derecha (será donde se muestren los resultados entre otras cosas). Inicialmente le asignamos un texto igual a "0".Al panel principal le colocamos el layout BorderLayout, agregamos el cuadro de texto arriba y al centro el panel que contiene todos los botones generados anteriormente.

Capturando los eventos

Nuestra interfaz nos quedó muy bonita, pero no hace nada. Debemos darle funcionalidad y esto lo hacemos en el evento que captura los click del usuario sobre los diferentes botones de la interfaz.

UNIDAD 5

Dispositivos móviles

Ahora basta con pulsar sobre el botón Edit, lo que dará lugar a la aparición de la ventana de edición:

Sobre esta ventana, en el recuadro Icon escribiremos /icons/iconoPeq.png, tal y como se aprecia a continuación:

Al finalizar se pulsa sobre el botón Aceptar de la ventana de edición. Con esto queda registrado el cambio de la propiedad correspondiente al icono del MIDlet:

Y pulsando sobre el botón OK desaparece la ventana de propiedades. Esto es todo lo necesario para poder generar y ejecutar el MIDlet. En primer lugar, procedemos a generar las clases a partir del código fuente. Para ello se pulsa el botón Build. Si todo ha ido bien, aparecerá un mensaje indicado que la generación se realizó de forma correcta. En caso de haber errores, se mostrarán en la ventana principal de KToolbar.

En cuanto se ha generado el MIDlet, podemos ejecutar mediante el botón Run. Al pulsarlo, aparecerá el emulador con el MIDlet listo para ejecución.

Conclusiones

Esta materia aporta al perfil la competencia para desarrollar soluciones de software utilizando programación concurrente, programación de eventos, que soporte interfaz gráfica y comunicación con dispositivos móviles.

Se inicia estudiando la programación concurrente desde la conceptualización del hilo, su creación, control y destrucción, así como la sincronización de varios hilos.

Finalmente la materia se complementa con la introducción a la programación móvil, a través de la revisión de las distintas tecnologías, selección de una de ellas y desarrollo de una aplicación básica. Para el logro de los objetivos es necesario que el estudiante tenga competencias previas en cuanto a paradigmas de programación, el uso de metodologías para la solución de problemas mediante la construcción de algoritmos utilizando un lenguaje de programación orientada a objetos, el manejo de conceptos básicos de Hardware y Software, construcción de modelos de software empleando el lenguaje de modelado unificado (UML).

Debido a las competencias que el estudiante requiere como base para el desarrollo de las planteadas en este programa, la asignatura esta considerada cursarse cuando el estudiante haya desarrollado la competencia de programar, es recomendable cursarla inmediatamente después de haber aprobado el curso de programación orientada a objetos, y evitar cursarla en semestres muy avanzados tomando en cuenta que en esta materia el estudiante desarrollará competencias necesarias para cursos posteriores entre los que se encuentran los talleres de bases de datos y programación web.

Sistema de asignación y transferencia de créditos académicos programación de eventos, en donde el objetivo es que estudiante logre que la estructura y ejecución del programa dependan de los sucesos (eventos) que ocurran en el sistema o que ellos mismos provoquen. El estudiante debe desarrollar la habilidad de definir los eventos a los cuales el programa reaccionará y las acciones que seguirá al presentarse cada uno.

En la segunda unidad se estudia la Interfaz gráfica de usuario (GUI), dependiendo de las herramientas utilizadas en los cursos anteriores se puede elegir la misma herramienta o una distinta con el fin de que el estudiante aprenda a utilizar los componentes gráficos que brinde el entorno de desarrollo, que incluya el manejo de eventos y que desarrolle nuevos componentes derivados de los ya existentes pero que incluyan nuevas propiedades.

Las unidades uno y dos pueden ser estudiadas simultáneamente considerando que están estrechamente relacionadas, para ello es recomendable considerar los conocimientos previos del grupo y las herramientas de desarrollo con las que están familiarizados. La resolución de problemas como una herramienta resulta eficaz para aprender estos conocimientos, partiendo de la definición de un problema real que pueda ser resuelto utilizando la programación de eventos y requiera de una interfaz gráfica.

La tercer unidad se enfoca al estudio de la creación y manejo de librerías y componentes (estos términos pueden variar según el lenguaje de programación utilizado). Se entiende como librería a un conjunto de bloques de códigos de programación normalmente compilados, que pueden ser incluidos en una aplicación para su uso. Y a un componente como una clase de uso específico, lista para usar, que puede ser configurada o utilizada de forma visual, desde el entorno de desarrollo. Esta unidad debe enfatizar la creación de nuevas librerías y componentes y evitar el estudio exhaustivo de las que incluya el entorno de desarrollo, a estas últimas enfocarse solo en revisar la forma de utilizarlos.

En la cuarta unidad se aborda un tema complicado por lo que requiere de un tiempo razonable dentro del curso para su estudio, el tema de programación concurrente requiere de iniciar con el estudio a nivel conceptual sobre los hilos y su funcionamiento, y después ir implementando aplicaciones multi hilos. Uno de los puntos mas sensibles es la sincronización por lo que deben hacerse hincapié en una buena implementación. Para esta unidad es recomendable hacer prácticas sencillas para comprender la funcionalidad de los hilos, el manejo de sus estados y la sincronización, para finalmente desarrollar aplicaciones que usen la programación concurrente en la resolución de problemas reales. La quinta unidad se refiere al estudio de la programación de dispositivos móviles, la intención de esta unidad es realizar un estudio a nivel introductorio sobre las distintas tecnologías que hay en el mercado, y desarrollar aplicaciones sencillas para esta clase de dispositivos.

El enfoque sugerido para la materia requiere que las actividades prácticas promuevan el desarrollo de habilidades para la experimentación, tales como: identificación, manejo y control de variables y datos relevantes; planteamiento de hipótesis; trabajo en equipo; asimismo, propicien procesos intelectuales como inducción–deducción y análisis–síntesis con la intención de generar una actividad intelectual compleja; por esta razón varias de las actividades prácticas se han descrito como actividades previas al tratamiento teórico de los temas, de manera que no sean una mera corroboración de lo visto previamente en clase, sino una oportunidad para conceptualizar a partir de lo observado.

También se busca desarrollar habilidades creativas y emprendedoras, dando un espacio al estudiante para que detecte aéreas de oportunidad en su entorno y genere el proyecto que desarrollara en el transcurso del curso. Del mismo modo por la naturaleza de la materia debe promoverse la cultura de ética y respeto a los derechos de autor, tanto en las aplicaciones desarrolladas como en el uso de las herramientas utilizadas.

En las actividades prácticas sugeridas, es conveniente que el profesor busque sólo guiar a sus estudiantes para que ellos hagan la elección de las variables a controlar registrar. Para que aprendan a planificar, que no planifique el profesor todo por ellos, sino involucrarlos en el proceso de planeación.

En el transcurso de las actividades programadas es muy importante que el estudiante aprenda a valorar las actividades que lleva a cabo y entienda que está construyendo su hacer futuro y en consecuencia actúe de una manera profesional; de igual manera, aprecie la importancia del conocimiento y los hábitos de trabajo; desarrolle la precisión y la curiosidad, la puntualidad, el entusiasmo y el interés, la tenacidad, la flexibilidad y la autonomía.

El estudiante creará tipos de datos complejos utilizando estructuras de datos definidas por el usuario, buscar y seleccionar información sobre las opciones de tipos de datos definidos por el usuario de acuerdo a la sintaxis del lenguaje de programación empleado. Elaborar programas sobre manejo de bits.

Esta unidad aporta al perfil la competencia para desarrollar soluciones de software utilizando programación concurrente, programación de eventos, que soporte interfaz gráfica y comunicación con dispositivos móviles.