Libro de lenguaje Java

5/10/2018

Libro delenguajeJava-slidepdf.com

2011

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

http://slidepdf.com/reader/full/libro-de-lenguaje-java

1/199

ANDINO ARAUJO ENRÍQUEZ MENESES 5/10/2018


Gerente de marca: Ing. Darwin Alulema

LENGUAJE JAVA Prohibida la reproducción parcial o total de esta obra, por cualquier medio, sin autorización escrita de los autores y editor.

DERECHOS RESERVADOS © 2011, respecto a la primera edición. ISBN 970-10-2546-6 – http://slidepdf.com/reader/full/libro-de-lenguaje-java

Realizado en Quito Ecuador.

2/199

5/10/2018


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 prácticas para nuestra carrera.

Carlos, Roberto, Luis, Patty.


3/199

5/10/2018


PROLOGO Este libro está escrito con el fin de que sea útil como texto para los estudiantes de Ingeniería en Electrónica. 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 según la institución 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 fácil, ya que la investigación con seriedad y la redacción e ilustración con originalidad exigieron inversión de mucho tiempo. Sin embargo, además de la propia motivación que constantemente nos dieron nuestros padres, la razón 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 enseñanza que obtuvimos en el camino. La obra que ponemos a consideración está realizado por jóvenes 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 público 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 lógico 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.


4/199

5/10/2018


ÍNDICE Capítulo 1 ...................................................................................................................................... 8 1. Historia de Java ......................................................................................................................... 9 2. Características ........................................................................................................................... 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 repetición .............................................................. 23 CAPÍTULO 2 ................................................................................................................................. 32 5 Objetos ..................................................................................................................................... 33

5.1. Instanciación 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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

5/199

17.1.1. Acciones sobre los componentes ............................................................................. 72

5/10/2018


Ejemplo........................................................................................................................................ 79 18. Interfaces GUI........................................................................................................................ 82 Ejercicio ....................................................................................................................................... 82 CAPITULO 5 ................................................................................................................................. 87 19. Información 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. Serialización........................................................................................................................... 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. Suspensión de un Hilo ......................................................................................................... 110

26.1. Método Suspend ........................................................................................................... 111 26.2. Parada de un Hilo ......................................................................................................... 111 Ejemplo...................................................................................................................................... 112 Capitulo 7 .................................................................................................................................. 114 27. Adquisición de Datos .......................................................................................................... 115 28. Acondicionamiento de señales ........................................................................................... 115 29. Señales Digitales.................................................................................................................. 115

29.1. Regeneración de una señal digital maltratada .............................................................. 116 30. Puerto Serie ......................................................................................................................... 117

30.1. Descripción del puerto Serie ........................................................................................ 117 http://slidepdf.com/reader/full/libro-de-lenguaje-java 6/199 31. Puerto Paralelo .................................................................................................................... 117

5/10/2018


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


7/199

5/10/2018


Capítulo 1

Introducción al capítulo

En este capítulo veremos una breve historia del desarrollo de Java así como sus características. De igual manera desarrollaremos ejemplos que serán ejecutados solo en el DOS, en esta parte no se realizarán programas en el IDE Netbeans, sin embargo se desarrollará la explicación de ciertos métodos y convenciones a usar en Java.


8/199

5/10/2018


1. Historia de Java Java fue desarrollado por la compañía Sun Microsystems en los años 90´s y es de código abierto hasta la actualidad, sin embargo en la actualidad tiene que solventar muchos problemas como la velocidad de ejecución ya que si hacemos una comparación tarda 20 veces mas que un programa en C, además se prevee que dejará de ser de código abierto ya que la empresa originaria lo vendió a Oracle. Java utiliza muchas características de C++ que no estaban incluidas en C, sin embargo entre las características que podemos destacar que Java no usa de C++ tenemos las siguientes:

Punteros Variables globales Goto

• No existen punteros evitando el acceso a

volátil (RAM).

• Lo único global son los nombres de las

la memoria

clases.

• En reemplazo a esta sentencia tenemos break

continue que cumple los casos importantes deygoto.

Asignación de memoria

• El operador new asigna un espacio de memoria a un

Conversión de tipos insegura

• Se realiza una comprobación en tiempo de ejecución

objeto.

y emite excepciones si algo llega a fallar.

2. Características Java es un lenguaje que gracias a sus características permite que se desarrolle de una manera más amigable con el usuario por ello es:


9/199

5/10/2018


Simple Diseño similar a C o C++. Seguro Implementa barreras de seguridad en el lenguaje y en el sistema de ejecución en tiempo real.

Robusto Proporciona comprobaciones en compilación y tiempo de ejecución.

Orientado a objetos Con caracteristicas de encapsulamiento, herencia y polimorfismo.

Interpretado y compilado a la vez Compilado en la medida de que su código fuente se transforma en código de máquina e interpretado os bytecodes se ejecutan directamente sobre la máquina.

Distribuido Proporciona una colección de clases para uso en aplicaciones de red.

Indiferente a la arquitectura y portable Cualquier computador que contenga un sistema de ejecución (jre) puede ejecutar el código. Produce applets

Multihilo

Son pequeños programas que aparecen en las páginas web con la capacidad de ejecutar acciones muy complejas.

Mientras un hilo encarga de se comunicación, el otro se encargue de interactuar con el usuario y otro de realizar cálculos.

Dinámico No conecta los módulos hasta la ejecución, cada “pieza” es

responsable de una función que se pueden añadir mediante una red. http://slidepdf.com/reader/full/libro-de-lenguaje-java

10/199

5/10/2018


En resumen, Java necesita de una máquina virtual (jre)donde el 80% no depende de la misma y el 20% depende, es decir que dependiendo de la máquina virtual se puede ejecutar el código (jdk compilador).

3. Programando en Bloc de notas Antes de proceder a programar en Netbeasn IDE, debemos familiarizarnos con el lenguaje es por ello que vamos aprender hacerlo en Bloc de notas. Este es el primer paso, luego de desarrollar varias aplicaciones estaremos listos para hacerlo en el IDE estipulado. Vamos a ver paso a paso como hacerlo así que tenga en cuenta lo siguiente: 

1ro: Configurar el Path. Para ello usted puede observarlo como hacerlo en las siguientes gráficas:

Dirigirse a Panel de control y seleccionar Sistema.

Ilustración 1. Panel de Control - Sistema.

En Sistema seleccionar Opciones Avanzadas y allí Variables de entorno.


11/199

5/10/2018


Ilustración 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.

Ilustración 3. Modificando Variables del sistema. Luego de seleccionar correctamente debe dirigirse a la carpeta de destino donde instalo Java y copiar la dirección solo hasta Bin.

Ilustración 4. Dirección de origen Java.

De esta forma quedará configurado y podremos ejecutar los programas desde el Command. 

2do: Escribir el programa. En este punto con sus conocimientos básicos de C++ usted puede escribir un programa. Veremos el siguiente ejemplo para demostrar cómo proceder y familiarizarnos con ciertos elementos: a. Nombre de la clase.

El nombre de la clase debe ser igual al nombre del archivo, sin embargo12/199 el mismo debe ser guardado en un tipo .java.


5/10/2018


Ilustración 5. Nombre de la clase.

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

Ilustración 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 línea de código correspondiente. Que es la que nos indica el método principal en donde la máquina virtual comienza a leer y ejecutar.

Ilustración 8. Método Principal. d. Bloque de código. En esta parte escribiremos los métodos y objetos que nuestro programa. Se debe tener especial cuidado entre mayúsculas y minúsculas ya que java si reconoce los mismos. http://slidepdf.com/reader/full/libro-de-lenguaje-java

13/199

5/10/2018


Ilustración 9. Bloque de código. 

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 opción Ejecutar del DOS).

Ilustración 10. cmd.

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

Ilustración 11. Escribiendo en el DOS.

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


14/199

5/10/2018


Ilustración 12. Compilando el programa.

Sabremos que el programa se compilo correctamente si no salta ninguna línea de mensaje de error. Enseguida corremos el programa con la siguiente línea de código.

Ilustración 13. Ejecutando el programa. De esta forma observamos el programa y sus resultados. Después 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 programación en la sección de Ayudas al usuario, al final de este capítulo.

Ejercicios 1. Escriba un programa que presente en pantalla su nombre completo en una línea de código y en la siguiente línea su fecha de nacimiento. http://slidepdf.com/reader/full/libro-de-lenguaje-java

Tips: Debe hacer manejo de saltos de línea con \n.

15/199

5/10/2018


2. Escriba un programa que presente en pantalla las notas de la asignatura de Tecnologías de Software. En la primera línea se escribirá el nombre de la asignatura. En las siguientes líneas se escribirán las notas de los tres parciales poniendo la nota de cada uno en líneas 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 número como número. Tips: El enunciado no da restricción alguna, preferiblemente guarde en una variable las notas y luego imprima.

3. Basándose en la clase Hola modifique su código de tal manera que se imprima en pantalla su nombre y apellido en una línea y en la segunda línea su número de cédula. Considerando que tanto su nombre, apellido y número de cédula deben guardarse en una variable cada una. Tips: Como lo pide el ejercicio guarde en una variable los datos y luego imprima.

4. Fundamentos para escribir en Java Para programa en Java se necesita de ciertas consideraciones acotando que en un futuro usaremos el patrón de diseño MVC (modelo, vista, controlador) el mismo que será explicado en el siguiente capítulo, ahora veremos cómo se desarrollará en Java los :


16/199

