2011

APRENDIENDO JAVA
Java y sus aplicaciones
Descubra de una forma cmoda y clara el lenguaje del nuevo siglo.

ANDINO, ARAUJO, ENRQUEZ, MENESES QUINTO B1 16/07/2011

Gerente de marca: Ing. Darwin Alulema

LENGUAJE JAVA Prohibida la reproduccin parcial o total de esta obra, por cualquier medio, sin autorizacin escrita de los autores y editor. DERECHOS RESERVADOS 2011, respecto a la primera edicin. ISBN 970-10-2546-6 Realizado en Quito Ecuador.

Agradecemos a nuestros padres y amigos que han comprendido nuestras arduas tareas de estudio.

De igual manera agradecemos al Ing. Darwin Alulema por su dedicacion, paciencia y extraordinaria eficacia al transmitirnos sus conocimientos y permitirnos desarrollar aplicaciones prcticas para nuestra carrera.

Carlos, Roberto, Luis, Patty.

PROLOGO Este libro est escrito con el fin de que sea til como texto para los estudiantes de Ingeniera en Electrnica. Los temas tratados cubren totalmente el programa semestral de estudios de una asignatura fundamental en la carrera. El nombre oficial de esta materia puede variar segn la institucin en la que se imparta, pero su contenido y los temas que deben ser cubiertos son casi los mismos. Escribir este libro no fue una tarea fcil, ya que la investigacin con seriedad y la redaccin e ilustracin con originalidad exigieron inversin de mucho tiempo. Sin embargo, adems de la propia motivacin que constantemente nos dieron nuestros padres, la razn final por la que decidimos hacerlo fue porque la tarea de nuestro profesor as lo exigi ya que en el camino de este semestre de se hizo necesaria comprobar el grado de enseanza que obtuvimos en el camino. La obra que ponemos a consideracin est realizado por jvenes estudiantes, es por ello que el lenguaje utilizado es una forma de comunicar todo lo aprendido en nuestras palabras, gracias a ello se ha hecho totalmente entendible para cualquier pblico que lo quiera aprender. De igual forma lo que tratamos es subsanar deficiencias que encontramos en tutoriales o textos previamente indagados presentando temas de un orden lgico y con una buena cantidad de ejemplos. Esperamos que los futuros ingenieros la vean como una herramienta til en sus estudios y agradecemos la oportunidad de nuestro tutor por la invaluable oportunidad para poder realizarla.

NDICE
Captulo 1 ...................................................................................................................................... 8 1. Historia de Java ......................................................................................................................... 9 2. Caractersticas ........................................................................................................................... 9 3. Programando en Bloc de notas ............................................................................................... 11 4. Fundamentos para escribir en Java ......................................................................................... 16 4.1. Tipos de variables............................................................................................................. 17 4.2. Peticiones de valores al usuario ....................................................................................... 23 4.2.1. Instrucciones condicionales y de repeticin .............................................................. 23 CAPTULO 2 ................................................................................................................................. 32 5 Objetos ..................................................................................................................................... 33 5.1. Instanciacin de Objetos: ................................................................................................. 33 6. Clases ....................................................................................................................................... 33 7. Netbeans IDE ........................................................................................................................... 35 7.1. Preparando el rea de trabajo ........................................................................................... 36 8. Referencias .............................................................................................................................. 41 9. Tipos de acceso ....................................................................................................................... 41 Ejercicios...................................................................................................................................... 42 Ayudas al Usuario ........................................................................................................................ 44 Capitulo 3 .................................................................................................................................... 48 13. Polimorfismo ......................................................................................................................... 51 14. Clases abstractas ................................................................................................................... 51 15. Interfaces............................................................................................................................... 51 15.1. Excepciones.................................................................................................................... 52 15.1.1. Bloques Try-Catch. ................................................................................................. 54 16. JOptionPane .......................................................................................................................... 55 Ejemplos ...................................................................................................................................... 58 Ejercicio ....................................................................................................................................... 65 Ayudas al usuario ........................................................................................................................ 66 Capitulo 4 .................................................................................................................................... 69 17. Componentes de una interfaz grafica con el usuario ........................................................... 70 17.1. Componentes y contenedores ......................................................................................... 71 17.1.1. Acciones sobre los componentes ............................................................................. 72 5

Ejemplo........................................................................................................................................ 79 18. Interfaces GUI........................................................................................................................ 82 Ejercicio ....................................................................................................................................... 82 CAPITULO 5 ................................................................................................................................. 87 19. Informacin Datos Entrada ................................................................................................... 88 19.1. Entrada y Salida de Datos .............................................................................................. 88 19.2. Tipos de Flujos ............................................................................................................... 88 19.3. Acceso Aleatorio a Datos ............................................................................................... 89 19.4. Entrada Salida de Datos con Flujo de Bytes y Caracteres.............................................. 89 20. Serializacin........................................................................................................................... 89 20.1. ObjectOutputStream y ObjectInputStream .................................................................... 90 Ejemplo........................................................................................................................................ 90 Ejercicio ....................................................................................................................................... 98 Ayudas al usuario ........................................................................................................................ 99 CAPITULO 6 ............................................................................................................................... 106 21.1. Diferencia entre proceso de Sistema Operativo y Thread Java .................................... 107 21.2. Multi-threading ............................................................................................................ 107 21.2.1. Un solo Hilo vs Multi-hilo .................................................................................... 107 22. Thread desde el mismo lenguaje ........................................................................................ 108 23. Formas de definir una clase para ejecutarse con otras clases ............................................ 108 24. Clase Thread ........................................................................................................................ 109 25. Interfaz Runnable ................................................................................................................ 109 26. Suspensin de un Hilo ......................................................................................................... 110 26.1. Mtodo Suspend ........................................................................................................... 111 26.2. Parada de un Hilo ......................................................................................................... 111 Ejemplo...................................................................................................................................... 112 Capitulo 7 .................................................................................................................................. 114 27. Adquisicin de Datos .......................................................................................................... 115 28. Acondicionamiento de seales ........................................................................................... 115 29. Seales Digitales .................................................................................................................. 115 29.1. Regeneracin de una seal digital maltratada .............................................................. 116 30. Puerto Serie ......................................................................................................................... 117 30.1. Descripcin del puerto Serie ........................................................................................ 117 31. Puerto Paralelo .................................................................................................................... 117 6

31. 1. Modos de Transmisin de Datos ................................................................................. 118 32. Manejo del Puerto Serie...................................................................................................... 118 Ejemplos .................................................................................................................................... 120 33. Manejo del Puerto Paralelo ................................................................................................ 123 Ejemplos .................................................................................................................................... 125

Captulo 1

Introduccin al captulo

En este captulo veremos una breve historia del desarrollo de Java as como sus caractersticas. De igual manera desarrollaremos ejemplos que sern ejecutados solo en el DOS, en esta parte no se realizarn programas en el IDE Netbeans, sin embargo se desarrollar la explicacin de ciertos mtodos y convenciones a usar en Java.

1. Historia de Java
Java fue desarrollado por la compaa Sun Microsystems en los aos 90s y es de cdigo abierto hasta la actualidad, sin embargo en la actualidad tiene que solventar muchos problemas como la velocidad de ejecucin ya que si hacemos una comparacin tarda 20 veces mas que un programa en C, adems se prevee que dejar de ser de cdigo abierto ya que la empresa originaria lo vendi a Oracle. Java utiliza muchas caractersticas de C++ que no estaban incluidas en C, sin embargo entre las caractersticas que podemos destacar que Java no usa de C++ tenemos las siguientes:

Punteros Variables globales Goto Asignacin de memoria Conversin de tipos insegura

No existen punteros evitando el acceso a la memoria voltil (RAM). Lo nico global son los nombres de las clases.

En reemplazo a esta sentencia tenemos break y continue que cumple los casos importantes de goto.
El operador new asigna un espacio de memoria a un objeto. Se realiza una comprobacin en tiempo de ejecucin y emite excepciones si algo llega a fallar.

2. Caractersticas
Java es un lenguaje que gracias a sus caractersticas permite que se desarrolle de una manera ms amigable con el usuario por ello es:

Simple Diseo similar a C o C++. Seguro Implementa barreras de seguridad en el lenguaje y en el sistema de ejecucin en tiempo real. Orientado a objetos Con caracteristicas de encapsulamiento, herencia y polimorfismo.

Robusto Proporciona comprobaciones en compilacin y tiempo de ejecucin.

Interpretado y compilado a la vez Compilado en la medida de que su cdigo fuente se transforma en cdigo de mquina e interpretado os bytecodes se ejecutan directamente sobre la mquina.

Distribuido Proporciona una coleccin de clases para uso en aplicaciones de red.

Indiferente a la arquitectura y portable Cualquier computador que contenga un sistema de ejecucin (jre) puede ejecutar el cdigo. Produce applets Son pequeos programas que aparecen en las pginas web con la capacidad de ejecutar acciones muy complejas. Multihilo Mientras un hilo se encarga de comunicacin, el otro se encargue de interactuar con el usuario y otro de realizar clculos.

Dinmico No conecta los mdulos hasta la ejecucin, cada pieza es responsable de una funcin que se pueden aadir mediante una red.

10

En resumen, Java necesita de una mquina virtual (jre)donde el 80% no depende de la misma y el 20% depende, es decir que dependiendo de la mquina virtual se puede ejecutar el cdigo (jdk compilador).

3. Programando en Bloc de notas

Antes de proceder a programar en Netbeasn IDE, debemos familiarizarnos con el lenguaje es por ello que vamos aprender hacerlo en Bloc de notas. Este es el primer paso, luego de desarrollar varias aplicaciones estaremos listos para hacerlo en el IDE estipulado. Vamos a ver paso a paso como hacerlo as que tenga en cuenta lo siguiente: 1ro: Configurar el Path. Para ello usted puede observarlo como hacerlo en las siguientes grficas: Dirigirse a Panel de control y seleccionar Sistema.

Ilustracin 1. Panel de Control - Sistema.

En Sistema seleccionar Opciones Avanzadas y all Variables de entorno.

11

Ilustracin 2. Opciones Avanzadas - Variables de Entorno. En la ventana de Variables de entorno usted debe asegurarse de seleccionar MODIFICAR mas no en las opciones Nueva o Borrar.

Ilustracin 3. Modificando Variables del sistema.

Luego de seleccionar correctamente debe dirigirse a la carpeta de destino donde instalo Java y copiar la direccin solo hasta Bin.

Ilustracin 4. Direccin de origen Java.

De esta forma quedar configurado y podremos ejecutar los programas desde el Command. 2do: Escribir el programa. En este punto con sus conocimientos bsicos de C++ usted puede escribir un programa. Veremos el siguiente ejemplo para demostrar cmo proceder y familiarizarnos con ciertos elementos: a. Nombre de la clase. El nombre de la clase debe ser igual al nombre del archivo, sin embargo el mismo debe ser guardado en un tipo .java.
12

Ilustracin 5. Nombre de la clase.

Ilustracin 6. Nombre.java b. Llaves. Las llaves nos indican el comienzo y fin de un bloque de cdigo, es por ello que se debe tener un cuidado especial en abrir y cerrar las mismas.

Ilustracin 7. Llaves. c. Definir el comienzo del programa. Para ello se debe hacer uso de la palabra public (acceso ilimitado a los objetos de la clase). Seguidamente se debe incorporar la lnea de cdigo correspondiente. Que es la que nos indica el mtodo principal en donde la mquina virtual comienza a leer y ejecutar.

Ilustracin 8. Mtodo Principal. d. Bloque de cdigo. En esta parte escribiremos los mtodos y objetos que nuestro programa. Se debe tener especial cuidado entre maysculas y minsculas ya que java si reconoce los mismos.

13

Ilustracin 9. Bloque de cdigo. 3ro: Compilar y ejecutar el programa. Para ello se debe asegurar que el archivo se guarde como Nombre.java. Ahora nos dirigimos a Command (en la opcin Ejecutar del DOS).

Ilustracin 10. cmd.

En la ventana que se abrir debemos escribir las siguientes lneas. Hasta empezar en el disco donde est guardado el proyecto.

Ilustracin 11. Escribiendo en el DOS.

Ahora buscaremos el origen el nombre del programa con que guardamos y lo compilamos.

14

Ilustracin 12. Compilando el programa.

Sabremos que el programa se compilo correctamente si no salta ninguna lnea de mensaje de error. Enseguida corremos el programa con la siguiente lnea de cdigo.

Ilustracin 13. Ejecutando el programa. De esta forma observamos el programa y sus resultados. Despus de desarrollar este ejemplo, el estudiante est en la capacidad de desarrollar los ejercicios para mejorar sus habilidades. Ojo. Si tiene problemas en realizar estos ejercicios puede revisar la programacin en la seccin de Ayudas al usuario, al final de este captulo.

Ejercicios
1. Escriba un programa que presente en pantalla su nombre completo en una lnea de cdigo y en la siguiente lnea su fecha de nacimiento. Tips: Debe hacer manejo de saltos de lnea con \n.
15

2. Escriba un programa que presente en pantalla las notas de la asignatura de Tecnologas de Software. En la primera lnea se escribir el nombre de la asignatura. En las siguientes lneas se escribirn las notas de los tres parciales poniendo la nota de cada uno en lneas distintas. En la ltima escribir la nota final de la asignatura. Escriba lo que sea texto como un texto entre comillas dobles y lo que sea un nmero como nmero. Tips: El enunciado no da restriccin alguna, preferiblemente guarde en una variable las notas y luego imprima.

3. Basndose en la clase Hola modifique su cdigo de tal manera que se imprima en pantalla su nombre y apellido en una lnea y en la segunda lnea su nmero de cdula. Considerando que tanto su nombre, apellido y nmero de cdula deben guardarse en una variable cada una. Tips: Como lo pide el ejercicio guarde en una variable los datos y luego imprima.

4. Fundamentos para escribir en Java

Para programa en Java se necesita de ciertas consideraciones acotando que en un futuro usaremos el patrn de diseo MVC (modelo, vista, controlador) el mismo que ser explicado en el siguiente captulo, ahora veremos cmo se desarrollar en Java los :

16

Paquetes

Clases

Todas las letras deben ser escritas en minsculas.

La primera letra en mayscula.

Ejem: araujomeneses.ejemplo

Ejem: NombreClase

Mtodos y Variables

La primera letra en minscula la siguiente palabra en mayscula.

Ejem: nombreMetodo() nombreVariable

4.1. Tipos de variables Las variables pueden clasificarse segn su funcin y segn su naturaleza:

17

Tipos de variables

Segn su funcin

Segn su naturaleza

De Intancia

De Clase

Locales

Tipo Primitivo

De una Clase

Un array

Segn la funcin que cumplen las variables se pueden clasificar en:

De instancia Usadas para almacenar atributos del objeto, estn disponibles para todas las clases

De clase Usadas para almacenar atributos del objeto, estn disponibles para una clase determinada

Locales Son variables usadas dentro de los mtodos del programa

Ahora vamos a ver la definicin de las variables del tipo primitivo ya que son de suma importancia por dos motivos: Nos ayudan a no desperdiciar memoria utilizando variables que ocupan ms espacio de memoria del que en realidad necesitamos Por otro lado nos ayuda a que podamos elegir un tipo de dato que represente lo que deseamos adecuadamente

18

boolean

Valores verdaderos o falsos, ocupan un bit Caracteres, ocupan 16 bits

char

byte
Tipos de datos primitivo

Enteros con signo, ocupan 8 bits

int

Enteros con signo, ocupan 16 bits Enteros, ocupan 16bits y 64 bits respectivamente Reales, ocupan 32 bits

short, long

float, double

Otro tipo de datos primitivo son los vectores y matrices:

Arreglos

Estructura de datos que contienen el mismo tipo de datos

Propiedades

Se utilizan como contenedores Todos los datos son del mismo tipo El tamao del mismo se establece al crear el array (operador new) 19

Terminologa

Vectores

Matrices

Arrays unidimensionales

Arrays bidimensionales

Se usa corchetes [] para diferenciar de una variable normal

Declaracin

tipo identificador []; Unidimensional tipo [] identificador tipo identificador [][]; Bidimensional tipo [][] identificador; tipo, es el tipo de dato identificador, nombre de la variable

Donde

20

Son llamados del tipo String

Declara explicitamente un array llamado args

Cadenas

Implementada por la clase String

Declaracion: String [] args

Existen operadores en Java que nos permiten relacionar las variables para obtener datos como sumas, restas, etc: Operadores aritmticos:

+, p+q

Suma p y q

-, p-q

Resta q de p

*, p*q

Multiplica p y q

Operadores aritmticos

/, p/q

Divide p por q

%, p%q p++ ++p p---p

Residuo de dividir p por q Incrementa p en 1 Decrementa p en 1 Evalua antes/despus de incrementar Evalua antes/despus de decrementar

Existe una precedencia con la que Java maneja los operadores:

21

Operadores sufijo Operadores unarios Creacin o tipo Multiplicadores Suma, resta Desplazamiento Relaciones Igualdad Bitwise AND Bitwise exclusive OR Bitwise inclusive OR AND lgico OR lgico Condicional Asignacin

[], (params), expr++, expr-++expr, --expr, +expr, -expr, ~, ! new (type) expr *, /, % +, <<, >>, >>> <, >, <=, >=, instance of ==, != & ^ | && || ?, : =, +=, -=, *=, /=, %=, ^=, &=, |=, <<=, >>=, >>>=

Ejercicios Ojo. Si tiene problemas en realizar estos ejercicios puede revisar la programacin en la seccin de Ayudas al usuario, al final de este captulo.

4. Escriba un programa que defina dos variables enteras para describir las longitudes de los lados de un rectngulo. El programa debe calcular y escribir en la pantalla las longitudes de los lados, el permetro y el rea del rectngulo. (Suponga que el rectngulo mide 15cm de alto y 25 cm de ancho).

