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.