5/10/2018


Paquetes

Clases

Todas las letras deben ser escritas en minúsculas.

La primera letra en mayúscula.

Ejem:

Ejem: NombreClase

araujomeneses.ejemplo

Métodos y Variables

La primera en minúscula la letra siguiente palabra en mayúscula.

Ejem: nombreMetodo() nombreVariable

4.1. Tipos de variables Las variables pueden clasificarse según su función y según su naturaleza:


17/199

5/10/2018


Tipos de variables Según su función De Intancia





De Clase

Según su naturaleza

Locales

Tipo Primitivo

De una Clase

Un array

Según la función que cumplen las variables se pueden clasificar en:

De instancia Usadas para almacenar atributos del objeto, están disponibles para

De clase Usadas para almacenar atributos del objeto, están disponibles para

todas las clases

una clase determinada

Locales Son variables usadas dentro de los métodos del programa

Ahora vamos a ver la definición 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 más 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/199

5/10/2018


boolean

Valores verdaderos o falsos, ocupan un bit

char

Caracteres, ocupan 16 bits

byte

Enteros con signo, ocupan 8 bits

int

Enteros con signo, ocupan 16 bits

Tipos de datos primitivo

Enteros, ocupan

short, long

16bits y 64 bits respectivamente

float, double

Reales, ocupan 32 bits

Otro tipo de datos primitivo son los vectores y matrices:

Arreglos Estructura de datos que contienen el mismo tipo de datos

Propiedades

Se utilizan como contenedores Todos los datos son del mismo tipo


El tamaño del mismo se establece al crear el array (operador new)

19/199

5/10/2018


Terminología

Declaración

•

Vectores

Matrices

Arrays unidimensionales

Arrays bidimensionales

Se usa corchetes [] para diferenciar de una variable normal

tipo identificador []; Unidimensional• tipo [] identificador •

• Bidimensional•

Donde

• •

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


20/199

5/10/2018


Son llamados del tipo String

Declara explicitamente un array llamado args

Cadenas

Implementada por la clase String

Declaracion: String [] args Existen operadores en Java que nos permiten relacionar las variables para obtener datos como sumas, restas, etc: 

Operadores aritméticos:

Operadores aritméticos

+, p+q

Suma p y q

-, p-q

Resta q de p

*, p*q

Multiplica p y q

/, p/q

Divide p por q

%, p%q

Residuo de dividir p por q

p++ ++p

Incrementa p en 1

Evalua antes/después de incrementar

p---p

Decrementa p en 1

Evalua antes/después de decrementar

Existe una precedencia con la que Java maneja los operadores:


21/199

5/10/2018


Operadores sufijo Operadores unarios Creación o tipo Multiplicadores Suma, resta Desplazamiento Relaciones Igualdad Bitwise AND Bitwise exclusive OR Bitwise inclusive OR AND lógico OR lógico Condicional Asignación

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

Ejercicios Ojo. Si tiene problemas en realizar estos ejercicios puede revisar la programación en la sección de Ayudas al usuario, al final de este capítulo.

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

Tips. Revisar la fórmula para calcular el área y perímetro del rectángulo.

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, también, variables para el diámetro y la altura del cilindro. Suponga para el ejemplo que el cilindro tiene un diámetro de 15.5 cm y una altura de 42.4


22/199

5/10/2018


Ilustración 14. Cilindro.

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

Peticiones de valores al usuario Declaración:

Llamar objeto:

Scanner nombre = new Scanner (System.in)

variable = nombre.nextTipoVariable();

Tipos y método para leer teclado

byte

short

teclado.next Byte();

teclado.nex tShort();

int teclado.nex tInt();

long

float

double

teclado.nex tLong();

teclado.nex tFloat();

teclado.nex tDouble();

boolean teclado.nex tBoolean();

4.2.1. Instrucciones condicionales y de repetición Las instrucciones condicionales y las de repetición nos permiten realizar 23/199 operaciones que nos tomarían muchas líneas de código y mucho tiempo programando


5/10/2018


Este tipo de instrucciones se usa cuando debemos repetir una operación varias veces.

Condiciones y repetición Toma de decisión switch case if - else

Bucle

Misceláneo

while

continue

for

return

do - while

label:

break

Switch - Case

Para realizar sentencias condicionalmente basadas en alguna expresión

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


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

24/199

5/10/2018


If - Else

Da la posibilidad de ejecutar selectivamente otras sentencias basándose en algún criterio

if (expresión) sentencia1 else sentencia2

Después del primer if podemos poner los else q queramos

Realiza una acción mientras se cumpla una cierta condición

while(expresión) sentencia

While

Se ejecuta sentencia mientras la expresión sea verdadera, sentencia puede ser todo un bloque de código


25/199

5/10/2018


Se usa cuando se conoce los límites del bucle y su variación

For

for(inicialización; terminación; incremento) sentencia Generalmente se lo usa para recorrer por los espacios de un arreglo

Do - While

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

do{ sentencias} while(expresión boleana);

Sentencia de repetición muy poco usada

Java cuenta con toda una clase que contiene operaciones matemáticas, esta clase se conoce como Math


26/199

5/10/2018


Librería matemática de Java

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

El constructor de la clase es privado

Clase Math

Math es public para que pueda llamarse desde cualquier sitio

Clase String

Creación implícita: Dentro del objeto, Java crea un array de caracteres

System.out.println("Patty") Creación explicita: String str=new Sring("Patty")

Extrae una porción del String

Substring Debemos determinar el espacio donde queremos cortar http://slidepdf.com/reader/full/libro-de-lenguaje-java

Declaración: String subStr=str.substring(14);

27/199

5/10/2018


Usamos la función miembro estática valueOf

Convertir numero a string

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

Convertir un string en número

Debemos usar la función miembro estática parseInt de la clase Integer

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

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

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 línea del archivo se usa aux=in.readLine();

28/199

5/10/2018


Ayudas al usuario Ejercicio 1. …

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

Ejercicio 2.

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

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


29/199

5/10/2018


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; http://slidepdf.com/reader/full/libro-de-lenguaje-java

30/199

5/10/2018


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/199

5/10/2018


CAPÍTULO 2

INTRODUCCIÓN AL CAPÍTULO 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 capítulo será introducir al estudiante al mundo del IDE Netbeans para poder realizar aplicaciones aptas de nuestro nivel de aprendizaje. http://slidepdf.com/reader/full/libro-de-lenguaje-java

32/199

5/10/2018


5 Objetos Primero recordaremos la diferencia de declaración en programación tradicional y en orientada a objetos:

Orientada a Objetos

Tradicional Fraccion_simp = simplificada_fraccion (fraccion);

Scanner teclado = new Scanner(System.in);

5.1. Instanciación de Objetos: Para instanciar un objeto el método que se usa es “new”.

Antes de esto se tiene que declarar la variable que contendrá ese nuevo objeto Crea un objeto de la clase que le especifiquemos

String palabra1=new String("Ecuador");

new 6. Clases Una clase define la forma y comportamiento de un objeto. http://slidepdf.com/reader/full/libro-de-lenguaje-java

33/199

5/10/2018


a. Para crear una clase sólo 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 capítulo anterior. b. Los atributos Los datos se encapsulan dentro de una clase declarando variables dentro de las llaves de apertura y cierre de la declaración de la clase, variables que se conocen como atributos. Se declaran igual que las variables locales de un método en concreto. class MiPunto { int x, y; }

c. Los métodos Son subrutinas que definen la interfaz de una clase, sus capacidades y comportamiento. Un método puede tener cualquier nombre para identificarlo pero diferentes de los nombres los nombres de la clase en que está contenido. Los métodos se declaran al mismo nivel que las variables de instancia dentro de una definición de clase. tipo_devuelto nombre_de_método( lista-formal-de-parámetros ){ cuerpo_del_método; }


34/199

5/10/2018


7. Netbeans IDE

Netbeans es

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

La Plataforma Netbeans:

Es una base modular y extensible usada como una estructura de integración para crear aplicaciones de escritorio grandes

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

Un proyecto de código abierto de gran éxito con una gran base de usuarios y una comunidad en constante crecimiento