Tips. Revisar la frmula para calcular el rea y permetro del rectngulo.

5. Escriba un programa para calcular el rea y el volumen de un cilindro. Para ello declare una constante que guarde el valor de PI. Declare, tambin, variables para el dimetro y la altura del cilindro. Suponga para el ejemplo que el cilindro tiene un dimetro de 15.5 cm y una altura de 42.4

22

Ilustracin 14. Cilindro.

4.2. Peticiones de valores al usuario Se utiliza para obtener datos del exterior por ejemplo del teclado

Peticiones de valores al usuario

Declaracin: Scanner nombre = new Scanner (System.in) Llamar objeto: variable = nombre.nextTipoVariable();

Tipos y mtodo para leer teclado

byte

short

int

long

float

double

boolean

teclado.next Byte();

teclado.nex tShort();

teclado.nex tInt();

teclado.nex tLong();

teclado.nex tFloat();

teclado.nex tDouble();

teclado.nex tBoolean();

4.2.1. Instrucciones condicionales y de repeticin

Las instrucciones condicionales y las de repeticin nos permiten realizar operaciones que nos tomaran muchas lneas de cdigo y mucho tiempo programando
23

Este tipo de instrucciones se usa cuando debemos repetir una operacin varias veces.

Condiciones y repeticin Toma de decisin switch case Bucle Miscelneo

while

continue

if - else

for

return

do - while

label:

break

Switch - Case

Para realizar sentencias condicionalmente basadas en alguna expresin

switch(op) case 1: sentencia; brake; case 2: ...........................

Se debe poner brake para finalizar el flujo y salir del Case

24

If - Else

Da la posibilidad de ejecutar selectivamente otras sentencias basndose en algn criterio

if (expresin) sentencia1 else sentencia2

Despus del primer if podemos poner los else q queramos

Realiza una accin mientras se cumpla una cierta condicin

While

while(expresin) sentencia

Se ejecuta sentencia mientras la expresin sea verdadera, sentencia puede ser todo un bloque de cdigo

25

Se usa cuando se conoce los lmites del bucle y su variacin for(inicializacin; terminacin; incremento) sentencia Generalmente se lo usa para recorrer por los espacios de un arreglo

For

Do - While

Usado cuando por lo menos se quiere que el bucle ejecute una vez

do{ sentencias} while(expresin boleana);

Sentencia de repeticin muy poco usada

Java cuenta con toda una clase que contiene operaciones matemticas, esta clase se conoce como Math

26

Librera matemtica de Java

Math.abs(x) Math.sin(double) Math.log(double) Math.pow(a,b) etc...

Clase Math

El constructor de la clase es privado

Math es public para que pueda llamarse desde cualquier sitio

Clase String

Creacin implcita:

Dentro del objeto, Java crea un array de caracteres

System.out.println("Patty") Creacin explicita: String str=new Sring("Patty")

Extrae una porcin del String

Substring
Debemos determinar el espacio donde queremos cortar
Declaracin: String subStr=str.substring(14);

27

Convertir numero a string

Usamos la funcin miembro esttica valueOf

Ejemplo: int valor=10; String str=String.valueOf(valor); La clase String proporciona versiones de valueOf para convertir: int, long, float, double

Convertir un string en nmero

Debemos usar la funcin miembro esttica parseInt de la clase Integer

Ejemplo: String str="12"; int numero=Integer.parseInt(str.trim());

str.trim(), quita los espacios en blanco que muchas veces se producen al inicio o final de los nmeros

Usada para leer archivos de texto plano Buffered Reader Buffered Reader in=new Buffered Reader(new File Reader(archivo)); String archivo="nombr e,txt" Si queremos leer una lnea del archivo se usa aux=in.readLine();

28

Ayudas al usuario Ejercicio 1.

String nombre="Carlos Araujo"; int anioNacimiento=1988; System.out.println("su nombre es: "+nombre); System.out.println("su fecha de nacimiento es: "+anioNacimiento);

Ejercicio 2.
String Materia="TECNOLOGIAS DEL SOFTWARE"; String nota1="Primer parcial: "; String nota2="Segundo parcial: "; String nota3="Tercer parcial: "; String total="NOTA FINAL"; int n1=17; int n2=18; int n3=19; System.out.print(Materia+"\n"+nota1+n1+"\n"+nota2+n2+"\n"+nota3+n3+"\n"+total+(( n1+n2+n3)/3));

Ejercicio 3.
String nombre="Patty "; String apellido="Meneses"; String saludo="Hola "; String cedula="\n Tu # de cedula es: "; String numero="1002610234"; System.out.print(saludo+nombre+apellido+cedula+numero);
29

