Libro de Lenguaje Java
Libro de Lenguaje Java
APRENDIENDO JAVA
Java y sus aplicaciones
Descubra de una forma cmoda y clara el lenguaje del nuevo siglo.
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.
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:
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.
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.
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).
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.
Luego de seleccionar correctamente debe dirigirse a la carpeta de destino donde instalo Java y copiar la direccin solo hasta Bin.
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 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).
En la ventana que se abrir debemos escribir las siguientes lneas. Hasta empezar en el disco donde est guardado el proyecto.
Ahora buscaremos el origen el nombre del programa con que guardamos y lo compilamos.
14
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.
16
Paquetes
Clases
Ejem: araujomeneses.ejemplo
Ejem: NombreClase
Mtodos y Variables
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
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
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
char
byte
Tipos de datos primitivo
int
Enteros con signo, ocupan 16 bits Enteros, ocupan 16bits y 64 bits respectivamente Reales, ocupan 32 bits
short, long
float, double
Arreglos
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
tipo identificador []; Unidimensional tipo [] identificador tipo identificador [][]; Bidimensional tipo [][] identificador; tipo, es el tipo de dato identificador, nombre de la variable
Donde
20
Cadenas
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
Residuo de dividir p por q Incrementa p en 1 Decrementa p en 1 Evalua antes/despus de incrementar Evalua antes/despus de decrementar
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).
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
4.2. Peticiones de valores al usuario Se utiliza para obtener datos del exterior por ejemplo del 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();
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.
while
continue
if - else
for
return
do - while
label:
break
Switch - Case
24
If - Else
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
Java cuenta con toda una clase que contiene operaciones matemticas, esta clase se conoce como Math
26
Clase Math
Clase String
Creacin implcita:
Substring
Debemos determinar el espacio donde queremos cortar
Declaracin: String subStr=str.substring(14);
27
Ejemplo: int valor=10; String str=String.valueOf(valor); La clase String proporciona versiones de valueOf para convertir: int, long, float, double
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
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:
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:
Es una base modular y extensible usada como una estructura de integracin para crear aplicaciones de escritorio grandes
Administracin del almacenamiento (guardando y cargando cualquier tipo de dato) Administracin de ventanas
35
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
Le asignamos un nombre en este caso es Ejemplo y dejamos seleccionada la Opcin de Main class.
Ilustracin 20. Paso 2. De esta forma cuando creemos los 3 paquetes podremos observarlo en el esquema del proyecto.
38
As hemos logrado seguir el patrn de diseo MVC, ahora podremos crear nuestras clases en las cuales realizaremos nuestras aplicaciones.
Para poder ejecutar el programa haremos una breve salida de informacin de la siguiente forma: a. Escribimos el 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
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
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:
clase X X X X
subclase X* X
paquete X X X
todos
41
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.
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.
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
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.
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.
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
NegativeArraySizeExcep tion
No debera producirse nunca! El intento de crear un objeto con el operador new ha fallado por falta de memoria.
OutOfMemoryException
53
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.
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
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
59
60
Ilustracin 35. Clase Acciones. El programa en funcionamiento nos presentara las siguientes pantallas de ingreso para todas las variables
61
Y finalmente nos mostrara como resultado una pantalla donde veremos nuestros datos ingresados y despus veremos otra pantalla con los datos incrementados
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.
63
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
JFC
Swing
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.
Compone nt
Container
Jcompone nt
AbstractB utton
JComboB ox
Jlabel
JList
JMenuBar
JPanel
JPopupM enu
JButton
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
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.
73
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
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
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,
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
81
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
Teclado
Entrada Datos
Flujo Entrada
Salida Datos
Flujo Salida
Creacin Objeto Flujo datos lectura Escritura datos con mtodo apropiados Cierre Flujo
Carcateres
88
Entrada de Datos
OutputStream Salida de Datos ByteArrayOutputStream FileOutputStream FilterOutputStream BufferedOutputStream DataOutputStream PrintStream ObjectOutputStream PipedOutputStream
20. Serializacin
89
Ejemplo
Crear un programa que permita buscar y encontrar una persona. Primero creamos un nuevo proyecto.
90
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 64. Constructor vaco. Getter y Setter de las variable nombre, apellido, telfono.
94
Ilustracin 67. Getter y Setter telfono. En esta interface tenemos los ingresos para el nombre, apellido y telfono.
95
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 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.
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
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
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
Sistema multithread
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
107
23. Formas de definir una clase para ejecutarse con otras clases
108
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(); }
sleep
suspend
110
Mtodo suspend
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.
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.
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
Recepcin
Mediante PC, controla acciones a realizar en funcin de las seales externas adquiridas. manipulacin
Filtrado
Manipulacin y tratamiento en
Aislamiento Trmico
Multiplexado
Seales Digitales
Ondas Cuadradas
115
Solucin
Mediante
histresis
Entrega a su salida siempre una seal cuadrada, basado en rangos de niveles de voltaje para sus dos estados, ALTO y BAJO
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
116 Mediante un circuito digital, compuesto por un diodo y un transistor de potencia, opera igual
Comunicacin Serial
Comunicacin a distancias cortas < 15 metros velocidad Bits por segundo baudios
Conector DB-9
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.
Asncronas
Sncronas
118
Manejo del Puerto Serie JAVA mediante API Java Communications (COMM)
Controla perifricos
Win32com.dll
/jdk1.6/bin
Javax.comm.prope rties
/jdk1.6/jre/lib
Nivel Alto
Niveles de Comunicacin
Nivel Medio
Nivel Bajo
119
Ejemplos Conectarse mediante el Hyper Terminal del computador y ver la transmisin de los datos
Ilustracin 82. Acceder al Hyper Terminal. Establecemos los parmetros de configuracin regional
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.
Para finalizar creamos nuestra ventana de comandos con la habilitacin del botn que enviar la informacin.
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
6 mA 20mA
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
126
127
APNDICES
Apndice 1 Entornos de desarrollo integrado (IDE)
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
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.
Un TreeSet mantiene los objetos ordenados en lo que se conoce como red-black tree
129
JUnit
130
Comandos de JUnit
Logger Log4J
131
El Proceso de AOO
Definicin de subsistemas
Casos de uso
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 Subsistemas
133
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
Requiere de un complemento para Netbeans pero es muy util para entender mejor el programa
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
JAVA
MATLAB
Software matematico que ofrece un entorno de desarrollo integrado (IDE) con un lenguaje de programacin propio (lenguaje M).
Utiliza mtodos nativos permiten utilizar diferentes funciones de Matlab desde una Java. Necesita de tres clases: - CoreJMatLink - JMatLink - JMatLinkException
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.
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.
140
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
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 origen de las coordenadas de usuario est situado en la esquina superior izquierda del objeto Graphics2D (0,0)
Java2D define tres bloques de informacin para soportar la conversin entre las coordenadas de usuario y de dispositivo
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
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.
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
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
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 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
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
CARACTERSTICAS
CABLE PARALELO
Registro de Control
ESTRUCTURA
Registro de Estado
Registro de Datos
Se implementa un cable o una va fsica para cada bit de datos formando un bus
Se compone de 8 bits
146
Dispositivo micro controlado de visualizacin grfica para la presentacin de caracteres, smbolos o incluso dibujos
CARACTERSTICAS
FUNCIONAMIENTO
Podemos hacerlo por medio de sus pines de entrada de dos maneras posibles
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
Cuando el LCD no esta habilitado sus entradas y salidas pasan a alta impedancia.
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
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
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
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
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
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
//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
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");
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();
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();
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);
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;
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;
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();
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();
//
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