Administración de las interfaces de usuario (e . menús barras de herramientas

Administración de las configuraciones del usuario

Administración del almacenamiento (guardando y cargando cualquier tipo de dato) Administración de ventanas

Framework basado

en asistentes

(diálo o aso a aso


35/199

5/10/2018


7.1. Preparando el área de trabajo El área de trabajo de Netbeans está dado por:

1 3

4

2

Ilustración 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 códigos fuente de las clases junto con sus respectivos enlaces a sus interfaces gráficas (en caso de tenerlas), las librerías usadas, y algunos otros aspectos.

2.- Navegador: Esta zona funciona a modo de árbol; es el navegador de los objetos presentes en nuestra interfaz gráfica; es decir que allí se mostrará una lista jerárquica 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 diseño 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 patrón de diseño MVC: ◊

1ro. Creamos el nuevo archivo seleccionando el ícono de Nuevo proyecto.


36/199

5/10/2018


Ilustración 16. Nuevo Proyecto. Seleccionamos la opción Java-Java application.

Ilustración 17. Java Application.

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


Ilustración 18. Nombre Proyecto.

37/199

5/10/2018


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

Ilustración 19. Paso 1.

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

Ilustración 21. Esquema del proyecto. http://slidepdf.com/reader/full/libro-de-lenguaje-java

38/199

5/10/2018


Así hemos logrado seguir el patrón de diseño MVC, ahora podremos crear nuestras clases en las cuales realizaremos nuestras aplicaciones.

Ilustración 22. Creando una Clase.

Ilustración 23. Nombre de la Clase.

Para poder ejecutar el programa haremos una breve salida de información de la siguiente forma:

a. Escribimos el código

Ilustración 24. Escribir código.

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/199

5/10/2018


Ilustración 25. Compilar.

Ilustración 26. Sin error.

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

Ilustración 27. Run. Y observaremos los resultados en el espacio Output

Ilustración 28. Salida en consola.

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


40/199

5/10/2018


8. Referencias Las referencias en Java no son punteros ni referencias como en C++. Este hecho crea un poco de confusión 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 atención a un objeto de un tipo específico. No tenemos por qué saber cómo lo hace ni necesitamos saber qué hace ni, por supuesto, su implementación. Entre las más usadas tenemos this y null: Referencia al objeto que está ejecutando al método This this.largo = largo; Referencias Para asignar a una referencia el valor nulo se utiliza la constante null Null Por defecto: clase1;Clase Explícitamente: auto1=null;

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

Nivel de Acceso Private Protected Public Package

clase X X X X

subclase

paquete

todos

X* X

X X X

X


41/199

5/10/2018


En otras palabras podemos definir: Private

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

Public

Puede ser accedido desde cualquier código dentro del ámbito de un objeto instanciado a partir de la clase.

Protected

Friendly

Solamente cuando se ve involucrada en herencia

Acceso a todos los miembros privados y protegidos de esa clase

Aparece como

public void CualquieraAcced e(){}

public para los

miembros de clases derivadas de la clase

private String Numero

void MetodoDeMiPaquet e(){}

Aparece como

private para todas

las demás

protected void SubClases(){}

Ejercicios Ojo. Si tiene problemas en realizar estos ejercicios puede revisar el código fuente en la sección de Ayudas al usuario, al final de este capítulo.

1. Definir una clase que represente un auto. En la definición se debe incluir: El modelo, el color si la pintura es metalizada o no, la matricula, el tipo de auto, el año de fabricación, la modalidad del seguro. Tips: Revise la forma de ingresar constructores para la inicialización de las variables.

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


42/199

5/10/2018


3. Añadir a la clase Auto del ejercicio 1 un método de nombre imprime Auto que imprima el modelo y el color del auto.

4. Escribir un programa que tenga instancia de Auto, que un Audi de color gris. El programa ha de imprimir ununa 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 código numérico 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 métodos para obtener los valores de los atributos. El programa ha de construir un objeto con los siguientes valores: nombre “ TECNOLOGÍAS DE SOFTWARE PARA ELECTRÓNICA”, código 1017, nivel 5. A continuación 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/199

5/10/2018


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());

modelo

es

:"+carro.getModelo()+"\nel

color

es:

} } public class Auto { private String modelo; private String color; private String pintura; private String matricula; private String tipoDeAuto; private int año; private String seguro; public Auto() { this.modelo = "ninguno"; this.color = "ninguno";


44/199

5/10/2018


this.pintura = "ninguno"; this.matricula = "ninguno"; this.tipoDeAuto = "ninguno"; this.año = 0; this.seguro = "ninguno"; } public Auto(String modelo, String color, String pintura, String matricula, String tipoDeAuto, int año, String seguro) { this.modelo = modelo; this.color = color; this.pintura = pintura; this.matricula = matricula; this.tipoDeAuto = tipoDeAuto; this.año = año; this.seguro = seguro; } public int getAño() { return año; } public String getColor() { return color; } public void setColor(String color) { this.color = color; } public String getMatricula() { return matricula;


45/199

5/10/2018


} 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/199

5/10/2018


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/199

5/10/2018


Capitulo 3

Introducción al Capítulo En este capítulo contemplaremos conceptos más avanzados para programar en Java como herencia, polimorfismo, abstracción de clases. Con esto el estudiante estará en la capacidad de manipular completamente el lenguaje y podrá realizar interfaces más complejas.


48/199

5/10/2018


10. Herencia Dentro de la programación orientada a objetos existe el concepto de herencia, podemos crear objetos que requieran tener las mismas características 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 métodos que ya han sido escritos y definidos en otras clases, las clases que reciben los atributos y métodos 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 métodos tanto de la primera como de la segunda. Las ventajas entre otras pueden ser estandarización de clases, una de las más importantes es la reutilización de código que ya ha sido escrito y probado, entre otras.

10.1. Jerarquía La jerarquía 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.

Ilustración 29. Jerarquía.

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 algún tipo de relación y al heredar métodos y atributos de las clases padre, podría decirse que es una familia de clases con características especificas. Dentro del lenguaje todas las clases que hagamos o utilicemos son clases hijas de una súperdeclarar clase endentro común. clasecódigo). Object y esta es una herencia implícita (que49/199 no necesitamos de La nuestro


5/10/2018


10.2. Declaración de herencia Para declarar que una clase es hija de otra utilizamos la palabra reservada extends de la siguiente forma. public class ClaseHija extends ClasePadre{ … }

11. Referencias polimórficas En la que ClaseHija hereda los atributos de ClasePadre pero con esto surge una pregunta. ¿Cómo hacer referencia a los atributos de la clase padre o de sí misma cuando se necesite? Y más aun cuando sus atributos o métodos 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 polimórficas solo especificaremos a que clase pertenece los elementos que usemos.

12. Sobrecarga de métodos La sobrecarga de métodos es la escritura de métodos dentro de un programa con la misma etiqueta pero con diferente definición, esta definición dentro de java se la hace mediante el tipo y cantidad de argumentos que recibe un método. También existe la sobrecarga de constructores de igual manera estará definido por la cantidad de parámetros que se le envíe al constructor. String imprimir() {}

String imprimir(int a, int b) {}

String imprimir(int a) {}

String imprimir(String mensaje) {}


50/199

5/10/2018


13. Polimorfismo El polimorfismo es la creación de un método ya existente pero definido por la clase que lo posee, para ser más 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 método área, y el método perímetro, pero cada clase realiza el cálculo de los métodos de diferente forma.

14. Clases abstractas Una clase abstracta es una clase que posee atributos y métodos pero la cual no puede ser usada directamente como objeto ya que podría decirse que es intangible, los métodos que posee una clase abstracta pueden ser definidos en la misma o podrán ser definidos por las clases hijas. Para su declaración se utiliza la palabra abstract como veremos en el ejemplo abstract class A{ …

}

15. Interfaces Una interface es como crear una plantilla de una clase ya que se crearan métodos no definidos pero que deben existir de carácter obligatorio en las clases que implementen la interface y será en estas donde se definirá la forma que tienen los métodos dependiendo la necesidad del usuario, una interface es una clase abstracta pura ya que todos sus métodos serán abstractos. Una interface puede también 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 mayúscula ya que serán tomadas como constantes, en la clase que implemente esta interface se deberá 51/199


5/10/2018


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

15.1. Excepciones Dentro de en lenguaje existen creados específicamente paralael programación manejo de errores ya que enjava general, comoobjetos programadores podemos dejar pasar cierto tipo de cosas que nos pueden o no generar problemas en nuestro programa, un ejemplo muy típico y muy claro seria la operación división, si creamos un código donde realizaremos la división de dos números pero realizamos una división para cero tendremos un error con lo que podría entrar a un bucle infinito o hacer que nuestro computador no continúe trabajando, pero java nos permite manejar el error de cierta manera con las excepciones. Una excepción 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 también 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 excepción de este tipo es la división para cero

•

Se produce cuando se intenta acceder a una variable o método que todavía no ha sido creado

ArithmeticException

NullPointerException


52/199

5/10/2018


•

El intento de cambiar una clase afectada por referencias en otros objetos, específicamente cuando esos objetos todavía no han sido recompilados.

•

El intento de convertir un objeto a otra clase que no es válida

IncompatibleClassChangeEx ception

ClassCastException

•

NegativeArraySizeExcep tion

Puede ocurrir si hay un error aritmético al intentar cambiar el tamaño de un arreglo

• “¡No debería producirse nunca! El

intento de crear un objeto con el operador

OutOfMemoryException

new ha fallado por falta de memoria”.


53/199

5/10/2018


•

Se referenció una clase que el sistema no encuentra.

•

Se genera al intentar acceder a un elemento de un arreglo más allá de los límites definidos inicialmente para ese arreglo

NoClassDefFoundExcept ion

ArrayIndexOutOfBound sException

•

Por definición, el usuario nunca debería ver este error y esta excepción no debería 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 también podemos crear nuestras propias excepciones.

15.1.1. Bloques Try-Catch. Dentro del lenguaje Java se utiliza estas dos palabras reservadas para el manejo de errores, al escribir la palabra try generamos un bloque de código el cual será donde se realiza la operación que podría darnos algún tipo de error, y con la palabra catch crearemos el bloque de código encargado de manejar la excepción. try{ … http://slidepdf.com/reader/full/libro-de-lenguaje-java

}

54/199

5/10/2018


catch (Exception e){ …

} Este es un ejemplo de cómo se escribe el código de una excepción dentro de los paréntesis que se encuentran después de la palabra catch escribimos el tipo de excepción 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 excepción pertenece cada uno, y también hay una palabra reservada que es finally la cual se usa después de los catch, este es un bloque de código que se ejecutara obligatoriamente, se que ocurra o no una excepción, se usa en casos los que debemos ejecutar algún proceso como por ejemplo cerrar un en fichero quenecesariamente se está utilizando. try{ …

} catch (IOException error1){ …

} catch (NullPointerException error2){ …

} finally{ …

}

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


55/199

5/10/2018


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 más funcionales. Tenemos métodos como los siguientes dentro de la clase JOptionPane:

JOptionPane.showInputDialog() •

La diferencia entre ellos es que tienen más o menos parámetros, según queramos aceptar o no las opciones por defecto. Los parámetros y sus significados son muy similares a los del método showOptionDialog(), pero hay una diferencia.

•

Si lospara métodos no tienen array de opciones, la ventana mostrará cajausamos de texto que elque usuario escriba la opción que desee (un texto libre) una

JOptionPane.showMessageDialog() •

Sólo muestra una ventana de aviso al usuario. La ejecución se detiene hasta que el usuario cierra la ventana. Hay varios métodos con el mismo nombre y más o menos parámetros, en función de si aceptamos las opciones por defecto (icono, por ejemplo) o queremos cambiar alguna cosa.

JOptionPane.showConfirmDialog() •

Muestra una ventana pidiendo una confirmación al usuario, estilo "¿Seguro que lo quieres borrar todo?" y da al usuario opción 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 opción que ha seleccionado el usuario. La primera de las opciones del array es la posición cero. Si se cierra la ventana con la cruz de la esquina superior derecha, el método devolverá -1


56/199

5/10/2018


parentComponent •

Se intentará determinar cuál es la ventana que debe hacer de padre del JOptionPane. puede pasarlanull, peroque conviene ejemplo,elel botón desde elSe cual se lanza acción provocapasar, que sepor visualice JOptionPane

message •

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

.

title •

El título para la ventana

optionType: •

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


57/199

5/10/2018


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 •

Selección por defecto. Debe ser uno de los Object que hayamos pasado en el parámetro options. Se puede pasar null

Ejemplos

En los siguientes ejemplos crearemos diferentes clases donde usaremos los conceptos aprendidos en este capítulo. 1.- Crearemos una clase principal donde se encuentre el método Main, crearemos la clase A que será padre de la clase B y esta ultima será padre de la clase C, estas tres clases tendrán atributos del tipo entero y serán privados, cada una tendrá un atributo x y un atributo y, la clase A tendrá dos constructores del tipo public uno sin parámetros y el otro con parámetros uno para x y otro para y, y poseerá métodos del tipo protected que serán heredados. Y una clase Acciones donde utilizaremos la visualización que nos brinda JOptionPane http://slidepdf.com/reader/full/libro-de-lenguaje-java

58/199

5/10/2018


Ilustración 30. Proyecto.

Ilustración 31. Clase Principal.


59/199

5/10/2018


Ilustración 32. Clase A.

Ilustración 33. Clase B. http://slidepdf.com/reader/full/libro-de-lenguaje-java

60/199

5/10/2018


Ilustración 34. Clase C.

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


61/199

5/10/2018


Ilustración 36. Ingreso de variables.

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

Ilustración 37. Salida del programa.

2.-Definir una clase abstracta aviones, con dos métodos despegar y aterrizar. Definir una interface vuelos, con dos constantes una para velocidad máxima 1500, y otra para velocidad mínima 1000. Además el método 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. Además defina los métodos 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 Hércules que sea hija de aviones e implemente a la interface vuelos. Que tenga como atributos el peso y el estado del aeropuerto. Además defina los métodos 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/199


5/10/2018


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

Ilustración 38. Clase Aviones.

Ilustración 39. Interface Vuelos.


63/199

5/10/2018


Ilustración 40. Clase Boing747.

Ilustración 41. Clase hércules.


64/199

5/10/2018


Para realizar las pruebas defina una clase principal en la que se cree dos aviones, uno Hércules y otro Boing; y se pida al usuario que ingrese el peso de cada avión y el estado del aeropuerto. El usuario determinara si se encuentra volando o por despegar. Si el avión está volando se deberá ingresar la velocidad. A partir de los datos ingresados hacer el análisis 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 teléfono 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 método que permita presentar en pantalla la información Métodos 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 método que permita presentar en pantalla la información Un método de consulta Un método que permita asignar el libro a un nuevo usuario Un método 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. Además 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/199

5/10/2018


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 año"), new EntradaSalida().leerInt("leer ID")); } return (aux); } public Persona[] fechaComun(Persona[] estudiantes, String año) { int i, acum = 0; Persona aux[]; for (i = 0; i < estudiantes.length; i++) { if (estudiantes[i].getFecha().compareTo(año)==0) { acum = acum + 1; } } aux = new Persona[acum]; acum = 0; for (i = 0; i < estudiantes.length; i++) { if (estudiantes[i].getFecha().equals(año)) { aux[acum] = estudiantes[i]; acum = acum + 1; http://slidepdf.com/reader/full/libro-de-lenguaje-java

}