Ejercicio 4.
public class PrincipalRectangulo{ public static void main(String args []){ //llamando a la funcion /*Rectangulo rectangulo1= new Rectangulo (); System.out.println("valor de perimetro: "+rectangulo1.perimetro()); System.out.println("valor de area: "+rectangulo1.area());*/ //asignando una variable Rectangulo rectangulo1= new Rectangulo(); int perimetro = rectangulo1.perimetro(); int area = rectangulo1.area(); System.out.println("valor de perimetro: "+perimetro); System.out.println("valor de area: "+area); } public class Rectangulo{ public int b=25; public int h=15; int perimetro (){ int p=0; p=2*b+2*h; return p; } int area (){ int a=0; a=b*h; return a;

30

Ejercicio 5.
public class Cilindro{ double pi=3.1416; double a=42.4; double r=(15.5/2); double volumen(){ double v=0; v=pi*r*r*a; return v; } double area(){ double area=0; area=2*pi*r*(a+r); return area; } } public class PrincipalCilindro{ public static void main(String args []) //llamando a la funcion Cilindro cilindro1= new Cilindro (); System.out.println("valor de volumen: "+cilindro1.volumen()); System.out.println("valor de area: "+cilindro1.area()); } } {

31

CAPTULO 2

INTRODUCCIN AL CAPTULO En esta parte, vamos revisar brevemente lo que se refiere a objetos y clases en Java ya que es muy similar a C++, lenguaje que en estas instancias el estudiante debe saber manejar correctamente. Para poder empezar a programar en Netbeans es necesario que se conozca este entorno, por ello el objetivo de este captulo ser introducir al estudiante al mundo del IDE Netbeans para poder realizar aplicaciones aptas de nuestro nivel de aprendizaje.

32

5 Objetos
Primero recordaremos la diferencia de declaracin en programacin tradicional y en orientada a objetos:

Tradicional Fraccion_simp = simplificada_fraccion (fraccion);

Orientada a Objetos Scanner teclado = new Scanner(System.in);

5.1. Instanciacin de Objetos:

Para instanciar un objeto el mtodo que se usa es new.

Antes de esto se tiene que declarar la variable que contendr ese nuevo objeto Crea un objeto de la clase que le especifiquemos String palabra1=new String("Ecuador");

new
6. Clases
Una clase define la forma y comportamiento de un objeto.

33

a. Para crear una clase slo se necesita usar la palabra clave reservada class seguida de un identificador legal y un bloque delimitado por dos llaves para el cuerpo de la clase. class MiPunto { ... } OJO: El nombre de la clase debe tener el mismo nombre del archivo, como ya se explico en el captulo anterior. b. Los atributos Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de la declaracin de la clase, variables que se conocen como atributos. Se declaran igual que las variables locales de un mtodo en concreto. class MiPunto { int x, y; } c. Los mtodos Son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento. Un mtodo puede tener cualquier nombre para identificarlo pero diferentes de los nombres los nombres de la clase en que est contenido. Los mtodos se declaran al mismo nivel que las variables de instancia dentro de una definicin de clase. tipo_devuelto nombre_de_mtodo( lista-formal-de-parmetros ){ cuerpo_del_mtodo; }

34

7. Netbeans IDE

Netbeans
es

Un IDE que permite que las aplicaciones sean desarrolladas a partir de un conjunto de componentes de software llamados mdulos

Una herramienta para programadores pensada para escribir, compilar, depurar y ejecutar programas

Un proyecto de cdigo abierto de gran xito con una gran base de usuarios y una comunidad en constante crecimiento

La Plataforma Netbeans:

Administracin de las interfaces de usuario (ej. mens y barras de herramientas)

.

Es una base modular y extensible usada como una estructura de integracin para crear aplicaciones de escritorio grandes

Administracin de las configuraciones del usuario

Administracin del almacenamiento (guardando y cargando cualquier tipo de dato) Administracin de ventanas

Framework basado en asistentes (dilogo paso a paso)

.

35

7.1. Preparando el rea de trabajo

El rea de trabajo de Netbeans est dado por:

1 3 4

Ilustracin 15. rea de trabajo. 1.- Projects: Como vemos, el nombre del proyecto aparece en la esquina superior y en negrita, a partir de el se ramifica el rbol de las subcarpetas, las cuales agrupan los cdigos fuente de las clases junto con sus respectivos enlaces a sus interfaces grficas (en caso de tenerlas), las libreras usadas, y algunos otros aspectos. 2.- Navegador: Esta zona funciona a modo de rbol; es el navegador de los objetos presentes en nuestra interfaz grfica; es decir que all se mostrar una lista jerrquica de todos los componentes colocados en el formulario, y desde ah se controlar el orden de estos, sus respectivos nombres y con el clic derecho sobre cada objeto, se podr modificar las propiedades que cada uno posee. 3.- Esta ser la zona que mostrar todo el trabajo que realicemos en el proceso de diseo de nuestra interfaz y clases. 4.- Propiedades: En este espacio podremos modificar las propiedades propias de nuestras clases. Para empezar debemos tener en cuenta que seguiremos el patrn de diseo MVC: 1ro. Creamos el nuevo archivo seleccionando el cono de Nuevo proyecto.

36

Ilustracin 16. Nuevo Proyecto. Seleccionamos la opcin Java-Java application.

Ilustracin 17. Java Application.

Le asignamos un nombre en este caso es Ejemplo y dejamos seleccionada la Opcin de Main class.

Ilustracin 18. Nombre Proyecto.

37

Ya creado el proyecto se deben introducir 3 paquetes con los siguientes pasos:

Ilustracin 19. Paso 1.

Ilustracin 20. Paso 2. De esta forma cuando creemos los 3 paquetes podremos observarlo en el esquema del proyecto.

Ilustracin 21. Esquema del proyecto.

38

As hemos logrado seguir el patrn de diseo MVC, ahora podremos crear nuestras clases en las cuales realizaremos nuestras aplicaciones.

Ilustracin 22. Creando una Clase.

Ilustracin 23. Nombre de la Clase.

Para poder ejecutar el programa haremos una breve salida de informacin de la siguiente forma: a. Escribimos el cdigo

Ilustracin 24. Escribir cdigo.

Nos dirigimos al cono Compilar, cuando el IDE termine de comprobar que no existan errores en el espacio de Output podremos observar en letras verdes lo siguiente:

39

Ilustracin 25. Compilar.

Ilustracin 26. Sin error.

Enseguida podremos ejecutar el proyecto seleccionando el cono con el mismo nombre.

Ilustracin 27. Run. Y observaremos los resultados en el espacio Output

Ilustracin 28. Salida en consola.

De esta forma hemos dado un breve vistazo al rea en el cual trabajaremos, como pudimos observar no es muy complejo y al contrario cualquier estudiante estar en la capacidad de manejar este entorno de manera fcil y correcta.

40

8. Referencias
Las referencias en Java no son punteros ni referencias como en C++. Este hecho crea un poco de confusin entre los programadores que llegan por primera vez a Java. Las referencias en Java son identificadoras de instancias de las clases Java. Una referencia dirige la atencin a un objeto de un tipo especfico. No tenemos por qu saber cmo lo hace ni necesitamos saber qu hace ni, por supuesto, su implementacin. Entre las ms usadas tenemos this y null:
Referencia al objeto que est ejecutando al mtodo
This this.largo = largo; Referencias

Para asignar a una referencia el valor nulo se utiliza la constante null

Null Por defecto: Clase clase1; Explcitamente: auto1=null;

9. Tipos de acceso
El control de acceso se aplica siempre a nivel de clase, no a nivel de objeto. La tabla siguiente muestra el nivel de acceso que est permitido a cada uno de los especificadores:

Nivel de Acceso Private Protected Public Package

clase X X X X

subclase X* X

paquete X X X

todos

41

En otras palabras podemos definir:

Private

Public

Protected

Friendly

Solamente puede ser accedido por otros miembros de la propia clase. No puede ser accedido por miembros de una clase heredada

Puede ser accedido desde cualquier cdigo dentro del mbito de un objeto instanciado a partir de la clase.

Solamente cuando se ve involucrada en herencia

Acceso a todos los miembros privados y protegidos de esa clase

public void CualquieraAcced e(){}

Aparece como public para los miembros de clases derivadas de la clase

void MetodoDeMiPaquet e(){}

private String Numero

Aparece como private para todas las dems

protected void SubClases(){}

Ejercicios
Ojo. Si tiene problemas en realizar estos ejercicios puede revisar el cdigo fuente en la seccin de Ayudas al usuario, al final de este captulo.

1. Definir una clase que represente un auto. En la definicin se debe incluir: El modelo, el color si la pintura es metalizada o no, la matricula, el tipo de auto, el ao de fabricacin, la modalidad del seguro. Tips: Revise la forma de ingresar constructores para la inicializacin de las variables.

2. Se desea imprimir el modelo y el color de un auto dado, para ello se pide escribir un mtodo que acepte un objeto de la clase Auto. Si dicha referencia no es null, el mtodo deber imprimir el modelo y el color. Si es null, el mtodo no har nada. Tips. Revisar el manejo de la referencia null.

42

3. Aadir a la clase Auto del ejercicio 1 un mtodo de nombre imprime Auto que imprima el modelo y el color del auto.

4. Escribir un programa que tenga una instancia de Auto, que un Audi de color gris. El programa ha de imprimir un mensaje que diga de qu modelo y color es el auto. Tips. Asigne objetos en donde crea conveniente.

5. Escriba un programa que disponga de una clase para representar las asignaturas de una carrera. Una asignatura tiene, un cdigo numrico y el nivel en el cual se imparte. Los valores iniciales han de proporcionarse en el constructor ya que la clase utiliza el principio de encapsulamiento. La clase ha de tener mtodos para obtener los valores de los atributos. El programa ha de construir un objeto con los siguientes valores: nombre TECNOLOGAS DE SOFTWARE PARA ELECTRNICA, cdigo 1017, nivel 5. A continuacin el programa debe imprimir los valores del objeto por pantalla. Tips. Lea detenidamente el enunciado y realice el programa paso a paso con encapsulamiento.

43

Ayudas al Usuario
Ejercicios 1, 2, 3, 4: public class Acciones { public void imprimir(Auto auto) { if (auto.equals(null)) {} else { System.out.println(auto); } } public void imprimirAuto(String color,String modelo){ Auto carro=new Auto(modelo, color, "wesco", "pbd-4498", "vmw",88, "soat"); System.out.println("el "+carro.getColor()); } } public class Auto { private String modelo; private String color; private String pintura; private String matricula; private String tipoDeAuto; private int ao; private String seguro; public Auto() { this.modelo = "ninguno"; this.color = "ninguno"; modelo es :"+carro.getModelo()+"\nel color es:

44

this.pintura = "ninguno"; this.matricula = "ninguno"; this.tipoDeAuto = "ninguno"; this.ao = 0; this.seguro = "ninguno"; } public Auto(String modelo, String color, String pintura, String matricula, String tipoDeAuto, int ao, String seguro) { this.modelo = modelo; this.color = color; this.pintura = pintura; this.matricula = matricula; this.tipoDeAuto = tipoDeAuto; this.ao = ao; this.seguro = seguro; } public int getAo() { return ao; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public String getMatricula() { return matricula;
45

} public String getModelo() { return modelo; } public String getPintura() { return pintura; } public void setPintura(String pintura) { this.pintura = pintura; } public String getSeguro() { return seguro; } public void setSeguro(String seguro) { this.seguro = seguro; } public String getTipoDeAuto() { return tipoDeAuto; } public void setTipoDeAuto(String tipoDeAuto) { this.tipoDeAuto = tipoDeAuto; } public String toString(){ return ("modelo: "+modelo+"color: "+color); } public class Principal { public static void main(String[] args) {
46

Auto a1 = new Auto(); /* new Acciones().imprimir(a1); //new para no crear el objeto (x vagos) //a1.imprimirAuto(a1.getColor(), a1.getModelo()); a1.*/ Acciones mostrar=new Acciones(); mostrar.imprimirAuto("gris", "Audi"); }

47

Capitulo 3

Introduccin al Captulo
En este captulo contemplaremos conceptos ms avanzados para programar en Java como herencia, polimorfismo, abstraccin de clases. Con esto el estudiante estar en la capacidad de manipular completamente el lenguaje y podr realizar interfaces ms complejas.

48

10. Herencia
Dentro de la programacin orientada a objetos existe el concepto de herencia, podemos crear objetos que requieran tener las mismas caractersticas de otras, como los seres humanos heredamos de nuestros padres el color de cabello, color de ojos, color de la piel, entre otras cosas. Puede haber clases que necesiten de atributos o mtodos que ya han sido escritos y definidos en otras clases, las clases que reciben los atributos y mtodos de otro objeto son llamadas clase hijas y las que dan estos atributos son llamadas clases padre. Una clase hija puede ser hija de otra clase que a su vez ya es hija de otra clase superior y la ultima heredara los atributos y mtodos tanto de la primera como de la segunda. Las ventajas entre otras pueden ser estandarizacin de clases, una de las ms importantes es la reutilizacin de cdigo que ya ha sido escrito y probado, entre otras.

10.1. Jerarqua
La jerarqua de objetos hace completamente referencia a la herencia entre ellos. Se dice que una superclase es una clase padre y una subclase es la case hija.

Ilustracin 29. Jerarqua.

En la imagen podemos ver un ejemplo de herencia donde la clase Animal es la clase padre (superclase) y las clases Vertebrados e Invertebrados son clases hijas (subclases), como vemos podemos crear nuevas clases que tienen algn tipo de relacin y al heredar mtodos y atributos de las clases padre, podra decirse que es una familia de clases con caractersticas especificas. Dentro del lenguaje todas las clases que hagamos o utilicemos son clases hijas de una sper clase en comn. La clase Object y esta es una herencia implcita (que no necesitamos declarar dentro de nuestro cdigo).
49

10.2. Declaracin de herencia

Para declarar que una clase es hija de otra utilizamos la palabra reservada extends de la siguiente forma. public class ClaseHija extends ClasePadre{ }

11. Referencias polimrficas

En la que ClaseHija hereda los atributos de ClasePadre pero con esto surge una pregunta. Cmo hacer referencia a los atributos de la clase padre o de s misma cuando se necesite? Y ms aun cuando sus atributos o mtodos tengan el mismo nombre. Pues esto se logra con la palabra this o con la palabra super las cuales son apuntan a la clase hija o padre respectivamente por ejemplo. this.w = w; super.incrementarX();

Con las referencias polimrficas solo especificaremos a que clase pertenece los elementos que usemos.

12. Sobrecarga de mtodos

La sobrecarga de mtodos es la escritura de mtodos dentro de un programa con la misma etiqueta pero con diferente definicin, esta definicin dentro de java se la hace mediante el tipo y cantidad de argumentos que recibe un mtodo. Tambin existe la sobrecarga de constructores de igual manera estar definido por la cantidad de parmetros que se le enve al constructor. String imprimir() {} String imprimir(int a) {} String imprimir(int a, int b) {} String imprimir(String mensaje) {}

50

13. Polimorfismo
El polimorfismo es la creacin de un mtodo ya existente pero definido por la clase que lo posee, para ser ms claros vamos a expresarlo con un ejemplo, tenemos varias clases Triangulo, Cuadrado, Circulo. Todas estas clases son hijas de la clase Figuras todas poseen el mtodo rea, y el mtodo permetro, pero cada clase realiza el clculo de los mtodos de diferente forma.

14. Clases abstractas

Una clase abstracta es una clase que posee atributos y mtodos pero la cual no puede ser usada directamente como objeto ya que podra decirse que es intangible, los mtodos que posee una clase abstracta pueden ser definidos en la misma o podrn ser definidos por las clases hijas. Para su declaracin se utiliza la palabra abstract como veremos en el ejemplo abstract class A{ }

15. Interfaces
Una interface es como crear una plantilla de una clase ya que se crearan mtodos no definidos pero que deben existir de carcter obligatorio en las clases que implementen la interface y ser en estas donde se definir la forma que tienen los mtodos dependiendo la necesidad del usuario, una interface es una clase abstracta pura ya que todos sus mtodos sern abstractos. Una interface puede tambin contener datos miembro, pero estos son siempre static y final. Una interface sirve para establecer un 'protocolo' entre clases. interface A{ final int X; String metodo (String msn); }

Los datos miembro de esta clase se escriben con mayscula ya que sern tomadas como constantes, en la clase que implemente esta interface se deber

51

especificar el cdigo para el mtodo que como vemos solo hemos escrito el encabezado mas no lo que hace el mtodo en s. class B implements A{ int constante=X; String metodo (String msn){ System.uot.println(msn+constante); } }

15.1. Excepciones
Dentro de la programacin en lenguaje java existen objetos creados especficamente para el manejo de errores ya que en general, como programadores podemos dejar pasar cierto tipo de cosas que nos pueden o no generar problemas en nuestro programa, un ejemplo muy tpico y muy claro seria la operacin divisin, si creamos un cdigo donde realizaremos la divisin de dos nmeros pero realizamos una divisin para cero tendremos un error con lo que podra entrar a un bucle infinito o hacer que nuestro computador no contine trabajando, pero java nos permite manejar el error de cierta manera con las excepciones. Una excepcin en lenguaje java es una clase que nos permite manejar un error, existen varios tipos de ellas, ya que existen una gran cantidad de aplicaciones para java existe tambin una numero de excepciones para las mismas Los nombres de las excepciones indican el tipo de error que se ha producido. Como se menciono anteriormente una excepcin de este tipo es la divisin para cero

ArithmeticException

Se produce cuando se intenta acceder a una variable o mtodo que todava no ha sido creado

NullPointerException

52

 El intento de cambiar una clase afectada por referencias en otros objetos, especficamente cuando esos objetos IncompatibleClassChangeEx todava no han sido recompilados. ception

El intento de convertir un objeto a otra clase que no es vlida

ClassCastException

NegativeArraySizeExcep tion

Puede ocurrir si hay un error aritmtico al intentar cambiar el tamao de un arreglo

No debera producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria.

OutOfMemoryException

53

 Se referenci una clase que el sistema no encuentra.

NoClassDefFoundExcept ion

Se genera al intentar acceder a un elemento de un arreglo ms all de los ArrayIndexOutOfBound lmites definidos inicialmente para ese arreglo

sException

Por definicin, el usuario nunca debera ver este error y esta excepcin no debera lanzarse

InternalException

Estos son algunos ejemplos de Excepciones que pueden ocurrir. Todas las excepciones son hijas de la clase Exception la cual es hija de la clase Throwable, nosotros tambin podemos crear nuestras propias excepciones.

15.1.1. Bloques Try-Catch.

Dentro del lenguaje Java se utiliza estas dos palabras reservadas para el manejo de errores, al escribir la palabra try generamos un bloque de cdigo el cual ser donde se realiza la operacin que podra darnos algn tipo de error, y con la palabra catch crearemos el bloque de cdigo encargado de manejar la excepcin. try{ }
54

catch (Exception e){ } Este es un ejemplo de cmo se escribe el cdigo de una excepcin dentro de los parntesis que se encuentran despus de la palabra catch escribimos el tipo de excepcin con la que trabajaremos que pueden ser ArithmeticException, NullPointerExceptio, y todos los casos que ya mencionamos anterior mente seguido de un nombre que en este casos es la letra e. Se puede agregar varios catch especificando a qu tipo de excepcin pertenece cada uno, y tambin hay una palabra reservada que es finally la cual se usa despus de los catch, este es un bloque de cdigo que se ejecutara obligatoriamente, se que ocurra o no una excepcin, se usa en casos en los que necesariamente debemos ejecutar algn proceso como por ejemplo cerrar un fichero que se est utilizando. try{ } catch (IOException error1){ } catch (NullPointerException error2){ } finally{ }

16. JOptionPane
Todo lo que hemos mencionado anterior mente sobre Java es una programacin que solo podemos visualizar en consola, ya sea en la consola CMD de Windows o en la consola de NetBeans.

55

Pero dentro de las aplicaciones de java tenemos herramientas que nos permiten hacer programas con los que se puede interactuar sin necesidad de que sea por consola, con esto realizaremos programas ms funcionales. Tenemos mtodos como los siguientes dentro de la clase JOptionPane:

JOptionPane.showInputDialog() La diferencia entre ellos es que tienen ms o menos parmetros, segn queramos aceptar o no las opciones por defecto. Los parmetros y sus significados son muy similares a los del mtodo showOptionDialog(), pero hay una diferencia. Si usamos los mtodos que no tienen array de opciones, la ventana mostrar una caja de texto para que el usuario escriba la opcin que desee (un texto libre)

JOptionPane.showMessageDialog()

Slo muestra una ventana de aviso al usuario. La ejecucin se detiene hasta que el usuario cierra la ventana. Hay varios mtodos con el mismo nombre y ms o menos parmetros, en funcin de si aceptamos las opciones por defecto (icono, por ejemplo) o queremos cambiar alguna cosa.

JOptionPane.showConfirmDialog()
Muestra una ventana pidiendo una confirmacin al usuario, estilo "Seguro que lo quieres borrar todo?" y da al usuario opcin de aceptar o cancelar ese borrado masivo que est a punto de hacer YES_OPTION, NO_OPTION, CANCEL_OPTION, OK_OPTION, CLOSED_OPTION

JOptionPane.showOptionDialog()
Devuelve un entero que representa la opcin que ha seleccionado el usuario. La primera de las opciones del array es la posicin cero. Si se cierra la ventana con la cruz de la esquina superior derecha, el mtodo devolver -1

56

parentComponent Se intentar determinar cul es la ventana que debe hacer de padre del JOptionPane. Se puede pasar null, pero conviene pasar, por ejemplo, el botn desde el cual se lanza la accin que provoca que se visualice el JOptionPane

message El mensaje a mostrar, habitualmente un String, aunque vale cualquier Object cuyo mtodo toString() devuelva algo con sentido

title El ttulo para la ventana

optionType:

Un entero indicando qu opciones queremos que tenga la ventana. Los posibles valores son las constantes definidas en JOptionPane: DEFAULT_OPTION, YES_NO_OPTION, YES_NO_CANCEL_OPTION, o OK_CANCEL_OPTION

57

messageType Un entero para indicar qu tipo de mensaje estamos mostrando. Este tipo servir para que se determine qu icono mostrar. ERROR_MESSAGE, INFORMATION_MESSAGE, WARNING_MESSAGE, QUESTION_MESSAGE, o PLAIN_MESSAGE options Si los objetos son componentes visuales, aparecer tal cual como opciones. Si son String, el JOptionPane pondr tantos botones como String

initialValue Seleccin por defecto. Debe ser uno de los Object que hayamos pasado en el parmetro options. Se puede pasar null

Ejemplos

En los siguientes ejemplos crearemos diferentes clases donde usaremos los conceptos aprendidos en este captulo. 1.- Crearemos una clase principal donde se encuentre el mtodo Main, crearemos la clase A que ser padre de la clase B y esta ultima ser padre de la clase C, estas tres clases tendrn atributos del tipo entero y sern privados, cada una tendr un atributo x y un atributo y, la clase A tendr dos constructores del tipo public uno sin parmetros y el otro con parmetros uno para x y otro para y, y poseer mtodos del tipo protected que sern heredados. Y una clase Acciones donde utilizaremos la visualizacin que nos brinda JOptionPane

58

Ilustracin 30. Proyecto.

Ilustracin 31. Clase Principal.

59

Ilustracin 32. Clase A.

Ilustracin 33. Clase B.

60

Ilustracin 34. Clase C.

Ilustracin 35. Clase Acciones. El programa en funcionamiento nos presentara las siguientes pantallas de ingreso para todas las variables

61

Ilustracin 36. Ingreso de variables.

Y finalmente nos mostrara como resultado una pantalla donde veremos nuestros datos ingresados y despus veremos otra pantalla con los datos incrementados

Ilustracin 37. Salida del programa.

2.-Definir una clase abstracta aviones, con dos mtodos despegar y aterrizar. Definir una interface vuelos, con dos constantes una para velocidad mxima 1500, y otra para velocidad mnima 1000. Adems el mtodo abstracto cinturones. Definir clase Boing747 que sea hija de aviones e implemente la interface vuelos. Que tenga como atributos el peso y el estado del aeropuerto. Adems defina los mtodos abstractos heredados. Para poder despegar el peso debe ser menos a 180 y el aeropuerto debe estar libre. Para poder aterrizar el aeropuerto debe estar libre y la velocidad menor a 1000. En caso de la velocidad mayor a 1500 se debe indicar que los cinturones deben asegurarse. Definir una clase Hrcules que sea hija de aviones e implemente a la interface vuelos. Que tenga como atributos el peso y el estado del aeropuerto. Adems defina los mtodos abstractos heredados. Para poder despegar el peso debe ser menor a 160 y el aeropuerto debe estar libre. Para poder aterrizar el aeropuerto debe estar

62

libre y la velocidad menor a 1500. En caso de ser la velocidad mayor a 1500 se debe indicar que los cinturones deben asegurarse.

Ilustracin 38. Clase Aviones.

Ilustracin 39. Interface Vuelos.

63

Ilustracin 40. Clase Boing747.

Ilustracin 41. Clase hrcules.

64

Para realizar las pruebas defina una clase principal en la que se cree dos aviones, uno Hrcules y otro Boing; y se pida al usuario que ingrese el peso de cada avin y el estado del aeropuerto. El usuario determinara si se encuentra volando o por despegar. Si el avin est volando se deber ingresar la velocidad. A partir de los datos ingresados hacer el anlisis si puede o no despegar o aterrizar y si deben o no asegurar los cinturones.

Ejercicio 1. Desarrolle un programa que permita almacenar el nombre y telfono de usuario de una biblioteca en una clase. Un constructor que inicialice sus atributos con Nadie y ooo Un constructor que inicialice sus atributos a partir de argumentos enviados Un mtodo que permita presentar en pantalla la informacin Mtodos de consulta y modificadores Una segunda clase que permita almacenar el nombre de un libro en una clase Un constructor que inicialice su atributo con Vacio. As como los atributos de la clase padre con Nadie y ooo Un constructor que inicialice su atributo y los de la clase padre a partir de argumentos enviados Un mtodo que permita presentar en pantalla la informacin Un mtodo de consulta Un mtodo que permita asignar el libro a un nuevo usuario Un mtodo que permita saber a partir de un grupo de libros si uno de ellos se encuentra o no asignado a un usuario En la clase principal el usuario definir con cuantos libros empieza el programa as como s los libros nombres de los libros nombres de los libros y si se encuentran o no asignados. Adems deber permitir al usuario seleccionar un libro y que se presente en pantalla el nombre del libro y los datos del usuario si existiese.

65

Ayudas al usuario
Ejercicio 1. public class Herramientas { public Persona[] inicalizarArreglo(int dimension) { Persona[] aux = new Persona[dimension]; for (int i = 0; i < aux.length; i++) { aux[i] = new Persona(new EntradaSalida().leerString("ingrese nombre"), new EntradaSalida().leerString("ingrese ao"), new EntradaSalida().leerInt("leer ID")); } return (aux); } public Persona[] fechaComun(Persona[] estudiantes, String ao) { int i, acum = 0; Persona aux[]; for (i = 0; i < estudiantes.length; i++) { if (estudiantes[i].getFecha().compareTo(ao)==0) { acum = acum + 1; } } aux = new Persona[acum]; acum = 0; for (i = 0; i < estudiantes.length; i++) { if (estudiantes[i].getFecha().equals(ao)) { aux[acum] = estudiantes[i]; acum = acum + 1; }
66

} return (aux); } public void imprimeArreglo(Persona [] estudiantes){ int i; for(i=0;i<estudiantes.length;i++){ System.out.println(estudiantes [i].getNombre()); } } } public class Persona { private String nombre; private String fecha; private int id; public Persona(String nombre, String fecha, int id) { this.nombre = nombre; this.fecha = fecha; this.id = id; } public Persona() { this.nombre = "Sin nombre"; this.fecha = "0000"; this.id = 0; } public String getFecha() { return fecha; }
67

public void setFecha(String fecha) { this.fecha = fecha; } public int getId() { return id; } public void setId(int id) { this.id = id; } public String getNombre() { return nombre; } public void setNombre(String nombre) { this.nombre = nombre; } } public class Principal { public static void main(String[] args) { Persona[] estudiantes = new Herramientas().inicalizarArreglo( new EntradaSalida().leerInt("ingrese la dimension")); Persona aux[] = new Herramientas().fechaComun(estudiantes, "1989"); new Herramientas ().imprimeArreglo(aux); } }

68

Capitulo 4

Introduccin al captulo
En este captulo realizaremos interfaces grficas, estos mtodos nos permitirn interactuar de una manera ms dinmica con el usuario. Realizaremos aplicaciones ms avanzadas con un grado de complejidad mayor a lo antes estudiado.

69

17. Componentes de una interfaz grafica con el usuario

Permitir crear entornos grficos de ventanas como las de Windows es algo muy til, dentro de Java existen componentes que nos permiten realizar esto (Java Fundation Classes) JFC por sus siglas es parte de la API de Java que contiene clases que nos permiten crear entornos grficos. JFC contiene paquetes que nos ayudan a crear dichos entornos que son:

JFC

AWT Abstract Window Toolkit

Swing

biblioteca de clases Java para el desarrollo de Interfaces de Usuario Grficas.

El entorno que ofrece es muy simple

es un paquete ms ligero que AWT Swing existe desde la JDK 1.1

La programacin que se utiliza para crear interfaces graficas se denomina programacin orientada a eventos debido a que el programa estar esperando que suceda algo ya sea mediante botones o cualquier tipo de indicadores, para registrar estos eventos se utiliza los objetos oyentes o listeners, cuando esto sucede el programa es avisado, y ejecutara las acciones que sean programadas. El paquete java.awt incluye tambin unos sub paquetes que son:

java.awt.color java.awt.datatransfer java.awt.dnd java.awt.event java.awt.font java.awt.geom java.awt.im java.awt.image java.awt.image.renderable java.awt.print
70

Analizaremos algunas funciones. Las clases del paquete swing han sido construidas sobre las clases awt. Swing es actualmente el paquete ms utilizado para construir interfaces grficas.

17.1. Componentes y contenedores

Una interface grfica est construida en base a elementos grficos bsicos, los componentes. Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores. Los Contenedores contienen y organizan la situacin de los Componentes; adems, los Contenedores son en s mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. Tambin contienen el cdigo necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicacin. En el AWT, todos los Contenedores son instancias de la clase Container o uno de sus subtipos. Los Componentes deben circunscribirse dentro del Contenedor que los contiene. Esto hace que el anidamiento de Componentes (incluyendo Contenedores) en Contenedores crean rboles de elementos, comenzando con un Contenedor en la raz del rbol y expandindolo en sus ramas. A continuacin presentamos el rbol que representa la interface que corresponde con la aplicacin grfica generada anteriormente.
Object

Compone nt

Container

Jcompone nt

AbstractB utton

JComboB ox

Jlabel

JList

JMenuBar

JPanel

JPopupM enu

JButton

JMenuIte m JRadioBu ttonMenu Item

JToggleB utton

JCheckBo xMenuIte m

JMenu

JCheckBo x

JradioButt on

71

17.1.1. Acciones sobre los componentes Existen varias acciones para cada componente, cada una es un mtodo y depende de cual escojamos nos devolver un tipo de dato, gracias a la ayuda de NetBeans no tenemos que memorizar un sin nmero de mtodos esto se lo logra visualizar poniendo el nombre del elemento por ejemplo si es un text field colocamos su nombre y al presionar un punto ( . ) para hacer referencia a un elemento de la clase JTextField se nos desplegara la ayuda si eso no ocurre podemos presionar las teclas control (ctrl) mas la tecla espacio (space).

Ilustracin 42. Acciones. Aqu un ejemplo de ciertas opciones que un botn nos puede brindar

Ilustracin 43. Opciones.

72

Dentro de los estndares que maneja el lenguaje java cada elemento tendr un mtodo setter y un meto getter, para verificar el estado podemos buscar entre las opciones que empiecen con la palabra is seguido de otra que definir lo que buscamos como por ejemplo isVisible(); y muchos mtodos ms. Cada contenedor de igual manera tendr sus propios mtodos. a. Componentes AWT y Swing Cada componente AWT tiene un componente Swing de el mismo tipo pero su nombre empezara con una jota ( J ) que muestra que pertenece al tipo Swing NetBeans nos permite seleccionar directamente de un men localizado al lado derecho de su IDE.

Ilustracin 44. Contenedores Swing.

Ilustracin 45. Controles Swing.

Ilustracin 46. Men Swing.

73

Ilustracin 47. Ventana Swing.

Ilustracin 48. Componentes AWT. El nombre de cada componente nos da una breve idea de para que ser utilizado

Label
texto impreso sobre el frame que se utiliza como etiqueta

Button
su uso depender del programador

Text Field
nos permite crear una lnea de texto modificable o no

74

Text Area
parecido al anterior, nos permite crear un rea de texto pero en este caso el tamao ser ms de una lnea.

Cambas
crea un rea donde podemos colocar dibujos conocidos en espaol como lienzo.

: Tambin al poseer un grafico cada clase que vamos a usar como componente podemos guiarnos por l para saber de qu se trata.

b. Eventos de AWT Eventos fsicos.- InputEvent, son eventos de la interaccin del usuario con la computadora como eventos hijos se tiene KeyEvent MouseEvent relacionados a una accin en el teclado y a una accin con el ratn respectivamente. Eventos Semnticos.- ActionEvent, se da cuando el usuario interacta por medio de mens listas o verificacin de casillas durante el uso del programa. Para cada evento Existe un oyente que usar.

75

Ilustracin 49. Evento.

Hemos utilizado un estndar para los nombres de los elementos, al colocar un elemento en un contenedor NetBeans automticamente le da un nombre pero para el programador debe ser ms fcil dar sus propios nombres, y con el fin de que el cdigo sea comprensible para cualquier persona que desee leer el cdigo hemos intentado dar una mayor facilidad sobre los nombres por ejemplo: Botones: sern nombrados con un distintivo seguido del nombre del botn btnNombre. Label: sern nombrados con un distintivo seguido del nombre de la etiqueta lblNombre. Text Field: sern nombrados con un distintivo seguido del nombre de la lnea de texto txtNombre. Fuentes Para poder personalizar nuestro trabajo tenemos varios elementos que podemos modificar uno de ellos es el tipo de letra que usaremos y podemos modificarla desde las propiedades de los objetos colocados dentro de nuestros contenedores o hacerlo mediante cdigo, esto podemos hacerlo usando el objeto Font.
76

Font fuente =new Font(tipo de letra, estilo, tamao); Como vemos podemos modificar el tipo, el estilo y el tamao.
Tipos de fuente

TimesRoman

Helvitica

Courier

Arial

Estilos

Font.BOLD

Font.PLAIN

Font.ITALIC

Para cambiar el estilo de fuente usamos el mtodo void setFont(fuente); Color Color tiene unos mtodos que soportan un sistema de colores estndar llamado RGB (estndar RGB) que, a su vez, es el sistema de colores por defecto en la API Java2D; la figura representa este espacio de colores. A pesar de ello tambin puede crearse un color en un sistema distinto, para lo que se utiliza el constructor anteriormente mencionado que toma como parmetros un objeto ColorSpace y un arreglo de reales que representan las componentes o muestras adecuadas a ese espacio: el objeto ColorSpace identificar el sistema de colores.
77

Ilustracin 50. Ejemplo color.

El espacio de colores RGB en el que tambin se muestra la ubicacin exacta de los componentes puros rojo, verde y azul, adems del blanco. En la clase color tambin existen constantes para los colores ms usados: black, White, Green, blue, red, yelow, magenta, cian, Orange, pink, etc.

78

Ejemplo
Realizar un lienzo donde podremos graficar de forma muy parecida a la herramienta Paint de Microsoft en el lienzo podremos graficar rectngulos y lneas de estilo libre como si fuera un lpiz en dos colores diferentes,

Ilustracin 51. Pantallas.

Tambin crearemos un botn con la opcin de salir para cerrar la aplicacin en la parte superior al lienzo colocaremos etiquetas que nos indicaran el ancho y el alto de el lienzo, tambin en la parte inferior colocaremos etiquetas pero estas nos indicaran el valor de la posicin donde se encuentra el cursor y un botn para limpiar el lienzo.

79

En la parte superior hemos colocado un menBar que nos permite agregar pestaas y dentro de cada pestaa un conjunto de mens. A continuacin podemos leer el cdigo del programa para poder entender que realiza cada botn.

80

Ilustracin 52. Cdigo fuente.

81

18. Interfaces GUI

La mayor parte de las aplicaciones que se utilizan hoy en da incluyen interfaces de usuario ms sofisticadas que las de las aplicaciones que se ejecutan en modo consola. Java incluye, como parte de su biblioteca de clases estndar, un conjunto de componentes para crear interfaces grficas de usuario. Siguiendo la filosofa de su lema (write once, run anywhere), estos componentes permiten crear interfaces portables.

Ejercicio
Con lo revisado anteriormente realizar la emulacin de una calculadora.

Ilustracin 53. Esquema calculadora. package calculadora; import java.awt.*; import java.awt.event.*; import java.util.Stack; import javax.swing.*; public class Main extends JFrame implements ActionListener { private JTextField t; Stack<String> stack; char operator;
82

boolean finished;

public static void main(String[] args) { new Main(); } public Main() { super("Calculadora Bsica - Versin 1.1"); finished = false; stack = new Stack<String>(); this.initFrame(); } private void initFrame() { String labelButtons[] = {"7", "8", "9", "/", "4", "5", "6", "*", "1", "2", "3", "-", "0", ".", "=", "+", "C"}; JPanel cp = (JPanel) this.getContentPane(); cp.setLayout(new BorderLayout()); JPanel p = new JPanel(); p.setLayout(new GridLayout(0, 4)); for (int i = 0; i < labelButtons.length; ++i) { JButton button = new JButton(labelButtons[i]); button.addActionListener(this); p.add(button); } t = new JTextField(); t.setHorizontalAlignment(JTextField.RIGHT);

83

t.setEditable(false); cp.add(t, BorderLayout.PAGE_START); cp.add(p, BorderLayout.CENTER); this.setSize(300, 300); this.setLocationRelativeTo(null); this.setVisible(true); this.setDefaultCloseOperation(Main.EXIT_ON_CLOSE); } public void actionPerformed(ActionEvent e) { char c = ((JButton) e.getSource()).getText().charAt(0); if (finished) { t.setText(""); finished = false; } if (c >= '0' && c <= '9') { t.setText(t.getText() + c); } else if (c == '.') { if (!t.getText().contains(".") && !t.getText().equals("")) { t.setText(t.getText() + "."); } } else if (c == 'C') { t.setText(""); stack.removeAllElements(); } else if (c == '=') { calc();
84

} else { operator = c; if (!t.getText().equals("")) { stack.push(t.getText()); } t.setText(""); } } private void calc() { if (!t.getText().equals("") && !stack.isEmpty()) { double a = Double.parseDouble(stack.pop()); double b = Double.parseDouble(t.getText()); double r = 0; if (operator == '+') { r = a + b; } else if (operator == '-') { r = a - b; } else if (operator == '*') { r = a * b; } else if (operator == '/') { r = a / (b != 0 ? b : 1); } t.setText(Double.toString(r)); } finished = true;
85

} }

86

CAPITULO 5

Introduccin al captulo En este captulo revisaremos teora bsica para el ingreso de datos, no necesitamos aprender mucha teora as que lo explicaremos en su mayora con ejemplos. El estudiante estar en la capacidad de crear sus propias interfaces interactuando con el usuario, es decir podr avanzar siempre y cuando el usuario ingrese la informacin.

87

19. Informacin Datos Entrada

Objetos en Internet Comunicacin en Red Archivos
Informacin Datos Entrada

Teclado

19.1. Entrada y Salida de Datos

Creacin Objeto Flujo datos lectura Lectura Flujo Cierre Flujo

Entrada Datos

Flujo Entrada

Salida Datos

Flujo Salida

Creacin Objeto Flujo datos lectura Escritura datos con mtodo apropiados Cierre Flujo

19.2. Tipos de Flujos

Carcateres

Bytes Tipos de Flujos

88

19.3. Acceso Aleatorio a Datos

19.4. Entrada Salida de Datos con Flujo de Bytes y Caracteres

Flujo con Caracteres Reader BufferReader LineNumberReader CharArrayReader FilterReader PushbackReader InputStreamReader FileReader PipedReader StringReader Flujo con Bytes InputStream ByteArrayInputStream FileInputStream FilterInputStream BufferedInputStream DataInputStream LineNumberInputStream PushbackInputStream ObjectInputStream PipedInputStream SequenceInputStream StringBufferInputStream

Entrada de Datos

Writer BufferWriter CharArrayWriter FilterWriter OutputStreamWriter FileWriter PipedWriter PrintWriter

OutputStream Salida de Datos ByteArrayOutputStream FileOutputStream FilterOutputStream BufferedOutputStream DataOutputStream PrintStream ObjectOutputStream PipedOutputStream

20. Serializacin
89

public class Capitulo5 implements Serializable {...}

Objeto se convierte en secuencia de bytes

Sublases son serializables

Implementa interfaz Serializable

No declara campos ni mtodos

20.1. ObjectOutputStream y ObjectInputStream

ObjectOutputStream ObjectInputStream

Escribe Objetos a Stream

Lee objetos desde Stream Constructor: ObjectInputStream(InputStream inStream);

Constructor: ObjectOutputStream(OutputStream outStream);

Ejemplo
Crear un programa que permita buscar y encontrar una persona. Primero creamos un nuevo proyecto.

90

Ilustracin 54. Nuevo Proyecto. Le asignamos un nombre.

Ilustracin 55. Nombre del Proyecto. Repetimos el procedimiento para cada uno de los paquetes que deseamos crear: modelo, vista, controlador

Ilustracin 56. Crear Paquetes. En el paquete controlador, creamos una clase llamada Acciones y la desarrollamos con nuestros mtodos. Tenemos la declaracin de la clase Acciones, adems de implementar el mtodo escribir, que es de tipo void, tiene como argumentos un arreglo de objetos de tipo Persona y un objeto de tipo File, as como de las diferentes implementaciones de objetos de tipo FileOutputStream, ObjectOutputStream.

91

Ilustracin 57. Acciones. El mtodo leer retorna un arreglo de Personas, tiene como argumentos un String, en este caso llamado file. Creamos los objetos de tipo FileInputStream, ObjectInputStream y retornamos el arreglo de Persona.

Ilustracin 58. OutputStream. Mtodo buscar retorna una Persona, tiene como argumentos un arreglo de tipo Persona, y un String llamado nuevo. Se crea un for para que d el nmero total de personas y se hace una condicin del arreglo de personas en el cual se busca por apellido, al final se debera retornar el arreglo de personas si cumple esta condicin, pero sino una Persona.

Ilustracin 59. Mtodo Buscar. Mtodo ingresar devuelve un arreglo de personas, tiene como argumentos un arreglo personas, y una persona. Creamos un objeto de arreglo de personas y dentro de un lazo for ponemos el nmero de personas, aqu hacemos el arreglo de personas, y fuera de este for, hacemos que el objeto que habamos creado, sea igual a persona.

92

Ilustracin 60. Mtodo Ingresar. El mtodo cargar retorna un arreglo de tipo objeto, sus datos miembro son un fichero, y dos arreglos de tipo String. Realizamos un for para que dos contadores se vayan incrementando, para los dos arreglos de Strings.

Ilustracin 61. Mtodo Cargar. Implementacin clase Persona para que sea serializable, y hacemos la declaracin de 3 variables de la clase.

93

Ilustracin 62. Class Persona. Se crea un constructor con argumentos. Recibe tres Strings que son nombre, apellido y telfono.

Ilustracin 63. Constructor con parmetros. Creamos un constructor vaco.

Ilustracin 64. Constructor vaco. Getter y Setter de las variable nombre, apellido, telfono.

Ilustracin 65. Getter y Setter de Nombre.

94

Ilustracin 66. Getter y Setter apellido.

Ilustracin 67. Getter y Setter telfono. En esta interface tenemos los ingresos para el nombre, apellido y telfono.

Ilustracin 68. Interface.

95

Declaramos un arreglo de personas.

Ilustracin 69. Arreglo personas. Esta es la interface para buscar

Ilustracin 70. Interfaz buscar. Se declara un objeto de tipo persona y tambin de un arreglo de personas. En el constructor ubicamos el archivo.

Ilustracin 71. Objeto tipo persona. En el botn aceptar. El objeto de tipo persona lo igualamos al mtodo buscar de la clase acciones, enviando los respectivos parmetros.

Ilustracin 72. Botn aceptar.

96

Interfaz creada para Guardar.

Ilustracin 73. Interfaz guardar. Creamos un objeto de tipo File, y un arreglo de personas, adems de un objeto de la clase acciones.

Ilustracin 74. Nuevos objetos. El botn Ruta tiene un objeto de tipo JFileChooser, una variable de tipo entera. Hacemos una condicin para poder encontrar la ruta.

97

Ilustracin 75. Botn ruta. El botn Aceptar, tenemos el objeto de acciones y seleccionamos el mtodo escribir, con sus respectivos parmetros.

Ilustracin 76. Aceptar.

Ejercicio 1. Realizar una aplicacin que cambie el fondo del Frame, ingresando el nmero en las cajas de texto para modificar los colores.

98

Ayudas al usuario Clase Acciones package tec1b.serializacion.controlador; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import tec1b.serializacion.modelo.Colores; public class Acciones { File aux = new File("Archivo.txt"); public void escribir(Colores colores) throws FileNotFoundException, IOException { FileOutputStream escribir = new FileOutputStream(aux); ObjectOutputStream escribir2 = new ObjectOutputStream(escribir); escribir2.writeObject(colores); } public Colores leer() throws FileNotFoundException, ClassNotFoundException { FileInputStream leer=new FileInputStream(aux); ObjectInputStream leer2=new ObjectInputStream(leer); return (Colores)leer2.readObject(); } } IOException,

Clase Modelo package tec1b.serializacion.modelo; import java.io.Serializable; public class Colores implements Serializable{ public int azul; public int verde; public int rojo; public Colores() { rojo=0;
99

verde=0; azul=0; } }

Clase NewJFrame package tec1b.serializacion.vista; import java.awt.Color; import java.io.FileNotFoundException; import java.io.IOException; import java.util.logging.Level; import java.util.logging.Logger; import tec1b.serializacion.controlador.Acciones; import tec1b.serializacion.modelo.Colores; public class NewJFrame extends javax.swing.JFrame { Colores color = new Colores(); public NewJFrame() { initComponents(); } private void initComponents() { jPanel1 = new javax.swing.JPanel(); lblRojo = new javax.swing.JLabel(); lblAzul = new javax.swing.JLabel(); jLabel3 = new javax.swing.JLabel(); txtRojo = new javax.swing.JTextField(); txtAzul = new javax.swing.JTextField(); txtVerde = new javax.swing.JTextField(); btnEjecutar = new javax.swing.JButton(); btnSalir = new javax.swing.JButton(); jComboBox = new javax.swing.JComboBox(); setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE); jPanel1.setBorder(javax.swing.BorderFactory.createEtchedBorder()); lblRojo.setText("Rojo"); lblAzul.setText("Azul"); jLabel3.setText("Verde");
100

txtRojo.setAutoscrolls(false); btnEjecutar.setText("Ejecutar"); btnEjecutar.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { btnEjecutarActionPerformed(evt); } }); btnSalir.setText("Salir"); btnSalir.addActionListener(new java.awt.event.ActionListener() { public void actionPerformed(java.awt.event.ActionEvent evt) { btnSalirActionPerformed(evt); } }); jComboBox.setModel(new javax.swing.DefaultComboBoxModel(new "Cambiar", "Guardar", "Leer" })); String[] {

javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(jPanel1); jPanel1.setLayout(jPanel1Layout); jPanel1Layout.setHorizontalGroup( jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(jPanel1Layout.createSequentialGroup() .addContainerGap() .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.TRAI LING, false) .addComponent(jComboBox, javax.swing.GroupLayout.Alignment.LEADING, 0, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(btnSalir, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addComponent(btnEjecutar, javax.swing.GroupLayout.Alignment.LEADING, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addGroup(javax.swing.GroupLayout.Alignment.LEADING, jPanel1Layout.createSequentialGroup() .addComponent(lblRojo) .addGap(24, 24, 24) .addComponent(txtRojo)) .addGroup(javax.swing.GroupLayout.Alignment.LEADING, jPanel1Layout.createSequentialGroup()
101

.addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA DING) .addComponent(jLabel3) .addComponent(lblAzul)) .addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEA DING, false) .addComponent(txtVerde) .addComponent(txtAzul, javax.swing.GroupLayout.DEFAULT_SIZE, 57, Short.MAX_VALUE)))) .addContainerGap(155, Short.MAX_VALUE)) ); jPanel1Layout.setVerticalGroup( jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(jPanel1Layout.createSequentialGroup() .addContainerGap() .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASE LINE) .addComponent(lblRojo) .addComponent(txtRojo, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASE LINE) .addComponent(lblAzul) .addComponent(txtAzul, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(18, 18, 18) .addGroup(jPanel1Layout.createParallelGroup(javax.swing.GroupLayout.Alignment.BASE LINE) .addComponent(jLabel3) .addComponent(txtVerde, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)) .addGap(18, 18, 18) .addComponent(btnEjecutar, javax.swing.GroupLayout.PREFERRED_SIZE, 35, javax.swing.GroupLayout.PREFERRED_SIZE) .addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.RELATED)
102

.addComponent(btnSalir, javax.swing.GroupLayout.PREFERRED_SIZE, javax.swing.GroupLayout.PREFERRED_SIZE)

35,

.addPreferredGap(javax.swing.LayoutStyle.ComponentPlacement.UNRELATED) .addComponent(jComboBox, javax.swing.GroupLayout.PREFERRED_SIZE, 33, javax.swing.GroupLayout.PREFERRED_SIZE) .addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)) ); javax.swing.GroupLayout layout = new javax.swing.GroupLayout(getContentPane()); getContentPane().setLayout(layout); layout.setHorizontalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(javax.swing.GroupLayout.Alignment.TRAILING, layout.createSequentialGroup() .addContainerGap() .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addContainerGap()) ); layout.setVerticalGroup( layout.createParallelGroup(javax.swing.GroupLayout.Alignment.LEADING) .addGroup(layout.createSequentialGroup() .addContainerGap() .addComponent(jPanel1, javax.swing.GroupLayout.DEFAULT_SIZE, javax.swing.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE) .addContainerGap()) ); pack(); private void btnSalirActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0); } private void btnEjecutarActionPerformed(java.awt.event.ActionEvent evt) { switch (jComboBox.getSelectedIndex()) { case 0: color.azul = Integer.parseInt(txtAzul.getText()); color.rojo = Integer.parseInt(txtRojo.getText()); color.verde = Integer.parseInt(txtVerde.getText()); jPanel1.setBackground(new Color(color.rojo, color.verde, color.azul)); break; case 1: { color.azul = Integer.parseInt(txtAzul.getText()); color.rojo = Integer.parseInt(txtRojo.getText()); color.verde = Integer.parseInt(txtVerde.getText());
103

try { new Acciones().escribir(color); } catch (FileNotFoundException ex) { Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex); } break; } case 2: try { color = new Acciones().leer(); } catch (FileNotFoundException ex) { Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex); } catch (IOException ex) { Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex); } catch (ClassNotFoundException ex) { Logger.getLogger(NewJFrame.class.getName()).log(Level.SEVERE, null, ex); } txtAzul.setText(String.valueOf(color.azul)); txtRojo.setText(String.valueOf(color.rojo)); txtVerde.setText(String.valueOf(color.verde)); jPanel1.setBackground(new Color(color.rojo, color.verde, color.azul)); break; } } public static void main(String args[]) { java.awt.EventQueue.invokeLater(new Runnable() { public void run() { new NewJFrame().setVisible(true); } }); } // Variables declaration - do not modify private javax.swing.JButton btnEjecutar; private javax.swing.JButton btnSalir; private javax.swing.JComboBox jComboBox; private javax.swing.JLabel jLabel3; private javax.swing.JPanel jPanel1; private javax.swing.JLabel lblAzul; private javax.swing.JLabel lblRojo; private javax.swing.JTextField txtAzul; private javax.swing.JTextField txtRojo; private javax.swing.JTextField txtVerde;
104