66/199

5/10/2018


} return (aux); } public void imprimeArreglo(Persona [] estudiantes){ int i; for(i=0;i

67/199

5/10/2018


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/199

5/10/2018


Capitulo 4

Introducción al capítulo En este capítulo realizaremos interfaces gráficas, estos métodos nos permitirán interactuar de una manera más dinámica con el usuario. Realizaremos aplicaciones más avanzadas con un grado de complejidad mayor a lo antes estudiado.


69/199

5/10/2018


17. Componentes de una interfaz grafica con el usuario Permitir crear entornos gráficos de ventanas como las de Windows es algo muy útil, dentro de Java existen componentes que nos permiten realizar esto (Java Fundation Classes) JFC por sus siglas es parte de la API de Java que contiene clases que nos permiten crear entornos gráficos. JFC contiene paquetes que nos ayudan a crear dichos entornos que son:

JFC

AWT Abstract Window Toolkit

biblioteca de clases Java para el desarrollo de Interfaces de

El entorno que ofrece es muy simple

Swing

es un paquete más ligero que AWT Swing existe desde la JDK 1.1

Usuario Gráficas.

La programación que se utiliza para crear interfaces graficas se denomina programación 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 también 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/199

5/10/2018


Analizaremos algunas funciones. Las clases del paquete swing han sido construidas sobre las clases awt. Swing es actualmente el paquete más utilizado para construir interfaces gráficas.

17.1. Componentes y contenedores Una interface gráfica está construida en base a elementos gráficos básicos, los componentes. Los Componentes no se encuentran aislados, sino agrupados dentro de Contenedores. Los Contenedores contienen y organizan la situación de los Componentes; además, los Contenedores son en sí mismos Componentes y como tales pueden ser situados dentro de otros Contenedores. También contienen el código necesario para el control de eventos, cambiar la forma del cursor o modificar el icono de la aplicación. En el AWT, todos los Contenedores son instancias de la clase Container o uno de sus subtipos. Los Componentes deben circunscribirse dentro del Contenedor que los contiene. Esto hace que el anidamiento de Componentes (incluyendo Contenedores) en Contenedores crean árboles de elementos, comenzando con un Contenedor en la raíz del árbol y expandiéndolo en sus ramas. A continuación presentamos el árbol que representa la interface que corresponde con la aplicación gráfica generada anteriormente. Object

Compone nt

Container

Jcompone nt

JButton

JMenuIte m

JCheckBo xMenuIte m

JMenu

AbstractB

JComboB

utton

ox

Jlabel

JList

JMenuBar

JPanel

JPopupM enu

JToggleB utton JRadioBu ttonMenu Item

JCheckBo x

JradioButt on

71 http://slidepdf.com/reader/full/libro-de-lenguaje-java

71/199

5/10/2018


17.1.1. Acciones sobre los componentes Existen varias acciones para cada componente, cada una es un método y depende de cual escojamos nos devolverá un tipo de dato, gracias a la ayuda de NetBeans no tenemos que memorizar un sin número de métodos 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).

Ilustración 42. Acciones. Aquí un ejemplo de ciertas opciones que un botón nos puede brindar

Ilustración 43. Opciones.


72/199

5/10/2018


Dentro de los estándares que maneja el lenguaje java cada elemento tendrá un método 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 métodos más. Cada contenedor de igual manera tendrá sus propios métodos. 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.

Ilustración 44. Contenedores Swing.

Ilustración 45. Controles Swing.

Ilustración 46. Menú Swing.


73/199

5/10/2018


Ilustración 47. Ventana Swing.

Ilustración 48. Componentes AWT. El nombre de cada componente nos da una breve idea de para que será utilizado

Label

Button

Text Field

texto impreso sobre el frame

su uso dependerá

nos permite crear una línea

que seetiqueta utiliza como

del programador

de texto o no modificable


74/199

5/10/2018


Text Area parecido al anterior, nos permite crear un área de texto pero en este caso el tamaño será más de una línea.

Cambas crea un área donde podemos colocar dibujos conocidos en español como lienzo.

: También 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 físicos.- InputEvent, son eventos de la interacción del usuario con la computadora como eventos hijos se tiene KeyEvent MouseEvent relacionados a una acción en el teclado y a una acción con el ratón respectivamente. Eventos Semánticos.- ActionEvent, se da cuando el usuario interactúa por medio de menús listas o verificación de casillas durante el uso del programa. Para cada evento Existe un oyente que usar.


75/199

5/10/2018


Ilustración 49. Evento.

Hemos utilizado un estándar para los nombres de los elementos, al colocar un elemento en un contenedor NetBeans automáticamente le da un nombre pero para el programador debe ser más fácil dar sus propios nombres, y con el fin de que el código sea comprensible para cualquier persona que desee leer el código hemos intentado dar una mayor facilidad sobre los nombres por ejemplo:

Botones: serán nombrados con un distintivo seguido del nombre del botón btnNombre. Label: serán nombrados con un distintivo seguido del nombre de la etiqueta lblNombre. Text Field: serán nombrados con un distintivo seguido del nombre de la línea 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 código, esto podemos hacerlo usando el objeto Font. 76 http://slidepdf.com/reader/full/libro-de-lenguaje-java

76/199

5/10/2018


Font fuente =new Font(“tipo de letra”, estilo, tamaño);

Como vemos podemos modificar el tipo, el estilo y el tamaño. Tipos de fuente

TimesRoman

Helvitica

Courier

Arial

Estilos

Font.BOLD

Font.PLAIN Font.ITALIC Para cambiar el estilo de fuente usamos el método void setFont(fuente);

Color Color tiene unos métodos soportande uncolores sistemapor de colores llamado RGB (estándar RGB) que, a su vez, esque el sistema defecto estándar en la API Java2D; la figura representa este espacio de colores. A pesar de ello también puede crearse un color en un sistema distinto, para lo que se utiliza el constructor anteriormente mencionado que toma como parámetros 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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

77/199

5/10/2018


Ilustración 50. Ejemplo color.

El espacio de colores RGB en el que también se muestra la ubicación exacta de los componentes puros rojo, verde y azul, además del blanco. En la clase color también existen constantes para los colores más usados: black, White, Green, blue, red, yelow, magenta, cian, Orange, pink, etc.


78/199

5/10/2018


Ejemplo Realizar un lienzo donde podremos graficar de forma muy parecida a la herramienta Paint de Microsoft en el lienzo podremos graficar rectángulos y líneas de estilo libre como si fuera un lápiz en dos colores diferentes,

Ilustración 51. Pantallas.

También crearemos un botón con la opción de salir para cerrar la aplicación en la parte superior al lienzo colocaremos etiquetas que nos indicaran el ancho y el alto de el lienzo, también en la parte inferior colocaremos etiquetas pero estas nos indicaran el valor de la posición donde se encuentra el cursor y un botón para limpiar el lienzo.


79/199

5/10/2018


En la parte superior hemos colocado un menúBar que nos permite agregar pestañas y dentro de cada pestaña un conjunto de menús. A continuación podemos leer el código del programa para poder entender que realiza cada botón.


80/199

5/10/2018


Ilustración 52. Código fuente.


81/199

5/10/2018


18. Interfaces GUI La mayor parte de las aplicaciones que se utilizan hoy en día incluyen interfaces de usuario más sofisticadas que las de las aplicaciones que se ejecutan en modo consola. Java incluye, como parte de su biblioteca de clases estándar, un conjunto de componentes para crear interfaces gráficas de usuario. Siguiendo la filosofía de su lema (“write once, ru n anywhere”), estos componentes permiten crear interfaces portables.

Ejercicio Con lo revisado anteriormente realizar la emulación de una calculadora.

Ilustración 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 stack; char operator; 82 http://slidepdf.com/reader/full/libro-de-lenguaje-java

82/199

5/10/2018


boolean finished;

public static void main(String[] args) { new Main(); } public Main() { super("Calculadora Básica - Versión 1.1"); finished = false; stack = new Stack(); 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/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

84/199

5/10/2018


} 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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

85/199

5/10/2018


} }