// End of variables declaration }

105

CAPITULO 6

Introduccin al captulo En este captulo nos enfocaremos en un nuevo termino como son los hilos. Con este mtodo se puede dar una impresin de movimiento por ello es de gran necesidad para nosotros ponerlo a conocimiento del estudiante.

106

21. Mquina Virtual Java

Sistema multithread

Ejecuta varios programas simultneamente

Asigna tiempos de ejecucin, prioridades

21.1. Diferencia entre proceso de Sistema Operativo y Thread Java

Sistema Operativo

Thread Comparte recursos, memoria variables y objetos definidos dentro de Sistema Operativo

21.2. Multi-threading

Series describen codigo y datos Programas constan con al menos una serie

Una o ms series se ejecute el cdigo al mismo tiempo

Se crea CPU virtual

21.2.1. Un solo Hilo vs Multi-hilo

107

22. Thread desde el mismo lenguaje

Thread desde el mismo lenguaje

Comunicacin con el usuario, transmisin con fichero

Accede a recursos del Sistema

23. Formas de definir una clase para ejecutarse con otras clases

108

Extendiendo clase Thread Implementando Interfaz Runnable

public class Ejemplo1 extends Thread

public class Ejemplo2 implements Runnable

24. Clase Thread

Empleando clase Thread public class ThreadEjemplo extends Thread {

public void run() {}

} Clase Thread Generacin y ejecucin Thread public static void main(String[]args) { ThreadEjemplo A=new ThreadEjemplo(); A.start(); }