86/199

5/10/2018


CAPITULO 5

Introducción al capítulo En este capítulo revisaremos teoría básica para el ingreso de datos, no necesitamos aprender mucha teoría así que lo explicaremos en su mayoría 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 información.


87/199

5/10/2018


19. Información Datos Entrada Objetos en Internet Comunicación en Red Archivos Información Datos Entrada

Teclado

19.1. Entrada y Salida de Datos 

Entrada Datos

Salida Datos

• Flujo Entrada

• Flujo Salida

Creación Objeto



Flujo datos lectura Lectura Flujo Cierre Flujo



Creación Objeto



Flujo datos lectura





datos con Escritura método apropiados Cierre Flujo

19.2. Tipos de Flujos

Carcateres

Bytes Tipos de Flujos


88/199

5/10/2018


19.3. Acceso Aleatorio a Datos

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

Flujo con Bytes

Reader

InputStream

BufferReader LineNumberReader CharArrayReader FilterReader PushbackReader InputStreamReader FileReader PipedReader StringReader

ByteArrayInputStream FileInputStream FilterInputStream BufferedInputStream DataInputStream LineNumberInputStream PushbackInputStream ObjectInputStream PipedInputStream SequenceInputStream StringBufferInputStream

Writer BufferWriter CharArrayWriter FilterWriter OutputStreamWriter FileWriter PipedWriter PrintWriter

E n tr a d a d e D a to s

OutputStream ByteArrayOutputStream FileOutputStream FilterOutputStream BufferedOutputStream DataOutputStream PrintStream ObjectOutputStream PipedOutputStream

S a li d a d e Da to s

20. Serialización 89 http://slidepdf.com/reader/full/libro-de-lenguaje-java

89/199

5/10/2018


public class Capitulo5 implements Serializable {...}

Objeto se convierte en secuencia de bytes

Implementa interfaz Serializable

Sublases son serializables

No declara campos ni métodos

20.1. ObjectOutputStream y ObjectInputStream ObjectOutputStream

ObjectInputStream

Escribe Objetos a Stream

Lee objetos desde Stream

Constructor: ObjectOutputStream(OutputStream outStream);

Constructor: ObjectInputStream(InputStream inStream);

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


90/199

5/10/2018


Ilustración 54. Nuevo Proyecto. Le asignamos un nombre.

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

Ilustración 56. Crear Paquetes. En el paquete controlador, creamos una clase llamada Acciones y la desarrollamos con nuestros métodos. Tenemos la declaración de la clase Acciones, además de implementar el método 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/199

5/10/2018


Ilustración 57. Acciones. El método 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.

Ilustración 58. OutputStream. Método 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 número total de personas y se hace una condición del arreglo de personas en el cual se busca por apellido, al final se debería retornar el arreglo de personas si cumple esta condición, pero sino una Persona.

Ilustración 59. Método Buscar. Método 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 número de personas, aquí hacemos el arreglo de personas, y fuera de este for, hacemos que el objeto que habíamos creado, sea igual a persona.


92/199

5/10/2018


Ilustración 60. Método Ingresar. El método 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.

Ilustración 61. Método Cargar. Implementación clase Persona para que sea serializable, y hacemos la declaración de 3 variables de la clase.


93/199

5/10/2018


Ilustración 62. Class Persona. Se crea un constructor con argumentos. Recibe tres Strings que son nombre, apellido y teléfono.

Ilustración 63. Constructor con parámetros. Creamos un constructor vacío.

Ilustración 64. Constructor vacío. Getter y Setter de las variable nombre, apellido, teléfono.

Ilustración 65. Getter y Setter de Nombre. 94 http://slidepdf.com/reader/full/libro-de-lenguaje-java

94/199

5/10/2018


Ilustración 66. Getter y Setter apellido.

Ilustración 67. Getter y Setter teléfono. En esta interface tenemos los ingresos para el nombre, apellido y teléfono.

Ilustración 68. Interface.


95/199

5/10/2018


Declaramos un arreglo de personas.

Ilustración 69. Arreglo personas. Esta es la interface para buscar

Ilustración 70. Interfaz buscar. Se declara un objeto de tipo persona y también de un arreglo de personas. En el constructor ubicamos el archivo.

Ilustración 71. Objeto tipo persona. En el botón aceptar. El objeto de tipo persona lo igualamos al método buscar de la clase acciones, enviando los respectivos parámetros.

Ilustración 72. Botón aceptar. 96 http://slidepdf.com/reader/full/libro-de-lenguaje-java

96/199

5/10/2018


Interfaz creada para Guardar.

Ilustración 73. Interfaz guardar. Creamos un objeto de tipo File, y un arreglo de personas, además de un objeto de la clase acciones.

Ilustración 74. Nuevos objetos. El Ruta para tienepoder un objeto de tipo JFileChooser, una variable de tipo entera. Hacemos unabotón condición encontrar la ruta.


97/199

5/10/2018


Ilustración 75. Botón ruta. El botón Aceptar, tenemos el objeto de acciones y seleccionamos el método escribir, con sus respectivos parámetros.

Ilustración 76. Aceptar.

Ejercicio 1. Realizar una aplicación que cambie el fondo del Frame, ingresando el número en las cajas de texto para modificar los colores.


98/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

99/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

100/199

5/10/2018


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 String[] { "Cambiar", "Guardar", "Leer" })); 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, 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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

101/199

5/10/2018


.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

102/199

5/10/2018


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

35,

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

103/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

104/199

5/10/2018


// End of variables declaration }


105/199

5/10/2018


CAPITULO 6

Introducción al capítulo En este capítulo nos enfocaremos en un nuevo termino como son los hilos. Con este método se puede dar una impresión de movimiento por ello es de gran necesidad para nosotros ponerlo a conocimiento del estudiante.


106/199

5/10/2018


21. Máquina Virtual Java

Sistema multithread

Ejecuta programas varios simultáneamente

Asigna ejecución, tiempos de prioridades

21.1. Diferencia entre proceso de Sistema Operativo y Thread Java

Sistema Operativo

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

21.2. Multi-threading

Series describen codigo y datos

Se crea CPU virtual

Una o más series se ejecute el código al mismo tiempo Programas constan con al menos una serie