25. Interfaz Runnable

109

Empleando Interfaz Runnable public class RunnableEjemplo implements Runnable { public void run() {} } Interfaz Runnable Generacin y ejecucin Thread public static void main(String[]args) { RunnableEjemplo A=new RunnableEjemplo(); new Thread(A).start(); }

26. Suspensin de un Hilo

sleep

suspend

110

26.1. Mtodo Suspend

Mtodo suspend

Para activar nuevamente con resume

No detiene ejecucin indefinidamente

26.2. Parada de un Hilo

stop Para ejecucin hilo permanentemente

isAlive Comprueba si instancia esta viva o no

111

Ejemplo
Creamos la clase Hilo1, donde manejamos en el constructor el concepto de hilo, y en el mtodo run de tipo void, hacemos correr al segundo hilo.

Ilustracin 77. Clase Hilo1.

En el hilo2 hacemos la misma declaracin que el hilo1 en el constructor, y en el mtodo void run ubicamos el tiempo en el que queremos que salga el mensaje.

Ilustracin 78. Clase Hilo2.

112

En una clase principal llamamos al primer hilo.

Ilustracin 79. Clase Principal.

113

Capitulo 7

Introduccin al captulo En este captulo revisaremos la interfaz con los puertos revisando las componentes bsicas para la comunicacin con el puerto serie y paralelo.

114

27. Adquisicin de Datos

Seales externas: Analgicas, Digitales.

Recepcin

Adquisicin de seales y conversor.

Mediante PC, controla acciones a realizar en funcin de las seales externas adquiridas. manipulacin

28. Acondicionamiento de seales

Amplificacin

Filtrado

Manipulacin y tratamiento en

Aislamiento Trmico

Multiplexado

1. Tratamiento de las seales en cada proceso

29. Seales Digitales

Seales Digitales

Seales de dos estados: ALTO y BAJO

Ondas Cuadradas

Se generan ruidos por causas ajenas, se deforma la seal digital

115

Solucin

Circuito Integrado Schmith - Trigger

Mediante

histresis

Entrega a su salida siempre una seal cuadrada, basado en rangos de niveles de voltaje para sus dos estados, ALTO y BAJO

29.1. Regeneracin de una seal digital maltratada

Fenmeno de Rebotes en las Seales

Se presentan en Contactos metlicos generan Varias oscilaciones en cada cambio de estado pulsadores

afectando a: Seales que trabajan a velocidades muy elevadas solucin Por Hardware1 Con filtro RC Por Hardware2 Mediante inversores Por Software Generando retardos, para q se estabilice la seal. 200ms

Elementos Electrnicos

Buffers

Rels

Optoacoplador

Circuitos integrados que a su salida generan mayor corriente que otro CI

Mediante un circuito electromecnico se controla desde electrnica digital, a elementos de

116 Mediante un circuito digital, compuesto por un diodo y un transistor de potencia, opera igual

30. Puerto Serie

Comunicacin Serial

Envo de bits de un perifrico a otro viceversa.

La transmisin se la realiza en cadenas de bits.

Ms lenta en comparacin con la comunicacin paralela.

Comunicacin a distancias cortas < 15 metros velocidad Bits por segundo baudios

30.1. Descripcin del puerto Serie

Estndar de comunicacin RS-232

Conector del puerto Serial que lo tenemos como perifrico

HIGH +12 volts LOW -12 volts Regin -3 y +3 indefinida

Conector DB-9

Envo de datos TXD Recepcin de datos RXD Comunicacin asncrona

31. Puerto Paralelo

117

Puerto Paralelo

Mediante el envo de bits en buses completos. Bus de datos, direcciones, control. Tipos de Simplex Comunicacin Full Duplex

Half Duplex O transmite o recibe un terminal est informacin, pero no ambas a la vez Envo y recepcin de informacin al mismo tiempo con un canal para cada pin de transmisin

Mediante una sola lnea Si se enva datos, solo puede recibir y viceversa.

31. 1. Modos de Transmisin de Datos

Modos de Transmisin de Datos TX

Asncronas

Sncronas

Cuando el transmisor y el receptor no estn sincronizados temporalmente.

Cuando bits especiales dan a conocer el sincronismo de transmisor receptor en su transmisin

32. Manejo del Puerto Serie

118

Manejo del Puerto Serie JAVA mediante API Java Communications (COMM)

Controla perifricos

Puerto Paralelo. RS-232

Puerto Serie IEEE-1284

Instalacin Comm.jar /jdk1.6/jre/lib/ext

Win32com.dll

/jdk1.6/bin

Javax.comm.prope rties

/jdk1.6/jre/lib

Acceso a puerto de comunicacin CommPortIdentifier CommPort

Nivel Alto

Niveles de Comunicacin

Nivel Medio

Nivel Bajo

119

Maneja interfaces RS-232 IEEE-1284

Relacionado al sistema operativo

Ejemplos Conectarse mediante el Hyper Terminal del computador y ver la transmisin de los datos

Ilustracin 80. Conectar Hyper Terminal. Creamos una nueva conexin.

Ilustracin 81. Nueva conexin.

120

Accedemos al Hyper Terminal como se indica en el grfico.

Ilustracin 82. Acceder al Hyper Terminal. Establecemos los parmetros de configuracin regional

Ilustracin 83. Configuracin. Todo listo para proceder al envo de informacin

121

Ilustracin 84. Envo de texto. 2.- Creacin de un programa que me permitir el envo de un mensaje serialmente, utilizando los COM disponibles en el puerto.

Ilustracin 85. Puerto Serie. Importamos las libreras de comunicacin serial y creamos nuestra clase.

Ilustracin 86. Serial.

122

Para finalizar creamos nuestra ventana de comandos con la habilitacin del botn que enviar la informacin.

Ilustracin 87. Class ventana.

33. Manejo del Puerto Paralelo

Manejo del Puerto Paralelo JAVA

Se trabaja con la direccin 378 del bus de datos pines 8 pins Salida D0-D7 5 pins Status S4-S7 y S3 4 pins Control C0-C3 8 pins tierra 18-25

Norma TTL HIGH 5 volts LOW 0 volts Librera a usarse COMUNICATIONSAPI.

6 mA 20mA

Agregar librera Jnpout32pkg.jar 123

crear Liberia: Import jnpout32.*; Objeto: pPort Puerto = new pPort(); Direcciones

en WINDOWS/system32

378

Bus de Datos

379

Bus de Estado

37A

Bus de Control

124

Ejemplos
1.- Aplicacin que nos permite visualizar el bus de datos a la salida en el puerto paralelo

Ilustracin 88. Habilitacin del Puerto serial. 2.- Aplicacin que permitir escribir en el registro 0X378, 0X37A y leer el registro 0X379

Ilustracin 89. Lectura de registros.

125

Ventana que me indica cmo controlar la direccin a manejar y el mensaje

Ilustracin 90. Ventana de seleccin.

126

127

APNDICES
Apndice 1 Entornos de desarrollo integrado (IDE)

Entornos de Desarrollo Integrado

Un IDE es un programa que nos permite desarrollar, compilar, y ejecutar programas en determinado lenguaje de programacin. Es un proyecto de desarrollo de software de cdigo de fuente abierto, su principal objetivo es la construccin de herramientas integradas para el desarrollo de aplicaciones, as mismo su proyecto global se basa en subproyectos. Proporciona un IDE de clase empresarial basado en la infraestructura de cdigo abierto con soporte para los diferentes servidores. Se centra en la productividad para el desarrollo de cdigo, de esta forma el editor analiza el cdigo en el camino y proporciona sugerencias. Era de libre descarga, gracias a su cdigo de refactorizacin lo hace de gran ayuda para el usuario. No es de fcil entendimiento sin embargo sus aplicaciones son de mayor y mejor No es una herramienta que se usa para crear aplicaciones que se ejecuten en una maquina virtual de java, las aplicaciones y servicios generados con Visual J# slo se ejecutarn en .NET Framework, creado por Microsoft.

Eclipse

JBuilder

JDeveloper

JIdea

Visual J#

128

Apndice 2 Estructuras en Java

Estructuras

Numeracion

Coleccion

Vector

Directorio de Java

LINKEDLIST

ARRAYLSIT

HASHSET

HASHMAP

TREESET

Es un tipo escencial de clase, que hereda java.lang.Enum . No permite el uso del operador new para la creacin de objetos

Es un objeto que almacena un conjunto de referencias a otros objetos, dicho de otra manera, es una especie de array de objetos.

Aadir objetos a la coleccin Eliminar objetos de la coleccin Obtener un objeto de la coleccin Localizar un objeto de la coleccin Iterar a traves de una coleccin

La clase vector nos proporciona una solucion alternativa para cuando queremos guardar objetos pero no sabemos cuantos, un vector es similar a un array, la diferencia estriba en que un vector crece automaticamente cuando alcanza la dimension inicial maxima .

Para crear un directorio con Java deberemos de utilizar un objeto File. La ruta que debe de contener dicho objeto deber hacer referencia a un directorio en lugar de a un archivo.

Es una lista enlazada de Recipientes (nodos) donde cada uno contiene: elementos (objetos, otras listas, etc) y uno o dos punteros hacia posiciones de memoria que indican al anterior o siguiente nodo, til cuando se quiere insertar o eliminar elementos al principio o al final de la lista.

A diferencia de los arrays clsicos, un ArrayList permite aumentar el tamao del vector indefinidamente (hasta lo que la memoria permita) y agregar o quitar elementos.

Es una estructura de datos que contiene un conjunto de objetos. Permite buscar un objeto dentro del conjunto de forma rpida y fcil.

Permite guardar elementos, donde cada elemento es un par clave/valor.

Un TreeSet mantiene los objetos ordenados en lo que se conoce como red-black tree

129

Apndice 3 Pruebas y Depuracin de cdigo

Pruebas de caja blanca

Pruebas de caja negra

JUnit
130

Comandos de JUnit

Logger Log4J

131

Apndice 4 Anlisis Orientado a Objetos

El Proceso de AOO

Modelo objetoRelacin y Modelo objetocomportamiento

Anlisis del dominio

Definicin de subsistemas

Analisis Orientado a Objetos

Componentes genricos del modelo de anlisis OO

Casos de uso

Modelado de clasesresponsabilidadescolaboraciones (CRC)

132

Modelo objeto-Relacin y Modelo objeto-comportamiento Finalmente en la bsqueda de nuestro anlisis orientado a objetos definiremos cuales son las clases colaboradoras, el anlisis gramatical, aqu obtendremos y encontraremos la responsabilidad con varias preguntas que nos ayudaran a definir de donde vienen como son: cerca de, de parte de, contenido en, trasmite a, obtenindole a, se compone de, etc. , en el cual verificaremos la exactitud y consistencia con el debido comportamiento de su objeto . Diseo Orientado a Objetos El Diseo Orientado a Objetos DOO, proporciona un diseo que alcanza diferente niveles de modularidad explicados detalladamente, los componentes se organizan en subsistemas, se encapsulan datos. Reside en su capacidad para construir cuatro conceptos importantes de diseo de software: abstraccin, ocultamiento (ocultacin) de informacin, independencia funcional y modularidad Pirmide de Diseo Orientado a Objetos

Diseo de Responsabilidades

Diseo de Mensajes

Diseo de Clases y Objetos

Diseo de Subsistemas

133

Pruebas Orientadas a Objetos

Apndice 5 Ingeniera Inversa Para todas las aplicaciones estudiadas de ingeniera inversa se necesita programas especiales o complementos, como es el caso de creacin de diagramas UML,

134

Ingenieria Inversa
Decompilador

Conceptos
decompilador permite obtener el cdigo fuente de un programa a partir de los archivos .class o .jar; en Java es posible obtener los nombres originales de las clases, mtodos, atributos

Ofuscacion de codigo

ofuscador modifica el cdigo fuente para dar nombres cortos, sin significado y sin seguir los convenios de nomenclatura de Java

Creacion de diagramas UML a partir de codigo y viceversa

Requiere de un complemento para Netbeans pero es muy util para entender mejor el programa

Instalador de aplicaciones Java para windows

Creacion de un archivo tipo .exe a partir de un archivo .jar

Apndice 6 Componentes SWING El paquete Swing es parte de la JFC (Java Foundation Classes) en la plataforma Java. La JFC provee facilidades para ayudar a la gente a construir GUIs. Swing abarca componentes como botones, tablas, marcos, etc... Las componentes Swing se identifican porque pertenecen al paquete javax.swing

135

Apndice 7 JMathlink Mediante esta interface de JMatLink podemos enlazar Matlab con java y podemos usar las herramientas para de este para poder facilitar nuestra programacin.