21.2.1. Un solo Hilo vs Multi-hilo


107/199

5/10/2018


22. Thread desde el mismo lenguaje Thread desde el mismo lenguaje Comunicación con el usuario, transmisión con fichero Accede a recursos del Sistema

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


108/199

5/10/2018


Extendiendo clase Thread

•

public class Ejemplo1 extends Thread

Implementando Interfaz Runnable

•

public class Ejemplo2 implements Runnable

24. Clase Thread Empleando clase Thread public class ThreadEjemplo extends Thread {

public void run() {}

} Generación y ejecución Thread public static void main(String[]args) {

Clase Thread

ThreadEjemplo A=new ThreadEjemplo(); A.start(); }

25. Interfaz Runnable


109/199

5/10/2018


Empleando Interfaz Runnable public class RunnableEjemplo implements Runnable { public void run() {} }

Interfaz Runnable

Generación y ejecución Thread public static void main(String[]args) { RunnableEjemplo A=new RunnableEjemplo(); new Thread(A).start(); }

26. Suspensión de un Hilo sleep

suspend


110/199

5/10/2018


26.1. Método Suspend

Método suspend

Para activar nuevamente con resume

No detiene ejecución indefinidamente

26.2. Parada de un Hilo stop Para ejecución hilo permanentemente

isAlive Comprueba si instancia esta viva o no


111/199

5/10/2018


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

Ilustración 77. Clase Hilo1.

En el hilo2 hacemos la misma declaración que el hilo1 en el constructor, y en el método void run ubicamos el tiempo en el que queremos que salga el mensaje.

Ilustración 78. Clase Hilo2. 112 http://slidepdf.com/reader/full/libro-de-lenguaje-java

112/199

5/10/2018


En una clase principal llamamos al primer hilo.

Ilustración 79. Clase Principal.


113/199

5/10/2018


Capitulo 7

Introducción al capítulo En este capítulo revisaremos la interfaz con los puertos revisando las componentes básicas para la comunicación con el puerto serie y paralelo.


114/199

5/10/2018


27. Adquisición de Datos

Señales externas: Analógicas, Digitales.

Recepción

Mediante PC, controla acciones a realizar en función de las señales externas adquiridas. manipulación

Adquisición de señales y conversor.

28. Acondicionamiento de señales Amplificación

Filtrado

Manipulación y tratamiento en

Aislamiento Térmico

Multiplexado

1. Tratamiento de las señales en cada proceso

29. Señales Digitales Señales Digitales Señales de dos estados: ALTO y BAJO

Se generan ruidos por causas ajenas, se deforma la señal digital http://slidepdf.com/reader/full/libro-de-lenguaje-java

Ondas Cuadradas

115 115/199

5/10/2018


Solución

Circuito Integrado Schmith - Trigger Mediante

histéresis

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

29.1. Regeneración de una señal digital maltratada Fenómeno de Rebotes en las Señales Se presentan en Contactos metálicos

pulsadores

generan Varias oscilaciones en cada cambio de estado afectando a: Señales que trabajan a velocidades muy elevadas solución Por Hardware1 Con filtro RC

Por Hardware2 Mediante inversores

Por Software Generando retardos, para q se estabilice la señal. 200ms

Elementos Electrónicos Buffers

Relés

Circuitos integrados que a Mediante un circuito su salida generan mayor electromecánico se corriente que otro CI controla desde electrónica http://slidepdf.com/reader/full/libro-de-lenguaje-java digital, a elementos de

O toaco lador

116 Mediante un circuito

digital, compuesto por un diodo y116/199 un transistor de potencia, opera igua

5/10/2018


30. Puerto Serie Comunicación Serial

Envío de bits de un periférico a otro viceversa.

La transmisión se la realiza en cadenas de bits.

Más lenta en comparación con la comunicación aralela. Comunicación a distancias cortas < 15 metros

velocidad Bits por segundo



baudios

30.1. Descripción del puerto Serie Estándar de comunicación RS-232

Conector del puerto Serial que lo tenemos como periférico

HIGH  +12 volts LOW  -12 volts Región -3 y +3 indefinida

Conector DB-9

Envío de datos TXD Recepción de datos RXD Comunicación asíncrona

31. Puerto Paralelo


117/199

5/10/2018


Puerto Paralelo

Mediante el envío de bits en buses completos. Bus de datos, direcciones, control. Tipos de

Comunicación Full Duplex

Simplex

Half Duplex O transmite un terminal opero recibe está información, no ambas a la vez

Mediante una sola línea Si se envía datos, solo puede recibir y viceversa.

Envío y recepción información al de mismo tiempo con un canal para cada pin de transmisión

31. 1. Modos de Transmisión de Datos Modos de Transmisión de Datos TX

Asíncronas

Cuando el transmisor y el receptor no están sincronizados tem oralmente.

Síncronas

Cuando bits especiales dan a conocer el sincronismo de transmisor – receptor en su transmisión

32. Manejo del Puerto Serie


118/199

5/10/2018


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

Controla periféricos Puerto Paralelo. RS-232

Puerto Serie IEEE-1284

Instalación Comm.jar

…/jdk1.6/jre/lib/ext

Win32com.dll

Javax.comm.prope

…/jdk1.6/bin

…/jdk1.6/jre/lib

Acceso a puerto de comunicación CommPortIdentifier CommPort

Nivel Alto

Niveles de Comunicación

Nivel Medio

Nivel Bajo


119/199

5/10/2018


Relacionado al sistema operativo

Maneja interfaces RS-232 IEEE-1284

Ejemplos Conectarse mediante el Hyper Terminal del computador y ver la transmisión de los datos

Ilustración 80. Conectar Hyper Terminal. Creamos una nueva conexión.

Ilustración 81. Nueva conexión. 120 http://slidepdf.com/reader/full/libro-de-lenguaje-java

120/199

5/10/2018


Accedemos al Hyper Terminal como se indica en el gráfico.

Ilustración 82. Acceder al Hyper Terminal. Establecemos los parámetros de configuración regional

Ilustración 83. Configuración. Todo listo para proceder al envío de información


121/199

5/10/2018


Ilustración 84. Envío de texto. 2.- Creación de un programa que me permitirá el envío de un mensaje serialmente, utilizando los COM disponibles en el puerto.

Ilustración 85. Puerto Serie. Importamos las librerías de comunicación serial y creamos nuestra clase.

Ilustración 86. Serial. 122 http://slidepdf.com/reader/full/libro-de-lenguaje-java

122/199

5/10/2018


Para finalizar creamos nuestra ventana de comandos con la habilitación del botón que enviará la información.

Ilustración 87. Class ventana.

33. Manejo del Puerto Paralelo Manejo del Puerto Paralelo JAVA

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

Norma TTL HIGH 5 volts LOW 0 volts Librería a usarse COMUNICATIONSAPI.

6 mA – 20mA

Agregar librería Jnpout32pkg.jar 123


123/199

5/10/2018


crear

en WINDOWS/system32

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

378

Bus de Datos

379

Bus de Estado

37A

Bus de Control


124/199

5/10/2018


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

Ilustración 88. Habilitación del Puerto serial. 2.- Aplicación que permitirá escribir en el registro 0X378, 0X37A y leer el registro 0X379

Ilustración 89. Lectura de registros. 125 http://slidepdf.com/reader/full/libro-de-lenguaje-java

125/199

5/10/2018


Ventana que me indica cómo controlar la dirección a manejar y el mensaje

Ilustración 90. Ventana de selección.


126/199

5/10/2018



127/199

5/10/2018


APÉNDICES Apéndice 1 Entornos de desarrollo integrado (IDE) Entornos de Desarrollo Integrado

Eclipse

Un IDE es un programa que nos permite desarrollar, compilar, y ejecutar programas en determinado lenguaje de programación. Es un proyecto de desarrollo de software de código de fuente abierto, su principal objetivo es la construcción de herramientas integradas para el desarrollo de aplicaciones, así mismo su proyecto global se basa en subproyectos.

JBuilder

Proporciona un IDE de clase empresarial basado en la infraestructura de código abierto con soporte para los diferentes servidores.

JDeveloper

Se centra en la productividad para el desarrollo de código, esta forma el editor analiza el código en el camino y de proporciona sugerencias.

JIdea

Visual J#

Era de libre descarga, gracias a su código de refactorización lo hace de gran ayuda para el usuario. No es de fácil 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# sólo se ejecutarán en .NET Framework, creado por Microsoft.

128


128/199

5/10/2018


Apéndice 2 Estructuras en Java

Estructuras

Numeracion

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

Coleccion

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

Añadir objetos a la colección Eliminar objetos de la colección Obtener un objeto de la colección Localizar un objeto de la colección Iterar a traves de una colección

Vector

Directorio de Java

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.

LINKEDLIST

ARRAYLSIT

HASHSET

HASHMAP

Es una estructura de datos que contiene un conjunto de objetos. Permite buscar un objeto dentro del conjunto de forma rápida y fácil.

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

TREE

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 o indican al anterior siguiente nodo, Útil cuando se quiere insertar o eliminar elementos al principio o al final de la lista.

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

Un Tre mantie objetos or en lo que s como red-b

129


129/199

5/10/2018


Apéndice 3 Pruebas y Depuración de código

Pruebas de caja blanca

Pruebas de caja negra

JUnit 130 http://slidepdf.com/reader/full/libro-de-lenguaje-java

130/199

5/10/2018


Comandos de JUnit

Logger Log4J


131/199

5/10/2018