136

Tecnologias del Software I

JAVA

MATLAB

Tiene un modelo de objetos ms simple y elimina herramientas de bajo nivel.

Software matematico que ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de programacin propio (lenguaje M).

Es una librera que conecta Java y Matlab

Utiliza mtodos nativos permiten utilizar diferentes funciones de Matlab desde una Java. Necesita de tres clases: - CoreJMatLink - JMatLink - JMatLinkException

Basado en JNI (Java Native Interface) JMATLINK

1. Uso de JMATLINK en NETBEANS: a. Extraemos la clase principal test_jmatlink de JMATLINK.RAR . b. Otra forma de ejecutar la librera JMATLINK es mediante TestGui(dentro de JMATLINK.RAR). c. Para un mejor entendimiento se recomienda revisar la documentacin adjunta del JMATLINK.RAR que esta dentro de la carpeta java.doc

137

Apendice 8 Java FX

Es un nuevo lenguaje diseado para animaciones y grficos. Permite la vinculacin de componentes escritos en otros lenguajes (principalmente en Java) con rapidez, cdigo simple y completamente orientado a objetos. Ofrece una atractiva mezcla de la ubicuidad, la capacidad, la expresividad y rendimiento. Tiene el conjunto esencial de las tecnologas, herramientas y recursos necesarios para los desarrolladores y diseadores para crear y desplegar contenido expresivo y potente dentro del navegador, escritorio, mviles, TV y otros dispositivos conectados.

Apndice 9 Google Maps

Es un servicio gratuito de Google. Es un servidor de aplicaciones de mapas en la Web. Ofrece imgenes de mapas desplazables, as como fotos satelitales del mundo entero e incluso la ruta entre diferentes ubicaciones o imgenes a pie de calle Street View.
138

Una imagen satelital o imagen de satlite se puede definir como la representacin visual de la informacin capturada por un sensor montado en un satlite artificial.

JPOSITION
Biblioteca de clases usada para desplegar mapas de Google Maps desde Java.

GUI
programa informtico que acta de interfaz de usuario, utilizando un conjunto de imgenes y objetos grficos para representar la informacin y acciones disponibles en la interfaz

Es un archivo.jar, dentro del cual est el cdigo que nos permite cargar el mapa as como definir sus caractersticas

AWT

Componente grafico pesado, que en cada plataforma solopueden tener una representacion determinada.

SWING

Componente grafico ligero, que pude tomar diferentes aspectos y comportamientos, pues es tomado de una biblioteca de clases

139

Programacion orientada a eventos la estructura como la ejecucin de los programas van determinados por los sucesos que ocurran en el sistema, definidos por el usuario o que ellos mismos provoquen.

Deteccin de Eventos permite interactuar con el usuario en cualquier momento de la ejecucin

Ilustracin 91. Cdigo.

140

El primer objeto creado ser el siguiente:

El segundo objeto creado ser el siguiente:

Se define un arraylist:

Al tener la posibilidad de tener ms de un punto se crea el Arraylist definido como Marker, el cual se llamara listaPuntos que dentro de l se ir agregando el objeto punto para que se pueda desplegar la lista de puntos desplegada en el mapa.

141

Apndice 10 Java 2D
JAVA 2D

Proporciona un robusto conjunto de imgenes y herramientas de dibujo para grficos de alta calidad.
java.awt.Graphics2D

Es una clase que extiende a java.awt.Graphic

El lienzo puede estar enlazado con un rea fsica de un monitor, o representar una imagen en memoria que slo se desea manipular y no tiene representacin directa durante este proceso.

Un objeto Graphics (clase abstracta) representa el lienzo abstracto y el contexto en el que puede dibujarse cualquier cosa.

El proceso en Java2D est controlado por un objeto de esta clase Graphics2D.

Sus atributos o caractersticas contextuales que son, a su vez, objetos.

El conjunto de estos atributos es lo que conforma el contexto.

Coordenadas de Usuario (user space) Sistema de Coordenadas de Java2D

El origen de las coordenadas de usuario est situado en la esquina superior izquierda del objeto Graphics2D (0,0)

X: desplazamiento hacia la derecha Y: desplazamiento hacia abajo

GraphicsEnvironment: Define la coleccin de dispositivos visibles desde una plataforma Java.

pantallas, impresoras y buffers de imagen

Coordenadas de Dispositivo (device space)

Java2D define tres bloques de informacin para soportar la conversin entre las coordenadas de usuario y de dispositivo

GraphicsDevice: Define un dispositivo concreto de grficos

Dispositivo de visualizacin SVGA puede funcionar en varios modos

GraphicsConfiguration: Define un modo de ese dispositivo concreto

142

Mtodo Devuelve un contains(double x, boolean double y) contains(Point2D p) contains(double x, double y, double ancho, double largo) contains(Rectangle 2D r) getBounds() getBounds2D() boolean boolean

Descripcin Determina si las coordenadas estn dentro de la Shape Igual al anterior pero con un Point2D Determina si el rea rectangular entra dentro de la Shape

boolean Rectangle Rectangle2D

getPathIterator(Aff PathIterator ineTransform at)

getPathIterator(Aff PathIterator ineTransform at, double aplanamiento) intersects(double x, boolean double y, double ancho, double largo) intersects(Rectangl boolean e2D r)

Igual que el anterior pero con un Rectangle2D Devuelve el rectngulo mnimo que recubre la Shape Devuelve un rectngulo ms optimizado que en el anterior caso Devuelve un Iterator que itera sobre los subtrazos de la figura. Si queremos transformar las iteraciones, usamos la transformada, sino sencillamente pasamos null en el mtodo Igual que el anterior, pero el segundo parmetro otorga un comportamiento plano a las secciones iteradas de la figura que sean curvas Testea si el interior de la Shape interseca con el interior del rea rectangular pasada como parmetro Igual que el anterior pero con un Rectangle2D.

Public Elipse() { initComponents(); } Constructor que inicializa los componentes visuales.