Apéndice 4 Análisis Orientado a Objetos

El Proceso de AOO

ModeloyobjetoRelación Modelo objetocomportamiento

Análisis del dominio

Analisis Orientado a Objetos

Definición de subsistemas

Casos de uso

Componentes genéricos del modelo de análisis OO

Modelado de clasesresponsabilidadescolaboraciones (CRC)


132/199

5/10/2018


Modelo objeto-Relación y Modelo objeto-comportamiento Finalmente en la búsqueda de nuestro análisis orientado a objetos definiremos cuales son las clases colaboradoras, el análisis 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, obteniéndole a, se compone de, etc. , en el cual verificaremos la exactitud y consistencia con el debido comportamiento de su objeto .

Diseño Orientado a Objetos El Diseño Orientado a Objetos DOO, proporciona un diseño 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 diseño de software: abstracción, ocultamiento (ocultación) de información, independencia funcional y modularidad

Pirámide de Diseño Orientado a Objetos

Diseño de Responsabilidades

Diseño de Mensajes

Diseño de Clases y Objetos

Diseño de Subsistemas


133/199

5/10/2018


Pruebas Orientadas a Objetos

Apéndice 5 Ingeniería Inversa Para todas las aplicaciones estudiadas de ingeniería inversa se necesita programas especiales o complementos, como es el caso de creación de diagramas UML,


134/199

5/10/2018


Ingenieria Inversa

Conceptos decompilador permite obtener el código fuente de un programa a

Decompilador

partirnombres de los archivos .class .jar; en Java es posible obtener los originales deolas clases, métodos, atributos

Ofuscacion de codigo

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

Creacion de diagramas UML a partir de codigo y viceversa

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

Instalador de aplicaciones Java para windows

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

Apéndice 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/199

5/10/2018


Apéndice 7 JMathlink Mediante esta interface de JMatLink podemos enlazar Matlab con java y podemos usar las herramientas para de este para poder facilitar nuestra programación.


136/199

5/10/2018


Tecnologias del Software I

JAVA

MATLAB

Tiene un modelo de objetos más simple y elimina herramientas de bajo nivel.

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

Es una librería que conecta Java y Matlab

Utiliza métodos nativos permiten utilizar diferentes funciones de Matlab desde una Java. Necesita de tres clases:

Basado en JNI (Java Native Interface)

- CoreJMatLink - JMatLink - JMatLinkException JMATLINK

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


137/199

5/10/2018


Apendice 8 Java FX l

i

i

i

i

engua je d señado para an mac ones y gráf cos. Permite l a vinculación Es un nuevo escritos de componentes en otros lengua jes (principalmente en Java) con rapidez, código 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 tecnologías, herramientas y recursos necesarios para los desarrolladores y diseñadores para crear y desplegar contenido expresivo y potente dentro del navegador, escritorio, móviles, TV y otros dispositivos conectados.

Apéndice 9 Google Maps Es un servicio gratuito de Google. Es un servidor de aplicaciones de mapas en la Web. Ofrece imágenes de mapas desplazables, así como fotos satelitales del mundo entero e incluso la ruta entre diferentes ubicaciones o imágenes a pie de calle Street View. 138 http://slidepdf.com/reader/full/libro-de-lenguaje-java

138/199

5/10/2018


Una imagen satelital o imagen de satélite se puede definir como la representación visual de la información capturada por un sensor montado en un satélite artificial.

JPOSITION

GUI programa informático que actúa de interfaz de usuario, utilizando un conjunto de imágenes y objetos gráficos para representar la información y acciones disponibles en la interfaz

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

Es un archivo.jar, dentro del cual está el código que nos permite cargar el mapa así como definir sus características

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/199

5/10/2018


Programacion orientada a eventos •

la estructura como ejecución de los programas van determinados por los sucesos que ocurran en el sistema, definidos por el usuario o que ellos mismos provoquen.

Detección de Eventos •

permite interactuar con el usuario en cualquier momento de la ejecución

Ilustración 91. Código.


140/199

5/10/2018


El primer objeto creado será el siguiente:

El segundo objeto creado será el siguiente:

Se define un arraylist:

Al tener la posibilidad de tener más 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/199

5/10/2018


Apéndice 10 Java 2D JAVA 2D

Proporciona un robusto conjunto de imágenes y herramientas de dibujo para gráficos de alta calidad. java.awt.Graphics2D

Es una clase que extiende a java.awt.Graphic

El lienzo puede estar enlazado con un área física de un monitor, o representar una imagen en memoria que sólo se desea manipular y no tiene representación directa durante este proceso.

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

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

Sus atributos o características contextuales que son, a su vez, objetos.

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

Coordenadas de Usuario (user space)

X: desplazamiento hacia la derecha Y: desplazamiento hacia abajo

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

Sistema de Coordenadas de Java2D

GraphicsEnvironment: Define la colección de dispositivos visibles desde una plataforma Java.

Coordenadas de Dispositivo (device space)

Java2D define tres bloques de información para soportar la conversión entre las coordenadas de dispositivode usuario y

GraphicsDevice: Define un dispositivo concreto de gráficos

pantallas, impresoras y buffers de imagen

Dispositivo

de

visualización SVGA puede funcionar en varios modos

GraphicsConfiguration:

Define un modo de ese dispositivo concreto


142/199

5/10/2018


Método Devuelve un contains(double x, boolean double y)

contains(Point2D

boolean

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

Rectangle2D

PathIterator getPathIterator(Aff ineTransform at)

Descripción Determina si las coordenadas están dentro de la Shape Igual al anterior pero con un Point2D Determina si el área rectangular entra dentro de la Shape Igual que el anterior pero con un Rectangle2D Devuelve el rectángulo mínimo que recubre la Shape Devuelve un rectángulo más optimizado que en el anterior caso

getPathIterator(Aff PathIterator ineTransform at, double aplanamiento) intersects(double x, boolean double y, double

Devuelve unlaIterator subtrazos de figura. que itera sobre los Si queremos transformar las iteraciones, usamos la transformada, sino sencillamente pasamos null en el método Igual que el anterior, pero el segundo parámetro 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

ancho, double largo) intersects(Rectangl boolean e2D r)

como parámetro Igual que el anterior pero con un Rectangle2D.

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

public void paint( Graphics g ){ super.paint(g); // llamar al método paint de la superclase Graphics2D g2d=(Graphics2D)g; 143 http://slidepdf.com/reader/full/libro-de-lenguaje-java

143/199

5/10/2018


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); - Método para dibujar una elipse - Convierte el objeto g de tipo Graphics a Graphics 2d

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

public void paint( Graphics g ){

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

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

public void paint( Graphics g ){ super.paint(g); Graphics2D g2d=(Graphics2D)g; 144 http://slidepdf.com/reader/full/libro-de-lenguaje-java

144/199

5/10/2018


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

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

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

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

public void paint( Graphics g ){ super.paint(g); 145 http://slidepdf.com/reader/full/libro-de-lenguaje-java

145/199

5/10/2018


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); } - Método para dibujar un Rectángulo con relleno - Convierte el objeto g de tipo Graphics a Graphics 2d

Proyecto LCD PUERTO PARALELO

Es una interfaz entre la computadora y un periférico

CARACTERÍSTICAS

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

Se implementa un cable o una vía física para cada bit de datos formando un bus

ESTRUCTURA

CABLE PARALELO

Es el conector físico entre el puerto paralelo y el dispositivo periférico

Configuración

Registro de Control

Registro de Estado

Se compone de 4 bits, con un bit de configuración que no tiene conexión al exterior

Registro de entrada de información de 5 bits

Su dirección en el LPT1 es 0X37A

Su dirección en el LPT1 es 0X379

Registro de Datos

Se compone de 8 bits

Su dirección en el LPT1 es 0X378


146/199

5/10/2018


LCD (Pantalla de cristal liquido o Liquid Crystal Display)

CARACTERÍSTICAS

Dispone de 2 filas de 16 caracteres cada una.

Pantalla de caracteres ASCII, además de los caracteres Kanji y Griegos

Desplazamiento de los caracteres hacia la izquierda o la derecha.

Permite que el usuario pueda programar 8 caracteres

FUNCIONAMIENTO

Cada carácter dispone de una matriz de 5x7 puntos (pixeles)

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

Con bus de 4 bits o con bus de 8 bits

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

Memoria de 40 caracteres por línea de pantalla

Proporciona la dirección de la posición absoluta o relativa del caracter

Las líneas de datos son triestado

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

Conexión a un procesador usando un interfaz de 4 u 8 bits

Los pines 1 y 2

El pin número 3

El Pin numero 4 Denominado "RS" trabaja paralelamente al

•

Destinados para

Usado para ajustar el contraste de la

conectarle los 5 Voltios que requiere el modulo para su funcionamien to

pantalla; colocar es decir los caracteres más oscuros o más claros para poderse observar mejor

Bus de LCD datos del modulo • Si el Pin numero 4 = 0 le dirá al modulo LCD que está presente en el bus de datos una instrucción, por el contrario, si el Pin numero 4 = 1 le dirá al modulo LCD que está presente un símbolo o un carácter alfa numérico

• •

Dispositivo micro controlado de visualización gráfica para la presentación de caracteres, símbolos o incluso dibujos


147/199

5/10/2018


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 habilitación del modulo LCD tiene una finalidad básica: conectar y desconectar el modulo

Los Pines desde el 7 hasta el 14 • Representan 8 líneas que se utilizan para colocar el dato que representa una instrucción para el modulo LCD o un carácter alfa numérico. El Bus de datos es de 8 Bits de longitud y el Bit menos significativo está representado en el Pin más numero 7, el Pin significativo está representado en el Pin numero 14

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

public FrameControl() { initComponents(); bandera=1; Constructor que inicializa los componentes visuales. Este constructor existe en

o

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); En este método se define la opción a ser escogida: línea superior, inferior, o

o

borrado, con ello se maneja el tiempo de espera para que el LCD reciba la información y la presente en pantalla.

private void BORRARActionPerformed(java.awt.event.ActionEvent evt) { txtTexto.setText(""); 148 http://slidepdf.com/reader/full/libro-de-lenguaje-java

148/199

5/10/2018


SalidaParalelo e=new SalidaParalelo(2,500,txtTexto.getText()); Borra lo que este escrito en el txt.

o

private void btnSuperiorActionPerformed(java.awt.event.ActionEvent evt) { bandera=1; btnInferior.disable(); Escoge la línea superior para escribir en el LCD.

o

private void btnInferiorActionPerformed(java.awt.event.ActionEvent evt) { bandera=2; btnSuperior.disable(); Escoge la línea inferior para escribir en el LCD.

o

private void btnEscribirActionPerformed(java.awt.event.ActionEvent evt) { if (btnSuperior.isSelected()){ bandera=1; else{ bandera=2; SalidaParalelo e=new SalidaParalelo(bandera,500,txtTexto.getText()) } Envía la información a la línea para que escriba en pantalla.

o

private void menuLetrasActionPerformed(java.awt.event.ActionEvent evt) { this.dispose(); new Letras().setVisible(true); Selecciona solo la opcion de letras para la escritura.

o

private void menuNumerosActionPerformed(java.awt.event.ActionEvent evt) { this.dispose(); new Numeros().setVisible(true); Selecciona solo números para la escritura en el LCD.

o


149/199

5/10/2018


private void menuSimbolosActionPerformed(java.awt.event.ActionEvent evt) { this.dispose(); new Simbolo().setVisible(true); Selecciona solo simbolos para el ingreso en el LCD.

o

private void menuExitActionPerformed(java.awt.event.ActionEvent evt) { System.exit(0); Finaliza la aplicación.

o

Proyecto Nuestro problema radica en cómo resolver circuitos que usen un transistor, para conocer sus voltajes, corrientes, punto de operación y el modelo Darlington. package araujocampañamenesesquisnancela.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

150/199

5/10/2018


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

public String texto(){ String tTexto=""; try{ tTexto=dato.readLine(); }catch(Exception e){} return tTexto; } } package araujocampañamenesesquisnancela.transistores.controlador; import araujocampañamenesesquisnancela.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

151/199

5/10/2018


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

if(aux.equals("C")){ System.out.println("Colores.- "); resistencia.setValor(); } if(aux.equals("N")){ System.out.print("Valor: "); resistencia.setValor(ingreso.decimal()); } return resistencia; } } package araujocampañamenesesquisnancela.transistores.controlador; import araujocampañamenesesquisnancela.transistores.modelo.Transistor; public class IngresoTransistor { public Transistor setTransistor(){ Transistor transistor = new Transistor(); transistor.setTipo(); transistor.setBeta(); return transistor; } } 152 http://slidepdf.com/reader/full/libro-de-lenguaje-java

152/199

5/10/2018


package araujocampañamenesesquisnancela.transistores.controlador; import araujocampañamenesesquisnancela.transistores.modelo.Voltaje; import araujocampañamenesesquisnancela.transistores.modelo.Transistor; import araujocampañamenesesquisnancela.transistores.modelo.Resistencia; import araujocampañamenesesquisnancela.transistores.modelo.PBase; import araujocampañamenesesquisnancela.transistores.modelo.PColector; import araujocampañamenesesquisnancela.transistores.modelo.PEmisor; import araujocampañamenesesquisnancela.transistores.modelo.PBDarlington; import araujocampañamenesesquisnancela.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/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

154/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

155/199

5/10/2018


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 araujocampañamenesesquisnancela.transistores.modelo; public class Corriente { private double i = 0 ; private double iMA = 0;


156/199

5/10/2018


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 araujocampañamenesesquisnancela.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

157/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

158/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

159/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

160/199

5/10/2018


} 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 araujocampañamenesesquisnancela.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(); //IB transistor.setIB(temp); temp = fuente.getValor()/resistencias[1].getValor(); //ICmax


161/199

5/10/2018


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

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


162/199

5/10/2018


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

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


163/199

5/10/2018


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 araujocampañamenesesquisnancela.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(); //IB transistor.setIB(temp);

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


164/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

165/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

166/199

5/10/2018


resultados[10] = "El transistor se encuentra en la zona activa"; return resultados; } } package araujocampañamenesesquisnancela.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());

//IB

transistor.setIB(temp); temp = fuente.getValor()/resistencias[1].getValor(); //ICmax 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:");


167/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

168/199

5/10/2018


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 araujocampañamenesesquisnancela.transistores.modelo; public class PDivTension { public String[] calculos(Voltaje fuente,Resistencia[] resistencias, Transistor transistor1){ 169 http://slidepdf.com/reader/full/libro-de-lenguaje-java

169/199

5/10/2018


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()); //IB 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();


170/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

171/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

172/199

5/10/2018


return resultados; } } package araujocampañamenesesquisnancela.transistores.modelo;

public class PEmisor { public String[] calculos(Voltaje fuente,Resistencia[] resistencias, Transistor transistor1){ String[] resultados = new String[11]; Corriente iCMax = new Corriente(); Transistor transistor = new Transistor(); double temp = 0; transistor = transistor1; temp = (fuente.getValor() 0.7)/(resistencias[0].getValor()+transistor.getBeta()*resistencias[2].getValor());

//IB

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);

temp = transistor.getIE().getValor(); 173 http://slidepdf.com/reader/full/libro-de-lenguaje-java

173/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

174/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

175/199

5/10/2018


} } package araujocampañamenesesquisnancela.transistores.modelo; import araujocampañamenesesquisnancela.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

176/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

177/199

5/10/2018


} }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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

178/199

5/10/2018


} 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 araujocampañamenesesquisnancela.transistores.modelo; import araujocampañamenesesquisnancela.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

179/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

180/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

181/199

5/10/2018


} 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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

182/199

5/10/2018


vCE.setValor(vC.getValor()-vE.getValor()); return vCE; } public double getP(){ return vCE.getValor()*iC.getValor(); } } package araujocampañamenesesquisnancela.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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

183/199

5/10/2018


package araujocampañamenesesquisnancela.transistores.vista; import araujocampañamenesesquisnancela.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 POLITÉCNICA DEL EJERCITO"); System.out.println("\t\tDEPARTAMENTO DE ELÉCTRICA Y ELECTRÓNICA\n");

do{ System.out.println("\t\tRESOLUCIÓN 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/199

5/10/2018


Proyecto Diseñar un osciloscopio mediante interfaces GUI que nos permita modelar señales senoidales, cuadráticas, triangulares, de ruido blanco y un termómetro. 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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

185/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

186/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

187/199

5/10/2018


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

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

public void grafica() {

Graphics g=getGraphics(); int b; do{ y0 =a*Math.sin((x0*w)*Math.PI/180); 188 http://slidepdf.com/reader/full/libro-de-lenguaje-java

188/199

5/10/2018


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

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

if (y0>0){ Line2D linea=new Line2D.Double((x0+fase), a+255, (x1+fase), a+255); //

System.out.println("x0: "+x0+" y: "+(y0));

//

System.out.println("x1: "+x1+" y: "+(y1)); g2.draw(linea); } if (y0<0){ Line2D linea=new Line2D.Double((x0+fase), ((-1)*a)+255, (x1+fase),((-1)*a)+255);

//

System.out.println("x0: "+x0+" y: "+(y0));

//

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


189/199

5/10/2018


}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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

190/199

5/10/2018


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

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

w=Double.parseDouble(acciones.conversion(txtPeriodo.getText())); //Fase=Integer.parseInt(JOptionPane.showInputDialog("Ingrese fase")); //System.out.print(Valor+""+Frec); } 191 http://slidepdf.com/reader/full/libro-de-lenguaje-java

191/199

5/10/2018


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

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

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

System.out.println("x0: "+x0+" y0: "+(y0));

//

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

} 192 http://slidepdf.com/reader/full/libro-de-lenguaje-java

192/199

5/10/2018


package andinoaraujoenriquezmeneses.osc.modelo;

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

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

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

public RuidoBlanco(double a, double w,double fase) { this.a = a; this.w = w; this.t = 0; 193 http://slidepdf.com/reader/full/libro-de-lenguaje-java

193/199

5/10/2018


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();


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

do{ y0 =a*Math.random(); y1 =a*Math.random(); x0++; x1++; 194 http://slidepdf.com/reader/full/libro-de-lenguaje-java

194/199

5/10/2018


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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

195/199

5/10/2018


* @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 http://slidepdf.com/reader/full/libro-de-lenguaje-java

196/199

5/10/2018


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


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

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

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

Line2D linea=new Line2D.Double((x0+fase), y0+255, (x1+fase), y1+255); //

System.out.println("x0: "+x0+" y: "+(y0)); 197


197/199

5/10/2018


//

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

} }


198/199

5/10/2018


Referencias Bibliográficas Castilla. León. 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

bibliográficas.

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/199

Libro de lenguaje Java

Recommend Documents