public void paint( Graphics g ){ super.paint(g); // llamar al mtodo paint de la superclase

Graphics2D g2d=(Graphics2D)g;

143

g2d.setPaint(Color.red); g2d.setStroke(new BasicStroke(5.0f)); g2d.draw(new Ellipse2D.Double(x+60,y,ANCHO,ALTO-10)); g2d.drawString("ELIPSE 2D",x+150,150); Mtodo para dibujar una elipse Convierte el objeto g de tipo Graphics a Graphics 2d

public ElipseRelleno() { initComponents(); } Constructor que inicializa los componentes visuales

public void paint( Graphics g ){ super.paint(g); // llamar al mtodo paint de la superclase

Graphics2D g2d=(Graphics2D)g; g2d.setPaint(new GradientPaint(x+400,y+140,Color.MAGENTA,x+400,y+175,Color.CYAN,true)); g2d.fill(new Ellipse2D.Double(x+50,y+30,ANCHO,ALTO-10)); g2d.drawString("ELIPSE 2D",x+70,y); Mtodo para dibujar una elipse con relleno Convierte el objeto g de tipo Graphics a Graphics 2d

public Linea() { initComponents(); } Constructor que inicializa los componentes visuales

public void paint( Graphics g ){ super.paint(g); Graphics2D g2d=(Graphics2D)g;

144

g2d.setStroke(new BasicStroke(10.0f)); g2d.draw(new Line2D.Double(20,280,200,150)); g2d.drawString("LINEA 2D",x+70,y); Mtodo para dibujar una linea Convierte el objeto g de tipo Graphics a Graphics 2d

public Rectangulo() { initComponents(); } Constructor que inicializa los componentes visuales

public void paint( Graphics g ){ super.paint(g); Graphics2D g2d=(Graphics2D)g; g2d.setPaint(Color.blue); g2d.setFont(new Font("Monospaced", Font.ITALIC, 15)); g2d.setStroke(new BasicStroke(3.0f)); g2d.draw(new Rectangle2D.Double(x,y,ANCHO,ALTO)); g2d.drawString("RECTANGULO 2D",x+120,y); } Mtodo para dibujar un Rectngulo Convierte el objeto g de tipo Graphics a Graphics 2d

public RectanguloRelleno() { initComponents(); } Constructor que inicializa los componentes visuales

public void paint( Graphics g ){ super.paint(g);

145

Graphics2D g2d=(Graphics2D)g; g2d.setPaint(new GradientPaint(x+400,y,Color.red,x+520,y+70,Color.green, true )); g2d.setFont(new Font( "Serif",Font.BOLD,15)); g2d.fill(new Rectangle2D.Double(x,y,ANCHO, ALTO)); g2d.drawString("RECTANGULO 2D CON RELLENO",x+120,y); } Mtodo para dibujar un Rectngulo con relleno Convierte el objeto g de tipo Graphics a Graphics 2d

Proyecto LCD
PUERTO PARALELO

Es una interfaz entre la computadora y un perifrico

CARACTERSTICAS

CABLE PARALELO
Registro de Control

ESTRUCTURA

Registro de Estado

Registro de Datos

Los bits de datos viajan juntos, enviando un paquete de byte a la vez

Se implementa un cable o una va fsica para cada bit de datos formando un bus

Es el conector fsico entre el puerto paralelo y el dispositivo perifrico

Se compone de 4 bits, con un bit de configuracin que no tiene conexin al exterior

Configuracin

Registro de entrada de informacin de 5 bits

Se compone de 8 bits

Su direccin en el LPT1 es 0X37A

Su direccin en el LPT1 es 0X379

Su direccin en el LPT1 es 0X378

146

LCD (Pantalla de cristal liquido o Liquid Crystal Display)

Dispositivo micro controlado de visualizacin grfica para la presentacin de caracteres, smbolos o incluso dibujos

CARACTERSTICAS

FUNCIONAMIENTO

Dispone de 2 filas de 16 caracteres cada una.

Cada carcter dispone de una matriz de 5x7 puntos (pixeles)

Podemos hacerlo por medio de sus pines de entrada de dos maneras posibles

Pantalla de caracteres ASCII, adems de los caracteres Kanji y Griegos

Con bus de 4 bits o con bus de 8 bits

Memoria de 40 caracteres por lnea de pantalla

El control de contraste se realiza al dividir la alimentacin de 5V con una resistencia variable de 10K

Desplazamiento de los caracteres hacia la izquierda o la derecha. Permite que el usuario pueda programar 8 caracteres

Proporciona la direccin de la posicin absoluta o relativa del caracter

Las lneas de datos son triestado

Cuando el LCD no esta habilitado sus entradas y salidas pasan a alta impedancia.

Conexin a un procesador usando un interfaz de 4 u 8 bits

Los pines 1 y 2 Destinados para conectarle los 5 Voltios que requiere el modulo para su funcionamien to

El pin nmero 3 Usado para ajustar el contraste de la pantalla; es decir colocar los caracteres ms oscuros o ms claros para poderse observar mejor

El Pin numero 4 Denominado "RS" trabaja paralelamente al Bus de datos del modulo LCD Si el Pin numero 4 = 0 le dir al modulo LCD que est presente en el bus de datos una instruccin, por el contrario, si el Pin numero 4 = 1 le dir al modulo LCD que est presente un smbolo o un carcter alfa numrico

147

El pin numero 5 Denominado "R/W" trabaja paralelamente al Bus de datos del modulo LCD Si el Pin numero 5 = 0 el modulo LCD escribe en pantalla el dato que est presente el Bus; pero si el Pin numero 5 = 1 significa que usted necesita leer el dato que est presente el bus del modulo LCD

El pin numero 6 Denominado "E" que significa habilitacin del modulo LCD tiene una finalidad bsica: conectar y desconectar el modulo

Los Pines desde el 7 hasta el 14 Representan 8 lneas que se utilizan para colocar el dato que representa una instruccin para el modulo LCD o un carcter alfa numrico. El Bus de datos es de 8 Bits de longitud y el Bit menos significativo est representado en el Pin numero 7, el Pin ms significativo est representado en el Pin numero 14

Los pines 15 y 16 Destinados para suministrar la corriente al Back Light

public FrameControl() { initComponents(); bandera=1; o Constructor que inicializa los componentes visuales. Este constructor existe en todos los Frames: public FrameInicio(), public Letras(), public Numeros(), public Simbolo(). public SalidaParalelo(int direccion, int tiempo, String texto) { Paralelo.output((short) 0x379, (short) 0x01); o En este mtodo se define la opcin a ser escogida: lnea superior, inferior, o borrado, con ello se maneja el tiempo de espera para que el LCD reciba la informacin y la presente en pantalla. private void BORRARActionPerformed(java.awt.event.ActionEvent evt) { txtTexto.setText("");
148

SalidaParalelo e=new SalidaParalelo(2,500,txtTexto.getText()); o Borra lo que este escrito en el txt. private void btnSuperiorActionPerformed(java.awt.event.ActionEvent evt) { bandera=1; btnInferior.disable(); o Escoge la lnea superior para escribir en el LCD. private void btnInferiorActionPerformed(java.awt.event.ActionEvent evt) { bandera=2; btnSuperior.disable(); o Escoge la lnea inferior para escribir en el LCD. private void btnEscribirActionPerformed(java.awt.event.ActionEvent evt) { if (btnSuperior.isSelected()){ bandera=1; else{ bandera=2; SalidaParalelo e=new SalidaParalelo(bandera,500,txtTexto.getText()) } o Enva la informacin a la lnea para que escriba en pantalla. private void menuLetrasActionPerformed(java.awt.event.ActionEvent evt) { this.dispose(); new Letras().setVisible(true); o Selecciona solo la opcion de letras para la escritura. private void menuNumerosActionPerformed(java.awt.event.ActionEvent evt) { this.dispose(); new Numeros().setVisible(true); o Selecciona solo nmeros para la escritura en el LCD.
149

private void menuSimbolosActionPerformed(java.awt.event.ActionEvent evt) { this.dispose(); new Simbolo().setVisible(true); o Selecciona solo simbolos para el ingreso en el LCD. private void menuExitActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0); o Finaliza la aplicacin.

Proyecto
Nuestro problema radica en cmo resolver circuitos que usen un transistor, para conocer sus voltajes, corrientes, punto de operacin y el modelo Darlington. package araujocampaamenesesquisnancela.transistores.controlador; import java.io.*; public class IngresoDatos { private BufferedReader dato = new BufferedReader(new InputStreamReader(System.in)); public double decimal (){ double dNumero = 0; try{ dNumero = Double.parseDouble(dato.readLine()); }catch(Exception e){} return dNumero; } public int entero (){ int iNumero=0; try{
150

iNumero = Integer.parseInt(dato.readLine()); }catch(Exception e){} return iNumero; }

public String texto(){ String tTexto=""; try{ tTexto=dato.readLine(); }catch(Exception e){} return tTexto; } } package araujocampaamenesesquisnancela.transistores.controlador; import araujocampaamenesesquisnancela.transistores.modelo.Resistencia; public class IngresoResistencias { public Resistencia setResistencia(String nombre){ Resistencia resistencia = new Resistencia(); IngresoDatos ingreso = new IngresoDatos(); resistencia.setNombre(nombre); String aux = ""; do{ System.out.println("\nIngresar la resistencia de " + nombre); System.out.println("Colores. (C)"); System.out.println("Valor numerico. (N)");
151

System.out.print("Ingreso por: "); aux = ingreso.texto(); }while(!aux.equals("C") & !aux.equals("N"));

if(aux.equals("C")){ System.out.println("Colores.- "); resistencia.setValor(); } if(aux.equals("N")){ System.out.print("Valor: "); resistencia.setValor(ingreso.decimal()); } return resistencia; } } package araujocampaamenesesquisnancela.transistores.controlador; import araujocampaamenesesquisnancela.transistores.modelo.Transistor; public class IngresoTransistor { public Transistor setTransistor(){ Transistor transistor = new Transistor(); transistor.setTipo(); transistor.setBeta(); return transistor; } }
152

package araujocampaamenesesquisnancela.transistores.controlador; import araujocampaamenesesquisnancela.transistores.modelo.Voltaje; import araujocampaamenesesquisnancela.transistores.modelo.Transistor; import araujocampaamenesesquisnancela.transistores.modelo.Resistencia; import araujocampaamenesesquisnancela.transistores.modelo.PBase; import araujocampaamenesesquisnancela.transistores.modelo.PColector; import araujocampaamenesesquisnancela.transistores.modelo.PEmisor; import araujocampaamenesesquisnancela.transistores.modelo.PBDarlington; import araujocampaamenesesquisnancela.transistores.modelo.PDivTension; public class Sesion { private IngresoDatos ingreso = new IngresoDatos(); public String[] ingresoDatos(){ int i = 0; int aux = 0; IngresoResistencias ingresoR = new IngresoResistencias(); IngresoTransistor ingresoT = new IngresoTransistor(); Resistencia[] resistencias = new Resistencia[5]; Transistor[] transistor = new Transistor[2]; String[] resultados = new String[12]; Voltaje fuente = new Voltaje(); for (i = 0; i < resultados.length; i++) resultados[i] = new String(); for (i = 0 ; i < resistencias.length ; i++) resistencias[i] = new Resistencia();

153

do{ System.out.println(); System.out.println("Escoja el circuito sobre el que se trabajara: "); System.out.println("1. Polarizacion de base."); System.out.println("2. Realimentacion de emisor."); System.out.println("3. Polarizacion con realimentacion de colector."); System.out.println("4. Polarizacion por divisor de tension."); System.out.println("5. Polarizacion de base con Darlington."); System.out.println("6. Salir."); System.out.print("Usted desea la opcion: "); aux = ingreso.entero(); }while((aux <= 0) | (aux > 6)); if(aux == 6){ for (i = 0;i<(resultados.length-1);i++) resultados[i] = new String(); resultados[11] = "salir"; return resultados; } System.out.println("Indique el voltaje de la fuente: "); fuente.setValor(ingreso.decimal()); transistor[0] = new Transistor(); transistor[0] = ingresoT.setTransistor(); switch (aux){ case 1: resistencias[0] = ingresoR.setResistencia("Base");
154

resistencias[1] = ingresoR.setResistencia("Colector"); PBase circuitoB = new PBase(); resultados = circuitoB.calculos(fuente,resistencias,transistor[0]); break; case 2: resistencias[0] = ingresoR.setResistencia("Base"); resistencias[1] = ingresoR.setResistencia("Colector"); resistencias[2] = ingresoR.setResistencia("Emisor"); PEmisor circuitoE = new PEmisor(); resultados = circuitoE.calculos(fuente,resistencias,transistor[0]); break; case 3: resistencias[0] = ingresoR.setResistencia("Base"); resistencias[1] = ingresoR.setResistencia("Colector"); PColector circuitoC = new PColector(); resultados = circuitoC.calculos(fuente,resistencias,transistor[0]); break; case 4: resistencias[0] = ingresoR.setResistencia("Base 1"); resistencias[1] = ingresoR.setResistencia("Base 2"); resistencias[2] = ingresoR.setResistencia("Colector"); resistencias[3] = ingresoR.setResistencia("Emisor"); PDivTension circuitoT = new PDivTension(); resultados = circuitoT.calculos(fuente,resistencias,transistor[0]); break;
155

case 5: System.out.println("Datos para el segundo transistor"); transistor[1] = new Transistor(); transistor[1] = ingresoT.setTransistor(); resistencias[0] = ingresoR.setResistencia("Base"); resistencias[1] = ingresoR.setResistencia("Colector"); PBDarlington circuitoBaseD = new PBDarlington(); resultados = circuitoBaseD.calculos(fuente,resistencias,transistor); break; case 6: for (i = 0;i<(resultados.length-1);i++) resultados[i] = new String(); resultados[11] = "salir"; break; default: break; } return resultados; } } package araujocampaamenesesquisnancela.transistores.modelo; public class Corriente { private double i = 0 ; private double iMA = 0;

156

public void setValor(double valor){ i = valor; iMA = xMil(valor); } public double getValor(){ return i; } public double getMA(){ return iMA; } public double xMil(double valor){ return valor*1000; } } package araujocampaamenesesquisnancela.transistores.modelo; public class Darlington { private String tipo = "NPN"; private Corriente iB = new Corriente(); private Corriente iC = new Corriente(); private Corriente iE = new Corriente(); private Voltaje vB = new Voltaje(); private Voltaje vC = new Voltaje(); private Voltaje vE = new Voltaje(); private Voltaje vCE = new Voltaje(); private int beta1 = 100;
157

private int beta2 = 100; private int beta = (beta1 + beta1*beta2 + beta2); public void setTipo(String type){ if (type.equals("NPN")|type.equals("PNP")) tipo = type; else System.out.print("Tipo no valido"); } public String getTipo(){ return tipo; } public void setBeta1(int valor){ if (valor > 0){ beta1 = valor; beta = beta1 + beta1*beta2 + beta2; }else System.out.print("Beta no valido"); } public void setBeta2(int valor){ if (valor > 0){ beta2 = valor; beta = beta1 + beta1*beta2 + beta2; }else System.out.print("Beta no valido"); }
158

public int getBeta(){ return beta; } public void setIB(double valor){ iB.setValor(valor); findICIB(); findIEIB(); } public Corriente getIB(){ return iB; } private void findICIB(){ iC.setValor(beta*iB.getValor()); } private void findIEIB(){ iE.setValor((beta+1)*iB.getValor()); }

public void setIC(double valor){ iC.setValor(valor); findIEIC(); } public Corriente getIC(){ return iC; }
159

private void findIEIC(){ iE.setValor(iC.getValor()+(iB.getValor()*(beta1+1))); } public void setIE(double valor){ iE.setValor(valor); } public Corriente getIE(){ return iE; } public void setVB(double valor){ vB.setValor(valor); vE.setValor(valor-1.4); } public Voltaje getvB(){ return vB; } public void setVC(double valor){ vC.setValor(valor); } public Voltaje getvC(){ return vC; } public void setVE(double valor){ vE.setValor(valor); vB.setValor(valor+1.4);
160

} public Voltaje getvE(){ return vE; } public Voltaje getvCE(){ vCE.setValor(vC.getValor()-vE.getValor()); return vCE; } public double getP(){ return vCE.getValor()*iC.getValor(); } } package araujocampaamenesesquisnancela.transistores.modelo; public class PBDarlington { public String[] calculos(Voltaje fuente,Resistencia[] resistencias, Transistor[] transistorV){ String[] resultados = new String[11]; Corriente iCMax = new Corriente(); Darlington transistor = new Darlington(); double temp = 0; transistor.setBeta1(transistorV[0].getBeta()); transistor.setBeta2(transistorV[1].getBeta()); temp = (fuente.getValor() - 1.4)/resistencias[0].getValor(); transistor.setIB(temp); temp = fuente.getValor()/resistencias[1].getValor(); //ICmax //IB

161

iCMax.setValor(temp); if(transistor.getIC().getValor()>=temp) transistor.setIC(temp); temp = transistor.getIC().getValor(); resistencias[1].setCorriente(temp);

temp = fuente.getValor()-resistencias[1].getVoltaje(); transistor.setVC(temp); transistor.setVE(0); System.out.println("\n\nResultados:"); if (transistor.getvB().getValor()<1) resultados[0] = "Voltaje base = " + transistor.getvB().getMV() + " mV"; else resultados[0] = "Voltaje base = " + transistor.getvB().getValor() + " V"; if (transistor.getvC().getValor()<1) resultados[1] = "Voltaje colector = " + transistor.getvC().getMV() + " mV"; else resultados[1] = "Voltaje colector = " + transistor.getvC().getValor() + " V"; if (transistor.getvE().getValor()<1) resultados[2] = "Voltaje emisor = " + transistor.getvE().getMV() + " mV"; else resultados[2] = "Voltaje emisor = " + transistor.getvE().getValor() + " V"; if (transistor.getvCE().getValor()<1) resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getMV() + " mV";

162

else resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getValor() + " V";

if (fuente.getValor()<1) resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getMV() + " mV"; else resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getValor() + " V"; if (transistor.getIB().getValor()<1) resultados[5] = "Corriente base = " + transistor.getIB().getMA() + " mA"; else resultados[5] = "Corriente base = " + transistor.getIB().getValor() + " A"; if (transistor.getIC().getValor()<1) resultados[6] = "Corriente colector = " + transistor.getIC().getMA() + " mA"; else resultados[6] = "Corriente colector = " + transistor.getIC().getValor() + " A"; if (transistor.getIE().getValor()<1) resultados[7] = "Corriente emisor = " + transistor.getIE().getMA() + " mA"; else resultados[7] = "Corriente emisor = " + transistor.getIE().getValor() + " A"; if (iCMax.getValor()<1) resultados[8] = "Colector colector maxima = " + iCMax.getMA() + " mA"; else resultados[8] = "Colector colector maxima = " + iCMax.getValor() + " A";

163

resultados[9] = "Potencia disipada = " + transistor.getP(); if (transistor.getIC().getValor() == iCMax.getValor()) resultados[10] = "El transistor se encuentra en saturacion"; else if(transistor.getvCE().getValor()==fuente.getValor()) resultados[10] = "El transistor se encuentra en corte"; else resultados[10] = "El transistor se encuentra en la zona activa"; return resultados; } } package araujocampaamenesesquisnancela.transistores.modelo; public class PBase { public String[] calculos(Voltaje fuente, Resistencia[] resistencias, Transistor transistor1){ String[] resultados = new String[11]; Corriente iCMax = new Corriente(); Transistor transistor = new Transistor(); double temp = 0; transistor = transistor1; temp = (fuente.getValor() - 0.7)/resistencias[0].getValor(); transistor.setIB(temp); //IB

temp = fuente.getValor()/resistencias[1].getValor(); iCMax.setValor(temp); if(transistor.getIC().getValor()>=temp)

//ICmax

164

transistor.setIC(temp); temp = transistor.getIC().getValor(); resistencias[1].setCorriente(temp); temp = fuente.getValor()-resistencias[1].getVoltaje(); transistor.setVC(temp); transistor.setVE(0); System.out.println("\n\nResultados:"); if (transistor.getvB().getValor()<1) resultados[0] = "Voltaje base = " + transistor.getvB().getMV() + " mV"; else resultados[0] = "Voltaje base = " + transistor.getvB().getValor() + " V"; if (transistor.getvC().getValor()<1) resultados[1] = "Voltaje colector = " + transistor.getvC().getMV() + " mV"; else resultados[1] = "Voltaje colector = " + transistor.getvC().getValor() + " V"; if (transistor.getvE().getValor()<1) resultados[2] = "Voltaje emisor = " + transistor.getvE().getMV() + " mV"; else resultados[2] = "Voltaje emisor = " + transistor.getvE().getValor() + " V"; if (transistor.getvCE().getValor()<1) resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getMV() + " mV"; else resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getValor() + " V"; if (fuente.getValor()<1)
165

resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getMV() + " mV"; else resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getValor() + " V"; if (transistor.getIB().getValor()<1) resultados[5] = "Corriente base = " + transistor.getIB().getMA() + " mA"; else resultados[5] = "Corriente base = " + transistor.getIB().getValor() + " A"; if (transistor.getIC().getValor()<1) resultados[6] = "Corriente colector = " + transistor.getIC().getMA() + " mA"; else resultados[6] = "Corriente colector = " + transistor.getIC().getValor() + " A"; if (transistor.getIE().getValor()<1) resultados[7] = "Corriente emisor = " + transistor.getIE().getMA() + " mA"; else resultados[7] = "Corriente emisor = " + transistor.getIE().getValor() + " A"; if (iCMax.getValor()<1) resultados[8] = "Colector colector maxima = " + iCMax.getMA() + " mA"; else resultados[8] = "Colector colector maxima = " + iCMax.getValor() + " A"; resultados[9] = "Potencia disipada = " + transistor.getP(); if (transistor.getIC().getValor() == iCMax.getValor()) resultados[10] = "El transistor se encuentra en saturacion"; else if(transistor.getvCE().getValor()==fuente.getValor()) resultados[10] = "El transistor se encuentra en corte"; else
166

resultados[10] = "El transistor se encuentra en la zona activa"; return resultados; } } package araujocampaamenesesquisnancela.transistores.modelo; public class PColector { public String[] calculos(Voltaje fuente,Resistencia[] resistencias, Transistor transistor1){ String[] resultados = new String[11]; Corriente iCMax = new Corriente(); Transistor transistor = new Transistor(); double temp = 0; transistor = transistor1; temp = (fuente.getValor() 0.7)/((transistor.getBeta()+1)*resistencias[1].getValor()+resistencias[0].getValor()); transistor.setIB(temp); temp = fuente.getValor()/resistencias[1].getValor(); iCMax.setValor(temp); if(transistor.getIC().getValor()>=temp) transistor.setIC(temp); temp = (transistor.getIC().getValor()+transistor.getIB().getValor()); resistencias[1].setCorriente(temp); temp = fuente.getValor()-resistencias[1].getVoltaje(); transistor.setVC(temp); transistor.setVE(0); System.out.println("\n\nResultados:"); //ICmax

//IB

167

if (transistor.getvB().getValor()<1) resultados[0] = "Voltaje base = " + transistor.getvB().getMV() + " mV"; else resultados[0] = "Voltaje base = " + transistor.getvB().getValor() + " V"; if (transistor.getvC().getValor()<1) resultados[1] = "Voltaje colector = " + transistor.getvC().getMV() + " mV"; else resultados[1] = "Voltaje colector = " + transistor.getvC().getValor() + " V"; if (transistor.getvE().getValor()<1) resultados[2] = "Voltaje emisor = " + transistor.getvE().getMV() + " mV"; else resultados[2] = "Voltaje emisor = " + transistor.getvE().getValor() + " V"; if (transistor.getvCE().getValor()<1) resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getMV() + " mV"; else resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getValor() + " V"; if (fuente.getValor()<1) resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getMV() + " mV"; else resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getValor() + " V"; if (transistor.getIB().getValor()<1) resultados[5] = "Corriente base = " + transistor.getIB().getMA() + " mA"; else resultados[5] = "Corriente base = " + transistor.getIB().getValor() + " A";
168

if (transistor.getIC().getValor()<1) resultados[6] = "Corriente colector = " + transistor.getIC().getMA() + " mA"; else resultados[6] = "Corriente colector = " + transistor.getIC().getValor() + " A"; if (transistor.getIE().getValor()<1) resultados[7] = "Corriente emisor = " + transistor.getIE().getMA() + " mA"; else resultados[7] = "Corriente emisor = " + transistor.getIE().getValor() + " A"; if (iCMax.getValor()<1) resultados[8] = "Colector colector maxima = " + iCMax.getMA() + " mA"; else resultados[8] = "Colector colector maxima = " + iCMax.getValor() + " A"; resultados[9] = "Potencia disipada = " + transistor.getP(); if (transistor.getIC().getValor() == iCMax.getValor()) resultados[10] = "El transistor se encuentra en saturacion"; else if(transistor.getvCE().getValor()==fuente.getValor()) resultados[10] = "El transistor se encuentra en corte"; else resultados[10] = "El transistor se encuentra en la zona activa"; return resultados; } } package araujocampaamenesesquisnancela.transistores.modelo; public class PDivTension { public String[] calculos(Voltaje fuente,Resistencia[] resistencias, Transistor transistor1){
169

String[] resultados = new String[11]; Corriente iCMax = new Corriente(); Voltaje theveninV = new Voltaje(); Resistencia theveninR = new Resistencia(); Transistor transistor = new Transistor(); double temp = 0; transistor = transistor1; temp = (resistencias[0].getValor()*resistencias[1].getValor())/(resistencias[0].getValor()+resistenci as[1].getValor()); theveninR.setNombre("thevenin"); theveninR.setValor(temp); temp = resistencias[1].getValor()*fuente.getValor()/(resistencias[0].getValor()+resistencias[1].get Valor()); theveninV.setValor(temp); temp = (theveninV.getValor() 0.7)/(theveninR.getValor()+transistor.getBeta()*resistencias[3].getValor()); transistor.setIB(temp); temp = fuente.getValor()/(resistencias[2].getValor()+resistencias[3].getValor()); //ICmax iCMax.setValor(temp); if(transistor.getIC().getValor()>=temp) transistor.setIC(temp); temp = transistor.getIC().getValor(); resistencias[2].setCorriente(temp); temp = fuente.getValor()-resistencias[2].getVoltaje();

//IB

170

transistor.setVC(temp); temp = transistor.getIE().getValor(); resistencias[3].setCorriente(temp); temp = resistencias[3].getVoltaje(); transistor.setVE(temp); System.out.println("\n\nResultados:"); if (transistor.getvB().getValor()<1) resultados[0] = "Voltaje base = " + transistor.getvB().getMV() + " mV"; else resultados[0] = "Voltaje base = " + transistor.getvB().getValor() + " V"; if (transistor.getvC().getValor()<1) resultados[1] = "Voltaje colector = " + transistor.getvC().getMV() + " mV"; else resultados[1] = "Voltaje colector = " + transistor.getvC().getValor() + " V"; if (transistor.getvE().getValor()<1) resultados[2] = "Voltaje emisor = " + transistor.getvE().getMV() + " mV"; else resultados[2] = "Voltaje emisor = " + transistor.getvE().getValor() + " V"; if (transistor.getvCE().getValor()<1) resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getMV() + " mV"; else resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getValor() + " V"; if (fuente.getValor()<1) resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getMV() + " mV";
171

else resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getValor() + " V"; if (transistor.getIB().getValor()<1) resultados[5] = "Corriente base = " + transistor.getIB().getMA() + " mA"; else resultados[5] = "Corriente base = " + transistor.getIB().getValor() + " A"; if (transistor.getIC().getValor()<1) resultados[6] = "Corriente colector = " + transistor.getIC().getMA() + " mA"; else resultados[6] = "Corriente colector = " + transistor.getIC().getValor() + " A"; if (transistor.getIE().getValor()<1) resultados[7] = "Corriente emisor = " + transistor.getIE().getMA() + " mA"; else resultados[7] = "Corriente emisor = " + transistor.getIE().getValor() + " A"; if (iCMax.getValor()<1) resultados[8] = "Colector colector maxima = " + iCMax.getMA() + " mA"; else resultados[8] = "Colector colector maxima = " + iCMax.getValor() + " A"; resultados[9] = "Potencia disipada = " + transistor.getP(); if (transistor.getIC().getValor() == iCMax.getValor()) resultados[10] = "El transistor se encuentra en saturacion"; else if(transistor.getvCE().getValor()==fuente.getValor()) resultados[10] = "El transistor se encuentra en corte"; else resultados[10] = "El transistor se encuentra en la zona activa";
172

return resultados; } } package araujocampaamenesesquisnancela.transistores.modelo;

public class PEmisor { public String[] calculos(Voltaje fuente,Resistencia[] resistencias, Transistor transistor1){ String[] resultados = new String[11]; Corriente iCMax = new Corriente(); Transistor transistor = new Transistor(); double temp = 0; transistor = transistor1; temp = (fuente.getValor() 0.7)/(resistencias[0].getValor()+transistor.getBeta()*resistencias[2].getValor()); transistor.setIB(temp); temp = fuente.getValor()/(resistencias[1].getValor()+resistencias[2].getValor()); //ICmax iCMax.setValor(temp); if(transistor.getIC().getValor()>=temp) transistor.setIC(temp); temp = transistor.getIC().getValor(); resistencias[1].setCorriente(temp); temp = fuente.getValor()-resistencias[1].getVoltaje(); transistor.setVC(temp);

//IB

temp = transistor.getIE().getValor();
173

resistencias[2].setCorriente(temp); temp = resistencias[2].getVoltaje(); transistor.setVE(temp); System.out.println("\n\nResultados:"); if (transistor.getvB().getValor()<1) resultados[0] = "Voltaje base = " + transistor.getvB().getMV() + " mV"; else resultados[0] = "Voltaje base = " + transistor.getvB().getValor() + " V"; if (transistor.getvC().getValor()<1) resultados[1] = "Voltaje colector = " + transistor.getvC().getMV() + " mV"; else resultados[1] = "Voltaje colector = " + transistor.getvC().getValor() + " V"; if (transistor.getvE().getValor()<1) resultados[2] = "Voltaje emisor = " + transistor.getvE().getMV() + " mV"; else resultados[2] = "Voltaje emisor = " + transistor.getvE().getValor() + " V"; if (transistor.getvCE().getValor()<1) resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getMV() + " mV"; else resultados[3] = "Voltaje colector-emisor = " + transistor.getvCE().getValor() + " V"; if (fuente.getValor()<1) resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getMV() + " mV"; else resultados[4] = "Voltaje colector-emisor maximo = " + fuente.getValor() + " V";
174

if (transistor.getIB().getValor()<1) resultados[5] = "Corriente base = " + transistor.getIB().getMA() + " mA"; else resultados[5] = "Corriente base = " + transistor.getIB().getValor() + " A"; if (transistor.getIC().getValor()<1) resultados[6] = "Corriente colector = " + transistor.getIC().getMA() + " mA"; else resultados[6] = "Corriente colector = " + transistor.getIC().getValor() + " A"; if (transistor.getIE().getValor()<1) resultados[7] = "Corriente emisor = " + transistor.getIE().getMA() + " mA"; else resultados[7] = "Corriente emisor = " + transistor.getIE().getValor() + " A"; if (iCMax.getValor()<1) resultados[8] = "Colector colector maxima = " + iCMax.getMA() + " mA"; else resultados[8] = "Colector colector maxima = " + iCMax.getValor() + " A"; resultados[9] = "Potencia disipada = " + transistor.getP();

if (transistor.getIC().getValor() == iCMax.getValor()) resultados[10] = "El transistor se encuentra en saturacion"; else if(transistor.getvCE().getValor()==fuente.getValor()) resultados[10] = "El transistor se encuentra en corte"; else resultados[10] = "El transistor se encuentra en la zona activa"; return resultados;
175

} } package araujocampaamenesesquisnancela.transistores.modelo; import araujocampaamenesesquisnancela.transistores.controlador.IngresoDatos; import ingresodatos.*; public class Resistencia { private String nombre; private double valor; private double valorK; private double voltaje; private double corriente; private IngresoDatos ingreso = new IngresoDatos(); public void setNombre(String id){ nombre = "Resistencia " + id; } public String getNombre(){ return nombre; } public void setValor(double valor){ if (valor >= 0){ this.valor = valor; }else{ System.out.println("El valor de la resistencia no puede ser negativo"); } setMil();
176

if (valor < 1000) System.out.println(nombre + " = " + this.valor + " ohm"); else System.out.println(nombre + " = " + this.valorK + " kohm"); } public double getValor(){ return valor; } public boolean setValor(){ int primero = 11; int segundo = 11; int tercero = 11; String colores[] = {"Ne","Ca","Ro","An","Am","Ve","Az","Vi","Gr","Bl"}; do{ System.out.print("Primer color: {Ne,Ca,Ro,An,Am,Ve,Az,Vi,Gr,Bl}"); for (int i = 0; i < 10 ; i++){ if (ingreso.texto().equals(colores[i])) primero = i; } }while(primero>9); do{ System.out.print("Segundo color: {Ne,Ca,Ro,An,Am,Ve,Az,Vi,Gr,Bl}"); for (int i = 0; i < 10 ; i++){ if (ingreso.texto().equals(colores[i])) segundo = i;
177

} }while(segundo>9); do{ System.out.print("Tercer color: {Ne,Ca,Ro,An,Am,Ve,Az,Vi,Gr,Bl}"); for (int i = 0; i < 10 ; i++){ if (ingreso.texto().equals(colores[i])) tercero = i; } }while(tercero>9);

valor = primero*10; valor += segundo; valor *= Math.pow(10,tercero); setMil(); if (valor < 1000) System.out.println(nombre + " = " + this.valor + " ohm"); else System.out.println(nombre + " = " + this.valorK + " kohm"); return true; } public void setMil(){ valorK = valor/1000; } public double getKilo(){ return valorK;
178

} public void setVoltaje(double voltaje){ this.voltaje = voltaje; } public double getVoltaje(){ return voltaje; }

public void setCorriente(double corriente){ this.corriente = corriente; setVoltaje(corriente*valor); } public double getCorriente(){ return corriente; } } package araujocampaamenesesquisnancela.transistores.modelo; import araujocampaamenesesquisnancela.transistores.controlador.IngresoDatos; public class Transistor { private String tipo = "NPN"; private Corriente iB = new Corriente(); private Corriente iC = new Corriente(); private Corriente iE = new Corriente(); private Voltaje vB = new Voltaje(); private Voltaje vC = new Voltaje();
179

private Voltaje vE = new Voltaje(); private Voltaje vCE = new Voltaje(); private int beta = 100; public void setTipo(){ IngresoDatos ingreso = new IngresoDatos(); String type = ""; do{ System.out.print("\nDesea un transistor NPN o PNP: "); type = ingreso.texto(); }while(!type.equals("NPN")&!type.equals("PNP")); } public String getTipo(){ return tipo; } public void setBeta(){ IngresoDatos ingreso = new IngresoDatos(); do{ System.out.print("\nBeta = "); beta = ingreso.entero(); }while(beta<1); } public int getBeta(){ return beta; } public void setIB(double valor){
180

iB.setValor(valor); findICIB(); findIEIB(); } public Corriente getIB(){ return iB; } private void findICIB(){ iC.setValor(beta*iB.getValor()); } private void findIEIB(){ iE.setValor((beta+1)*iB.getValor()); } public void setIC(double valor){ iC.setValor(valor); findIEIC(); } public Corriente getIC(){ return iC; } private void findIEIC(){ iE.setValor(iC.getValor()+iB.getValor()); } public void setIE(double valor){ iE.setValor(valor);
181

} public Corriente getIE(){ return iE; } public void setVB(double valor){ vB.setValor(valor); vE.setValor(valor-0.7); } public Voltaje getvB(){ return vB; } public void setVC(double valor){ vC.setValor(valor); } public Voltaje getvC(){ return vC; } public void setVE(double valor){ vE.setValor(valor); vB.setValor(valor+0.7); } public Voltaje getvE(){ return vE; } public Voltaje getvCE(){
182

vCE.setValor(vC.getValor()-vE.getValor()); return vCE; } public double getP(){ return vCE.getValor()*iC.getValor(); } } package araujocampaamenesesquisnancela.transistores.modelo; public class Voltaje { private double v = 0 ; private double vMV = 0; public void setValor(double valor){ v = valor; vMV = xMil(valor); } public double getValor(){ return v; } public double xMil(double valor){ return valor*1000; } public double getMV(){ return vMV; } }
183

package araujocampaamenesesquisnancela.transistores.vista; import araujocampaamenesesquisnancela.transistores.controlador.*; public class Main { public static void main(String[] args) { String[] resultados = new String[12]; Sesion sesion = new Sesion(); Resultados ventana = new Resultados(); System.out.println("\n\t\t ESCUELA POLITCNICA DEL EJERCITO");

System.out.println("\t\tDEPARTAMENTO DE ELCTRICA Y ELECTRNICA\n");

do{ System.out.println("\t\tRESOLUCIN DE CIRCUITOS CON TRANSISTORES\n"); resultados = sesion.ingresoDatos(); if (resultados[11] != null) System.exit(0); for (int i = 0; i < resultados.length; i++){ System.out.println(resultados[i]); } ventana.ingreso(resultados); ventana.setVisible(true); }while(true); } }

184

Proyecto
Disear un osciloscopio mediante interfaces GUI que nos permita modelar seales senoidales, cuadrticas, triangulares, de ruido blanco y un termmetro. package andinoaraujoenriquezmeneses.osc.controlador; import andinoaraujoenriquezmeneses.osc.vista.EjemploFrame; public class Acciones extends EjemploFrame { public double frecuencia; public double amplitud; public double fase; public String conversion(String frecuencia){ String periodo; double respuesta; respuesta = (1/Double.parseDouble(frecuencia)); periodo= String.valueOf(respuesta); return periodo; } } package andinoaraujoenriquezmeneses.osc.controlador; import andinoaraujoenriquezmeneses.osc.controlador.Acciones; import java.awt.Dimension; import java.awt.Rectangle; import java.awt.Robot; import java.awt.image.BufferedImage; import java.io.File; import javax.imageio.ImageIO;

185

import javax.swing.JOptionPane; public class Captura { int a; public Captura(int a) { this.a = a; } public void pantalla() { try { Acciones acciones = new Acciones(); // // System.out.println("[ Captura iniciada ]"); JOptionPane.showMessageDialog(acciones,"[ Captura iniciada ]" ); String FILENAME = "D:/captura"+a+".png"; Captura.captureScreen(FILENAME); Thread.sleep(10); // System.out.println("[ Captura finalizada ]"); JOptionPane.showMessageDialog(acciones,"Captura de pantalla\n" +" finalizada\n\nrevise en su dico D:" );

} catch (Exception e) { e.printStackTrace(); } } static public void captureScreen(String fileName) throws Exception { Dimension screenSize = java.awt.Toolkit.getDefaultToolkit().getScreenSize(); Rectangle screenRectangle = new Rectangle(screenSize); Robot robot = new Robot();
186

BufferedImage image = robot.createScreenCapture(screenRectangle); ImageIO.write(image, "png", new File(fileName)); } package andinoaraujoenriquezmeneses.osc.modelo; import andinoaraujoenriquezmeneses.osc.controlador.Acciones; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Line2D; import javax.swing.JPanel; import javax.swing.JTextField; public class Cuadrada extends JPanel { public double a; public double w; public double periodo; public double t; public double x0; public double y0; public double x1; public double y1; public double fase; public Cuadrada(double a, double w,double fase) { this.a = a; this.w = w;
187

this.t = 0; this.x0 = 0; this.y0 = 0; this.x1 = 1; this.y1 = 0; this.fase=fase; setSize(700, 500); setVisible(true); setLocation(12, 19); } public void setDatos(JTextField txtAmplitud, JTextField txtPeriodo,JTextField txtFase){ Acciones acciones=new Acciones();

w=Double.parseDouble(acciones.conversion(txtPeriodo.getText())); //Fase=Integer.parseInt(JOptionPane.showInputDialog("Ingrese fase")); //System.out.print(Valor+""+Frec); }

public void grafica() {

Graphics g=getGraphics(); int b; do{ y0 =a*Math.sin((x0*w)*Math.PI/180);

188

y1 =a*Math.sin((x1*w)*Math.PI/180); x0++; x1++;

Graphics2D g2=(Graphics2D)g; g2.setColor(Color.BLUE); g2.setStroke(new BasicStroke(1.0f));

if (y0>0){ Line2D linea=new Line2D.Double((x0+fase), a+255, (x1+fase), a+255); // // System.out.println("x0: "+x0+" y: "+(y0)); System.out.println("x1: "+x1+" y: "+(y1)); g2.draw(linea); } if (y0<0){ Line2D linea=new Line2D.Double((x0+fase), ((-1)*a)+255, (x1+fase),((-1)*a)+255); // // System.out.println("x0: "+x0+" y: "+(y0)); System.out.println("x1: "+x1+" y: "+(y1)); g2.draw(linea); } try{ Thread.sleep(2); }catch(InterruptedException e){}

189

}while(x0<800); }

} package andinoaraujoenriquezmeneses.osc.modelo;

import andinoaraujoenriquezmeneses.osc.controlador.Acciones; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Line2D; import javax.swing.JPanel; import javax.swing.JTextField;

/** * * @author Carlos */ public class DienteSierra extends JPanel { public double a; public double w; public double periodo; public double t; public double x0;
190

public double y0; public double x1; public double y1; public double fase;

public DienteSierra(double a, double w, double fase) { this.a = a; this.w = w; this.t = 0; this.x0 = 0; this.y0 = 0; this.x1 = (90/w); this.y1 = 0; this.fase=fase; setSize(700, 500); setVisible(true); setLocation(12, 19); } public void setDatos(JTextField txtAmplitud, JTextField txtPeriodo,JTextField txtFase){ Acciones acciones=new Acciones();

w=Double.parseDouble(acciones.conversion(txtPeriodo.getText())); //Fase=Integer.parseInt(JOptionPane.showInputDialog("Ingrese fase")); //System.out.print(Valor+""+Frec); }

191

public void grafica() { Graphics g=getGraphics(); double x3,x4; do{ y0 =a*Math.sin((x0*w)*3.1416/180); y1 =a*Math.sin((x1*w)*3.1416/180);

Graphics2D g2=(Graphics2D)g; g2.setColor(Color.GREEN); g2.setStroke(new BasicStroke(1.0f));

Line2D linea=new Line2D.Double((x0+fase), y0+255, (x1+fase), y1+255); System.out.println("imprime linea"); // // System.out.println("x0: "+x0+" y0: "+(y0)); System.out.println("x1: "+x1+" y1: "+(y1)); g2.draw(linea); x0=x0+(90/w); x1=x0+(90/w); try{ Thread.sleep(2); }catch(InterruptedException e){} }while(x0<800);

}
192

package andinoaraujoenriquezmeneses.osc.modelo;

import andinoaraujoenriquezmeneses.osc.controlador.Acciones; import java.awt.*; import java.awt.geom.Line2D;

import javax.swing.JPanel; import javax.swing.JTextField;

public class RuidoBlanco extends JPanel { public double a; public double w; public double periodo; public double t; public double x0; public double y0; public double x1; public double y1; public double fase;

public RuidoBlanco(double a, double w,double fase) { this.a = a; this.w = w; this.t = 0;

193

this.x0 = 0; this.y0 = 0; this.x1 = 1; this.y1 = 0; this.fase=fase; setSize(700, 500); setVisible(true); setLocation(12, 19); } public void setDatos(JTextField txtAmplitud, JTextField txtPeriodo,JTextField txtFase){ Acciones acciones=new Acciones();

w=Double.parseDouble(acciones.conversion(txtPeriodo.getText())); //Fase=Integer.parseInt(JOptionPane.showInputDialog("Ingrese fase")); //System.out.print(Valor+""+Frec); }

public void grafica() { Graphics g=getGraphics();

do{ y0 =a*Math.random(); y1 =a*Math.random(); x0++; x1++;

194

Graphics2D g2=(Graphics2D)g; g2.setColor(Color.CYAN); g2.setStroke(new BasicStroke(1.0f)); Line2D linea=new Line2D.Double(x0+w+fase, y0+200, x1+w+fase, y1+200); g2.draw(linea); try{ Thread.sleep(2); }catch(InterruptedException e){} }while(x0<800); } } package andinoaraujoenriquezmeneses.osc.modelo;

import andinoaraujoenriquezmeneses.osc.controlador.Acciones; import java.awt.BasicStroke; import java.awt.Color; import java.awt.Graphics; import java.awt.Graphics2D; import java.awt.geom.Line2D; import javax.swing.JPanel; import javax.swing.JTextField;

/** *
195

* @author Andino Araujo Enriquez Meneses */ public class Seno2 extends JPanel {

public double a; public double w; public double periodo; public double t; public double x0; public double y0; public double x1; public double y1; public double fase;

public Seno2(double a, double w, double fase) { this.a = a; this.w = w; this.t = 0; this.x0 = 0; this.y0 = 0; this.x1 = 1; this.y1 = 0; this.fase=fase; setSize(700, 500); setVisible(true);
196

setLocation(12, 19); } public void setDatos(JTextField txtAmplitud, JTextField txtPeriodo,JTextField txtFase){ Acciones acciones=new Acciones();

w=Double.parseDouble(acciones.conversion(txtPeriodo.getText())); //Fase=Integer.parseInt(JOptionPane.showInputDialog("Ingrese fase")); //System.out.print(Valor+""+Frec); }

public void grafica() { Graphics g=getGraphics();

do{ y0 =a*Math.sin((x0*w)*3.1416/180); y1 =a*Math.sin((x1*w)*3.1416/180); x0++; x1++;

Graphics2D g2=(Graphics2D)g; g2.setColor(Color.red); g2.setStroke(new BasicStroke(1.0f));

Line2D linea=new Line2D.Double((x0+fase), y0+255, (x1+fase), y1+255); // System.out.println("x0: "+x0+" y: "+(y0));

197

//

System.out.println("x1: "+x1+" y: "+(y1)); g2.draw(linea); try{ Thread.sleep(2); }catch(InterruptedException e){} }while(x0<800); } }

198

Referencias Bibliogrficas
Castilla. Len. Java. http://zarza.usal.es/~fgarcia/doc/tuto2/I_2.htm. Extrahido el dia 10 de Julio del 2011 desde PC personal.

lvarez Gonzalo. 1997-1999. Qu es Java?. http://www.iec.csic.es/criptonomicon/java/quesjava.html. Extrahido el dia 10 de Julio del 2011 desde PC personal. Hostalia. 1999. Articulos Java. http://www.desarrolloweb.com/articulos/1841.php. Extrahido el dia 10 de Julio del 2011 desde PC personal. Manosalvas Juan. 2002. Referncias bibliogrficas. http://sunsite.dcc.uchile.cl/java/docs/JavaTut/Cap1/ref_java.html. Extrahido el dia 10 de Julio del 2011 desde PC personal.

Martl James. 2005. Turorial Java. http://dis.um.es/~bmoros/Tutorial/parte5/cap5-7.html. Extrahido el dia 10 de Julio del 2011 desde PC personal.

199