Pancho Riveros

Seminario de JAVA (2006)

2008-10-10T19:54:00.001-07:00

Dictado por la empresa hace mucho tiempo

4Minds Software Ltda.

www.4minds.cl

Índice

1.- Programación orientada a objetos Pág. 4

Paradigma de la programación Pág. 4

Propiedades y comportamiento de los objetos Pág. 4

Propuestas de un modelo de diseño Pág. 5

Diagramas de clases Pág. 6

2.- Introducción en java Pág. 7

Características de java Pág. 7

Compilación y ejecución de programas Pág. 7

Compilador de Java Pág. 8

Nuestro primer programa java Pág. 8

Programar comentarios Pág. 9

Variables y constantes Pág. 9

Variables finales Pág. 10

Nombre de variables Pág. 10

Alcance de variables Pág. 11

Operadores de java Pág. 11

Precedencia de los operadores en java Pág. 13

Expresiones y sentencias Pág. 13

Sentencias de control de flujo Pág. 13

if-else Pág. 14

switch Pág. 15

Sentencias de bucle Pág. 16

while y do-while Pág. 16

for Pág. 17

Clase System Pág. 18

Secuencias de escape Pág. 19

3.- Clases Pág. 20

Árbol de clases Pág. 20

Tipos de clases Pág. 20

Declarar, inicializar y usar un objeto Pág. 20

Referenciar variables de un objeto Pág. 21

Sentencia static Pág. 21

Nuestro primer objeto Java Pág. 22

Eliminar objetos Java Pág. 23

Interfaces Pág. 23

Clases anónimas Pág. 24

4.- Paquetes Pág. 25

Sentencia Import Pág. 25

Archivos JAR Pág. 25

Classpath Pág. 26

Creación de paquetes Pág. 27

Árbol de paquetes o subpaquetes Pág. 27

La clase Object Pág. 28

Conversión de tipos Pág. 28

Algunas clases de Java Pág. 29

Math Pág. 29

Integer Pág. 30

Random Pág. 31

StringTokenizer Pág. 32

Runtime Pág. 33

5.- Vectores y matrices Pág. 34

Secuencias de variables Pág. 34

Arreglos unidimensionales Pág. 34

Algoritmos Pág. 35

6.- Herencia: Subclases y superclases Pág. 36

Herencia simple Pág. 36

¿Que variable miembro hereda una subclase? Pág. 36

Escribir clases, atributos y métodos finales Pág. 39

Clases y métodos abstractos Pág. 39

Jerarquía de composición Pág. 39

7.- Errores y excepciones Pág. 41

La jerarquía de las excepciones Pág. 41

Uso de try, catch y finally Pág. 42

Pila de llamadas Pág. 44

Lanzar excepciones Pág. 45

Capturar excepciones más genéricas Pág. 46

8.- Streams Pág. 47

Flujo de datos Pág. 47

Lecturas y escrituras en archivos usando streams Pág. 49

FileReader y FileWriter Pág. 52

Objetos persistentes Pág. 52

9.- AWT Pág. 54

Interfaces gráficas Pág. 54

Componentes y contenedores Pág. 54

Clase Component Pág. 54

Button Pág. 55

Choice Pág. 56

CheckBox Pág. 57

List Pág. 57

Clase Containers Pág. 58

Window Pág. 59

Frame Pág. 59

Dialog Pág. 59

Panel Pág. 59

10.- Applets Pág. 60

¿Que son los applets? Pág. 60

El AppletViewer Pág. 60

Métodos Pág. 60

Nuestro Primer applet Pág. 61

Sonidos en los applets Pág. 62

1.- Programación orientada a objetos.

1.1.- Paradigma de la programación.

Cuando utilizamos una computadora, lo que buscamos una solución a un problema. Pero ellas entienden lenguaje binario, y solo son capaces de sumar bits y mover bytes de un lugar a otro. Como programadores, debemos indicarle a la computadora que es lo que deseamos que ella realicé, y para ello nos vemos en la obligación de utilizar un lenguaje de programación. Éste es un lenguaje intermedio, que luego será traducido a binario, siendo una herramienta que nos permite dar órdenes a la computadora sobre como resolver un problema en particular.

La forma en que especifiquemos la solución depende del paradigma de programación que utilicemos. Los paradigmas son un modelo que representa un enfoque específico para el desarrollo de sistemas. No existe paradigma mejor que otro, hay situaciones en que uno resulta más adecuado, todos tienen ventajas y desventajas. El paradigma en que nos enfocaremos en esta ocasión es el de "Programación Orientada a Objetos" (POO).

1.1.1.- Propiedades y comportamiento de los objetos.

¿Qué es un objeto? La respuesta es simple, basta con mirar a nuestro alrededor para ver que estamos rodeados de objetos. Si observamos más detalladamente veremos que estos objetos tienen propiedades o atributos. Por ejemplo, el objeto auto tiene motor, ruedas y asientos. El objeto avión posee estas mismas propiedades, pero se diferencian en que el avión puede volar y el auto no. Vale decir, los objetos también tienen un comportamiento propio.

Entonces, un objeto es una entidad compleja que posee propiedades (datos, atributos) y comportamiento (funcionalidad, métodos). Además, cada objeto expone una interfaz a otros objetos que indica cómo éstos pueden interactuar (comunicarse) con él. Esta interfaz provee un conjunto de métodos. La interfaz del automóvil estará dada por los métodos "arranca", "frena", "dobla", etc., y es a través de ellos que podemos interactuar con el objeto (Figura 1).

Auto	Nombre del objeto
motor
ruedas	atributos
asientos
arranca()
frena()	métodos
dobla()

Figura 1. Representación del objeto Auto con sus atributos y métodos.

Cabe aclarar que el comportamiento es exclusivo del objeto. Si bien algunos objetos a simple vista son iguales, internamente pueden ser muy distintos. Por ejemplo, un automóvil cuyo motor utiliza bencina y otro diesel. Si aprendemos a manejar uno, sin problema podemos manejar el otro. Ambos objetos se nos presentan de la misma forma, pero sus motores son muy distintos. Es decir, los objetos presentan la misma interfaz pero ocultan información de su funcionamiento, esto se conoce como encapsulamiento, y gracias a él se puede cambiar un objeto por otro que presente la misma interfaz, y todo debería funcionar igual.

Cuando definimos un objeto lo hacemos en función de otros objetos conocidos. Si alguien nos dice "un auto es como una moto, pero tiene cuatro ruedas", nos define al automóvil a través de un objeto de similares características. Sin darnos cuenta hacemos clasificaciones. Generalizando, nos damos cuenta de que ambos son medios de transporte. En el paradigma de objetos esto es conocido como herencia, y es útil para no tener que definir comportamientos de forma repetitiva.

Por ejemplo, tendremos un objeto transporte, que tendrá propiedades como "cantidad de pasajeros", "numero de puertas", etc., y métodos como "anda", "frena" y "dobla". De esta manera definiríamos un automóvil como un transporte, agregando las particularidades del automóvil que no estén definidas en transporte.

Ahora que sabemos agrupar clases, podríamos agregar más objetos a nuestro modelo, como por ejemplo el objeto avión. Es decir, las clases simplemente son conjuntos de objetos que comparten propiedades y comportamientos. El objeto avión definido como un transporte heredará las propiedades y los métodos de éste. Notamos que no es lo mismo hacer andar un avión que un automóvil, de tal forma que necesitamos agregar el método anda para que el avión vuele y el automóvil ruede. Esto se denomina polimorfismo, y nos permite tener comportamientos distintos de un método para objetos diferentes.

Revisando el ejemplo del transporte, automóvil y avión notamos que existe una jerarquía, a la cabeza está transporte y de éste cuelgan el avión y el automóvil. En este paradigma esto se denomina jerarquía de herencia (figura 2).

Figura 2. Árbol de jerarquía de herencias. En este caso,

los objetos Avión y Automóvil heredan del objeto Transporte.

El automóvil, además de ser un objeto y un transporte, esta compuesto de por otros objetos, como un volante, radio, pedales, etc. Aquí nos encontramos frente a una jerarquía de elementos. Esta se conoce como jerarquía de composición y sirve para representar que uno o más objetos están dentro de otro (figura 3).

Figura 3. Árbol de jerarquía de composición. En este caso,

el Automóvil esta compuesto por los objetos Volante, Radio y Pedal.

Para finalizar, si tenemos un solo objeto automóvil, esto no significa que nuestro programa podrá tener un solo automóvil. Para entender esto debemos conocer el concepto de instancia, que nos permite crear la cantidad de automóviles que deseemos. Para lograr esto, cada objeto deberá tener un método que nos permita crear una instancia de éste.

Una clase no está limitada a comportarse sólo como lo define su padre, sino que además puede definir un comportamiento propio, es decir, se pueden agregar nuevos métodos en ella.

1.2.- Propuesta de un modelo de diseño.

Suponiendo el juego Gato, en donde dos participantes tienen fichas y por turno las ubican en un tablero de 3x3. Para resolver el problema lo primero que vamos a hacer es determinar los objetos.
A simple vista tenemos "Jugador", "Tablero" y "Ficha". Cada una de las fichas será una instancia de la clase ficha. El tablero tiene casilleros, así que agregamos "Casilla" a la lista de objetos. Por otra parte, el jugador puede ser "Humano" o la "Computadora", que también son agregados a la lista de objetos.

Una vez que estamos seguros de haber determinado todos los objetos debemos agregarle atributos y métodos a cada uno. Comenzando por Tablero, el atributo más importante que posee son las casillas. Entre sus métodos tenemos "ponerFicha()", y para verificar si hay ganador esta "buscarLinea()". Para el objeto Casilla tenemos el atributo dos atributos, su "coordenada" y el otro es el objeto Ficha. El objeto Jugador, que tiene varias instancias del objeto ficha. Y finalmente Humano tiene el atributo nombre y Computadora tiene el atributo inteligencia, lo que nos permite un juego con varios niveles.

Una vez determinado los atributos y métodos de los objetos, debemos determinar la jerarquía de herencia, en donde los objetos Computadora y Humano heredan del objeto Jugador. Para la jerarquía de composición tenemos que el Tablero esta compuesto de Casillas y el Jugador de Fichas.

Esto que se hizo es un modelo simplificado de representación. Una vez terminado ya estamos listos para escribir el código correspondiente.

Cuando modelamos tendemos a creer que nuestra representación es la más clara que existe, pero puede ser difícil de comprender para otros. Para evitar esto existen herramientas que ayudan al modelado de la programación orientada a objetos a través de estándares. Una de las más utilizadas es UML (Unified Modeling Language).

Esta herramienta provee de varias representaciones. Algunas son muy comunes, tanto que ya hemos utilizado varias de ellas. UML utiliza como herramientas los diagramas gráficos para representar el sistema. A continuación haremos una explicación del más útil para comprender la orientación a objetos.

1.2.1.- Diagrama de clases.

Los diagramas de clases representan un conjunto de elementos del modelo que son estáticos, como las clases y los tipos, sus contenidos y las relaciones que se establecen entre ellos (Figura 4).

Jugador		Tablero
Ficha1		Casilla
Ficha2
...
FichaN
elegirCasilla()		ponerFicha()
		buscarLinea()

Figura 4. Diagrama de clases del Gato.

2.- Introducción a java.

2.1.- Características de java.

Las principales características de java respecto a otros lenguajes de programación son las siguientes:

· Simple: Java ofrece toda la funcionalidad de un lenguaje potente, y a la vez elimina las cosas más confusas y menos usadas de otros lenguajes. Además implementa el garbage collector (recolector de basura), gracias al cual el programador no debe asegurar el correcto uso de memoria, como en C++.

· Orientado a objetos: Fue diseñado como un lenguaje orientado a objetos desde el principio, a diferencia de C++, que fue una extensión de C. En java, cada objeto se agrupa en estructuras encapsuladas con sus datos y métodos que manipulan esos datos.

· Distribuido: Java proporciona una colección de clases para uso en aplicaciones de red, que permite abrir sockets y establecer y aceptar conexiones con servidores o clientes remotos. Lo que facilita la creación de aplicaciones distribuidas.

· Interpretado y compilado a la vez: Java es compilado ya que su código fuente se transforma en una suerte de código de máquina (bytecodes) semejantes a instrucciones en Assembler. Es interpretado ya que dichos bytecodes se pueden ejecutar directamente en cualquier máquina en que se haya instalado el intérprete.

· Robusto: Java fue diseñado para crear sistemas fiables. Para ellos proporciona muchas comprobaciones en compilación y en tiempo de ejecución.

· Seguro: Ya que por naturaleza es distribuido, la seguridad es vital. Implementa barreras de seguridad en el lenguaje y en el sistema de ejecución en tiempo real.

· Multiplataforma: Como esta diseñado para soportar aplicaciones distribuidas, y considerando lo heterogéneo de las redes, como Internet, necesitaba ser independiente de la plataforma. Den esta manera una aplicación se puede ejecutar desde un PC a un celular.

· Multitarea: Soporta sincronización de múltiples hilos de ejecución (multithreading) a nivel de lenguaje.

· Dinámico: El lenguaje y su sistema de ejecución en tiempo real son dinámicos en la fase de enlazado. Las clases sólo se enlazan a medida que son necesitadas. Además se pueden enlazar nuevos módulos de código bajo demanda, procedentes incluso desde la Red.

2.2.- Compilación y ejecución de programas.

Antes de comenzar deberos conseguir una distribución de Java de Sun Microsystems en su versión para desarrolladores. Podemos descargarla de www.java.sun.com. De acuerdo a nuestras necesidades debemos elegir una distribución particular. Las más populares son:

· J2SE (Java 2 Platform Standard Edition): La edición estándar provee un entorno para desarrollo de aplicaciones de escritorio y applets. Esta distribución se divide en dos categorías: Core Java y Desktop Java.

· J2EE (Java 2 Platform Enterprise Edition): Es la más difundida en el mercado empresarial, ya que define los estándares para desarrollar soportando todas las posibilidades de Java. Además posee herramientas para el desarrollo de servicios Web.

· J2ME (Java 2 Platform Micro Edition): Sirve para el desarrollo donde el soporte en el cual va a residir la aplicación sea reducido en cuanto a sus capacidades de almacenamiento. Es ideal para desarrollar aplicaciones para teléfonos celulares y PDAs.

Una vez elegida la distribución debemos tener en cuenta que existen dos versiones.

· SDK (Standard Development Kit): Provee de herramientas de desarrollo estándar.

· JRE (Java Runtime Environment): Provee el entorno de ejecución de Java.

Lo ideal es tener ambas versiones, SDK para programar, compilar y probar, y JRE para instalar en el PC donde se ejecutará la aplicación.

En nuestro caso utilizaremos la distribución J2SE. Además podemos elegir un IDE (Integrated Development Environment) que nos facilite el trabajo de compilación y ejecutar desde la línea de comando. Utilizaremos Eclipse, y puede ser bajado desde la página www.eclipse.org.

Una vez instalado el lenguaje Java podemos ver que en la carpeta principal, en el subdirectorio llamado bin, encontraremos, entre otros, los siguientes ejecutables de Java:

· java.exe: es el lanzador de aplicaciones de Java.

· javaw.exe: es el lanzador gráfico de aplicaciones.

· javac.exe: es el compilador de Java.

2.2.1.- Compilador de Java.

Una de las características del compilador Java es que junta su código en un archivo objeto de formato independiente sin que sea primordial la arquitectura de la máquina en que se ejecutará. Cualquier máquina que tenga el sistema de ejecución (run time) puede ejecutar ese código objeto, sin importar que la máquina en que ha sido generado (figura 1). Actualmente existen sistemas run time para Solaris, SunOs, Windows, Linux, Iris, Aix, Mac y Apple.

Figura 1. Ambiente de ejecución de Java.

2.3.- Nuestro primer programa Java.

Ahora que sabemos como compilar y ejecutar programas, realizaremos nuestro primer programa:

public class HolaMundo

{

public static void main(String argv[])

{

System.out.println("Hola mundo!!");

}

La salida del programa será:

Hola mundo!!

Ahora analicemos la estructura del programa. El nombre del objeto esta determinado por public class HolaMundo, mientras que el método principal esta dado por public static void main(String argv[]), a través del cual se lanzaran todas las aplicaciones, y cada aplicación ejecutará un solo main por cada ejecución.

Las llaves determinan los bloques de ejecución, y más adelante veremos que también determinarán el alcance de las variables. El punto y coma es el separador de instrucciones, es decir, maraca el fin de una instrucción y el comienzo de la otra. También podemos notar que no todas las líneas comienzas desde el margen izquierdo, esto es conocido como identación, y es útil al el programador para leer mas fácilmente el código, ya que determina los bloques de ejecución con mayor claridad.

2.3.1.- Programar comentarios.

Los comentarios nos sirven de guía, o para que otro programador vea nuestro código y lo entienda rápidamente. Existen, entre otros, los siguientes tipos:

· Comentario simple: se usa para hacer alguna anotación rápida sobe la línea de código siguiente o anterior, El modo de uso es el siguiente:

// Esto es un comentario simple

Si queremos escribir varias líneas utilizando este tipo de comentario debemos colocar la doble barra al comienzo de cada línea.

// Para hacer un comentario simple de varias líneas

// debemos anteponer doble barra a cada una de las líneas

· Comentario de varias líneas: se usa para escribir aclaraciones de más de una línea. Se utiliza de la siguiente manera:

Este es un comentario

de varias líneas

De todos modos se puede usar para comentarios de una línea:

/* Esto es un comentario de una línea */

2.3.2.- Variables y constantes.

Las variables son utilizadas para almacenar datos, y como su nombre lo indica, cambian a lo largo de la ejecución del programa. Cuando termina un bloque de ejecución, las variables declaradas en él mueren.

Cada variable posee un tipo de dato asociado, que determina el espacio utilizado, los valores que puede almacenar y las operaciones que se pueden realizar con ellos. Las constantes tienen el mismo concepto, sólo que no varían durante la ejecución del programa. Los tipos de datos primitivos soportados son:

Tipo de datos	Tamaño	Valores que puede tomar
Boolean	1 byte	true o flase
Char	2 bytes	Cualquier carácter ASCII
Byte	1 byte	Entero entre -128 y 127
Short	2 bytes	Entero entre -32.768 y 32.767
Int	4 bytes	Entero entre -2.147.483.648 y 2.147.483.647
Long	8 bytes	Entero entre -9.223.372.036.854.775.808 y 9.223.372.036.854.775.807
Float	4 bytes	Decimal de -3.402823E38 y -1.401298E-45 y de 1.401298E-45 a 3.402823E38
Duble	8 bytes	Decimal de -1.79769313486232E308 a -4.94065645841247E-324 y de 4.94065645841247E-324 a 1.79769313486232E308

Tabla 1. Tipos de datos primitivos.

Además Java provee un conjunto de datos secundarios, llamados así porque son datos compuestos. Estos datos son:

· String (compuesto por una serie de char).

· Array (compuesto por una serie de cualquier tipo de dato primitivo).

Antes de utilizar una variable debemos declararla. Veamos un ejemplo:

public class Declaracion

{

public static void main(String argv[])

{

// Declaramos i de tipo long

long i;

// Declaramos j de tipo entero y la inicializamos en 0

int j = 0;

}

Ahora que ya hemos declarado variables podemos utilizarlas. A continuación veremos un ejemplo, en donde además se informa el resultado por pantalla.

public class Prueba

{

public static void main(String argv[])

{

// Declaramos j de tipo entero y la inicializamos en 0

int j = 0;

// Sumamos 1 a i

i = i + 1;

// Imprimimos en pantalla

System.out.println("El valor de i es" + i);

}

2.3.2.1.- Variables Finales.

No se pueden declarar constantes como const, esta es una palabra que fue reservada para uso futuro. Si queremos declarar una constante debemos declarar una variable final de la siguiente forma:

final float a = 4.0f;

De esta forma la variable no puede ser modificada durante la ejecución del programa. De tener una línea de código que intenta modificar dicha variable se producirá un error en tiempo de compilación.

2.3.2.2.- Nombres de variables.

Las variables pueden tomar cualquier nombre, sin embargo hay una serie de palabras reservadas que no se pueden utilizar como identificadores. El conjunto de palabras reservadas puede clasificarse según el tipo de instrucción.

· Tipos de datos y retorno: boolean, byte, short, long, void, char, double, float, int, return, strictfp.

· Paquetes y clases: class, super, final, extends, interface, native, static, volatile, import, new, instanceof, abstracts, implements, synchronized, this, transient.

· Modificadores de acceso: public, private, protected, package.

· Ciclos y condiciones: if, switch, break, for, while, else, case, default, do, continue.

· Manejo de excepciones: throws, try, finally, throw, catch.

· Reservadas para uso futuro: goto, assert, const.

Por convención, los nombres de las variables empieza con minúscula, y en caso de que éste se encuentre compuesto de varias palabras, las restantes comenzarán con mayúscula. Por ejemplo, un nombre de variable puede ser fechaDeNacimiento. El guión bajo es aceptable en caso de constantes.

2.3.2.3.- Alcance de una variable.

Para entender el alcance de una variable, también llamado scope, primero debemos definir lo que son las variables globales y las variables locales. La primera puede ser usada en todo el programa, mientras que la segunda solo puede utilizarse dentro del bloque en que fue definida. La diferencia entre ambos tipos es precisamente el alcance. Veamos un ejemplo del alcance de las variables:

public class AlcanceVariable

{

static int j = 0;

public static void main(String argv[])

{

// Definimos un bloque de ejecución abriendo llaves

{

int a = 0;

a = a + 1;

}

// Se cierra el primer bloque y se crea un segundo bloque

{

int c = 2;

c = c + j;

c = c + a; // Instrucción inválida, a no existe en este bloque

}

// Se cierra el segundo bloque de ejecución

}

En este ejemplo la variable j es global a la clase, esto nos indica que en todo el programa se puede acceder a ella. La variable a es local al primer bloque de ejecución, cuando este bloque es ejecutado por completo la variable a deja de existir. En el segundo bloque, se puede sumar c con j, ya que c es local al bloque y j es global a la clase. La tercera instrucción de dicho bloque es invalida, ya que la variable a murió cuando terminó el primer bloque de ejecución.

2.4.- Operadores Java.

Los operadores pueden dividirse en siete grupos, a continuación podemos ver una tabla con los operadores de cada grupo:

· Operadores básicos:

Operador	Opera Sobre	Descripción
.	Objetos, datos miembro	Accede a miembros del objeto
(<Tipo>)	Tipos de datos	Convierte a un tipo de dato
instanceof	Objetos	Provee información sobre la instancia

Tabla 2. Tabla de operadores básicos.

· Operadores aritméticos:

Operador	Descripción
++/--	Incrementa o decrementa en uno la variable a la que se le ponga como sufijo (ej.: i++) o prefijo (ej.: ++i)
+/-	Invierte el signo de una variable
*	Multiplicación
/	División
%	Resto de la división
+/-	Suma/Resta

Tabla 3. Tabla de operadores aritméticos.

· Operadores lógicos:

Operador	Descripción
¡	Invierte el valor de un bolean
&	Operador AND (Y lógico) a nivel de bits
^	XOR a nivel de bits
\|	Operador OR (O lógico) a nivel de bits
&&	Operador AND condicional
\|\|	Operador OR condicional

Tabla 4. Tabla de operadores lógicos.

· Operadores de asignación:

Operador	Descripción	Ejemplo	Equivalencia
=	Asignación simple de derecha a izquierda	a=b+c
+=	Evalúa a la derecha y suma a la izquierda	a+=b	a=a+b
-=	Evalúa a la derecha y resta a la izquierda	a-=b	a=a-b
*=	Evalúa a la derecha y multiplica a la izquierda	a*=b	a=a*b
/=	Evalúa a la derecha y divide a la izquierda	a/=b	a=a/b

Tabla 5. Tabla de operadores de asignación.

· Operadores de comparación:

Operador	Descripción
<	Menor a
>	Mayor a
<=	Menor o igual a
>=	Mayor o igual a
==	Igual a
!=	Distinto a

Tabla 6. Tabla de operadores de comparación.

· Operadores de nivel de bits:

Operador	Descripción
~	NOT
<<	Traslado a izquierda
>>	Traslado a derecha
>>>	Traslado a derecha y complementa con ceros a la izquierda
&	AND
!	OR
^	XOR
<<=	Traslado a izquierda con asignación
>>=	Traslado a derecha con asignación
>>>=	Traslado a derecha y complementa con ceros a la izquierda con asignación

Tabla 7. Tabla de operadores de nivel de bits.

· Operador ternario:

Operador	Descripción
(expresión 1)?(expresión 2):expresión 3;	Evalúa la expresión 1, si es verdadera ejecuta la expresión 2, de lo contrario ejecuta la expresión 3

Tabla 8. Tabla de operador ternario.

El operador instanceof permite saber si un objeto pertenece o no a una clase determinada. Es un operador binario y se utiliza de la siguiente manera:

NombreDeLaInstancia instanceof NombreDeLaClase

Devuelve true si el objeto pertenece a la clase y false en caso contrario.

2.4.1.- Precedencia de operadores en Java.

La precedencia determina en qué orden se van a resolver las operaciones. La siguiente tabla nos muestra la precedencia de operadores en Java.

Orden	Operación
1	[] ()
2	++ -- ! - instanceof
3	new (type) expresión
4
5	* / %
6	+ -
7	<< >> >>>
8	< > <= >=
9	&
10	^
11	!
12	&&
13	!!
14	? :
15	= += -= *= /= %= ^=
16	&= != <<= >>= >>>=

Tabla 9. Precedencia de operadores en Java.

2.5.- Expresiones y sentencias.

Una expresión es un conjunto de variables unidas por operadores. Una expresión que termina en punto y coma es una sentencia. En una línea pueden ser incluidas varias sentencias, aunque es recomendable utilizar una línea para cada sentencia, ya que facilita la lectura y la comprensión del programa.

2.6.- Sentencias de control de flujo.

Estas sentencias o instrucciones, como su nombre lo indica, son utilizadas para controlar el flujo del programa, es decir, qué instrucción deberá ejecutar a continuación nuestro programa. A menudo requerimos que no se ejecuten una detrás de la otra, sino que el programa decida un camino en particular. A continuación vamos a ver las sentencias de control de flujo.

2.6.1.- if-else.

Esta sentencia significa "si – si no", si sucede algo hace una cosa, si no, hace otra. Es utilizada para generar bifurcaciones o saltos. Su sintaxis es:

if(condición)

{

/* Instrucciones que se ejecutarán

si la condición se cumple*/

}

else

{

/* Instrucciones que se ejecutarán

Si la condición no se cumple*/

}

Cuando se cumple una condición se dice que es verdadera, y se representa con true, si no, es falsa, y es representada por false.

En algunas ocasiones necesitamos que el programa haga algo si se cumple la condición, pero si no se cumple, queremos que no haga nada, esto quiere decir que no necesitamos el else. Aunque también podemos tener varias bifurcaciones condicionales del tipo if-else if. Veamos un ejemplo en donde apreciemos las distintas formas de utilizar la sentencia if-else:

public class pruebaIfElse

{

public static void main(String argv[])

{

int i = 2;

if(i == 1)

System.out.println("La variables es uno");

else

System.out.println("La variables es distinta de uno");

i = i + 2;

if(i == 3)

System.out.println("La variables es tres");

else if (i == 4)

System.out.println("La variables es cuatro");

else

System.out.println("La variables no tomó ningún valor esperado");

i = i – 3;

if(i > 0)

System.out.println("La variables es positiva, y es: " + i);

}

Si analizamos el programa, vemos que declaramos la variable i, y es inicializada en 2, a continuación verificamos si es igual a 1, ya que esta condición es false, el programa ejecuta el bloque del else, así se obtiene la siguiente salida:

La variable es distinta de uno

Luego sumamos 2 a i, quedando en 4, y preguntamos si es igual a 3, como esto es false, continuamos con el siguiente bloque, preguntando si i es igual a 4, ya que esta condición es true se genera la siguiente salida:

La variable es cuatro

Por ultimo, restamos 3 a la variable i, quedando en 1, luego verificamos si i es mayor que 0, lo que es true, obteniendo la salida:

La variable es positiva, y es: 1

2.6.2.- switch.

La sentencia switch se utiliza cuando una variable puede tomar distintos valores, y dependiendo de cual tome el programa seguirá un camino diferente. Su sintaxis es la siguiente:

switch(variable)

{

case valor1: // instrucciones para valor 1

case valor2: // instrucciones para valor 2

...

case valorN: // instrucciones para valor N

default: // instrucciones por defecto

}

La palabra reservada case define los posibles caminos según el valor de la variable. Al final encontramos la instrucción default, y este bloque será ejecutado si la variable no toma ninguno de los valores contemplados. Esta instrucción es opcional, ya que si deseamos que el programa no haga nada en caso de que la variable tome un valor distinto a los contemplados, simplemente la omitimos. La sentencia switch puede analizar variables del tipo char, byte, short o int, o expresiones que devuelvan resultados de los tipos mencionados.

Además, esta sentencia ejecutará el caso que cumpla con la condición, y todos los que siguen hasta el final. Si deseamos que ejecute de forma excluyente el caso que cumpla con el valor de la variable, debemos agregar al final de cada bloque la instrucción de corte break. Para el caso default no es necesario agregar break, ya que es el último caso, y de ejecutarse, no habrán casos posteriores.

Ahora veremos un ejemplo:

public class pruebaSwitch

{

public static void main(String argv[])

{

int i = 2;

swith(i)

{

case 1: System.out.println("primer caso");

break;

case 2: System.out.println("segundo caso");

case 3: System.out.println("tercer caso");

default: System.out.println("otro caso");

}

La salida que produce el programa será:

segundo caso

tercer caso

otro caso

En el ejemplo i toma el valor 2, de tal modo que el caso está contemplado en la segunda instrucción del switch, es decir, en case 2. Se ejecuta el caso que cumple la condición, pero como este no posee break, también ejecuta las instrucciones siguientes, hasta el final. Pero si modificamos el programa para que i tome el valor 1, la salida seria:

Primer caso

Ya que luego de ejecutarse la instrucción correspondiente a case 1, se ejecuta la instrucción de corte, por lo que no se ejecutan los bloques siguientes.

2.7.- Sentencias de bucle.

En un programa, cada sentencia es ejecutada una sola vez. Sin embrago, algunas veces necesitamos ejecutar varias veces una instrucción o un conjunto de instrucciones. El número de veces que deberá ser ejecutada dicha instrucción está dado por una condición.

Cuando usamos ciclos condicionales debemos asegurarnos que el corte de control se cumpla, de lo contrario el programa se quedará atrapado en el ciclo y no terminará nunca.

2.7.1- while y do-while.

En un ciclo while ejecuta un bloque mientras sea verdadera una condición. Su sintaxis es la siguiente:

while(condición)

{

/* bloque que se ejecutará mientras

la condición sea verdadera*/

}

Supongamos que deseamos mostrar por pantalla los números impares menores que 10. El código de dicho programa sería:

public class pruebaWhile

{

public static void main(String argv[])

{

int i = 1;

while(i<10)

{

System.out.println(i);

i = i + 2;

}

System.out.println("no hay mas números impares");

}

La salida del programa seria:

no hay mas números impares

El programa ejecutó el bloque cinco veces. Cada una de las ejecuciones es conocida como iteración. En el comienzo, i toma el valor 1, por lo que la condición del while es true, entonces ejecuta el bloque, imprime 1, y luego suma 2 a la variable, quedando en 3. Cuando termina el bloque vuelve a revisar la condición del while, que nuevamente es verdadera, ejecutando el bloque una vez más. Así sucesivamente. Cuando i toma el valor 11, se vuelve a verificar la condición del while, pero esta vez es false, por lo que termina el while, saliendo del bloque de iteración, y continúa ejecutando el resto del programa.

En algunos casos necesitamos que el bloque de iteración sea ejecutado por lo menos una vez, para luego verificar la condición, si ésta es true ejecuta nuevamente el bloque, de lo contrario el ciclo es terminado. Para ello existe la sentencia llamada do-while, con la siguiente sintaxis:

{

/* bloque que se ejecutará mientras

la condición sea verdadera*/

}

while(condición)

2.7.2.- for.

Esta sentencia es útil cuando deseamos realizar un número determinado de iteraciones. Se utiliza de la siguiente forma:

for(inicio; condición; iteración)

{

/* bloque de ejecución*/

}

Por ejemplo, si necesitamos imprimir los números entre 0 y 5 debemos realizar 6 iteraciones, desde el 0 al 5, y debemos saltar de uno en uno. El código será éste:

public class pruebaFor

{

public static void main(String argv[])

{

int i;

for(i = 0; i<6; i++)

{

System.out.println(i);

}

La salida generada es:

Esta sentencia funciona así. Primero inicializa la variable i en 0, esta parte se ejecuta una sola vez. Luego verifica la condición, como es true ejecuta el bloque de iteración. Una vez terminado dicho bloque, ejecuta la tercera parte del for, incrementando i en 1. Ahora vuelve a corroborar la condición, volviendo a ejecutar el bloque, ya que sigue siendo true. Así sucesivamente, hasta que adquiere el valor 6, dado que 6 no es menor que 6, el ciclo se da por terminado.

La decisión de utilizar for o while dependerá exclusivamente del programador, ya que en cualquier caso se puede usar ambas sentencias para resolver el mismo problema. Aunque es recomendable utilizar for, ya que el código resulta más simple para su lectura. Para el ejemplo anterior, el código del programa utilizando while es el siguiente:

public class pruebaWhileFor

{

public static void main(String argv[])

{

int i = 0;

while(i<6)

{

System.out.println(i);

i++;

}

2.8.- Clase System.

A lo largo de este texto hemos utilizado la clase System para imprimir valores por pantalla, pero esta clase representa varios recursos del sistema, y nos permite acceder a ellos independientemente del sistema operativo que estemos usando. Esta clase no se puede inicializar, y todas sus variables y métodos están declarados como static, y en todo momento sólo existirá una instancia de dicha clase en el sistema. Para utilizar sus variables y métodos sólo debemos invocarlos. Por ejemplo, para utilizar la variable out lo hacemos así:

System.out

De la misma forma procedemos para utilizar println de la instancia out:

System.out.println("Hola mundo!! ");

Esto es conocido como Standard I/O, por input/output, en español entrada/salida.

· System.in: entrada estándar (Standard input). Se utiliza para leer una entrada de datos del usuario.

· System.out: salida estándar (Standard output). Se usa para mostrar información al usuario.

· System.err: error estándar (Standard error). Se utiliza para mostrar mensajes de error al usuario.

Otro método útil de la clase System es getProperty(), el cual no entrega información valiosa acerca del sistema. Por ejemplo, con la siguiente línea obtenemos el nombre de usuario del sistema:

System.getProperty("user.name");

En la siguiente tabla vemos todas las propiedades que podemos entregarle como parámetro a este método, y que obtenemos con ello:

Propiedad	Descripción
"file.separator"	Separador de archivos
"java.class.path"	Classpath de Java
"java.class.version"	Versión del árbol de clases de Java
"java.home"	Directorio de instalación de Java
"java.vendor"	Nombre del distribuidor de Java
"java.vendor.url"	Dirección de Internet del distribuidor de Java
"java.version"	Versión de Java
"line.separator"	Separador de línea
"os.arch"	Arquitectura del sistema operativo
"os.name"	Nombre del sistema operativo
"os.version"	Versión del sistema operativo
"path.separatoe"	Separador de caminos
"user.dir"	Directorio actual de trabajo
"user.home"	Directorio Home del usuario
"user.name"	Nombre del usuario

Tabla 10. Lista de propiedades del método getProperty().

A través de System, también podemos forzar la ejecución del recolector de basura. Para realizar este procedimiento sólo hay que ejecutar la siguiente instrucción:

System.gc()

2.9.- Secuencias de escape.

Los lenguajes poseen caracteres especiales conocidos como caracteres de escape. Una serie de estos caracteres es conocida como secuencia de escape. Cuando en una línea de texto aparece uno de estos caracteres, el compilador sabe que debe se trata de un carácter de escape, y qué por lo tanto debe tratarlo de forma especial. Sabemos que una línea de texto debe estar entre comillas. Por ejemplo, la siguiente sentencia:

System.out.println("Esto es una línea de texto");

Imprime por pantalla:

Esto es una línea de texto

Si deseamos que la palabra línea se imprima entre comillas, y lo hacemos de la siguiente manera:

System.out.println("Esto es una "línea " de texto ");

El compilador arrojará un error, porque interpreta el mensaje como "Esto es una " y el resto no lo entiende. Entonces, la forma correcta de hacerlo es usando caracteres de escape:

System.out.println("Esto es una \"línea\" de texto");

Ahora, cuando el compilador encuentre el carácter \, sabrá que se trata de un carácter especial y sabrá cómo manejarlo. Esta sentencia nos produce la siguiente salida por pantalla:

Esto es una "línea" de texto

A continuación se muestran los caracteres de escape posibles y su uso.

Carácter	Secuencia de escape
Contra barra	\\
Backspace	\b
Retorno de carro	\r
Comilla doble	\"
Form feed	\f
Tab horizontal	\t
Nueva línea	\n
Carácter octal	\DDD
Comilla simple	\’
Carácter unicode	\uHHHH

Tabla 11. Secuencias de escape.

3.- Clases.

3.1.- Árbol de clases.

Como lenguaje orientado a objetos puro, en Java todo es una clase o forma parte de una. Lo más tedioso para los programadores que ya tienen alguna experiencia con otros lenguajes es, quizás, conocer todas las clases del árbol de Java, pero una vez entendido cómo está construido dicho árbol, es mucho más fácil incorporar nuevas clases ya implementadas a nuestra aplicación.

Entonces, cualquier aplicación de Java se entiende como una extensión del árbol de clases. A diferencia de C++, no se pueden declarar métodos o variables globales, se pueden simular a través de la sentencia static. La única sentencia que se puede usar fuera de una clase es import, pero el compilador reemplaza la sentencia con el contenido del archivo que se indique.

3.1.1.- Tipos de clases.

Si nos fijamos en los ejemplos que hemos desarrollado, notamos que todas las clases fueron definidas como public. Sin embargo, existen 4 modificadores para definir el tipo de clase:

· public: son las que más libertades poseen, ya que se puede acceder directamente ellas desde otras clases, o por medio de herencia. También son accesibles dentro del mismo paquete en que se han declarado, o desde otros paquetes a través de import.

· abstract: una clase de este tipo tiene al menos un método abstracto. Este tipo de clase no se instancia, sino que se utiliza como clase base para la herencia.

· final: es una clase que termina una herencia. Se puede ver como una hoja del árbol de clases. Desde este tipo de clases no se puede heredar.

· synshronizable: este modificador especifica que todos los métodos definidos en ella son sincronizados, es decir, que no se puede acceder al mismo tiempo.

3.2.- Declarar, inicializar y usar un objeto.

Cuando creamos una instancia de un objeto, debemos hacerlo a través de un constructor. El constructor pertenece al objeto, y lo que hace es tomar todos los recursos necesarios para que el objeto funcione correctamente, y devuelve la instancia del objeto. Entonces, cuando utilizamos la sentencia new, lo que estamos haciendo es llamar al constructor del objeto.

Para declarar un objeto se utiliza una sintaxis similar a la usada para declarar variables, es decir:

NombreDelObjeto nombreDeLaVariable = new NombreDelObjeto();

La sentencia new sirve para indicar que queremos una nueva instancia del objeto, y debemos tener en cuenta que este operador nos devuelve una referencia a un objeto, y que esta referencia debe ser asignada a una variable que pueda referenciar dicho objeto.

Si deseamos crear un objeto de la clase Character, tenemos que saber que su constructor es parametizado, y el parámetro que recibe es del tipo char. Para crear una instancia de Character de nombre c, e inicializada con el parámetro a debemos ejecutar la siguiente sentencia:

Character c = new Character('a');

Utilizando el método "charValue() de la clase Character podemos ordenarle al objeto que devuelva el valor con que fue instanciado. Para el ejemplo anterior, se envía un mensaje a la instancia c por medio del método charValue(), obteniendo el char a. El comando para hacer esto es:

c.charValue()

3.3.- Referenciar variables de un objeto.
En ocasiones, las variables y métodos que están dentro de un objeto don públicas, es decir, que no están encapsuladas. En estos casos las podemos referenciar, sin la necesidad de crear un objeto, desde cualquier parte de nuestra aplicación. Para ejemplificar esto, veamos las variables "MAX_VALUE" y "MIN_VALUE" de la clase Integer.

class PruebaInteger

{

public PruebaInteger()

{

}

public static void main(String argv[])

{

// Se muestran las variables públicas de la clase Integer

System.out.println("Máximo entero: " +Integer.MAX_VALUE);

System.out.println("Mínimo entero: " +Integer.MIN_VALUE);

}

La salida de este programa será:

Máximo entero: 2147483647

Mínimo entero: -2147483648

No confundamos el objeto Integer con el tipo de datos primitivo int. En este caso, Integer es la clase que representa al tipo de dato int, y provee métodos para el manejo de este tipo de dato. En Java todos los tipos de datos primitivos están representados por un objeto. Tenemos el objeto Long para long, Character para char, Double para double, etc.

Dado que "MAX_VALUE" y "MIN_VALUE" son variables públicas de la clase Integer, podemos referencialas directamente, sin una instancia. Por otra parte, para respetar un estándar, cuando declaremos variables de este tipo lo haremos siempre en mayúsculas.

En Java existen cuatro niveles de acceso, y todos son válidos para métodos y variables. Los niveles de acceso son los siguientes:

· public: se puede acceder a las variables y métodos de instancia publica desde cualquier lugar.

· protected: sólo las subclases de la clase pueden acceder a las variables y métodos de instancia protegidos.

· private: Las variables y métodos de instancia privados sólo son accesibles desde dentro de la clase. No son accesibles desde las subclases.

· friendly: si no se especifica el control de acceso, las variables y métodos de instancia se declaran automáticamente como friendly (amigables). El concepto es el mismo que para protected.

3.3.1.- Sentencia static.

En algunos casos vamos a necesitar que una variable no cambie de valor para ninguna instancia de la clase, es decir, que exista una única copia de la variable de instancia. Para esto se utiliza la sentencia static. Sirve tanto para variables como métodos. Pero un método declarado como static no podrá acceder a ninguna variable de la clase, ésta es una regla de acceso. Por lo tanto, los métodos estáticos sólo pueden modificar variables estáticas o variables locales.

Figura 1. Ejemplo de referencia de varios objetos a una

variable static. A1, A2 y A3 son instancias de A.

3.4.- Nuestro primer objeto Java.

A continuación crearemos la clase "empleado", que nos sirve para mantener la información de los empleados de una compañía.

public class Empleado

{

// Los datos miembros son declarados como privados

private int legajo;

private String nombre;

private float sueldo;

// Variable pública y estática que almacena el sueldo base de los empleados

public static flota SUELDO_BASE = 150f;

// En el constructor por defecto vamos a inicializar las variables

public Empleado()

{

this.legajo = 0;

this.nombre = new String();

this.sueldo = 0.0f;

}

/* En el constructor parametrizado inicializaremos las

variables con los parámetros correspondientes */

public Empleado(int legajo, String nombre, float sueldo)

{

this.legajo = legajo;

this.nombre = nombre;

this.sueldo = sueldo;

}

// El método getSueldo nos va a devolver el sueldo del empleado

public flota getSueldo

{

return(this.sueldo);

}

public static void main(String argv[])

{

/* Se inicializan dos empleados, uno por medio de el constructor

parametrizado y el otro utilizando el constructor por defecto */

Empleado emp1 = new Empleado();

Empleado emp2 = new Empleado(20, "Pablo", 700f);

//Mostraremos los sueldos de emp1 y emp2, además el sueldo base

System.out.println("Sueldo de empleado 1: " +emp1.getSueldo());

System.out.println("Sueldo de empleado 2: " +emp2.getSueldo());

System.out.println("Sueldo base: " +emp1.SUELDO_BASE);

}

La salida por pantalla que este programa genera es:

Sueldo de empleado 1: 0.0

Sueldo de empleado 2: 700.0

Sueldo base: 150.0

Podemos notar que a lo largo de este ejemplo se utilizó la palabra reservada this. Ésta se utiliza cuando se desea hacer referencia a una variable o a un método que es propio de la clase. Por ejemplo, en el constructor parametrizado, vemos que a "this.nombre", la variable nombre de la clase, le asigna "nombre", el nombre recibido como parámetro.

3.5.- Eliminar objetos Java.

En el ejemplo anterior, cuando termina el bloque de ejecución del main, mueren las instancias emp1 y emp2. No debemos preocuparnos de eliminar los objetos, ya que el Garbage Collector (recolector de basura) se encargará de eliminar de la memoria los objetos que ya no estén referenciados por nadie.

El Garbage Collector llamará al método finalize() de cada objeto que encuentre sin referencia. La función de este método es destruir un objeto por orden del Garbage Colector. Como en Java todas las clases heredan de Object, y ésta tiene el método finalize() implementado. En otras palabras, todos los objetos que componen Java tienen un método finalize().

3.6.- Interfaces.

Las interfaces son definiciones de clases abstractas. Éstas pueden contener métodos, pero todos ellos deben ser abstractos. Para los atributos, todos deben ser declarados como static final, o sea, constantes. Ahora veamos un ejemplo:

public interface Circulo

{

public void dibujar();

public double getRadio();

public double getDiametro();

}

Ahora, toda clase que implemente círculo deberá definir los tres métodos obligatorios. Veamos un ejemplo en donde implementemos la interfaz.

public class CirculoImplementado implements Circulo

{

double radio;

public CirculoImplementado(double r)

{

this.radio = r;

}

public void dibujar()

{

// Puedo declarar el método y no agregarle código

}

public double getRadio()

{

return(this.radio);

}

public double getDiametro()

{

return(2*this.radio);

}

Note que aparece la palabra reservada implements, y es a través de ella que declaramos que vamos a implementar la interfaz Circulo.

3.6.1.- Clases anónimas.

Una clase anónima es aquella que esta definida e instanciada en el mismo punto. Llevan ese nombre ya que dichas clases no tienen nombre de clase, y por lo tanto no pueden tener constructor y sólo puede existir una instancia de la clase.

Veamos el ejemplo de la interfaz Circulo, ahora vamos a declararla como anónima:

public class CirculoAnonimo

{

public CirculoAnonimo(double r)

{

// Declaro la clase anónima

new Circulo()

{

double radio;

public void dibujar()

{

}

public double getRadio()

{

return(this.radio);

}

public double getDiametro()

{

return(2*this.radio);

}

};

}

Se recomienda usar las clases anónimas solamente cuanto éstas tengas a lo más un atributo y dos métodos. Siempre que sea posible, debemos evitar el uso de clases anónimas.

4.- Paquetes.

4.1.- La sentencia import.

Como ya hemos visto, la sentencia import sirve para importar clases o conjuntos de clases (paquetes) desde el árbol de clases. Debemos recordar que las clases que fueron declaradas como public dentro del paquete son las únicas que se pueden importar.

Lo mas difícil de recordar, cuando se aprende Java, es donde se encuentra cada clase, es decir, el árbol de clases. Debemos tener en cuenta que los paquetes, además de contener clases, podrían tener otros paquetes. Se puede hacer una analogía entre los paquetes y los directorios y subdirectorios por un lado, y los archivos y las clases por otro, ya que la organización utilizada para mantener el árbol de clases es la misma.

Por otra parte, debemos tener en cuenta que existe un conjunto de paquetes generales que contienen a otros paquetes y clases agrupados según su función, es decir, que no es necesario conocer todo el árbol de clases para comenzar a programar, sino que iremos incorporando nuevos paquetes y clases a medida que vayamos aprendiendo el lenguaje.

import java.until.Vector;

Esto nos indica que dentro del paquete java se encuentra un paquete llamado until, y es dentro de el que está la clase Vector. Ahora, si necesitamos la clase LinkedList, que también se encuentra dentro de until, debemos agregar el siguiente import:

import java.until.Vector;

import java.until.LinkedList;

Ahora, si deseamos importar todas las clases publicas que se encuentran dentro del paquete until, debemos hacerlo así:

import java.until.*;

Al usar import debemos tener en cuenta que al final de una sentencia debe haber una clase publica o un asterisco que haga referencia al menos a una clase. Por lo tanto la ésta sentencia es incorrecta:

import java.until; // until es un paquete y no una clase

4.2.- Archivos JAR.

Luego de desarrollar nuestras aplicaciones, necesitamos distribuirlas de forma práctica y sencilla. Esto lo logramos a través de los archivos JAR, que pueden contener un conjunto de paquetes y clases, de tal forma que, agregando el archivo a nuestro proyecto extendemos el árbol de clases. Todas las clases que contenga el archivo JAR las importamos por medio de la sentencia import. El comando utilizado para crear estos archivos es:

jar{ctxu}[vfm0M] [nombre del jar] [archivo mainfest] [-C directorio] archivos

Las opciones más comunes son:

Comando	Resultado
C	Crea un nuevo archivo JAR
T	Muestra el contenido de un archivo JAR
X	Extrae las clases de un archivo JAR
U	Actualiza un JAR
V	Genera salida por pantalla
F	Especifica el nombre del archivo
M	Incluye un archivo manifies
0	Sólo almacenamiento, sin compresión

Tabla 1. Comandos para crear archivos JAR.

Ahora, como ejemplo, crearemos un archivo JAR con las clases del ejemplo de interfaces, las clases eran Circulo y CirculoImplementado. El comando para crear ejemplo.jar seria:

jar cvf ejemplo.jar Circulo.class CirculoImplementado.class

Ahora, la forma de ejecutar dicho archivo es mediante el comando java, pero debemos especificar cual de las clases del JAR contiene el programa principal (main). Para ello se usa el manifes, o archivo manifiesto. Ahora debemos crear un archivo manifiesto para nuestro JAR, que será de texto plano y quedará así:

Manifest-Version: 1.0

Main-Class: PruebaHerencia

Ahora podemos ejecutar el ejemplo con el comando java de la siguiente manera:

java -jar ejemplo.jar

El formato del archivo JAR es similar al de los archivos ZIP, por lo que utilizando una herramienta como WinZip podemos ver el contenido de estos archivos.

4.3.- Classpath.

El classpath es el camino de las clases, y sirve para indicarle a Java dónde están las clases que queremos usar. Podemos definir el classpath de dos formas, una primera es usando la opción -classpath del intérprete Java, la segunda es definiendo una variable de entorno en el sistema operativo. Cada una tiene sus ventajas y desventajas. Si lo definimos como variable de entorno no tenemos que escribir el classpath cada vez que compilamos o ejecutamos nuestra aplicación, pero el classpath puede cambiar de acuerdo con la aplicación.

Supongamos la siguiente clase:

import CirculoImplementado;

public class PruebaCamino

{

CirculoImplementado a = new CirculoImplementado();

public CirculoAnonimo()

{

}

Como vemos, estamos usando la clase CirculoImplementado, que se encuentra dentro del archivo ejemplo.jar, por eso lo importamos con la sentencia import. Para poder compilar y ejecutar esta clase debemos agregar ejemplo.jar en el classpath, y así extender el árbol de clases de Java, pidiéndole que incorpore las clases Circulo y CirculoImplementado. Suponiendo que el archivo ejemplo.jar se encuentra en c:\misJar, el código para compilar es el siguiente:

javac -classpath c:\misJar\ejemplo.jar PruebaCamino.java

Y el código para ejecutar es:

java -classpath c:\misJar\ejemplo.jar PruebaCamino.java

Además, podemos utilizar más de una clase, que estén en distintas partes del disco. Para hacerlo debemos agregar a nuestro classpath todos los caminos separados con un punto y coma (;) si estamos en Windows o con dos puntos (:) si estamos en Linux.

Si deseamos crear la variable de entorno debemos hacerlo utilizando el comando set, usando el mismo criterio:

set CLASSPATH=c:\misJar\ejemplo.jar

Ahora, para compilar y ejecutar se utilizaría, respectivamente:

javac PruebaCamino.java

java PruebaCamino.java

4.4.- Creación de paquetes.

Ahora que sabemos cómo usar paquetes y crear distribuciones, falta saber cómo crear estos paquetes, es decir, cómo agrupar nuestras clases según un criterio. Para esto existe la sentencia package. Esta sentencia se agrega al principio del archivo, y su sintaxis es:

package nombreDelPaquete;

Con esta línea se declara que la clase que está a continuación pertenece al paquete declarado. Por medio de la sentencia import, lo que evitamos es el conflicto entre nombres de clases. Es decir que en Java podemos tener varias clases con el mismo nombre, pero si deseamos usar dos en el mismo programa, estaremos obligados a usarlas con el nombre completo en cada referencia. Esto ocurre por ejemplo con la clase Date, que se encuentra en el paquete java.until y en java.sql. Si deseamos usarlas, no podemos hacer:

import java.until.Date;

import java.sql.Date;

public class PruebaImport

{

Date s;

Date m;

public PruebaImport()

{

}

Esto nos arrojará un error de doble import, porque no sabrá si queremos declarar las variables como Date de java.until o de java.sql. La forma correcta de hacerlo es:

import java.until.Date;

import java.sql.Date;

public class PruebaImport

{

java.until.Date s;

java.sql.Date m;

public PruebaImport()

{

}

De esta forma declaramos a s como Date del paquete java.until y a m como Date del paquete java.sql.

4.4.1.- Árbol de paquetes o subpaquetes.

En algunos casos necesitamos crear un paquete dentro de otro, por ejemplo, supongamos que deseamos armar la estructura de la Figura1:

Sistema	Paquete

Personas	Paquete

Empleado	Clase

Figura 1. Estructura de paquetes que deseamos lograr.

La declaración para la clase Empleado será:

// Declaro que empleado está dentro de personas, y personas dentro de sistema

package sistema.personas;

public class Empleado

{

public Empleado()

{

}

Ahora, cuando necesitemos usar Empleado, el import será:

import sistema.personas.*;

4.5.- La clase Object.

Como ya hemos visto anteriormente, Object es la clase superior de la jerarquía de Java, lo que equivale a decir que todas las clases de Java dependen de Object. Esta clase define algunos métodos que por herencia tendrán todas las clases de Java. Los métodos más importantes son:

clone(): crea un objeto a partir de otro de la misma clase. Si no puede hacerlo, lanza una excepción del tipo CloneNotSupportedException. Si queremos que nuestras clases tengas esta capacidad, debemos implementar la interfaz Clonable.

equals(): sirve para saber si dos objetos son iguales. Devuelve true si son referencia de la misma clase, o si son objetos diferentes pero con iguales valores en sus variables miembro, de lo contrario retorna false.

toString(): devuelve una cadena que contiene una representación del objeto como cadena de caracteres.

finalize(): es llamado por el Garbage Collector para eliminar un objeto.

notify(), notifyAll() y wait(): como Java fue creado en un momento en que la teoría de hilos estaba totalmente desarrollada, tenemos estos tres métodos que sirven para programar cualquier objeto Java como un Thread (hilo).

4.6.- Conversión de tipos.

A veces tenemos determinada clase de datos, pero lo necesitamos representado en otro tipo. Este cambio podemos necesitarlo entre tipos de datos primitivos. La conversión de tipos o casting es de una variable de mayor a una de menor precisión, debemos hacerla explícitamente porque es una conversión insegura y puede provocar errores. Para hacer la conversión explícita hay que anteponer el tipo al que deseamos convertir entre paréntesis. Por ejemplo, supongamos que hacemos la división entre dos double y queremos almacenar el resultado en un float. Entonces haremos:

double b=4;

double c=2;

float a = (double) (b/c)

Entre clases el casting es igual, sólo que conceptualmente no estamos reduciendo ni aumentando la precisión, sólo estamos cambiando la referencia.

Object a;

Integer b = (Integer) a;

Es bastante común hacerlo para usar los métodos de la clase a la cual convertimos, por que en la clase actual no tenemos dichos métodos. Sin embargo, para el casting entre clases, Java obliga a que entre ellas haya una relación por herencia. La conversión es implícita de la subclase a la superclase, y explícita si es a la inversa, es decir, de la superclase a la subclase.

4.7.- Algunas clases de Java.

A continuación mencionaremos las clases más usadas de Java, y alguno de sus métodos. Además, entregaremos una serie de aspectos relevante que hay que conocer de una clase antes de usarla. Ellos son:

· Descripción: para describir brevemente para qué sirve la clase.

· Tipo: para saber cómo está declarada la clase.

· Ubicación: para saber en qué rama del árbol de clases se encuentra.

· Superclase: cuál es la superclase, es decir, de quién hereda.

· Subclase: si tiene subclases, cuáles son.

· Implementa: para saber qué interfaz implementa, en caso de que lo haga.

· Atributos: cuáles son sus atributos miembro.

· Constructores: cómo se crea la clase en caso de ser instanciada.

Finalmente, los métodos más usados los veremos mediante ejemplos.

4.7.1.- Math.

Esta clase nos provee una serie de métodos para evaluar las funciones matemáticas más comunes. A continuación describimos sus principales características:

· Tipo: public final class.

· Ubicación: java.lang.

· Superclase: java.lang.Object.

· Subclase: -

· Implementa: -

· Atributos: dos constantes static: E y PI.

· Constructores: no tiene, recuerde que todos sus atributos y métodos son estáticos.

Ahora veamos un ejemplo:

import java.lang.*;

public class UsoClaseMath

{

public UsoClaseMath()

{

System.out.println("El valor de PI es: " +Math.PI);

System.out.println("La raíz cuadrada de 25 es: " +Math.sqrt(25));

System.out.println("5 elevado al cuadrado es: " +Math.pow(5,2));

System.out.println("El coseno de 60 es: " +Math.cos(60));

System.out.println("El seno de 60 es: " +Math.sen(60));

System.out.println("La tangente de 60 es: " +Math.tan(60));

System.out.println("El valor absoluto de -10 es: " +Math.abs(-10));

System.out.println("El mínimo entre 2 y 8 es: " +Math.min(2,8));

System.out.println("El máximo entre 2 y 8 es: " +Math.max(2,8));

}

public void main(String argv[])

{

new UsoClaseMath();

}

La salida del programa es:

El valor de PI es: 3.3141592653589793

La raíz cuadrada de 25 es: 5.0

5 elevado al cuadrado es: 25.0

El coseno de 60 es: -0.9524129804151563

El seno de 60 es: -0.3048106211022167

La tangente de 60 es: 0.320040389379563

El valor absoluto de -10 es: 10

El mínimo entre 2 y 8 es: 2

El máximo entre 2 y 8 es: 8

4.7.2.- Integer.

La clase Integer representa el tipo de dato primitivo int. Sus principales características:

· Ubicación: java.lang.

· Superclase: java.lang.Number.

· Subclase: -

· Implementa: Comparable, Serializable.

· Atributos: Tiene tres constantes static:

- MAX_VALUE: el valor máximo representable por int.

- MIN_VALUE: el valor mínimo representable por int.

- TYPE: el tipo de dato que representa.

· Constructores:

- Integer(int value), que crea una instancia Integer a partir del tipo primitivo int.

- Integer(String s), que crea una instancia Integer a partir del objeto String.

Ejemplo de uso:

public class UsoClaseInteger

{

Integer c;

public UsoClaseInteger()

{

// Creamos un Integer desde un int

Integer a = new Integer(1);

// Creamos un Integer desde un String

Integer b = new Integer("1");

// Si compareTo devuelve 0 quiere decir que los dos Integer son iguales

if(a.compareTo(b) == 0)

{

// intValue() devuelve el int con que está instanciado Integer

int suma = a.intValue() + b.intValue();

c = new Integer(suma);

}

// Convertimos el Integer a String usando el método toString()

System.out.println("El resultado es: " +c.toString());

}

public void main(String argv[])

{

new UsoClaseInteger();

}

Luego, la salida por pantalla es:

El resultado es: 2

4.7.3.- Random.

Esta clase genera números pseudorandom. Sus características son:

· Ubicación: java.until.

· Superclase: java.until.Object.

· Subclase: SecureRandom.

· Implementa: Serializable.

· Atributos: -

· Constructores:

- Random(): Crea un nuevo generador de números aleatorios.

- Random(long seed): Crea un nuevo generador de números aleatorios a partir de una semilla para no repetir secuencias.

Ejemplo de uso:

import java.until.*;

public class UsoClaseRandom

{

public UsoClaseRandom()

{

Random r = new Random()

System.out.println("Flotantes pseudoaleatorios:");

for(int i = 0; i < 5; i++)

System.out.print(r.nextFloat() + " ");

System.out.println("\nEnteros pseudoaleatorios entre 0 y 50:");

for(int i = 0; i < 5; i++)

System.out.print(r.nextInt(50) + " ");

}

public void main(String argv[])

{

new UsoClaseRandom();

}

Luego, la salida por pantalla es:

Flotantes pseudoaleatorios:

0.22639495 0.8039619 0.51486355 0.37433088 0.26232278

Enteros pseudoaleatorios entre 0 y 50:

30 6 41 45 18

4.7.4.- StringTokenizer.

La clase StringTokenzer permite dividir un String entre tokens, o delimitadores, de forma simple. Sus principales características:

· Ubicación: java.until.

· Superclase: java.until.Object.

· Subclase: -

· Implementa: Enumeration.

· Atributos: -

· Constructores:

- StringTokenizer(String str): crea un string tokenizer a partir de un string.

- StringTokenizer(String str, String delim): crea un string tokenizer a partir de un string, permitiendo declarar cuál es el delimitador.

- StringTokenizer(String str, String delim, bolean returnDelims): crea un string tokenizer a partir de un string, permitiendo declarar cuál es el delimitador y si el delimitador es parte de la cadena devuelta.

Ejemplo de uso:

import java.until.*;

public class UsoClaseStringTokenizer

{

String cadena = "Diego|27|011-4486-5863|Amabay 258|1754"

public UsoClaseStringTokenizer()

{

// Creamos el objeto con la cadena y el delimitados

StringTokenizer stk = new StringTokenizer(cadena,"|",);

System.out.println("Cantidad de tokens: " +stk.countTokens());

// Mientras haya más tokend

while(stk.hasMoreTokens())

{

// Tomo el siguiente y lo muestro

System.out.println(stk.nexElement());

}

System.out.println("Cantidad de tokens: " +stk.countTokens());

}

public void main(String argv[])

{

new UsoClaseStringTokenizer();

}

La salida del programa es:

Cantidad de tokens: 5

Diego

011-4486-5863

Amabay 258

1754

Cantidad de tokens: 0

4.7.5.- Runtime.

La clase Runtime permite a la aplicación comunicarse con el sistema operativo en el cual se está ejecutando. Sus características son:

· Ubicación: java.until.

· Superclase: java.until.Object.

· Subclase: -

· Implementa:-

· Atributos: -

· Constructores: -

Veamos un ejemplo:

public class UsoClaseRuntime

{

public UsoClaseStringRuntime()

{

Runtime rt = Runtime.getRuntime();

try{

// A través del método exec() ejecutamos notepad de Windows

rt.exec("C:\\WINDOWS\\NOTEPAD:EXE");

}

match(Exception ex){}

}

public void main(String argv[])

{

new UsoClaseRuntime();

}

5.- Vectores y matrices.

5.1.- Secuencias de variables.

Muchas veces, cuando programamos, nos encontramos con variables que tienes cosas en común y que guardan elación entre sí. Una de las herramientas que se utilizan para almacenar estas secuencias de variables son los vectores (array), en otras palabras, éstos representan una secuencia de cosas.

La representación más común de vectores es la siguiente:

Figura 1. Representación de un arreglo.

Los vectores no son conjuntos, porque en un conjunto no importa el orden y no se pueden repetir elementos. En un vector podemos tener el mismo elemento repetido todas las veces que lo necesitemos.

Para acceder a un elemento del vector lo hacemos a través de su índice. En nuestro ejemplo de la Figura 1, dicho índice va de 0 a 3, es decir, que el elemento de la posición 2 es V (Figura 2).

Longitud = 4
J	A	V	A
0	1	2	3	Índices

Figura 2. Propiedades de un array.

5.2.- Arreglos unidimensionales.

Los arreglos unidimensionales no son más que vectores de una dimensión. La definición de estos vectores es la siguiente:

TipoDeDato nombreDelVector[] = new TipoDeDato[cantidad de elementos];

Por ejemplo, para definir un vector de diez números enteros, se hace de la así:

int vector[] = new int[10];

Para cargar el vector, sencillamente lo hacemos a través del índice. Supongamos que deseamos poner un número en la quinta posición del vector. Recordemos ahora que la quinta posición lleva el índice cuatro, ya que el índice de los vectores comienza desde cero.

vector[4] = 8; // En el índice 4 se cargo el número 8

Ahora vamos a usar la sentencia for para cargar el vector completo:

for(int i=9; i<10; i++)

vector[i] = i;

Entonces el vector queda como se observa a continuación:

Figura 3. Vector cargado con un for de 0 a 9.

5.3.- Algoritmos.

En Java existe la clase Collections, la cual implementa una buena cantidad de algoritmos estáticos que operan sobre colecciones.

· sort(): implementa un método de ordenamiento mediante MerdeSort.

· reverse(): invierte el orden de los elementos del arreglo.

· binarySearch(): implementa búsqueda binaria de un elemento en particular.

· copy(): recibe dos listas y copia todos los elementos de una lista a la otra.

· fill(): llena el arreglo con un objeto determinado. Es muy útil para "limpiar".

· max(): devuelve el máximo de acuerdo con un comparador.

· min():devuelve el mínimo de acuerdo con un comparador.

6.- Herencia: Subclases y superclases.

6.1.- Herencia simple.

Hay veces que estamos frente a objetos que presentan entre sí ciertas similitudes. Por ejemplo, si tenemos la clase Persona, a partir de ella podemos definir Empleado, Alumno, Cliente, etc., ya que todos son personas. Frente a esto, la programación orientada a objetos provee la herencia, de forma tal que podemos construir objetos a partir de otros, de los cuales heredará sus atributos y métodos.

Java implementa la herencia simple, es decir que cada clase puede tener sólo una superclase. Para declarar que una clase hereda de otra se una la palabra reservada extends y a continuación el nombre de la superclase. Recordemos que en java "todas" las clases heredan de otra (Figura 1), ya que, de no especificar la superclase, se asume que hereda de java.lang.Object.

Figura 1. Number es superclase o clase padre de Integer, Float

y Double. A su vez, éstas son subclases o clases hijas de Number.

6.1.1.- ¿Que variable miembro hereda una subclase?.

La herencia depende del modificador que tenga la variable miembro de la clase, es decir, cómo está declarada la clase. Recordemos que los modificadores de los métodos y las variables pueden ser public, protected o private.

La herencia o el acceso a esos métodos y variables depende también de si la clase de la cual heredamos se encuentra en el mismo paquete de clase que estamos programando o en otro.

En Tabla 1 y Tabla 2 vemos la visibilidad de acuerdo con los modificadores.

Modificador	Se hereda	Es accesible
Si modificador	Sí	Sí
Public	Sí	Sí
Protected	Sí	Sí
Private	No	No

Tabla 1. Acceso y herencia de métodos de clases

que se encuentran dentro del mismo paquete.

Modificador	Se hereda	Es accesible
Si modificador	No	No
Public	Sí	Sí
Protected	Sí	No
Private	No	No

Tabla 2. Acceso y herencia de métodos de clases

que se encuentran en otros paquete.

Ahora vamos a implementar la clase Persona, y a partir de ella vamos implementaremos la clase alumno, para ejemplificar la teoría (Figura 2).

Figura 2. Alumno hereda de Persona.

public class Persona

{

// Note que codigo es declarado private y nombre protected

private int codigo;

protected String nombre;

// El constructor no hace nada

public Persona()

{

}

/* Se definen los métodos set y get, para poner y sacar,

respectivamente, el valor de codigo, ya que éste es privado */

public void setCodigo(int codigo)

{

this.codigo = codigo;

}

public void getCodigo()

{

return(this.codigo);

}

// También agregamos los métodos para acceder al nombre

public void setNombre(String nombre)

{

this.nombre = nombre;

}

public void getNombre()

{

return(this.nombre);

}

// Este método muesta los datos de la persona

public void mostrar()

{

System.out.println("Código: " +this.codigo);

System.out.println("Nombre: " +this.nombre);

}

Ahora veamos la clase alumno:

// Usamos extends para declarar que Alumno está heredando a Persona

public class Alumno extends Persona

{

/* Declaramos los datos de Alumno, nombre y codigo

no debemos declararlas porque se heredan */

float int notaPrimerCertamen;

float int notaSegundoCertamen;

public Alumno(int codigo, String nombre, float notaPrimero, float notaSegundo)

{

// Con super hacemos referencia a la variable nombre de la clase padre

super.nombre = nombre;

// Como codigo es privado se debe acceder a él a través del método setCodigo

super.setCodigo(codigo);

// Se inicializan las variables de Alumno

this.notaPrimerCertamen = notaPrimero;

this.notaSegundoCertamen = notaSegundo;

}

private float getPromedio()

{

return((this.notaPrimerCertamen + this.notaSegundoCertamen)/2);

}

// Este método muesta los datos del alumno y el promedio

public void mostrar()

{

// Usamos mostrar de la superclase y agregamos el promedio

super.mostrar();

System.out.println("Promedio: " +this.getPromedio());

}

Finalmente, para probar el ejemplo hacemos la clase Prueba Herencia, que instancia un Alumno y una Persona:

public class PruebaHerencia

{

public PruebaHerencia()

{

}

public static void mail(String argv[])

{

// Creamos una instancia Alumno y hacemos referencia al método mostrar del alumno

Alumno a = new Alumno(1,"Diego",80,100);

System.out.println("-Alumno-");

a.mostrar();

/* Creamos una instancia Persona. Luego se hace

referencia al método mostrar de persona */

Persona p = new Persona()

p.setCodigo(10);

p.setNombre("Fabián");

System.out.println("-Persona-");

p.mostrar();

}

La salida de este programa es:

-Alumno-

Código: 1

Nombre: Diego

Promedio: 90.0

-Persona-

Código: 10

Nombre: Fabián

6.2.- Escribir clases, atributos y métodos finales.

Cuando escribimos una clase, podemos usar la sentencia final, para asegurarnos de que no habrá subclases de ésta, es decir, las clases declaradas como final serán siempre hojas del árbol de clases.

También podemos declarar métodos como final, para asegurarnos de que no serán sobrecargados o sobrescritos por una subclase de la clase que los contiene.

En el caso de los atributos o datos miembro de una clase, cuando sean declarados como final, tendremos la certeza de que, una vez inicializado, no cambiará de valor durante toda la ejecución del programa. Podemos usar final en los atributos de la clase para simular constantes.

6.3.- Clases y métodos abstractos.

Una clase abstracta es una que está incompleta, y sólo ésta puede tener métodos abstractos. Éstos son aquellos que están declarados y pueden ser usados, pero todavía no están implementados. Una clase puede tener métodos abstractos si los hereda de una clase abstracta, o bien, si los tiene declarados explícitamente. Las clases abstractas no pueden ser instanciadas "nunca", si lo hacemos provocaremos un error en tiempo de compilación.

6.4.- Jerarquía de composición.

En el Capítulo 1 mencionamos que no sólo existía la jerarquía de herencia, sino que también existe la jerarquía de composición, Esta última puede ser vista como "contiene" o "tiene".

Aunque éste sea el caso más difícil de percibir, aún sigue siendo el caso más común de común de composición. Esto sucede cuando, en vez de usar los tipos de datos primitivos de Java para definir los atributos de una clase, lo hacemos con objetos que representan dichos tipos de datos.

Analicemos el siguiente ejemplo:

public class Empleado

{

Integer codigo;

String nombre;

Double sueldo;

Direccion direccion;

public Empleado()

{

}

En este caso tenemos la clase Empleado, que "contiene" tres objetos: Integer, String, y Double. Además el empleado tiene una dirección, representada a través del siguiente Objeto.

public class Direccion

{

String calle;

Integer numero;

public Direccion()

{

}

Note que la composición no se da solamente con la clase Direccion, ya que Integer, String y Double también son clases (Figura 3).

Figura 3. Composición de las clases Empleado y Direccion.

7.- Errores y excepciones.

7.1.- La jerarquía de las excepciones.

De la ejecución de nuestros programas va a surgir una serie de errores que debemos manejar de alguna manera. Para esto debemos determinar qué los provoca y, una vez definido eso, analizar qué camino tomar, evitar el error, mostrar un mensaje comprensible para el usuario, abortar la ejecución del programa, etc.

Java define una excepción como un objeto que es una instancia de la clase Throwable o alguna de sus subclases. Es decir que estamos ante una jerarquía de excepciones (Figura 1). Para comenzar, de Throwable heredan las clases Error y Exception.

Figura 1. Parte de la jerarquía de errores y excepciones de Java.

Por lo general, un error tiende a provocarse en condiciones anormales, eso significa que no tiene sentido o no es posible capturarlo. Por ejemplo, OutOfMemoryError indica que no hay más memoria. Debido a la imposibilidad de capturar los errores, el programa termina.

De la clase Error se heredan las siguientes:

· AWTError

· LinkageError

· ThreadDeath

· VirtualMachineError

Las excepciones, en cambio, se producen dentro de condiciones normales, es decir que no sólo es posible capturarlas, sino que también el lenguaje nos obliga a capturarlas y manejarlas. Hay algunas excepciones que son las más conocidas, por ejemplo, las que heredan de Exception, que son las siguientes:

· ClassNotFoundException

· InterruptedException

· IOException

· RuntimeException

· SQLException

Hasta ahora hablamos de errores y excepciones, pero sin embargo existe otro conjunto de excepciones que el lenguaje no nos obliga a capturar y manejar, pero si queremos, podemos hacerlo. Éstas son conocidas como RuntimeException, excepciones generadas en tiempo de ejecución, que reflejan un error de codificación e imprimen en pantalla un mensaje de error.

Nunca olvidemos que una excepción no es un error, sino un evento que nuestro programa no sabe cómo manejar. Siempre que se provoque una excepción, podemos capturarla y manejarla, o evitarla cambiando la lógica del programa.

7.2.- Uso de try, catch y finally.

Para capturar y manejar las excepciones, Java proporciona tres palabras reservadas, estas son try, catch y finally. Para comenzar veremos try y catch.

Entre un try y un catch vamos a escribir el código de programa que pueda provocar una excepción. La estructura general es la siguiente:

try

{

// Acá va el bloque de ejecución que puede provocar una excepción

}

catch(NombreDeLaExcepcion instancia)

{

// Aca va el bloque de ejecución que maneja la excepción en caso de producirse

}

En el catch va el nombre de la excepción que deseamos capturar. Si no sabemos qué excepción es, recordemos que hay una jerarquía de excepciones, de tal forma que se puede poner la clase padre de todas las excepciones: Exception.

No todos los errores deben ser listados al declarar un método. Las instancias de la clase Error y RunTimeException no deben ser listadas, pues tienen un tratamiento especial porque pueden ocurrir en cualquier lugar dentro de nuestro programa. Se dan situaciones de las que no somos directamente responsables y que producen estas excepciones, como la situación de OutOfMemoryError. Hay solamente seis tipos de excepciones que pueden ser listadas en cláusulas throws dentro de java.lang.

Veamos un ejemplo que produce una excepción, pero no vamos a capturarla, para analizar un poco la salida de error.

// Vamos a crear un paquete de pruebas

package pruebas;

// Importamos java.until.* para usar la clase Vector

import java.until.*;

public class PruebaError

{

// Declaramos el vector

Vector v = new Vector();

public PruebaError()

{

c.addElement(new String("Sergio"));

c.addElement(new String("Francisco"));

c.addElement(new String("Hismael"));

c.addElement(new String("Erich"));

// Note que el for intentará recorrer un vector de diez elementos

for(int i=0; i<10; i++)

{

// Tomamos el elemento de la posición i y lo muestro

System.out.println(v.get(i));

}

public static void main(String argv[])

{

/* Creamos el objeto pero no lo referenciamos ya

que no vamos a usar más que el constructor */

new PruebaError();

}

Luego de compilar este programa, lo ejecutamos y obtenemos esta salida:

Sergio

Francisco

Ismael
Erich

java.lang.ArrayIndexOutOfBoundsException: Array index out of range:

at java.until.Vector.get(Vector.java:699)

at pruebas.PruebaError.<init>(PruebaError.java:19)

at pruebas.PruebaError.main(PruebaError.java:26)

Exception in thread "main"

El programa no causa ningún error de compilación, pero sí un error de ejecución. Esto es un RuntimeException.

Analizando el error vemos, primero, el nombre de la excepción provocada, en este caso ArrayIndexOutOfBoundsException, y a continuación, el mensaje de error. Luego de informar la excepción, muestra la línea exacta en que fue provocada. Es conveniente leer esto de abajo hacia arriba, de manera tal que podamos ver dónde empezó todo e ir siguiéndolo con nuestro código. Vemos que todo empezó en la línea 26, de paquete pruebas, en la clase PruebaError, en el método main. Si vamos a esta línea vemos que es donde creamos el objeto PruebaError. Seguimos hacia arriba, y ahora vemos que el error está en la línea 19 del paquete pruebas, en el objeto PruebaError, en el constructor, por eso dice <init>. Si vemos en el código, en esta línea es donde sacamos un elemento del vector, es entonces cuando determinamos cuál es la línea de código que provoca el error y por qué.

Ahora debemos elegir una solución. Podemos cambiar el límite del for de 10 a 4, para asegurarnos de no querer sacar más elementos, o podemos capturar la excepción y manejarla. Para capturar la excepción debemos poner las líneas que provocaron la excepción entre un try y un catch. En el ejemplo anterior debemos encerrar al for:

try

{

for(int i=0; i<10; i++)

{

// Tomamos el elemento de la posición i y lo muestro

System.out.println(v.get(i));

}

catch(ArrayIndexOutOfBoundsException e)

{

System.out.println("Intentó sacar más elementos!!");

}

Ahora, la salida es:

Sergio

Francisco

Ismael
Erich

Intentó sacar más elementos!!

Como vemos, lo único que logramos es mostrar el mismo error, sólo que de manera mas comprensible. En ciertos casos, vamos a usar el bloque catch para evitar el error, no sólo para mostrarlo.

El lenguaje no nos obliga a capturar las excepciones que se provocan en tiempo de ejecución, sin embargo, éstas se producen, y muy a menudo. Entonces, empezará ejecutando el try, si se produce alguna excepción, corta el try y ejecuta el catch. Finalmente, lo que va en el bloque finally, se ejecutará siempre, haya habido excepciones o no. Algo muy común es usar dicho bloque para limpiar variables, cerrar archivos, restablecer conexiones, es decir, tareas que hayan podido quedar truncadas según se haya ejecutado el try completo o no.

La estructura de un bloque con try, catch y finally es la siguiente:

try

{

// Acá va el bloque de ejecución que puede provocar una excepción

}

catch(NombreDeLaExcepcion instancia)

{

// Aca va el bloque de ejecución que maneja la excepción en caso de producirse

}

finally

{

//Este bloque se ejecuta siempre, sin importar si ejecutó el bloque del try o del catch

}

Java nos obliga a capturar algunas excepciones, y a manejarlas de alguna manera, es decir, que encerremos la línea que produce dicha excepción dentro de un try y un catch. Pero, si no queremos manejarla dentro del bloque, podemos lanzar la excepción hacia arriba, para que el bloque que llame a éste se encargue de manejar la excepción. Es decir, que la excepción le deberá manejar el padre en la pila de llamadas. Antes de continuar, veamos de qué se trata esto de la pila de llamadas.

7.2.1.- Pila de llamadas.

La pila de llamadas es un arreglo que cera el intérprete de Java en tiempo de ejecución para saber en todo momento quién llamó a quién. Esto sirve al programa para saber dónde tiene que seguir ejecutando cuando termina un bloque de ejecución.

La pila de llamadas para el ejemplo anterior lo podemos observar a continuación:

Figura 2. Pila de llamadas de Java.

Entonces, cuando una excepción no es tratada en el método donde se produce, Java buscar un bloque try catch en el método que lo trajo al actual. Si la excepción se lanza hasta el tope de la pila de llamadas sin encontrar un administrador específico para la excepción, entonces la ejecución se detendrá y dará un mensaje. Es decir, podemos suponer que Java nos está proporcionando un bloque try catch implícito, que imprime un mensaje de error, indica las últimas entradas en la pila de llamadas y sale. Este mensaje es el stack trace o camino de la pila. Para imprimir un stack trace en una excepción capturada, lo hacemos a través del método printStackTrace() de Exception.

7.3.- Lanzar excepciones.

Entonces, si no queremos manejar la excepción y deseamos que lo haga el padre en la pila de llamadas, usamos la sentencia throws.

package pruebas;

public class PruebaThrow

{

public PruebaThrow

{

}

// El método devuelve el resultado de la división

public flota divide(int a, int b) throws ArithmeticException

{

// Esta línea provoca la excepción que el throws lanza hacia arriba en la pila

return(a/b);

}

public static void main(String argv[])

{

PruebaThrow p = new PruebaThrow();

// La llamada provocará un ArithmeticException causado por la división por 0

try

{

flota c = p.divide(15,0);

}

catch(ArithmeticException ex)

{

// Imprimimos un mensaje de error

System.out.println("Error de división por 0");

// Imprimimos el stack trace

ex.printStackTrace();

}

El método divide es el que provoca la excepción, pero a través de throws, la lanza hacia arriba para que la maneje su padre en la pila de llamadas. Aquí, el padre es el main. Este se encargará de manejar la excepción provocada.

Ahora vamos a agregar un nuevo método a nuestra clase, que también puede provocar una excepción, esta vez, un ClassCastException. Este método es:

// Convierte de Object a Integer

public Integer convertir(Object a)

{

return((Integer)a);

}

A continuación, el bloque de ejecución puede provocar un ArithmeticException o un ClassCastException. Para poder manejar ambas excepciones, sólo debemos agregar un nuevo catch, es decir que podemos tener cuantos catch como necesitemos. El nuevo main y bloque try catch quedarían así:

public static void main(String argv[])

{

PruebaThrow p = new PruebaThrow();

/* La primera sentencia provocará un ArithmeticException causado por la división

por 0. La segunda un ClassCastException por intentar convertir de Float a Integer */

try

{

flota c = p.divide(15,0);

p.convertir(new Flota(c));

}

catch(ArithmeticException ex)

{

System.out.println("Error de división por 0");

}

catch(ClassCastException ex)

{

System.out.println("Error Convirtiendo Float a Integer");

}

7.4.- Capturar excepciones más genéricas.

Como vimos en el ejemplo anterior, podemos tener cuantos catch creamos necesarios, pero también vimos que con agregar sólo una línea al bloque de ejecución se provocaba una excepción que el programa no estaba preparado para manejar.

Aprovechando la jerarquía de excepciones, podemos reemplazar todos los catch de excepciones particulares por la superclase Exception, haciendo una captura genérica. Ahora el main del ejemplo anterior quedaría así:

public static void main(String argv[])

{

PruebaThrow p = new PruebaThrow();

try

{

flota c = p.divide(15,0);

p.convertir(new Flota(c));

}

catch(Exception ex)

{

System.out.println("Error!!");

ex.printStackTrace();

}

Veamos el mensaje de error. Ahora no sabemos cuál es la excepción que se provocó, porque estamos capturando la excepción genérica. Nos queda por analizar el mensaje, a través del objeto getMessage(), o el stack trace, a través de printStackTrace().

8.- Streams.

8.1.- Flujo de datos.

La información podrá ser representada por algún tipo de Java, es decir, podrá ser Object, String, Charater, etc. Para poder leer y escribir esta información hay que manejar flujos de información, y para esto Java provee los streams (Figura 1).

Figura 1. Stream de entrada y stream de salida.

Entonces, los streams representan flujos de datos o de información. Estos flujos podrán ser de entrada o de salida. Generalmente, los algoritmos para manejar los datos son los siguientes:

Figura 2. Secuencia de algoritmos de lectura y escritura.

El problema radica ahora en el dispositivo del cual estamos leyendo o escribiendo, es decir, si bien el algoritmo es similar para cualquier dispositivo, no es lo mismo leer o escribir datos del disco duro que de otra PC en una red.

Para que no tengamos que preocuparnos por los tipos de dispositivos, Java ofrece el paquete java.io (java input/output). Este paquete contiene un conjunto de clases que nos permitirán manejar cualquier flujo de entrada/salida. Las clases están divididas según dos categorías: flujos de caracteres (character stream) y flujos de bytes (bytes stream).

·
Bytes stream: sirve para el manejo de entradas y salidas de bytes, y su uso lógicamente está orientado a la lectura y escritura de datos binarios. Las clases más usadas para el tratamiento de flujos de bytes son ImputStream y OutputStream (Figura 3 y Figura 4).

Figura 3. Árbol de clases de Byte Stream ImputStream.

Figura 4. Árbol de clases de Byte Stream OutputStream.

·
Character streams: sirven para el manejo de entradas y salidas de caracteres. Dichos flujos usan codificación Unicote y, por lo tanto, se pueden internacionalizar. Las dos clases para este caso son Read y Write (Figura 5 y Figura 6).

Figura 5. Árbol de clases de Character Stream Read.

Figura 6. Árbol de clases de Character Stream Write.

8.2.- Lecturas y escrituras en archivos usando streams .

El caso más común en que necesitaremos usar streams será el de archivos. Para esto, encontramos las clases FileOutputStream, FileInputStream, FileReader y FileWriter. Comenzaremos por FileOutputStream, el cual, como su nombre lo indica, crea un flujo de datos de salida de un archivo.

package pruebas;

import java.io.*;

public class PruebaArchivoSalida

{

public PruebaArchivoSalida()

{

// Declaramos la variable miArchivo del tipo FileOutputStream

FileOutputStream miArchivo;

// Declaramos el String para gravar en el archivo

String dato = new String();

try

{

/* Creamos el archivo a través del constructor

de la clase FileOutputStream(String nombre) */

miArchivo = new FileOutputStream("C:\\archivo.txt");

// Grabamos 5 líneas

for(int i = 0; i<5; i++)

{

/* Grabamos el número de línea. Agregamos al final la

secuencia de escape \n para que no grabe todo seguido*/

dato = "Línea (" +i +") \n";

/* Recordemos que el método write espera un array de bytes, así

que usamos el método getBytes() de String para obtener esto */

miArchivo.write(dato.getBytes());

}

// Cerramos el archivo

miArchivo.close();

}

catch(IOException ex)

{

/* Tanto el constructor como los métodos write y close lanzan

una excepción del tipo IOException que debemos capturar */

System.out.println("Error: " +ex.getMessage());

}

public static void mail(String argv[])

{

new PruebaArchivoSalida();

}

Este programa no genera ninguna salida por pantalla, pero, si todo va bien, genera un archivo en el directorio raíz del disco C. Este archivo se abre con cualquier editor de textos. Aunque debemos tener en cuenta que algunos editores no soportan las secuencias de escape y las representan con algún otro carácter. En el archivo generado vemos:

Línea (0)

Línea (1)

Línea (2)

Línea (3)

Línea (4)

Ahora, aprovechando que tenemos un archivo generado, usaremos FileInputStream para abrirlo, leerlo y mostrarlo por pantalla.

package pruebas;

import java.io.*;

public class PruebaArchivoEntrada

{

public PruebaArchivoEntrada()

{

// Declaramos la variable miArchivo del tipo FileInputStream

FileInputStream miArchivo;

// Creamos el array de byte para almacenar la información que leemos del archivo

byte linea[] = new byte[55];

try

{

/* Abrimos el archivo a través del constructor

de la clase FileInputStream(String nombre) /*

miArchivo = new FileInputStream("C:\\archivo.txt");

miArchivo.read(linea);

/* Debemos convertir el byte[] a String para que la información

leída del archivo sea entendible para nosotros */

System.out.println(new String(linea));

// Cerramos el archivo

miArchivo.close();

}

catch(IOException ex)

{

/* Tanto el constructor como los métodos read y close lanzan

una excepción del tipo IOException que debemos capturar */

System.out.println("Error: " +ex.getMessage());

}

public static void mail(String argv[])

{

new PruebaArchivoEntrada();

}

Para simplificar el ejemplo, creamos el array de 55, ya que sabíamos de antemano que eso era lo que ocupaba el archivo de bytes. De esa forma se pudo leer el archivo completo en una sola lectura. Generalmente no sabemos qué tamaño ocupa el archivo, peor aún, el archivo va a ir cambiando de tamaño. Para manejar esto hay que hacer un programa similar al de escritura, es decir, usando un ciclo.

Por otra parte, el error capturado de esta manera, si lo hubiera, no nos permite especificarle al usuario si se provocó cuando quisimos abrir el archivo, grabarlo o cerrarlo. La forma correcta sería capturar la excepción cada vez que quisiéramos hace algo con el archivo, para poder informar mejor el error o manejarlo de alguna manera.

8.2.1.- FileReader y FileWriter.

Las clases anteriores, como vimos, eran stream de bytes. FileReader y FileWriter, en cambio, son stream de char, es decir que, tomando como referencia los ejemplos anteriores, cambiando los array de bytes por array de char y convirtiendo cada cadena a array char, vamos a obtener los mismos resultados.

8.3.- Objetos persistentes.

En algunas ocasiones necesitaremos no perder la instancia de un objeto cuando termine el programa, es decir, precisaremos guardar dicha información contenida en el objeto. Para esto se usan los objetos persistentes.

Para programar un objeto persistente debemos implementar la interfaz Serializable del paquete java.io. Simplemente declaramos la clase como:

public class ObjetoPersistente implements Serializable

Una vez hecho esto, debemos crear un método que se encargue de grabar el objeto a través del método writeObject() de ObjectOutputStream. Para ejemplificar, implementaremos el código de la clase ObjetoPersistente.

import java.io.*;

public class ObjetoPersistente implements Serializable

{

String nombre;

String apellido;

int edad;

public ObjetoPersistente(String n, String a, int e)

{

this.nombre = n;

this.apellido = a;

this.edad = e;

}

// Implementamos el método guardarObjeto

public void guardarObjeto()

{

try{

// Creamos el archivo

FileOutputStream archivo = new FileOutputStream("C:\\objeto.ser");

// Creamos el stream de salida del objeto

ObjectOutputStream out = new ObjectOutputStream(archivo);

// Grabamos el objeto

out.writeObject(this);

out.flush();

// Cerramos el stream

out.close;

// Cerramos el archivo

archivo.close();

}

catch(IOException ex)

{

System.out.println("Error al grabar objeto: " +ex.getMessage());

}

public static void main(String argv[])

{

ObjetoPersistente op = new ObjetoPersistente("Miguel","Alvarado",22);

op.guardarObjeto();

}

Como resultado obtendremos el archivo objeto.ser con la información del objeto. Note en el ejemplo que el método writeObject() recibe this como parámetro, se deduce que se puede implementar el método fuera de la clase y enviarle el objeto seriablizable. En nuestro caso, la línea sería:

out.writeObject(op);

Es decir, en la instancia de ObjetoPersistente, para mostrar esto modificaremos el main para leer el objeto grabado. Antes de modificar el main, haremos la sobrecarga del método toString() para mostrar cómo quedó instanciado el objeto al final de la ejecución. Ahora sí, el main será:

public static void main(String argv[])

{

try

{

FileInputStream archivo = new FileInputStream("C:\\abjeto.ser");

ObjectInputStream in = new ObjectInputStream(archivo);

/* Leemos el objeto, y como readObject devuelve un objero lo

convertimos a ObjetoPersistente y lo referenciamos con op */

ObjetoPersistente op = (ObjetoPersistente)in.readObject();

in.close();

archivo.close();

}

catch(Exception ex)

{

ex.printStackTrace();

}

System.out.println("Instanciado con: " +opLeido.toString());

}

La salida del programa será:

Instanciado con: Miguel Alvarado de 22 años de edad

9.- AWT.

9.1.- Interfaces gráficas de usuario.

Hoy en día, una de las cosas más importantes de los sistemas es la interfaz de usuario. Al usuario final no le interesan las características técnicas de nuestro software, pero sí, que sea fácil de usar. Para lograr una GUIs (Graphical User Interface, en español interfaces gráficas de usuario) vamos a usar AWT (Abstract Windows Toolkit).

Debido a que Java es multiplataforma, provee un conjunto de herramientas para poder construir aplicaciones gráficas multiplataforma. El problema, a veces, consiste en que cuando migramos a otra plataforma, posiblemente no veamos lo mismo en una plataforma que en otra. Por este motivo, hay que tener en cuenta que la versión de AWT que SUN lanzó al mercado fue desarrollada en sólo dos meses y representa, quizás, el punto más débil del lenguaje. Esta situación hace que construir una ventana simple se vuelva una tarea complicada y muy tediosa.

La biblioteca AWT contiene un conjunto completo de clases y métodos para dar soporte al uso de ventanas y a las GUIs. La estructura básica del AWT se basa en Componentes y Contenedores. La versión actual del AWT se puede resumir en los puntos que se exponen a continuación:

· Los Contenedores contienen Componentes, que son los controles básicos.

· No se usan posiciones fijas de los Componentes, sino que están situados a través de una disposición controlada (layouts).

· El común denominador de más bajo nivel se acerca al teclado, mouse y manejo de eventos.

· Alto nivel de abstracción respecto al entorno de ventanas en que se ejecute la aplicación.

· La arquitectura de la aplicación es dependiente del entorno de ventanas, en vez de tener un tamaño fijo.

· Depende bastante de la plataforma en que se ejecuta la aplicación.

· Carece de un formato de recursos. No se puede separar el código de lo que es propiamente interfaz.

9.2.- Componentes y Contenedores.

Una interfaz gráfica está construida en base a elementos gráficos básicos, los Componentes. Típicos ejemplos de estos Componentes son los botones, barras de desplazamiento, etiquetas, listas, cajas de selección o campos de texto. Los Componentes permiten al usuario interactuar con la aplicación y proporcionar información desde el programa al usuario sobre el estado del programa. En AWT, todos los Componentes de la interfaz de usuario son instancias de la clase Component o uno de sus subtipos.

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.

9.3.- Clase Component.

Component es una clase abstracta que representa todo lo que tiene una posición, un tamaño, que puede ser pintado en pantalla y puede recibir eventos. No tiene constructores públicos, ni puede ser instanciada. Sin embargo, puede ser extendida para proporcionar una nueva característica incorporada a Java, conocida como componentes Lightweight. Los Objetos derivados de dicha clase que se incluyen en AWT son los que aparecen a continuación:

· Button

· Canvas

· Checkbox

· Choice

· Container

- Panel

- Window

- Dialog

- Frame

· Label

· List

· Scrollbar

· TextComponent

- TextArea

- TextField

Sobre estos Componentes se podrían hacer más agrupaciones y quizá la más significativa es la que diferencia los Componentes según el tipo de entrada. Así habría Componentes con entrada de tipo no-textual como los botones de pulsación (Button), las listas (List), botones de marcación (Checkbox), botones de selección (Choice) y botones de comprobación (CheckboxGroup), Componentes de entrada y salida textual como los campos de texto (TextField), las áreas de texto (TextArea) y las etiquetas (Label), y otros Componentes, en donde se encontrarían algunos como las barras de desplazamiento (Scrollbar), zonas de dibujo (Canvas) e incluso los Contenedores (Panel, Window, Dialog y Frame), que también pueden considerarse como Componentes.

9.3.1.- Button.

La clase Button es una clase que produce un componente de tipo botón con un título. El constructor más utilizado es el que permite pasarle como parámetro una cadena, que será la que aparezca como título e identificador del botón en el interfaz de usuario. Así:

Button nombreBoton = new Button("título");

Pone al alcance del programador una serie de métodos entre los que destacan por su utilidad los siguientes:

Método	Descripción
addActionListener()	Añade un receptor de eventos de tipo Action producidos por el botón.
getLabel()	Devuelve la etiqueta o título del botón.
removeActionListener()	Elimina el receptor de eventos para que el botón deje de realizar acción alguna.
setLabel()	Fija el título o etiqueta visual del botón.

Tabla 1. Algunos métodos de la clase Button.

ActionListener es uno de los eventos de tipo semántico. Un evento de tipo Action se produce cuando el usuario pulsa sobre un objeto Button.

A continuación veremos un ejemplo, utilizando sólo un botón con una etiqueta que dice "Oprima aquí". Al oprimir dicho botón haremos que el programa muestre el número de veces que se ha hecho clic sobre el botón. El código es el siguiente:

import java.applet.*;

import java.awt.*;

import java.awt.event.*;

public class PruebaButton extends Applet implements ActionListener

{

private Button boton;

private int cuenta = 0;

public void init()

{

boton = new Button("Oprima aquí");

add(boton);

boton.addActionListener(this);

}

public void actionPerformed(ActionEvent event)

{

cuenta++;

repaint();

}

public void paint(Graphics g)

{

d.drawString("El número de veces que se a oprimido el botón es: " +cuenta, 10, 50);

}

9.3.2.- Choice.

Un cuadro de opción es una lista de opciones similar a un menú. Puede elegirse un elemento de la lista haciendo clic sobre el mismo. Luego, el elemento seleccionado aparece como la única parte visible de la lista.

Para crear un cuadro de opción, veamos un ejemplo:

import java.awt.*;

import java.applet.Applet;

import java.awt.event.*;

public class PruebaChoice extends Applet implements ItemLisetner

{

private Choice colorOpcion;

public void init()

{

colorOpcion = new Choice();

colorOpcion.add("Rojo");

colorOpcion.add("Blanco");

colorOpcion.add("Azul");

add(colorOpcion);

colorOpcion.addItemListener(this);

}

public void itemStateChanged(ItemEvent e)

{

if(e.getSource() == colorOpcion)

{

String unaOpcion = e.getItem().toString();

}

9.3.3.- Checkbox.

Ésta es una manera en la que el usuario puede especificar una o más opciones al hacer clic en una casilla de verificación. También se pueden agrupar en CheckboxGrup, que son un grupo de Checkbox que comparten la característica de que sólo una de las casillas puede seleccionarse a la vez. Los grupos de opciones son útiles para algunos programas, por ejemplo para seleccionar color, como vemos en el siguiente código:

import java.awt.*;

import java.applet.Applet;

import java.awt.event.*;

public class PruebaCheckbox extends Applet implements ItemLisetner

{

private CheckboxGroup c;

private Checkbox rojo, blanco, azul;

public void init()

{

c = new CheckboxGroup;

rojo = new Checkbox("Rojo", c, false);

add(rojo);

rojo.addItemListener(this);

blanco = new Checkbox("Blanco", c, true);

add(blanco);

blanco.addItemListener(this);

azul = new Checkbox("Azul", c, false);

add(azul);

azul.addItemListener(this);

}

public void itemStateChanged(ItemEvent e)

{

if((e.getSource() == rojo) || (e.getSource() == blanco) || (e.getSource() == azul))

{

showStatus("Estado de Grupo = " + rojo.getState() + "\t" + blanco.getState()

+ "\t" + azul.getState());

}

9.3.4.- List.

Este elemento es una lista de cadenas de texto, de la cual pueden seleccionarse uno o más elementos. Se proporciona una barra de desplazamiento para avanzar hacia arriba o abajo. Su constructor es:

List lista = new List(3, false);

Aquí, el primer parámetro especifica que sólo habrá tres elementos visibles en la lista a la vez, mientras que el segundo nos indica que sólo podremos seleccionar un elemento de la lista.

Ahora podemos ver un ejemplo:

import java.awt.*;

import java.applet.Applet;

import java.awt.event.*;

public class PruebaList extends Applet implements ItemLisetner

{

private List lista;;

public void init()

{

lista = new List(3, false);

lista.add("leche");

lista.add("azúcar");

lista.add("té");

lista.add("café");

add(lista);

lista.addActionListener(this);

}

public void actionPerformed(ActionEvent e)

{

if(e.getSource() == lista)

{

String listaSeleccion = lista.getSelectedItem();

}

Si deseamos una lista de la que se pueda seleccionar más de un elemento, entonces el segundo parámetro del método constructor debe ser true.

9.4.- Clase Container.

La clase Container es una clase abstracta derivada de Component, que representa a cualquier componente que pueda contener otros componentes. Se trata, en esencia, de añadir a la clase Component la funcionalidad de adición, sustracción, recuperación, control y organización de otros Componentes.

Al igual que la clase Component, no dispone de constructores públicos y, por lo tanto, no se pueden instanciar objetos de la clase Container. Sin embargo, sí se puede extender para implementar los componentes Lightweight.

AWT proporciona varias clases de Contenedores:

· Panel

- Applet

· ScrollPane

- Window

- Dialog

o FileDialog

- Frame

Aunque los que se pueden considerar como verdaderos contenedores son Window, Frame, Dialog y Panel, porque los demás son subtipos con algunas características determinadas y solamente útiles en circunstancias muy concretas.

9.4.1.- Window.

Es una superficie de pantalla de alto nivel, una ventana. Una instancia de la clase Window no puede estar enlazada o embebida en otro Contenedor.

Una instancia de esta clase no tiene ni título ni borde, así que es un poco difícil de justificar su uso para la construcción directa de un interfaz gráfico, porque es mucho más sencillo utilizar objetos de tipo Frame o Dialog. Dispone de varios métodos para alterar el tamaño y título de la ventana, o los cursores y barrar de menús.

9.4.2.- Frame.

Una aplicación que utiliza ventanas necesita crear explícitamente dichas ventanas en la pantalla. Esta área se conoce como Frame (marco). La manera más sencilla en que una aplicación puede crear un marco es heredar (o extender) de la clase de biblioteca Frame. Para crear un marco se hace así:

nombreFrame = new Frame("título");

Ahora veamos algunos métodos de esta clase:

// Cambiamos su tamaño a 250 píxeles de ancho y 200 de alto

nombreFrame.setSize(250, 200);

// Lo hacemos visible

nombreFrame.setVisible(true);

// Agregamos un botón al Frame

Button b1 = new Button("Botón");

nombreFrame.add(b1);

9.4.3.- Dialog.

Es una superficie de pantalla de alto nivel, ventana, con borde y título, que permite entradas al usuario. La clase Dialog extiende la clase Window, que extiende la clase Container, que extiende a la clase Component. Y su controlador de posicionamiento por defecto es el BorderLayout.

De los constructores proporcionados por esta clase, destaca el que permite que el diálogo sea o no modal. Todos los constructores requieren un parámetro Frame y, algunos de ellos, permiten la especificación de un parámetro booleano que indica si la ventana que abre el diálogo será modal o no. Si es modal, todas las entradas del usuario serán recogidas por esta ventana, bloqueando cualquier entrada que se pudiese producir sobre otros objetos presentes en la pantalla. Posteriormente, si no se ha especificado que el diálogo sea modal, se puede hace que adquiera esta característica invocando al método setModal().

9.4.4.- Panel.

Un panel es una forma de agrupar varios componentes de manera conveniente. No tiene un contorno ni alguna otra forma de verse en pantalla, es como un contorno invisible. Por ejemplo, si deseamos que haya cientos de botones en la parte superior de la ventana y otros en la parte inferior, podemos crear paneles separados APRA cada uno de los grupos, y luego especificar que panel debe ir arriba y cual abajo. Su constructor es:

Panel p newPanel();

Luego podemos agregar componentes a ese panel:

Button b1 = new Button("Oprímame");

Button b2 = new Button("No, oprímame a mí");

p.add(b1);

p.add(b2);

10.- Applet.

10.1.- ¿Que son los applet?.

Son pequeños programas, comúnmente denominados componentes, ya que se van a embeber en otras aplicaciones, que se enlazan a una página Web. El enlace se logra a través de la etiqueta APPLET de HTML. Cuando el navegador que está levantando nuestra página encuentra esta etiqueta, entiende que debe ejecutar un applet, para ello levanta primero la maquina virtual y solicita los archivos necesario para la correcta ejecución del applet. Los problemas de esta implementación son los siguientes: la configuración de seguridad del navegador, los applet son pesados y en una ren lenda es posible que no se puedan ejecutar. Por lo tanto, cuando programemos applets deberemos tratar de que sean livianos y que no sean demasiado relevantes para que alguien que no desee ejecutarlos pueda seguir navegando en nuestra página sin problemas.

10.2.- El AppletViewer.

El applet asume que el código se está ejecutando desde dentro de un navegador. Para que no dependamos de un navegador, podemos hacer uso del AppletViewer, que tiene el aspecto de un pequeño navegador. Éste espera como argumento el nombre del fichero HTML que debe cargar, no se le puede pasar directamente un programa Java. Este fichero HTML debe contener una marca que especifica el código que cargará el AppletViewer.

Esta marca, como ya vimos, es la etiqueta de html APPLET:

<HTML>

</APPLET>

</HTML>

De esta manera el AppletViewer genera un espacio de navegación con un área gráfica donde se va a ejecutar nuestro applet PruebaApplet.class.

10.3.- Métodos.

Antes de entrar de lleno en el código, vamos a ver los métodos propios de la clase Applet y para qué sirven.

· init(): este método es llamado cada vez que la clase se carga por primera vez. El applet puede sobrecargar este método para fijar el tamaño del applet, cargar imágenes y sonidos necesarios para la ejecución del applet, y la asignación de valores a las variables globales a la clase que se utilice.

· start(): su función es hacer que el applet comience la ejecución. El método start() de la clase Applet no hace nada. Cada vez que la zona de visualización del applet queda expuesta, se llama a este método automáticamente, aunque podemos modificarlo para que el applet siga activo aun cuando no está expuesto a la visión.

· stop(): detiene la ejecución del applet. Se llama cuando el applet desaparece de la pantalla. Este método también hay que rescribirlo.

· destroy(): es llamado cuando ya no se va a usar más el applet, cuando se necesita que sean liberado todos los recursos dispuestos por el applet, por ejemplo, cuando se cierra el navegador. Como el sistema no sabe qué recursos usa el applet, entonces debemos rescribir este método para liberarlos de forma correcta.

· paint(Graphics g): este método es llamado cada vez que el área de dibujo del applet necesita ser actualizada. La clase Applet dibuja un rectángulo gris en el área, y la clase derivada debe sobrecargar este método para dibujar lo que necesite. El sistema llama en forma automática a este método cada vez que la zona de visualización del applet cambia. Este cambio puede deberse a que la página se actualiza, a que el applet queda tapado por otra ventana, queda fuera de la pantalla, etc. El método recibe como parámetro un objeto del tipo Graphics que delimita la zona que será pintada.

· update(Graphics g): ésta es la función que realmente se llama cuando se necesita una actualización de la pantalla. La clase Applet simplemente limpia e área y llama al método paint().

· repaint: llamando a este método se podrá forzar la actualización de un applet.

10.4.- Nuestro Primer applet.

Veamos un ejemplo:

package prueba;

import java.awt.*;

import java.applet.*;

import java.awt.event.*;

public class PruebaApplet extends Applet

{

GridBagLayout gridBagLayout1 = new GridBagLayout();

TextField TxNumeroUno = new TextField();

TextField TxNumeroDos = new TextField();

Button BotonSumar = new Button();

TextField TxResultado= new TextField();

public PruebaApplet()

{

}

// Inicializa el applet

public void init()

{

// Acá ponemos el código para armar la ventana

this.setLayout(gridBagLayout1);

TxResultado.setEnabled(false);

BotonSumar.setLabel("Sumar");

BotonSumar.addActionListener(new java.awt.event.ActionListener()

{ public void actionPerformed(ActionEvent e)

{ BotonSumar_actionPerformed(e); }});

this.add(TxNumeroUno, new GridBagConstraints(0, 0, 1, 1, 0.0, 0.0,

GridBagConstraints.CENTER, GridBagConstraints.NONE,

new Insets(20, 20, 1, 20), 50, 0));

this.add(TxNumeroDos, new GridBagConstraints(0, 1, 1, 1, 0.0, 0.0,

GridBagConstraints. CENTER, GridBagConstraints.NONE,

new Insets(1, 20, 20, 20), 50, 0));

this.add(BotonSumar, new GridBagConstraints(0, 2, 1, 1, 0.0, 0.0,

GridBagConstraints. CENTER, GridBagConstraints.NONE,

new Insets(0, 0, 0, 0), 0, 0));

this.add(TxResultado, new GridBagConstraints(0, 3, 1, 1, 0.0, 0.0,

GridBagConstraints. CENTER, GridBagConstraints.NONE,

new Insets(20, 20, 20, 20), 50, 0));

}

// Acción del botón sumar

void BotonSumar_actionPerformed(ActionEvent e)

{

int numeroUno = Integer.parseInt(TxNumeroUno.getText());

int numeroDos = Integer.parseInt(TxNumeroDos.getText());

int resultado = numeroUno + numeroDos;

TxResultado.setText(new Integer(resultado).toString());

}

Si intentamos ejecutarlo por consola, nos dará un error, ya que ésta ya no es una aplicación de consola, sino un applet. Y para ejecutarla, necesitamos embeberla en una página HTML. Así:

<html>

<head>

<title>

Página HTML de prueba

</title>

</head>

<body>

<h1>Ingrese dos números y presione el botón sumar</h1>.<br>

<applet

codebase = "."

code = "prueba.PruebaApplet.class"

name = "PruebaApplet"

width = "400"

height = "300"

hspace = "0"

vspace = "0"

10.5.- Sonidos en los applet.

Los applet pueden incluir sonidos a través de la interfaz AudioClip. El archivo de sonido puede ser cargado desde una dirección URL a través del método getAudioClip() para su posterior ejecución, o a través del método play(), también desde una URL, con la diferencia que este método lo carga y lo ejecuta. Otros métodos importantes que provee esta interfaz son loop() para repetir el sonido una vez que termine, y stop() para detener la ejecución del sonido.

Observación : Cualquier error o falta de algun tema porfavor contactarse a friveros at 4minds .cl Gracias!

Texto Bajo Licencia Creative Commons para mas información visite www.4minds.cl

Delitos E-legales en el Mundo

2008-10-10T19:46:00.001-07:00

Francisco Riveros E. fjrivero@inf.utfsm.cl

Textos: “CRIMINALIDAD INFORMÁTICA”, “LEGISLACIÓN ESPAÑA”,” LEGISLACIÓN SOBRE DELITOS INFORMATICOS PERÚ”, e Internet.

Resumen

El creciente avance que ha generado el desarrollo y el uso en general del uso de las tecnologías de la información en el quehacer del ser humano, influye y revoluciona los patrones de comportamiento y las relaciones sociales entre ellos. Debido a esta gran diversificación y globalización de las tecnologías de información, se desarrollan una serie de normativas en este ámbito bajo la disciplina del derecho, la cual hoy en día tiene que responder a nuevos y complejos problemas que se presentan, por la flexibilidad y la creación de nuevas Tecnologías. En donde también, la inexistencia de una legislación penal adecuada, posibilita la impunidad y desprotección jurídica a la sociedad en general. Para soslayar estos problemas es que los países toman diversas medidas para modificar continuamente sus legislaciones, hasta ser coadyuvados por organizaciones las cuales por medio de expertos ayudan a los estados para combatir este tema en conjunto.

Opinión

En el plano internacional se considero como definición de delito informático a “Ese acto ilegal, no ético o no autorizado que involucra el procesamiento de datos y la transmisión de los mismos”. Bajo este concepto, podemos ver que en los estados en el mundo se han adoptado diversas normativas y legislaciones para poder resguardarse sobre el problema de la e-legalidad. Pero el problema que se presenta, es que las legislaciones planteadas se adoptan a la tecnología vigente en el tiempo de la promulgación, esto provoca un gran vacio legal ya que las tecnologías de la información son muy flexibles y avanzan en el tiempo muy rápido, por lo que es necesario siempre una actualización a la legislación sobre los delitos informáticos en el tiempo.

Según las Naciones Unidas tenemos tres tipos de delitos: 1) Fraudes cometidos mediante manipulación de computadoras, 2) Daños o modificaciones de programas informáticos y 3) Acceso no autorizado a servicios y sistemas Informáticos. Bajo estos perfiles si revisamos el código Penal Español [[1]] podemos observar que no contempla directamente los delitos denominados “informáticos”, pero describe conductas delictivas descritas en el “Convenio sobre la Ciberdelincuencia” [[2]], en la que los datos o sistemas informáticos son instrumentos de comisión o el objeto del delito. En esta legislación se pone mucho énfasis en el descubrir secretos o vulnerar la intimidad de otra persona bajo los tópicos de las TI. En cambio, si analizamos el Código Penal Peruano [[3]], se pone explícitamente temas técnicos como la violación de base de datos, sistema o red de computadoras en todo sentido [[4]], o también se abarca ampliamente el tema sobre la pornografía infantil en Internet. De estas diferencias podemos inferir que se deben a las diversas situaciones enfrentadas por los estados para apaliar el problema de la delincuencia informática, pero tales medidas no logran una integración globalizada del tema. Por esto es vital que las legislaciones sean tomadas en conjunto por los estados bajo ciertos consensos ya que la problemática de los delitos informáticos requiere un estudio multidisciplinario con miras a determinar la forma más eficaz de luchar contra ellos, con un abordaje jurídico y técnico que se ponga especial atención en la prevención y en la detección de vulnerabilidades.

[1] http://delitosinformaticos.com/legislacion/espana.shtml

[2] http://194.179.107.38/media/Convenio_Ciberdelincuencia.pdf

[3] http://delitosinformaticos.com/legislacion/peru.shtml

[4] Capítulo XI, Delitos Informáticos, los artículos 208a y 208b

“Política Cambiaria en Chile”

2008-10-10T19:40:00.001-07:00

Trabajo Escrito por H Alayo S Labbe y Francisco Riveros

1. Introducción

En este trabajo, presentaremos como se ha manifestado la política cambiaria en chile, dividiendo por periodos históricos que marcaron hitos en la economía. En primera instancia, mostraremos una pequeña referencia teórica para explicar los determinantes del tipo de cambio y su incidencia en la economía. Luego analizaremos el periodo antes de 1973, posteriormente analizaremos el periodo entre el 1973 y 1990, para luego analizar el periodo de la década de los 90’s, finalización con la situación actual del país, en donde expondremos las políticas adoptadas por la autoridad de la época frente al caos económico heredado del gobierno de la Unidad Popular, para luego hacer frente a las crisis internacionales.

2. Marco Teórico

El tipo de cambio en palabras sencillas, es la cotización de una moneda en términos de otra moneda; Este expresa el numero de moneda que hay que dar para obtener una unidad de otra moneda, la cotización o tipo de cambio se determina por la relación entre la oferta y la demanda de divisas, en otras palabras, el tipo de cambio se determina por la relación entre la oferta y la demanda de moneda nacional con el fin de realizar las operaciones internacionales del país.

Al ser el tipo de cambio una variable económica clave, la determinación del sistema cambiario es relevante y debe estar vinculada, a más de los objetivos y prioridades de política. En el caso de los objetivos de la política cambiaria, la elección del régimen de tipo de cambio puede estar, condicionada a controlar la inflación, a disminuir la volatilidad del producto o a incrementar la competitividad de las exportaciones.

En general, dada la importancia del tipo de cambio en la asignación de recursos y en la transmisión de las expectativas, dos serían las características básicas que debería poseer un régimen óptimo:

· Reducir al máximo los movimientos bruscos, no predecibles y transitorios del tipo de cambio.

· Ajustarse a sus movimientos permanentes.

En consecuencia, en los regímenes más extremos de tipo de cambio, no cumplen con estos requisitos, por lo que se ha generado un nuevo concepto o interés en los tipos de cambio “administrados”, lo que llamamos: Bandas Cambiarias. Esta política de bandas respondería a las características señaladas anteriormente, ya que pretende manejar el tipo de cambio real mediante el establecimiento de una zona objetivo en términos de paridad cambiaria[1].

Tipos de Cambio:
En los tipos de cambio puede existir flexibilidad o rigidez, como un conjunto de infinitas variables dentro de los tipos de cambio, como se detallan a continuación:

Tipos de cambios rígidos y flexibles.
Tipos de cambios fijos y variables.
Tipos de cambios únicos y múltiples.

1. Cambio Rígido
El tipo de cambio rígido es aquel cuyas fluctuaciones están contenidas dentro de un margen determinado.

2. Cambio Flexible
El tipo de cambio flexible es aquel cuyas fluctuaciones no tienen límites precisamente determinados, lo que no significa que tales fluctuaciones sean ilimitadas o infinitas.

3.1 Uniones Monetarias:
Es cuando el país renuncia a la emisión de moneda propia, con lo cual el tipo de cambio desaparece como variable.
3.2 Incorporación a una moneda individual:
Es cuando el país de origen engancha su moneda a la de un país importante, que usualmente es el principal socio comercial, así mismo existen formas duras y blandas de enganche.
3.3 Enganches a una cesta de Monedas
Son arreglos fijados en relación a un conjunto de monedas de los países con la que se realiza la mayor porción de intercambio comercial.

3. Cambio Fijo
Comprenden aquellos arreglos cambiarios en los cuales el tipo de cambio esta ordinariamente "Anclado" a otras monedas y solo es modificado de forma discrecional y poco frecuente en circunstancias extraordinarias. Dependiendo del país, se divide en lo siguiente:

4. Cambio Único
El tipo de cambio único, como su nombre lo indica, es aquel que rige para todas las operaciones cambiarias, cualquiera que sea su naturaleza o magnitud. Se tolera cierta diferencia entre los tipos de compra y de venta de la divisacomo margen operativo para los cambistas en cuanto a sus gastos de administración y operación y beneficio normal. El ideal del FMI es el sistema de cambios únicos, que no admite discriminación en cuanto a las fuentes de origen de las divisas ni en cuanto a las aplicaciones de las mismas en los pagos internacionales.

3.- Historia de las Políticas Cambiarias en Chile

3.1 Política Cambiaria Antes de 1973

Desde 1930 a 1973 la economía chilena se caracterizó por una escasa importancia asignada al sector externo como un factor importante para su desarrollo, razón por la que la política cambiaria estuvo relegada a un segundo plano, sirviendo sólo como complemento otras políticas para el logro de objetivos considerados prioritarios a lo largo de distintos periodos.

Con el objetivo de preservar el funcionamiento de la economía y su nivel de ingreso, ante las fuertes variaciones que pudiese presentar la economía global, se postuló la creación de un sector industrial el cual pudiese sustentar un ritmo de crecimiento mas estable, cuyo desarrollo apoyaría la existencia de demanda interna, la cuál hasta ese entonces era satisfecha con importaciones. Esto hacia necesario proteger dicho sector, lo que hizo necesario instaurar barreras arancelarias y restricciones cuantitativas a la internación de mercaderías, para así asegurar el mercado local.

La política cambiaria se mantuvo prácticamente invariable desde 1932 hasta 1956 y consistió en el establecimiento de una amplia gama de tipos de cambio, tanto para los retornos de las exportaciones como para las importaciones.

En 1956 se intento simplificar las normas de operación del comercio exterior y una reestructuración del sistema de cambios múltiples, dejando un tipo de cambio para las mercaderías y otro para el turismo y transacciones de capital. Esto, buscaba una apertura de la economía al exterior y una revitalización del sector privado como elementos vitales para el crecimiento económico del país, ya que se estimaba que la estrategia de industrialización forzada se había agotado. Luego, hasta fines de la década del sesenta se busco combinar la acción estatal y la del sector privado, de manera de impulsar el crecimiento económico, buscando además, una expansión del mercado interno mediante la creación de acuerdos de integración regional como ALALC y Pacto andino. Esto requería modificaciones en materia de política cambiaria y arancelaria. Así, en la primera se establece una política de tipo de cambio con devaluaciones programadas, con la finalidad de mantener un nivel del tipo de cambio real. En la segunda, se plantea una política de desgravación sistemática tendiente a estableces un arancel externo mínimo.

Durante el periodo 1971 a 1973, el país experimento un proceso acelerado de estatización y un retorno a la idea de crecimiento hacia adentro, lo que condenso todos los problemas que se habían presentado en los periodos anteriores. Además, hubo un quiebre del sistema institucional y un desajuste generalizado de los mercados, entre ellos el sector externo, con un tipo de cambio múltiple, restricciones cuantitativas al comercio y abandono de la etapa iniciada en el periodo anterior.

En síntesis, la estrategia de desarrollo aplicada en Chile en el periodo previo a 1973 tuvo como norma general la industrialización basada en la sustitución de importaciones conjuntamente con un rol activo y de intervención estatal creciente en la economía.

La carencia de objetivos definidos en la política cambiaria condujo a una manipulación indebida del tipo de cambio, lo que conllevo a la aparición de múltiples tasas cambiarias dependiendo de los productos que se importaban o exportaban.

3.2 Política Cambiaria durante el periodo 1973-1989

El marco económico inicial está marcado por un desequilibrio en la balanza de pagos, agotamiento de los recursos internacionales, deuda externa, restricciones no arancelarias y aumento de las tasas de inflación, correspondiendo al Banco Central ser operador y ejecutor de la nueva política cambiaria, lo que permitió al país abandonar la de economía cerrada, iniciando la integración comercial en el exterior;

La función del tipo de cambio fue básicamente la de servir como instrumento regulador del nivel del comercio exterior, adoptando una política cambiaria de pequeñas devaluaciones, efectuadas por el Banco Central., lo que permitió mantener un tipo de cambio acorde con las condiciones económicas impuestas en el corto plazo. Por fechas, las etapas son:

ENE ’73 – JUN ’76: Tipo de cambio reptante, que es devaluar, periódicamente y con ajustes pequeños, el tipo de cambio de acuerdo a la diferencia entre las tasas de inflación doméstica y externa relevantes.

El tipo de cambio fue utilizado como instrumento de incentivos al sector exportador; como instrumento que permita reflejar verdaderamente la relación entre los precios internos y los internacionales., como apoyo a la apertura comercial y financiera al exterior. Además se determinó la necesidad de efectuar, en primer termino, una reducción de los niveles arancelarios vigentes.

JUN ’76 – FEB ’78: se procedió a revaluar el peso en 10% (el dólar baja de $19,75 a $17,77); el tipo de cambio aumento primero en un 4%, y después 3%. Para los periodos siguientes el reajuste del tipo de cambio se hizo en la forma ya habitual, que era la correspondiente a la tasa de variación del IPC habido en el mes anterior.

FEB ’78 – JUN ’79: En febrero de 1978 el gobierno anuncio un cambio de política cambiaria, que consultaba tasas decrecientes de devaluación. Estas equivalían, aproximadamente a la inflación mensual registrada en el mes anterior. Se partió con una tasa decreciente de 2,5%, para llegar en diciembre a 0,7%. Se mantendría esta política durante el año siguiente, teniendo como meta la mantención del tipo de cambio real para garantizar a los exportadores rentabilidad, pero también permitir traer al país los productos que se requieren del extranjero a precios razonables.

JUN ’79 – ’82: Este periodo se caracterizo por un desarrollo acelerado y estable en todas las áreas de la economía (El PGB real creció 8,3% en 1979 y 7,5% en 1980) Entre 1981 y 1982, se produjo una violenta alza en el costo real del crédito interno, introduciendo un tercer elemento que le restaba competitividad a la industria de bienes transables, obligándola a operar con un costo financiero real excesivamente alto.

’83 – ’89: Este período comienza con una total confusión que refleja la crisis total en que se encontraba la economía. Así, en conjunto con la devaluación de 1982, l tipo de cambio se liga a una canasta de monedas, la que se reajustaba diariamente un 0,2%.

La crisis externa generada en el período anterior obligaba a las autoridades a generar recursos externos para hacer frente a la escasez de divisas en que se encontraba el país, se generó una fuerte devaluación en la moneda. Aparte de las devaluaciones se implementa una política de significativo ajuste del gasto público, para que de este modo se le pueda dar un mayor espacio a la devaluación sin producir presiones inflacionarias; el objetivo primordial era hacer frente a la restricción externa (nula apertura de capitales), por lo que la inflación pasó a ser un objetivo secundario; en la última etapa del período fue frecuente modificar la regla de indización del dólar acuerdo por considerarse excesivas las variaciones del IPC (en 1988 se modificó 3 veces); entre junio de 1989 y el primer trimestre de 1990 el tipo de cambio se mantuvo pegado al limite superior de la banda de flotación.

3.3 Política cambiaria en los años 90

La política cambiaria en Chile, experimentó un cambio sustancial después de la crisis de 1982 y 1983. El tipo de cambio se devaluó diariamente. En ese entonces Chile estaba saliendo de una crisis de la deuda, acompañada de gran depreciación; se había llegado a máximos históricos del tipo de cambio oficial. En enero de 1992 la banda de flotación del mercado cambiario fue ampliada +/- 10% con lo que surgió una ola de expectativas revaluatorias alimentadas por ingresos de capitales.

Por ese tiempo y durante varios meses circuló por el Banco Central la proposición de iniciar, dentro de la banda, una flotación “sucia” o regulada. Los que propusieron esta intervención argumentaban que las normas vigentes, de banda pura, con un mercado informal crecientemente activo conducían a un tipo de cambio que se inclinaría hacia los extremos de la banda. La reevaluación brusca de casi 10% del tipo de cambio oficial entre Enero y Febrero de 1992 contribuyó a que el Banco Central iniciase la flotación sucia en Marzo. En ese tiempo, el tipo de cambio observado fluctuó en un rango de entre 1 y 8 puntos sobre el piso; vale decir, habitualmente pegado al piso, con activas compras por el Banco pero también con ventas esporádicas.

La ampliación de la banda creo expectativas respecto de que el Banco Central renunciaba a tratar de frenar presiones revaluatorias y defender la exportación, dando al mercado la determinación de la tasa observada en un rango más amplio. Con la definición de la flotación regulada, el Banco Central volvía a tener una gran capacidad de conducción que permitía fortalecer las variables de largo plazo en la determinación del tipo de cambio que enfrentaban los productores de rubros importables y exportables.

Luego de esta situación el Banco Central se vio presionado por el descenso de las tasas de interés de Estados Unidos; hecho que no pasó a mayores, pues Chile gozaba de un auge notable con una tasa de aumento del PIB situada en dos dígitos. Dada esta situación, el Banco Central quiso elevar en vez de reducir las tasas de interés internas; y aumentó la tasa de encaje para los ingresos de capitales, evitando así un estímulo al arbitraje.

En julio de 1992 se reemplazó al dólar como vínculo directo del tipo de cambio oficial por una canasta de monedas como nuevo tipo de cambio de referencia; hecho que introdujo mayor incertidumbre cambiaria a las operaciones en dólares en el corto plazo. Sin embargo, se dio una mayor estabilidad a los valores en pesos de los retornos de exportaciones. El desempeño efectivo del mercado en esa época, muestra que las apreciaciones cambiarias que se registraron en el periodo tendieron al equilibrio, consistentes además con la desaparición de causas de la crisis de los ochenta y con las mejoras netas de productividad de los productos chilenos.

El escenario de abundancia de flujos de capitales luego del 1995, tuvo al tipo de cambio casi pegado al piso de la banda hasta fines de 1997. Dada la existencia de expectativas abrumadoras a favor de la apreciación y el gran diferencial entre las tasas de rentabilidad esperada entre el peso y el dólar se brindó a los inversionistas extranjeros oportunidades muy lucrativas al refugiarse en la moneda nacional. Más allá de su adhesión formal a una banda móvil, el Banco Central en 1996 y 1997 estaba aceptando la flexibilidad cambiaria hacia la apreciación. A fin de reducir el piso de la banda, las autoridades hicieron ajustes contradictorios de las ponderaciones asignadas a cada moneda, provocando que la vinculación con una canasta de monedas perdiera credibilidad. También hubo una sobreestimación de la inflación externa usada para determinar el tipo de cambio, hecho que generó una reevaluación adicional de 10% entre 1995 y 1997.

Finalmente a fines del 1997, cuando la crisis asiática se sintió y las expectativas de apreciación cambiaron a expectativas de depreciación, el Banco Central frenó fuertemente las presiones al alza del tipo de cambio por la vía de la venta masiva de divisas. A mediados de 1998 se redujo la amplitud de la banda junto con una intensificación de un ajuste liderado por alzas en la tasa de interés de instancia del Banco al 14,5% real; todo ello se hizo para dar la señal de que el Banco Central no cedería a las presiones devaluatorias del mercado. Posteriormente, luego de ampliar la banda a fines del 1998, en septiembre de 1999 se suspendió el compromiso de la banda como un modo de facilitar el ajuste del tipo de cambio.

3.4 Política Cambiaria en el estado actual

Desde el año 2000, la economía chilena se ha visto impactada por variados disturbios derivados del ambiente internacional: por una parte la inestabilidad de economías emergentes, como la Argentina y, por otro, la confirmación de que economías más desarrolladas tendrían desempeños más pobres; como la de Estados Unidos.

En su historia, nuestro país ha experimentado diferentes regímenes cambiarios; hechos que muchas veces terminaron por aumentar, en vez de disminuir, los ajustes macroeconómicos. La razón se basa en que una economía como la chilena, pequeña, abierta al exterior y rica en recursos naturales debe tener un tipo de cambio real que fluctúe de forma considerable.

En 1999 el Banco Central tomó un régimen de flotación que ha permitido que la política monetaria sea usada para objetivos inflacionarios, hecho que además, ha permitido que el tipo de cambio sea una variable importante que absorbe los shocks externos, haciendo que los ajustes sean más eficientes y menos costosos.

En este régimen de flotación, el Banco Central no puede tratar de fijar un precio para el dólar y se permite que el mercado encuentre el equilibrio adecuado y congruente con los fundamentos de la economía. Hasta el 2001, el tipo de cambio real se depreció en términos reales casi un 30% respecto de 1999, dada la caída de los términos de intercambio y el deterioro del crecimiento internacional. La caída mencionada en términos de intercambio, implica que las exportaciones son más baratas que las importaciones, es decir, la valoración relativa por los bienes nacionales es menor internacionalmente.

El presidente del Banco Central, Sr. Vittorio Corbo ha mencionado que “el marco de políticas macroeconómicas que se han perfeccionado en Chile en los últimos 15 años, incluyendo la flotación del tipo de cambio, es el más apropiado para una economía pequeña, integrada al resto del mundo que está sujeta frecuentemente a estos cambios en su entorno.”

Hoy en día, Chile continúa en un ciclo expansivo y relativamente ordenado con excelentes condiciones externas. La caída del tipo de cambio real se basa en favorables términos de intercambio, muy influenciados por el alto precio del cobre. Por otro lado, el Banco Central ha seguido un proceso de reducción gradual del estímulo monetario con aumentos de la tasa de interés y el valor de las exportaciones ha alcanzado sus máximos niveles en el primer trimestre de 2006. De la misma forma, la apreciación real del tipo de cambio a partir del segundo trimestre de 2006 (8% más que el promedio entre los años 1999 y 2005) ha hecho que los intercambios estén sobre promedios históricos y los costos de financiamientos externos estén históricamente bajos.

Chile ha optado por este régimen de flotación cambiaria por sus experiencias anteriores y por una mejor compresión de los fenómenos involucrados. Se dice que de los años 70 se aprendió de la disciplina fiscal, en los 80 de la financiera y en los 90 de la flexibilidad cambiaria. Lo destacable de está flotación es la flexibilidad que se tiene para hacer frente a choques externos reales, favoreciendo una respuesta rápida a través de los precios relativos con menor impacto en el producto y el empleo. Este régimen de flotación facilita ajustes a choques financieros internacionales y no permite que el país esté tan vulnerable a una crisis de balanza de pagos. También, es destacable que el tipo de cambio flexible permite implementar políticas monetarias autónomas, enfocadas al logro de una meta de inflación que permita estabilizar el producto en torno al producto potencial. Por último, es preciso mencionar que la actual política cambiaria genera más incentivos al sector privado, llevando a menores niveles de endeudamiento externo, una menor dolarización de pasivos domésticos y una asignación más eficiente del riesgo cambiario al interior de la economía.

Sin lugar a dudas, la adopción de un régimen de flotación cambiaria da flexibilidad, evitando costosos ajustes ante alteraciones de condiciones, tanto externas como internas. Este sistema de flotación, más el sistema financiero sólido imperante hoy en día, han evitado las crisis cambiarias en nuestro país.

4.- Conclusiones

En el periodo 1930 a 1973, la economía chilena se caracterizó por una escasa importancia asignada al sector externo como un factor importante para su desarrollo, razón por la que la política cambiaria estuvo relegada a un segundo plano, sirviendo sólo como complemento otras políticas para el logro de objetivos considerados prioritarios a lo largo de distintos periodos.

En el periodo de 1973 a 1990, Entre el 73-76 se mantuvo vigente la política cambiaria, arancelaria y de fomento de exportaciones, que permitió duplicarles en un año, excluyendo el cobre. Entre los años 77-78 se creo una situación de competencia externa se estableció una mas estrecha relación entre el nivel del arancel y el tipo de cambio; El periodo de los años 79-82 se caracterizo por un desarrollo acelerado y estable en todas las áreas de la economía (El PBI real creció 8,3% en 1979 y 7,5% en 1980y 8,3% promedio de los nueve meses de 1981 con relación a igual lapso de 1980). Entre los años 83-89. el objetivo primordial en esta época era hacer frente a la restricción externa (nula apertura de capitales), que atravesaba el país, por lo que la inflación pasó a ser un objetivo secundario. La banda de flotación se amplió en sucesivas ocasiones durante este período. Comenzó con un 0,5% en 1984, lo que era visto como un precio razonable entre los precios de compra y venta. En junio de 1985 se amplió cerca del 2%, en enero de 1988 a cerca del 3% y en junio de 1989 a casi el 5%.

En la década de los 90, La banda de flotación establece que el sistema pueda resultar excesivamente manejado por el gobierno. Sin embargo, ello brinda la posibilidad a las autoridades de intervenir directamente cuando las circunstancias lo requieran, en función de proteger los intereses de la nación.

A contar de 1999 hasta hoy, en chile se estableció el mercado de libre flotación para el dólar lo que permitió a través de la aplicación de una buena política monetaria, mantener los índices macroeconómicos que convirtieron a chile en una de las economías más estables de América.

[1] Paridad Cambiaria: La teoría de la paridad cambiaria se basa en el concepto de que la política cambiaria debe utilizarse para mantener el equilibrio del sector externo de la economía. Esta teoría plantea que la tasa de cambio de equilibrio en el largo plazo es aquella que permite alcanzar el equilibrio de la balanza de pagos en un determinado periodo de tiempo. Esta paridad cambiaria es la relación entre la inflación interna del país y las inflaciones de los países con que comercia. Si la inflación interna del país es mayor, se encuentra en una situación de atraso cambiario, mientras que la situación inversa implica una posición de adelanto cambiario.

Aplicaciones de SVD en Biología

2008-10-10T19:38:00.001-07:00

Daniel Anguita	2273081-9
Marcos Fuentes F.	2273011-8
Sergio E. Labbé S.	2273031-2
Francisco J. Riveros E.	2273036-3
Marcelo Salazar	2273045-2

Lunes 3 de Julio de 2006

1 Resumen

La descomposición en valores singulares (SVD) es utilizada en diferentes áreas de la biología actualmente. En general, SVD se utiliza para el análisis de conjuntos de datos, que a menudo son grandes y “ruidosos”.

Entre las numerosas aplicaciones de SVD en la biología, se destacan en este trabajo tres: Dinámica de proteínas, Análisis de micro-arreglos de datos e Ingeniería inversa en redes genéticas. En cuanto a la dinámica de proteínas, se utiliza la SVD para analizar el movimiento de la hemoglobina muscular (myoglobin) respecto de la dinamica molecular. Según este método sirve para descomponer una trayectoria dinámica molecular hacia dentro de los modos fundamentales del movimiento atómico.

El análisis de micro-arreglos (microarrays) de datos, sirve para comparar distintos micro-arreglos de ADN. Se utiliza SVD en este campo, con el fin de obtener los “genes propios” (eigengenes o filas de la matriz V de la SVD) y el “análisis propio” (eigenassays o columnas de la matriz U de la SVD). Así, se comparan las muestras a través de estos dos parámetros obtenidos de la SVD, de donde se extraen patrones. El objetivo de encontrar estos patrones es lograr clasificar genes, inferir las funciones de los genes. Además, se busca clasificar enfermedades comparando con un micro-arreglo normal y estudiar los efectos de un estímulo interno.

La SVD, también es útil en la ingeniería inversa a redes de genes. La idea, es utilizar SVD para encontrar los mínimos cuadrado para encontrar la expresión que permita localizar una familia de soluciones, es decir, de tomar una matriz que representa genes y experimentos, y a través de mínimos cuadrados, encontrar la mejor familia de soluciones posibles.

Por otro lado, en este trabajo se agregan otros experimentos en los que se usan para analizar las capacidades metabólicas de dos especies de bacterias, comprobándose en estas dos que el “helicobacter pylori” tiene una red metabólica mas rígida que la “Haemophilus influenzae” para la producción de aminoácidos; Siendo la SVD, capaz de identificar los principales puntos de control para la regulación. Luego como punto principal del uso de SVD, fue que gracias a este procedimiento, se pudo aplicar a grandes números de ejemplos, por lo que se ocupan en grandes redes de genoma, antes difíciles de aplicar sin una transformación.

2 Introducción

La descomposición en valores singulares (SVD), es una herramienta en el álgebra lineal muy potente, que es muy usada para diversos ámbitos de investigación tanto como para análisis sintácticos como para la biología, entre otros casos. La SVD permite, a través de una serie de operaciones lineales elementales (todas las que involucran suma y/o multiplicación de filas y/o columnas), descomponer la información contenida en la matriz de datos y representar, en otras tres matrices, aspectos singulares o característicos de aquella información.

El principio de descomposición involucra la reducción del elevado numero de dimensiones con que los datos son descritos en la primera matriz, las que impiden distinguir los valores singulares. La reducción, en tanto, consiste en desechar la información incidental (es datos irrelevantes) considerado como ruido en los datos, proporcionando así un modelo de distribución normalizado de las frecuencias o modelo sin ruido, el que redunda en una representación matemática mas compacta y, por tanto, mas simple de computar.

Las matrices resultantes de la operación son:

Matriz ortogonal (U en la Figura 1): obtenida al procesar linealmente el número de columnas (ortogonal) de la matriz original (A en el ejemplo de la Figura 1). En esta matriz se representan datos como vectores en espacios de datos.

Figura 1 : Representación de matriz ortogonal

b) Matriz transpuesta (V en la Figura 2): obtenida al permutar las filas por las columnas), proporcionando una disposición ortogonal de los elementos de la fila A través de esta transposición se presentan documentos como vectores en espacios de datos.

Figura 2 : Representación de matriz transpuesta.

c) Matriz diagonal (E en la Figura 3): obtenida al procesar linealmente el número de filas, el número de columnas y la cantidad de dimensiones de la matriz original (A). La matriz diagonal representa el valor singular de (A) y en ella todos los elementos que no pertenecen a la diagonal son nulos o iguales a cero.

Figura 3 : Representación de matriz diagonal.

Las tres nuevas matrices (U), (V) y (E) dan origen a los vectores singulares de la representación matricial del corpus (A), a saber, vector de palabras, de documentos y de valor singular, respectivamente .La Figura 4, que se presenta a continuación, grafica la factorización con SVD.

Figura 4 : Representación de SVD

Si las tres nuevas matrices fueran multiplicadas, el producto resultante sería semejante, pero nunca idéntico a la matriz original, pues las dimensiones de esta ya han sido reducidas y solo puede ser reconstituida la información esencial, producto definido como valor singular (matriz E) y vectores singulares (matrices U y V). De este modo, tras la SVD se obtiene una información que no está directamente disponible en la primera representación matricial, sino que está latente en ella .

3 Tema de Aplicación

3.1 Dinámica de Proteínas

Como dijimos anteriormente en la introducción, por medio del análisis del SVD se ha usado para caracterizar a las proteínas dinámicas. En este caso se usa una SVD para analizar el movimiento de la hemoglobina muscular (myoglobin).Ya que según el profesor Romo [[1]], usando los métodos de dinámica molecular, es posible medir las posiciones atómicas de todos los átomos muestreados durante una simulación.

En el método de dinámica molecular se trabaja de la siguiente forma en un software:

Se leen los parámetros que especifican las condiciones de la corrida tales como la temperatura inicial, el numero de partículas, la posición de las partículas (estructura fcc, bcc, etc.) la densidad, el paso de tiempo Δt, tiempo total de simulación, etc.

Se inicializa el sistema, esto es, se asignan las posiciones y las velocidades iniciales.

Se calculan las fuerzas sobre todas las partículas.

Se integran las ecuaciones de movimiento de Newton. Este paso así como el anterior conforman el loop central de la simulación. Ellos son repetidos hasta haber calculado la evolución temporal del sistema durante el tiempo total de simulación deseado. Se van guardando las posiciones, velocidades, fuerzas, etc., durante cada paso en un archivo para luego ser procesadas.

Después de haber completado lo anterior, se calculan y se imprimen los diferentes promedios relevantes.

En otros experimentos el Prof. Ozkan, uso la SVD para el estudio si dos-estados proteínicos se pliegan en caminos o canales (funnels). El plegamiento proteico, es la segunda traducción del mensaje genético, este completa la información transferida del DNA al producto final, la proteína activa. En otras palabras, para entender completamente este proceso, es necesario descifrar el código de plegamiento, la segunda parte del mensaje genético:

DNA → RNA → cadena polipeptídica → ¿Proceso de plegamiento? →Proteina activa

Según el estudio de Ozkan, mostró que el modelo de plegamiento puede producir que esconda intermediarios. Una gran multiplicidad de trayectorias fueron observadas a nivel microscópico, empero estas colapsaban al esconder intermediarios a nivel microscópico corriendo en paralelo. Esta SVD fue usada para procesar estos datos, bajando a un nivel que podría ser analizado visualmente. Una matriz de 32 x M, fue creada fuera de M conformaciones de los 16mer cadenas de aminoácidos. Aquí las eigenfilas de los dos más grandes valores singulares fueron usadas como eje para un grafico 3-dimensional con el eje-z representando a la energía. Así, una representación de dos dimensiones de la energía de vista fue desarrollada usando la SVD. Por ejemplo podemos ver una vista para configuraciones para 4 o más contactos:

3.2 Análisis de Micro-Arreglos de Datos.

Los micro arreglos de datos, se entienden como matrices en las que las filas corresponden a genes, mientras que las columnas son experimentos, por lo que cada entrada de la matriz a_ij, es la respuesta del gen i cuando se aplica el experimento j. En la siguiente figura se muestra la descomposición.

En este caso, las columnas de la matriz U de la SVD recibe el nombre de “análsis propio”, mientras que las filas de la matriz V “genes propios” (de ahora en adelante se utilizan los nombres en inglés que están en la figura. La idea, es que la respuesta de un gen frente a un estimulo, se puede escribir como combinación lineal del eigengen, mientras que la expresión de un experimento, como combinación lineal de un eigenassay.

Alineando el procedimiento con los fundamentos de la SVD, tenemos que la matriz que contiene los datos experimentales, se descompone en sus vectores propios y en otros que deforman estos vectores. La SVD tradicional, muestra que la matriz de datos en este caso parte de una circunferencia formada por los vectores propios de norma 1, y que se amplifica con la matriz que contiene los valores singulares, para luego rotar el producto de lo anterior y generar una hiper-elipse rotada a partir de la circunferencia de radio 1. La matriz de valores singulares y las columnas de la matriz U de eigenassays, representan los estímulos proporcionados a los genes en estado natural que son representados por las filas de la matriz V.

3.3 Ingeniería Inversa en Redes Genéticas

Si un sistema se encuentra operando cerca de un estado estable, las dinámicas (fluctuaciones de la concentración en una red de genes) se pueden aproximar a través de la ecuación:

Donde x, es la concentración de mRNAs que reflejan los niveles de expresión de los genes, los λ_i, representan las tasas de auto-degradación, las W_ij, describe el tipo y fuerza de la interacción entre los genes i y j, las b_i, son el estímulo interno, y ε_irepresentan el ruido.

Un experimento aplica un estímulo y usa un micro-arreglo para medir las concentraciones de N mRNAs diferentes. Al repetir M veces este experimento, se puede obtener una estimación de x.

Ahora, la ecuación anterior, puede escribirse en forma matricial, de la siguiente manera:

Donde la matriz A es una combinación de W, es decir, que la solución para A, permite obtener W, que es lo que se busca.

El objetivo de la ingeniería inversa, es usar la matriz medida B, X y X’ para deducir A y por lo tanto la matriz de conectividad W. Tomando la transpuesta del sistema anterior, queda:

Si M = N, y además X es de rango completo, basta con invertir X para encontrar A. Sin embargo, típicamente, M es mucho mayor que N por el alto costo de perturbaciones y medidas. Por lo tanto, se tiene un problema indeterminado. Una forma de abordar el problema es utilizando la SVD, donde al descomponer la transpuesta de X queda:

Si se asume que todos los valores singulares de la transpuesta de X están al final de la diagonal de W, se puede obtener una solución particular para A:

Donde 1/w_j se reemplaza por 0 si w_j = 0.

Por lo anterior, sabemos que todas las posibles soluciones son:

La solución a elegir, es aquella que los errores de mínimos cuadrados. Este método, trata de encontrar una solución que se acerque lo más posible a la encontrada.

Cabe señalar que las redes de genes a menudo son poco densas, esto quiere decir que la mayoría de los genes no interactúa con otros. Por lo que en vez de buscar una solución con el mínimo error cuadrático, se busca por una solución con el mínimo número de conexiones, o la “matriz de escasez”.

En el gráfico de la izquierda, se muestra el número de errores (E), cometidos por la ingeniería inversa como una función de M, el número de medidas.

El segundo gráfico, muestra el número crítico de medidas, M_c, requerida para cubrir correctamente la matriz de conectividad, en función de N, el tamaño de la red para sistemas lineales. Los círculos muestran los datos , mientras que la recta, es la aproximación por mínimos cuadrados.

3.4 Otros Problemas

Sobre otras aplicaciones de la SVD, podemos ver el uso para analizar las capacidades metabólicas de dos especies de bacterias. El análisis del espacio de soluciones y la dominancia del primer valor singular revelo que la “Helicobacter pylori” tiene una red metabólica mas rígida que la “Haemophilus influenzae” para la producción de aminoácidos. Así la SVD fue capaz de identificar las principales ramas de la red que pueden ser identificados como principales puntos de control para la regulación.

En ese estudio se mostró que la SVD de una matriz (W) formada para un random de ejemplos desde el espacio de soluciones en el estado estacionario de las redes metabólicas hRBC (human red blood cell) dan acercamientos similares dentro de las propiedades regulatorias de la red, tal como fueron obtenidas con la SVD de P, obtenida de los Extreme pathways (ExPas). Estos nuevos acercamientos tienen dos principales ventajas. Primero, esto funciona con una representación directa de las formas del espacio de soluciones metabólicos sin el factor de unión de una distribución no uniforme de los Extreme pathways y segundo, que el procedimiento SVD puede ser aplicado a grandes números de ejemplos, tal como sería producido desde las redes genome-scale.

4 Aporte Grupal

Dinámica de Proteínas.

En este caso, SVD provee de un método para descomponer una trayectoria dinámica molecular hacia dentro de los modos fundamentales del movimiento atómico. Los vectores singulares derechos, son proyecciones de las estructuras de proteínas sobre estos modos fundamentales mostrando el movimiento de la proteína en una base generalizada de bajas dimensiones. En este caso, análisis estadísticos de los vectores singulares derechos, pueden ser usados para clasificar sub-estados configuracionales discretos en la proteína. Luego, el retrato del espacio configuracional formado desde los vectores singulares derechos, pueden también ser usados para visualizar un movimiento complejo de dimensiones altas, y asimismo para examinar la magnitud del espacio muestreado por la simulación.

Análisis de Micro-Arreglos de Datos.

Los micro-arreglos son una de las últimas brechas en la biología molecular, el cual permite el monitoreo de la expresión de genes de miles de millones en paralelo y ya se esta produciendo una gran cantidad de información con estos datos. El análisis y manejo de estos datos se a convertido en uno de los mayores cuellos de botella en la utilización de esta tecnología. El fondo de los micro-arreglos son las imágenes, donde deben ser transformadas a expresiones matriciales de genes, es decir, tablas donde las filas representan genes y las columnas representan varios muestreos como tejidos finos de las condiciones experimentales, y los numeros en cada celda caracterizan a nivel de expresión particular de cada gen en una muestra particular. Estas matrices deben ser analizadas posteriormente, si cualquier conocimiento adyacente a los procesos biológicos es extraído.

Ingeniería Inversa en Redes Genéticas.

Descubriendo y entendiendo la complejidad de la interacción molecular que se traduce en un organismo vivo es uno de los restos más interesante de la biología molecular moderna. Por esto se usa ingeniería inversa optimizada buscando la reconstrucción de red de interacción entre genes dinámicos. La aproximación se basa en los micro-arreglos de datos y los conocimientos de la biología actual. Así se identifican estructuras de redes buscando sistemas ordinarios de ecuaciones diferenciales, las cuales simulan comportamientos que pueden encajar en la expresión de los genes. Métodos de re-muestreo son aplicados para validar el modelo de red dinámica.

Este algoritmo fue aplicado para diferenciar los distintos micro-arreglos de DNA.

5 Conclusiones

No cabe la menor duda que la técnica SVD, junto al gran avance computacional, se esta transformando en algo esencial y relevante para la biología, debido a que entrega la información de un punto de vista factorizado, sino que también esta filtra información redundante que muchas veces no hacen mas que entorpecer la etapa de análisis. La importancia de la SVD en biología puede ser apreciada si se revisan papers relacionados con el tema, de los cuales 81 realizan una referencia a esta técnica desde el año 2002, donde se mencionan nuevas técnicas y usos de esta descomposición de datos. Como los biólogos se han adaptado mejor a nuevas técnicas y herramientas, el uso de la SVD continuará creciendo en un futuro cercano.

[1] Romo T.D., Clarage J.B., Sorensen D.C., Phillips G.N., Jr. Automatic identification of

discrete substates in proteins: singular value decomposition analysis of timeaveraged

crystallographic refinements. Proteins 1995; 22:311-21.

BANCO CENTRAL E INFLACION

2008-10-10T19:32:00.001-07:00

( TRABAJO ESCRITO EN EL 2006 PARA ECONOMIA I/A)

El origen del Banco Central de Chile.

El Banco Central de Chile fue creado en virtud del decreto ley N° 486 del 21 de agosto de 1925, promulgado bajo el gobierno de don Arturo Alessandri Palma.

Abrió sus puertas al público el lunes 11 de enero de 1926. La institución comenzó sus actividades con un capital nominal de 150 millones de pesos de los cuales aproximadamente el 13% era aportado por el Estado, el 40% por los bancos comerciales nacionales y extranjeros que operaban en Chile y el 47% restante por el público mediante la suscripción de acciones.

Ismael Tocornal Tocornal y Francisco Garcés Gana eran el presidente y vicepresidente respectivamente.

La primera ley orgánica del Banco Central estuvo vigente hasta julio de 1953, cuando fue publicado el Decreto con Fuerza de Ley N° 106, dando origen a la segunda ley orgánica del Banco. En esta nueva ley, el Banco Central fue concebido como una institución autónoma de duración indefinida, cuyo objetivo fundamental consistía en “propender al desarrollo ordenado y progresivo de la economía nacional mediante una política monetaria y crediticia que, procurando evitar tendencias inflacionistas o depresivas, permita el mayor aprovechamiento de los recursos productivos del país”.

Los objetivos de la autonomía: una visión económica.

a) Estabilidad de la moneda

La actual ley orgánica constitucional del Banco Central de Chile establece, en su artículo 3°, que uno de los objetivos básicos del Instituto Emisor es velar por la estabilidad de la moneda. Esto significa evitar que el valor de la moneda se deprecie por efectos de la inflación. Así, es tarea del Banco Central preocuparse de que la inflación sea baja y estable.

b) Normal funcionamiento de los pagos internos

El artículo 3° de la ley orgánica constitucional del Banco Central de Chile establece el segundo objetivo básico del instituto emisor, el velar por el normal funcionamiento de los pagos internos.

Se entiende por sistema de pagos internos el conjunto de instituciones e instrumentos que facilitan la realización de transacciones en la economía. Por lo general se incluyen como componentes principales dentro de éste el circulante y los depósitos a la vista (cheques) en los bancos. Estos son los instrumentos que más usados en las transacciones que realizan los agentes económicos; una falla en su normal funcionamiento afectaría todo el sistema de pagos, con graves daños reales para la economía.

c) Normal funcionamiento de los pagos externos

El artículo 3° de la ley orgánica constitucional establece, finalmente, que el Banco Central de Chile debe velar por el normal funcionamiento de los pagos externos.

Políticas del Banco Central

A) Descripción de las principales políticas

1. Política monetaria

El Banco Central debe proteger el valor de la moneda nacional, el peso, buscando que la inflación sea baja y estable. El propósito de mantener una inflación baja y estable, que es la forma en que se interpreta en la práctica el concepto de estabilidad de precios.

2. Política cambiaria

Existe una política en estos momentos de flotación cambiaria, en donde el Banco Central regula por medio de esta cualquier alteración que sufra el mercado financiero, esto es, cualquier variación en los precios, corrigiendo de esta manera una inflación o deflación.

3. Política financiera

El Banco Central es el prestamista de última instancia de la economía, y por tanto provee liquidez a las instituciones que enfrentan problemas temporales de caja. El Banco Central también tiene facultades regulatorias en los pagos de intereses sobre cuentas corrientes y razones de crédito.

B) Mecanismos de transmisión y el horizonte de política

La transmisión de los cambios en la política monetaria hacia el resto de la economía sucede a través de varios canales y toma un tiempo relativamente largo y variable en materializarse. Así, son diversos los mecanismos a través de los cuales una determinada acción de política (reflejada en un cambio en la tasa de interés de política) puede tener impacto en la inflación y la actividad. Una política monetaria más restrictiva incide en un menor gasto privado en inversión y consumo y, por esa vía, afecta a la brecha entre la demanda agregada y el producto potencial y, finalmente, a la inflación.

C) Características de la conducción de la política monetaria

Las reuniones del Consejo con la Comisión de Hacienda del Senado son fundamentales para mantener a la sociedad informada y compenetrada de la discusión y conducción macroeconómicas, así como para que el Banco Central reciba retroalimentación respecto de las políticas seguidas y de la percepción existente respecto a ellas. Las decisiones de política se toman en reuniones mensuales, las cuales son anunciadas públicamente con seis meses de anticipación.

D) Conducción operativa de la política monetaria

La meta operacional de mediano plazo se define en términos de la variación del índice de precios al consumidor (IPC). Este indicador, sin embargo, puede mostrar un grado relativamente alto de volatilidad mes a mes, como resultado de variaciones de los precios de alimentos perecibles y de combustibles. Por lo tanto, para interpretar la información de precios periódicamente y a corto plazo (hasta doce meses), el Banco Central centra su atención preferentemente en mediciones de inflación subyacente o de tendencia, en particular la variación del IPC subyacente (el índice total excluyendo verduras, frutas y combustibles) que registra el Instituto Nacional de Estadísticas. Para proyectar la evolución de la tendencia de la inflación en un horizonte de mediano plazo, entre 12 y 24 meses, se usan ambos indicadores, cuestión que no plantea problemas prácticos ni de interpretación, puesto que ambos registros tienden a coincidir en un horizonte de dos años.

Funciones y Organización

A) Funciones

1. Emisión:

El Banco Central tiene la potestad exclusiva para emitir billetes y acuñar monedas. Los billetes y monedas emitidos por el Banco Central son los únicos medios de pago con poder liberatorio, circulación ilimitada y curso legal en todo el país.

2. Regulación de la cantidad de dinero en circulación y de crédito:

El Banco Central puede abrir líneas de crédito, otorgar refinanciamiento y descontar y redescontar documentos negociables en moneda nacional o extranjera, a las empresas bancarias y sociedades financieras; fijar las tasas de encaje que, en proporción a sus depósitos y obligaciones, deban mantener esas entidades y las cooperativas de ahorro y crédito; ceder documentos de su cartera de colocaciones o de inversiones a bancos y financieras y adquirir de las mismas, documentos de sus carteras de colocaciones o de inversiones, y, finalmente, realizar operaciones de mercado abierto.

3. Regulación del sistema financiero y del mercado de capitales:

El Banco Central está facultado para regular las captaciones de fondos del público por parte de las empresas bancarias, sociedades financieras y cooperativas de ahorro y crédito; fijar los intereses máximos que puedan pagar las mismas entidades sobre depósitos a la vista; dictar las normas y limitaciones a que deben sujetarse los bancos y financieras en materia de avales y fianzas en moneda extranjera; fijar las relaciones entre las operaciones activas y pasivas de las empresas bancarias, sociedades financieras y cooperativas de ahorro y crédito; reglamentar el funcionamiento de las cámaras compensadoras; y autorizar los sistemas de reajuste que utilicen en sus operaciones de crédito de dinero en moneda nacional las empresas bancarias, sociedades financieras y cooperativas de ahorro y crédito. En las operaciones de crédito de dinero en moneda nacional en que no es parte alguna de estas entidades, se puede pactar libremente cualquier sistema de reajuste, sin necesidad de autorización del Banco Central.

4. Facultades para cautelar la estabilidad del sistema financiero:

Estas atribuciones son fundamentalmente dos: primero, conceder a las empresas bancarias y sociedades financieras créditos en caso de urgencia por un plazo no superior a noventa días, cuando éstas presenten problemas derivados de una falta transitoria de liquidez, operaciones que están dentro de la función de prestamista de última instancia que corresponde a los bancos centrales; y segundo, conceder créditos o adquirir activos a esas mismas entidades cuando hayan presentado proposiciones de convenio o hayan sido declaradas en liquidación forzosa.

5. Funciones del Banco como agente fiscal:

El Banco Central, a solicitud del Ministro de Hacienda, puede actuar como agente fiscal en la contratación de créditos externos e internos y en aquellas operaciones que sean compatibles con las finalidades de la institución.

6. Atribuciones en materias internacionales:

Son facultades del Banco, entre otras, participar y operar con los organismos financieros extranjeros o internacionales; contratar toda clase de créditos en el exterior; emitir títulos y colocarlos en el extranjero; conceder créditos a estados extranjeros, bancos centrales o entidades bancarias o financieras extranjeras o internacionales, cuando dichos créditos tengan por objeto facilitar el cumplimiento de los objetivos del Banco; y mantener, administrar y disponer de sus reservas internacionales, ya sea en el país o en el exterior.

7. Facultades en materia de operaciones de cambios internacionales:

El Banco Central tiene la potestad para formular y administrar las políticas cambiarias. No obstante, las políticas de comercio exterior corresponden al Presidente de la República, las cuales son implementadas a través de diversos ministerios y el Servicio Nacional de Aduanas. El Banco Central mantiene, sin embargo, sistemas de información de las operaciones de comercio exterior en relación con sus implicancias cambiarias (retorno y liquidación de exportaciones y cobertura de importaciones).

8. Funciones estadísticas: El Banco Central debe publicar oportunamente las principales estadísticas macroeconómicas nacionales, incluyendo aquellas de carácter monetario y cambiario, de balanza de pagos y las cuentas nacionales.

B) Organización

Consejo

La autoridad máxima del Banco Central es el Consejo, que tiene a su cargo la dirección y administración del Banco, correspondiéndole ejercer todas las facultades y atribuciones que la ley orgánica le encomienda.

El Consejo está compuesto por cinco miembros designados por el Presidente de la República, previo acuerdo del Senado. Duran en sus cargos diez años, pudiendo ser reelegidos por períodos iguales, renovándose uno cada dos años. El presidente del Consejo, que también lo es del Banco, es designado por el Presidente de la República de entre los miembros del Consejo por un período de cinco años, o el tiempo menor que le reste como consejero. El vicepresidente es elegido por el mismo Consejo de entre sus miembros.

Autoridades del Banco

VITTORIO CORBO LIOI es presidente del Consejo del Banco Central de Chile desde mayo de 2003.

JOSÉ DE GREGORIO R. es Vicepresidente del Banco Central de Chile desde diciembre de 2003.

JORGE DESORMEAUX J., es consejero del Banco Central de Chile desde diciembre de 1999.

MANUEL MARFAN L. es consejero del Banco Central de Chile desde diciembre de 2003.

ENRIQUE MARSHALL RIVERA es Consejero del Banco Central desde diciembre de 2005.

Inflación

Índice de Inflación

La inflación supone que existe un aumento del precio de los bienes en general. Para poder medir ese aumento, se crean diferentes índices que miden el crecimiento medio porcentual de una cesta de bienes ponderada en función de lo que se quiera medir.

El índice más corrientemente utilizado para medir la inflación es el "índice de precios al consumidor" o IPC, el cual indica porcentualmente la variación en el precio promedio de los bienes y servicios que adquiere un consumidor típico en dos periodos de tiempo, usando como referencia lo que se denomina en algunos países la cesta básica.

En términos generales un proceso inflacionario se inicia por diversas causas, siendo una de las mas comunes la que se origina por un desequilibrio significativo entre la oferta y la demanda, es decir, cuando por diversas presiones económicas la demanda de bienes y servicios es superior a la oferta disponible de los mismos a los precios actuales, o cuando la oferta está limitada por la baja productividad o por restricciones del mercado.

Efectos de la inflación sobre la economía

La inflación no necesariamente es perjudicial para la economía de un país, siempre que sea moderada, es decir que no exceda digamos entre un 3 o 5%. La inflación moderada se considera como el elemento que engrasa las ruedas de la industria y comercio.

Otros efectos negativos de la inflación son:

Incrementa la incertidumbre afectando negativamente la inversión y el ahorro. Aumenta el consumo de bienes durables, ya que los consumidores anticipan compras de estos.

Redistribuye los ingresos de los pensionados o poseedores de instrumentos de renta fija a aquellos que tienen fuentes de ingresos más flexibles, como por ejemplo empleados que reciban aumentos de sueldo ajustados a la inflación.

Favorece al prestatario y perjudica al prestamista, por cuanto el valor del dinero disminuye en función del tiempo. Este factor es particularmente importante en relación al endeudamiento de los gobiernos ya que éstos reducen su deuda real por la pérdida de valor de la moneda. De aquí que la inflación sea vista como un impuesto.

Grados de inflación

Inflación moderada:

Cuando la subida de los precios sigue una tendencia gradual y lenta, con una variación anual de unos pocos puntos porcentuales, no se considera como problema económico y por el contrario, puede incluso llegar a estimular la actividad económica.
Inflación crónica o galopante:

Se conoce como inflación crónica al crecimiento continuo y elevado de precios, con variaciones anuales que oscilan entre el 10 y el 30% en algunos países industrializados y en la gran mayoría de países en vías de desarrollo.

Hiperinflación:

Es la forma más extrema, los aumentos persistentes de los precios pueden provocar la crisis de todo el sistema económico. Cuando los precios aumentan en forma persistente, el temor a que los precios continúen subiendo induce al mayor gasto de las familias y de las empresas y a la compra de bienes de capital para no mantener ahorros ociosos que se deprecian. Esta psicosis inflacionaria acentúa las presiones sobre los precios lo cual hace aumentar aún más la inflación.

Principales consecuencias de la inflación

En las economías desarrolladas las inflaciones moderadas se han considerado estimulantes siempre que no sobrepasen los límites críticos, los cuales ejercen efectos destructivos sobre la economía interna de un país, entre los que se destacan:

Distorsión del mercado
Deterioro de la calidad de vida
Desestímulo a la producción
Desestímulo al ahorro

Fuga de capitales
Déficit en la balanza comercial

Cura de la inflación

La cura de la inflación debe estar basada en un mecanismo monetario-cambiario que genere tasas de expansión monetaria que no excedan sustancialmente a la tasa de crecimiento del PIB.

Por reforma monetaria entendemos un cambio de moneda que establezca nuevas reglas para su emisión. Muchos países industrializados y en vías de desarrollo, en algún momento de su historia económica, han hecho reformas monetarias. Así, en Argentina el austral reemplazó al peso y en 1991 el peso argentino reemplazó al austral. En Brasil el cruzado reemplazó al cruceiro y el real recientemente reemplazó al cruzado. Pero para que las reformas monetarias sean exitosas es menester la existencia de nuevas reglas para su emisión, pues si no es así se pueden repetir los mismos errores que hicieron necesario, en su momento, cambiar de moneda.

El banco central, en Septiembre de 1999, el objetivo nominal sobre el tipo de cambio —representado en la existencia de una banda cambiaria— fue abandonado, adoptándose un régimen de flotación cambiaria. Ello eliminó una posible fuente de incoherencia en el diseño de régimen de política; el único compromiso del Banco Central es ahora mantener la inflación en la meta, además de reflejar la confianza de la autoridad en el mercado para determinar de manera autónoma el valor de la moneda nacional. En un mundo de alta volatilidad internacional y apertura de capitales, el mantener un compromiso cambiario no es sólo una tarea difícil sino que, como bien lo enseñan recientes experiencias, potencialmente muy costoso. La flexibilidad cambiaria elimina este compromiso, centrando todos los esfuerzos del Banco Central en la meta de inflación, la cual se convierte en el ancla nominal de la economía, evitando posibles confusiones. Adicionalmente, la flotación cambiaria confiere a la economía flexibilidad para enfrentar los shocks externos, facilitando un ajuste que de lo contrario podría ser pospuesto y, por ende, más complejo.

La flexibilidad cambiaria, sin embargo, no significa que el Banco Central de Chile no pueda intervenir en el mercado cambiario en situaciones excepcionales, si es que considera que la trayectoria de la moneda se ha alejado mucho de su valor de equilibrio, y es posible que existan costosas reversiones en el futuro. Tales intervenciones, sin embargo, son medidas transparentes y fundadas, definiéndose de manera explícita los plazos y montos involucrados, además de fundamentarse con claridad las razones que motivan estas acciones de excepción.

CONCLUSION

El Banco Central presenta informes de política monetaria, el que se enmarca dentro del esquema de metas de inflación que éste utiliza. Ahora que la inflación ya está en el rango fijado como meta de largo plazo, el objetivo principal de la política monetaria es mantener la inflación dentro de dicho rango y para este fin citado informe cumple con el rol fundamental, cual es, mantener informado al público de las razones que subyacen al accionar del Banco Central.

La operatoria de la política de metas de inflación requiere que el Banco Central oriente su accionar a lograr que la inflación proyectada se mantenga dentro de la meta fijada. Dado que la política monetaria opera con rezagos, para poder cumplir su objetivo el Banco Central tiene que tener la capacidad para proyectar la inflación para un período de tiempo en el cual la política monetaria sea capaz de afectarla(12 a 24 meses). Esta proyección debe considerar la forma en la cual ésta se genera y la evolución más probable en el tiempo de aquellos determinantes que no están bajo su control (el precio internacional del petróleo, la tasa de interés internacional, la evolución del producto y el comercio mundial, etc.). En este esquema, el Banco Central determina su tasa de política –tasa de instancia- tomando en cuenta las proyecciones de inflación para los próximos 12 a 24 meses. Dentro de este esquema, los shocks temporales que afectan la inflación observada, pero no la proyectada, no requieren de un cambio de política.

Lo se discute principalmente es sobre la importancia de tener como objetivo principal del Banco Central el logro de una inflación baja y predecible. Esto no significa que se privilegie el logro de una inflación baja por sobre un crecimiento alto, sino que reconoce que de acuerdo a la teoría y no en el producto. Además, el lograr una inflación baja y predecible es la principal contribución que se puede hacer la política monetaria al logro de una tasa de crecimiento alta y sostenida.

Fotos Antiguas

2008-10-10T19:24:00.001-07:00

Digamos que son unas fotos antiguas y las quise subir… del 2006 mas o menos en el laboratorio Intel Motorola.

Mi Oficina!! …cuando tenia mi empresa :(

2008-10-10T19:20:00.001-07:00

Bueno como pueden ver en la foto este era mi espacio donde realizaba mis funciones administrativas, programaticas y estudio … en mi antigua empresa 4MINDS Software LTDA. Viejos y buenos recuerdos…

Ayudantía 6

2008-10-10T19:07:00.001-07:00

Problema

Existe un experimento de física cuyo resultado esta dado en dos archivos.

Un archivo llamado nombre.dat que contiene registros con el nombre del experimento (string[10]),y el numero de muestras realizadas en dicho experimento(Integer).

El otro archivo, muestra.dat contiene números enteros correspondientes a los resultados de los experimentos.

Desarrolle un programa que lea y genere un tercer archivo de registros llamado resultado.dat, en el cual se almacene el nombre del experimento y el promedio de las muestras como un número real.

Resultado

program Fisica;

Type

registro1=RECORD

nombre :string[10];

numero:Integer;

end;

registro2=RECORD

nombre2:string[10];

resultado:Real;

end;

Arch1=FILE OF registro1;

Arch2=FILE OF integer;

Arch3=FILE OF registro2;

Var

a:Arch1;

b:Arch2;

c:Arch3;

x,i,suma:Integer;

temp:registro1;

temp2:registro2;

begin

ASSIGN(a,'nombre.dat');

ASSIGN(b,'muestra.dat');

ASSIGN(c,'resultado.dat');

RESET(a);

RESET(b);

REWRITE(c);

while not EOF a do

begin

READ(a,temp);

temp2.nombre:=temp1.nombre2;

suma:=0;

for i=1 to temp.numero do

begin

READ(b,x);

suma:=suma+x;

end;

temp2.resultado:=suma/temp.numero;

WRITE(c,temp2);

end;

CLOSE(a);

CLOSE(b);

CLOSE(c);

end.

nombre.dat

Exp_1 3
Exp_2 2

muestra.dat

4 2 6 4 1

nombre.dat

Exp_1 4.0
Exp_2 2.5

Arreglos Unidimensionales

2008-10-10T19:06:00.001-07:00

Es una estructura de datos en el que se almacena una colección de datos del mismo tipo.

Se declaran en la sección TYPE:

Type

Nombre_arreglo = Array[1..N] of tipo_de_dato;

Ejem:

Type

Vector:= Array[1..7] of Integer;

Var

A:Vector;

Sacar Promedio de un arreglo:

For i=1 to 7 Do

Suma := suma + A[i];

Suma := suma/7;

Para escribir un arreglo :

Writeln(A[5]);

Read(A[3]); o A[3]:= x

Read(x);

Para leer completamente

For i:=1 to 7 Do

Read(A[i]);

Ejemplo

Program promedio;

Const

N=57;

Type

Vector = Array[1..N] of Integer;

Var

A:Vector;

Suma,i:Integer;

Prom : Real;

Begin

For i :=1 to N do

Begin

Writeln(‘ingrese dato ‘,i);

Read(A[i]);

End;

Suma:=0;

For i :=1 to N do

Suma:= suma + A[i]

Prom:= suma/N;

Writeln(‘el promedio es ‘,prom);

END.

Ayudantía I de Pascal

2008-10-10T19:03:00.001-07:00

Ayudantía desarrollada en la UTFSM. Este documento es un draft o sea falta modificar algunas cosas yo solo ocupaba esto como apoyo.

Ayudantía I

Francisco Riveros E.

21/03/2006

I .Introducción: Programas antiguos ->Programación de ahora.

II. INTRODUCCION PSEUDOCODIGO

PALABRA	UTILIZACIÓN
ABRE	Abre un archivo
CASO	Selección entre múltiples alternativas
CIERRA	Cierra un archivo
ENTONCES	Complemento de la selección SI - ENTONCES
ESCRIBE	Visualiza un dato en pantalla
FIN	Finaliza un bloque de instrucciones
HASTA	Cierra la iteración HAZ - HASTA
HAZ	Inicia la iteración HAZ - HASTA
INICIO	Inicia un bloque de instrucciones
LEER	Leer un dato del teclado
MIENTRAS	Inicia la iteración mientras
NO	Niega la condición que le sigue

II.a SELECCIÓN

También conocida como la estructura SI-CIERTO-FALSO, plantea la selección entre dos alternativas con base en el resultado de la evaluación de una condición o predicado; equivale a la instrucción IF de todos los lenguajes de programación y se representa gráficamente de la siguiente manera:

III. ESTRUCTURA GENERAL DE UN PROGRAMA PASCAL

Program identificador ; {cabecera opcional en Turbo Pascal}

Uses identificadores

Label lista de etiquetas ; {sección de etiquetas}

Const

definiciones de constantes

Type

declaración de tipos de datos definidos por el usuario

Var

declaración de variables

Procedure

definiciones de procedimientos

Function

definiciones de funciones

begin {cuerpo del programa}

sentencias

end.

Program MiPrimerPrograma; {cabecera}

Uses

  Crt; {declaraciones}

Const

  iva =0.10;

Type

  cadena =string[35];

  meses  =1..12;

Var

  sueldo :real;

  numero :integer;

  nombre :cadena;

  Nmes   :meses;

begin

  ClrScr; {Limpia la pantalla}

  Write ('Escribe tu nombre : ');

  {Visualiza información en pantalla}

  ReadLn(nombre);{Leer un dato del teclado}

  WriteLn ('Bienvenido ', nombre);

  {Visualiza información en pantalla}

  Readkey; {Espera la pulsación de una tecla}

  ClrScr

end.

ADVERTENCIA:

Todo objeto referenciado en un programa debe haber sido previamente definido.

IV. IDENTIFICADORES

En la mayoría de los programas de computador, es necesario manejar datos de entrada o de salida, los cuales necesitan almacenarse en la memoria principal del computador en el tiempo de ejecución. Para poder manipular dichos datos, necesitamos tener acceso a las localidades de memoria donde se encuentran almacenados; esto se logra por medio de los nombres de los datos o IDENTIFICADORES.

Las reglas para formar los identificadores en Pascal son las siguientes:

Pueden estar compuestos de caracteres alfabéticos, numéricos y el carácter de subrayado ( _ ).

Deben comenzar con un carácter alfabético o el carácter de subrayado.

Puede ser de cualquier longitud (sólo los 63 primeros caracteres son significativos).

No se hace distinción entre mayúsculas y minúsculas.

No se permite el uso de los IDENTIFICADORES RESERVADOS en los nombres de variables, constantes, programas o sub-programas.

Identificadores válidos

Nombre

Cadena

Edad_Maxima

X_Y_Z

Etiqueta2

Identificadores no válidos

Num&Dias : carácter & no válido

X nombre : Contiene un blanco

begin    : es una palabra reservada

eje@s    : carácter @ no válido

V. DEFINICION DE CONSTANTES

El identificador reservado Const debe encabezar la instrucción, seguido por una lista de asignaciones de constantes. Cada asignación de constante debe consistir de un identificador seguido por un signo de igual y un valor constante, como se muestra a continuación:

Const

  valor_maximo =255;

  precision    =0.0001;

  palabra_clave='Tutankamen';

  encabezado   =' NOMBRE DIRECCION TELEFONO ';

CONSTANTES PREDEFINIDAS :

Nombre	Tipo	Valor
pi	real	3.1415926536 (Sólo en Turbo Pascal)
false	boolean
true	boolean
MaxInt	integer	32767

VI. DEFINICION DE TIPOS

La asignación de tipos a los datos tiene dos objetivos principales:

Detectar errores de operaciones en programas.

Determinar cómo ejecutar las operaciones.

Los tipos definidos por el programador pueden utilizarse para definir nuevos tipos, por ejemplo :

Type

  entero      = integer;

Var

   i,n :entero;

VI.a TIPOS ENTEROS

Tipos enteros predefinidos

Tipo	Rango	Formato
byte	0 .. 255	8 bits sin signo
integer	-32768 .. 32767	16 bits con signo
longint	-247483648 .. 2147483647	32 bits con signo
shortint	-128 .. 127	8 bits con signo
word	0 .. 65535	16 bits sin signo

VI.b TIPOS REALES

REAL

En el contexto de Pascal, un número real es aquel que está compuesto de una parte entera y una parte decimal, separadas por un punto. El rango de estos números está dado entre los valores 1E-38 y 1E+38 .

BOOLEAN

Un valor de tipo boolean puede asumir cualquiera de los valores de verdad denotados por los identificadores true y false, los cuales están definidos de tal manera que false < true .

CHAR

Un valor de tipo char es cualquier carácter que se encuentre dentro del conjunto ASCII ampliado, el cual está formado por los 128 caracteres del ASCII más los 128 caracteres especiales que presenta, en este caso, IBM.

Los valores ordinales del código ASCII ampliado se encuentran en el rango de 0 a 255. Dichos valores pueden representarse escribiendo el carácter correspondiente encerrado entre apóstrofes.

Así podemos escribir :

        'A' < 'a'

        Que significa : " El valor ordinal de A es menor que el de a " o " A está antes que a

STRING

Un tipo string (cadena) es una secuencia de caracteres de cero o más caracteres correspondientes al código ASCII, escrito en una línea sobre el programa y encerrado entre apóstrofos.

El tratamiento de cadenas es una característica muy potente de Turbo Pascal que contiene ISO Pascal estándar.

Ejemplos:

VAR

Nombre : String[30];

{Permite un máximo de 30 caracteres en la variable, si no es 255}

BEGIN

Nombre := 'Ernesto Chávez';

WriteLn (Nombre[5]);

{Visualiza el 5to caracter de la cadena}

END.

        'Turbo Pascal','Tecnológico', #13#10

Nota:

Una cadena sin nada entre los apóstrofos se llama cadena nula o cadena vacía.

La longitud de una cadena es el número de carácteres encerrados entre los apóstrofos.

PROGRAM Test;

VAR

   x : REAL;        { variable name is x, type is real

   i : INTEGER:     { variable name is i, type is integer

   c : CHAR;        { variable name is c, type is character

   s : STRING;      { variable name is s, type is string

BEGIN

    x := -34.55;    { valid real number assigned to variable x }

    x := -3.9E-3;   { valid real number assigned to variable x }

    WRITELN(x);     { x contains the value -3.9E-3 }

    i := 10;        { valid integer number assigned to variable i }

    i := i * i;     { valid (!) - i will be 100 now }

    i := 9933;      { valid integer number assigned to variable i }

    i := -99999;    { invalid integer - too small }

    i := 999.44;    { invalid assignment - types do not match }

    c := '1';       { valid character assigned to variable c }

    c := 1;         { invalid assignment - types do not match }

    c := 'Bert';    { invalid assignment - types do not match }

    c := 'd';       { valid character assigned to variable c }

    WRITELN(c);     { c contains the value 'd' }

    d := 'c';       { unknown variable - the variable d is not declared }

    WRITELN(s);     { invalid reference - s has undefined value }

END.

VII. OPERADORES

En Pascal, se manejan tres grupos de operadores:

ARITMÉTICOS

RELACIONALES

LÓGICOS

1.- OPERADORES ARITMETICOS BASICOS.

Operador	Operación	Operandos	Ejemplo	Resultado
+	Suma	real , integer	a + b	suma de a y b
-	Resta	real , integer	a - b	Diferencia de a y b
*	Multiplicación	real , integer	*a b**	Producto de a por b
/	División	real , integer	a / b	Cociente de a por b
div	División entera	integer	a div b	Cociente entero de a por b
mod	Módulo	integer	a mod b	Resto de a por b

Conviene observar lo siguiente:

Cuando los dos operandos sean del tipo integer, el resultado será de tipo integer.

Cuando cualquiera de los dos operandos, o ambos, sean del tipo real, el resultado será de tipo real.

Cuando, en la operación div, OPERANDO-1 y OPERANDO-2 tienen el mismo signo, se obtiene un resultado con signo positivo; si los operandos difieren en signo, el resultado es negativo y el truncamiento tiene lugar hacia el cero.

Ejemplos:

        7    div 3     = 2

        (-7) div (-3)  = 2

        (-7) div 3     = -2

        7    div (-3)  = -2

        15.0 div 3.0   = no válido

        15   div (4/2) = no válido

La operación div almacena sólo la parte entera del resultado, perdiéndose la parte fraccionaria (truncamiento).

La operación MODULO está definida solamente para OPERANDO-2 positivo. El resultado se dará como el entero no negativo más pequeño que puede ser restado de OPERANDO-1 para obtener un múltiplo de OPERANDO-2 ; por ejemplo :

6     mod 3    = 0

7     mod 3    = 1

(-6)  mod 3    = 0

(-7)  mod 3    = -1

(-5)  mod 3    = -2

(-15) mod (-7) = -1

En la operaciones aritméticas, debe asegurarse que el resultado de sumar, restar o multiplicar dos valores, no produzca un resultado fuera de los rangos definidos por la implementación para los diferentes tipos.

2.- OPERADORES RACIONALES

Símbolo	Significado
=	IGUAL que
<>	NO IGUAL que
<	MENOR que
>	MAYOR que
<=	MENOR o IGUAL que
>=	MAYOR o IGUAL que

Ejemplos

Relación	Resultado
20 = 11	false
15 < 20	true
PI > 3.14	true
'A' < 20	false
'A' = 65	true

3.- OPERADORES LOGICOS

NOT

Sintaxis : not operando

Descripción : Invierte el valor de verdad de operando.

AND

Sintaxis : operando.1 and operando.2

Descripción : Produce un resultado con valor de verdad true cuando ambos operandos tienen valor de verdad true; en cualquier otro caso el resultado tendrá un valor de verdad false.

Sintaxis : operando.1 or operando.2

Descripción : Produce un resultado con valor de verdad false cuando ambos operadores tienen valores de verdad false; en cualquier otro caso el resultado tendrá un valor de verdad true.

Expresiones

Precedencia de operadores
5	- (Menos unario)
4	not
3	* / div mod and shl shr
2	+ - or xor
1	= <> > < >= <=

Las reglas de evaluación para las expresiones son :

Si todos los operadores en una expresión tienen la misma precedencia, la evaluación de las operaciones se realiza de izquierda a derecha.

Cuando los operadores sean de diferentes precedencias, se evalúan primero las operaciones de más alta precedencia (en una base de izquierda a derecha ), luego se evalúan las de precedencia siguiente, y así sucesivamente.

Las reglas 1) y 2) pueden ser anuladas por la inclusión de paréntesis en una expresión.

Ejemplos :

·  3 + 2*5   {*,+}

   4 + 10 =14

·  20*4 div 5

  {Igual prioridad de izquierda a derecha : *,div}

80     div 5 = 16

3 - 5 * (20+(6/2))

3 - 5 * (20+(6/2)) = 3 - 5 * (20 + 3)

{paréntesis más interno}

= 3 - 5 * 23 {segundo paréntesis}

= 3 - 115 {Multiplicación}

= -112 {resta}

VIII.INSTRUCCIONES DE ASIGNACION

numero     := 100 ;

importe    := precio * cantidad ;

hipotenusa := sqrt(sqr(cateto_op)+sqr(cateto_ad ));

begin

  suma  := 1000.0;

  incr  := 20.0;

  total := suma + incr

  {Obsérvese la ausencia de punto y coma

   al final de la instrucción}

end.

READLN y READ

Var

  nombre   :string[30] ;

  edad     :integer;

  estatura :real;

  ReadLn(nombre);

  ReadLn(edad);

  ReadLn(estatura);

WRITELN Y WRITE

Write  ('! HOLA ');

WriteLn('AMIGOS !');

Ejemplo

Valor:= 25.0776;

Sentencias	Resultados	Comentario
WriteLn (Valor);	2.5077600000E+01
WriteLn(Valor:2);	2.5E+01
WriteLn(Valor:2:1);	25.1	Notese el redondeo
WriteLn(Valor:2:4);	25.0776
WriteLn(Valor:2:8);	25.07760000
WriteLn('Tec':1);	Tec
WriteLn('Tec':3);	Tec
WriteLn('Tec':5);	_ _ Tec	Espacios vacios _

IX. IF-THEN-ELSE

Dado que una condición produce un valor verdadero o falso, se necesita una sentencia de control que ejecute determinada sentencia si la condición es verdadera , y otra si es falsa. En Pascal esta alternativa se realiza con la sentencia IF-THEN-ELSE. A continuación se describe el diagrama de flujo y el formato de la sentencia.

Formatos de la sentencia IF:

if <condición>

  then

<instrucción_1>

  else

<instrucción_2>

if <condición> then

<instrucción_1>

  else

<instrucción_2>

En este caso, primero se evalúa condición y si el resultado arroja un valor de verdad(verdadero), se ejecuta instrucción_1 ; en caso contrario se ejecuta instrucción_2.

La condición es una expresión Booleana que puede ser verdadera o falsa (true o false). Una expresión Booleana se forma comparando valores de las expresiones utilizando operadores de relación (relacionales) o comparación y los operadores lógicos vistos anteriormente.

Ejemplos :

Sin ELSE

Program Edades;

Uses Crt;

Var

  edad : integer ;

begin

  WriteLn('Escribe tu edad : ');

  ReadLn(edad);

  if edad >= 18 then

     WriteLn('!Eres Mayor de edad !');

  WriteLn('Esta instrucción siempre se ejecuta');

  ReadKey

end.

Con ELSE:

Program Edades;

Uses Crt;

Var

  edad : integer ;

begin

  WriteLn('Escribe tu edad : ') ;

  ReadLn(edad) ;

  if edad >= 18 then

    begin

      WriteLn('!Eres Mayor de edad !');

      WriteLn('!Ya puedes Votar!')

end

  else

    begin

      WriteLn('!Eres Menor de edad !');

      WriteLn('!Aún no puedes votar!')

    end;

  WriteLn('Esta instrucción siempre se ejecuta');

  ReadKey

end.

Video Explicativo y Didáctico De la Crisis Económica de Hoy en Día.

2008-10-08T21:17:00.001-07:00

Aquí navegando por la web, encontré un video súper bueno que explica de manera didáctica y fácil como y que sucede con la crisis económica que esta tan en boga hoy en día, espero que pueda servir de algo. (Video lo saque de http://www.dreig.eu/caparazon/ – Blog Muy bueno):

Fotos

2008-10-04T09:24:00.001-07:00

Recopilación de Fotos de ayer y hoy aquí:

Fotos de mi Intercambio en Austria (PARTE I)
Fotos de mi Intercambio en Austria (PARTE II)
agregare otras fotos…

TRIZ para Software ( TRIZ for Software)

2008-10-02T09:10:00.001-07:00

Analogía de Patrones de Software

Introducción

Triz ha llegado a ser muy poderoso para resolver problemas y para crear soluciones innovadoras. Triz es principalmente usado para problemas mecánicos y en la forma actual, no tanto para problemas eléctricos de software. Pero para aplicar TRIZ al software tenemos que aplicar los principios de inventiva. Esos principios de inventiva son usados para resolver un problema algorítmico definiendo una situación ideal, analizando las contradicciones y usando los principios para desarrollar un mejor algoritmo. (Un algoritmo inteligente es como algo equivalente a una construcción inteligente en la Ing. Mecánica).

La traducción desde los Principios de Inventiva al Software es muy difícil de hacer para muchos. Incluso para usuarios expertos en TRIZ.

La traducción hecha por Kevin Rea [Kev-01] ayuda mucho pero solo si uno estas trabajando en un área de aplicación que es el caso de programación concurrente.

Un camino mejor es usar la metodología de Genrich Altschuller analizando las patentes en Ingeniería de Software y desarrollando completamente un nuevo conjunto de Principios de inventiva y Matriz de Contradicciones.

Esto nos abre un camino para poder seguir en nuestra investigación aplicando conceptos de Triz y viendo diversas analogías a este. Las próximas secciones veremos puntos importantes que en el Software resaltan muchos problemas con lo que Triz puede ser una ayuda para romper estas barreras. Asimismo en la otra sección veremos el primer acercamiento a Triz aplicado al software con la respectiva matriz y principios generados por analogías por el autor Darell Mann.

Algoritmos Rápidos

Los Ejemplos que son descritos en la base de datos TRIZ conciernen el desarrollo de algoritmos rápidos y confiables usando recursos limitados (tales como tamaño de memoria y velocidad del procesador). Tenemos que existen un sin número de patentes comerciales donde algunos son exitosos algoritmos o standards que pueden ser comercialmente interesantes, por ejemplo,

Algoritmos	Función
MP3	Procesamiento de Sonido
MPEG	Procesamiento de Video
Algoritmos de Búsqueda Rápida	Google

Tabla 1 - Algoritmos y funciones

Así podemos formarnos una idea, de que tener un conjunto de patentes de software podría ayudarnos a crear una matriz y principios y hacer lo que hizo Altshuller con las patentes.

Un autor llamado Graham Rawlinson concluye que: "TRIZ es muy útil, pero a menudo no acierta con las soluciones derivadas", esto quiere decir que a pesar de que Triz nos ayude a resolver nuestros problemas, no siempre vamos a tener la solución que queríamos o la solución esperada, es decir, no es la “panacea”.

El desarrollo de algoritmos rápidos ha sido sujeto de investigación desde inicios de los sesenta. (Cuando los computadores eran caros y los recursos eran limitados). Aunque muchos de los métodos desarrollados en ese entonces son todavía validos.

Ley de Moore

La ley de Moore expresa que aproximadamente cada dos años se duplica el número de transistores en un circuito integrado. Se trata de una ley empírica, formulada por el co-fundador de Intel, Gordon E. Moore el 19 de abril de 1965, cuyo cumplimiento se ha podido constatar hasta hoy.

Entonces con esa ley se decía que no habría un hardware que pudiera dar solución a los problemas de software que en los cuales se necesitaba de nuevo Hardware para poder realizar las tareas en un modo eficiente, ya que cuando el software probaba que es muy lento, o requiere mucha memoria, simplemente se espera por un nuevo hardware y el problema es resuelto automáticamente.

Crear algoritmos rápidos es importante cuando el Hardware requerido no es todavía disponible dentro un periodo largo de tiempo,

En ingeniería mecánica hay un desafío continuo en crear nuevos productos y tratar con crecientes contradicciones. En muchos productos las limitaciones técnicas han sido (casi) alcanzadas. Por ejemplo, por 100 años los automóviles han manejado bajo motores a combustión, 30 años después el avión comercial Concorde es el avión volando a velocidades supersónicas y así sucesivamente. O sea esto llega cada vez a hacer mas y mas difícil para desarrollar nuevos productos e incrementar la funcionalidad llega a ser pequeño.

Un ejemplo:

Supongamos que un ingeniero mecánico de una empresa automotriz va hacia su jefe y le dice: "Jefe, soy capaz de hacer nuestro motor un 5% más eficiente". Su Jefe probablemente le responda: "Estoy atónito, tomate todo tu tiempo que tu necesites y no olvides escribir una patente".

Ahora si un Ingeniero de Software va hacia su jefe y le dice: " Jefe, yo puedo hacer trabajar nuestro software 5% más rápido", su jefe probablemente responda, " Eso no es de importancia ahora, el próximo mes nosotros obtendremos un nuevo procesador el cual trabaja dos veces más rápido. Vuelve a tu trabajo, que todavía tienes 20 Bugs que resolver antes que termine esta semana, así que no malgastes mas tu tiempo".

Tamaño del Software

Tal como la memoria disponible se incrementa 2 veces en 18 meses, así también las líneas de código. Sin embargo, productos de software están llegando a ser más grandes cada año y más gente necesita desarrollar este software. Es más la moda como sistemas abiertos, subcontratación, re-uso, están disponibles para sobrepasar esto. Todo esto crea situaciones que son más complejas resultando en proyectos fuera de tiempo, software no confiable y clientes insatisfechos.

El principal desafío hoy en día es manejar esta creciente complejidad. Desde comienzos de los noventas hay un fuerte énfasis sobre los procesos de software. Muchas organizaciones están usando la capacidad madura de los modelos u otros frameworks para mejorar sus procesos de desarrollo de software.

Desarrollo de Arquitecturas

Otro camino para tratar con el incremento en la complejidad es crear una arquitectura de software. Una arquitectura de software provee de la estructura técnica para un proyecto. Una buena arquitectura hace que el resto del trabajo sea más fácil, pero una mala arquitectura hacer que el resto del trabajo sea casi imposible.

En la creación de arquitecturas se tiene que tratar con las demandas conflictivas. La arquitectura desempeña requerimientos funcionales y no funcionales. Ejemplos de requerimientos no funcionales son:

· Portabilidad

· Mantención

· Flexibilidad

· Extensibilidad

· Reusabilidad

Estos requerimientos no-funcionales son también conocidos como Soft Intents. En algunas áreas de aplicación un grafico de softgoal interdependencia es usado para visualizar estos conflictos. La mayoría de las soluciones son ajustadas a la "medida" entre estas demandas conflictivas. Difícilmente incluso todas estas demandas son completadas.

TRIZ podría ser muy útil en resolver estas peticiones conflictivas (Contradicciones) en una manera más satisfactoria. Desde que las arquitecturas son también usadas en otros campos como ing. Mecánica nosotros podemos aprender desde la aplicación de TRIZ en este campo.

Modas de una evolución tecnológica

Debido a que rápidamente se incrementan las capacidades del software es difícil decir cómo serán estos en el futuro. Es difícil imaginar que es posible en el futuro y que será exitoso.

Triz se enfoca en la evolución tecnológica y esto podría ser usado para identificar las posibilidades de futuro. Combinado con modas comerciales, esto ayuda en definir productos exitosos en una temprana edad.

Triz para el Software

La utilización de los ordenadores como instrumentos de ayuda a las diferentes actividades humanas ha cobrado tal importancia que hoy resulta casi inconcebible subsistir en un mundo tan competitivo sin su uso. Se puede decir que su aplicación ha cubierto todas las esferas de la actividad humana, siendo previsible que el uso de ordenadores vaya en aumento cada vez más.

Estos datos son suficiente argumento para sostener la importancia que tiene la investigación sobre el mejor uso de tales instrumentos mediante la elaboración de aplicaciones para estas.

Puede TRIZ ser aplicado para el diseño y creación de software? parece ser una cuestión que se plantea por un número cada vez mayor de empresas. Se propone en este documento indagar sobre el terreno y hacer sugerencias en cuanto a lo que un "TRIZ de Software” puede hacer.

Teniendo en cuenta los distintos autores (Darrel Mann, entre otros) al respecto, parece probable suponer que la sugerencia será, sí, TRIZ puede ser aplicado a software. No obstante a habida cuenta de algunos debates de TRIZ y software, parece que la respuesta positiva no es tan evidente.

Uno de los autores (Ikovenko[1]) habla en torno a este tema en el TRIZ Centrum conferencia en 2003 y llegó a la conclusión de que, básicamente, desde el desarrollo de software se encuentra aún en una etapa temprana de su evolución, en otras palabras, que el desarrollo de software es un arte y no una ciencia en si. Por lo que no era todavía probable que se prestara para al tratamiento de TRIZ, ya que no era considerado una ciencia como tal.

Mas franco aún fue Karasik[2], fue más vehemente en su despido de las posibilidades de aplicar TRIZ para problemas de software, “siendo un equipo un científico y un ingeniero un software” los 40 principios no serán aplicables a ingeniería de software bajo ninguna circunstancia.

El trigger para Karasik para incurrir en tal afirmación de primer orden fue la investigación

Publicada acerca de la lista de los 40 Principios de Inventiva para Software de Rea[3].haciendo una analogía de la situación es que los 40 Principios de Inventiva - o la mayoría de ellos por lo menos - se puede observar en el diseño de software, considerada absurda para el.

Sobre la base anterior de experiencias y el extenso análisis de las patentes realizadas durante el programa de investigación para la actualización de TRIZ, es nuestra firme convicción de que tiene TRIZ algo de importancia para ofrecer a ingenieros de software.

Sin embargo a diferencia de las materias ciencias duras: mecanica, hidráulica, etc. lo que ya podemos ver es que el sesgo y la orientación de las distintas herramientas de TRIZ es muy diferente a la de software que en otros campos de aplicación. Por lo que el autor (Darrel mann) con el fin de explorar los prejuicios que, sin embargo, en primer lugar hay que estudiar el contexto y los límites de lo que es y lo que no es un problema 'software'. Una buena forma de comenzar esta exploración, según Mann, entonces, es mediante la Ley de Sistema de Integridad TRIZ[4] (modificada) y ver cómo esto podría ser aplicado a sistemas informáticos. Es decir si un problema de software puede ser situado bajo esta perspectiva, así como las demás áreas lo han hecho, estos últimos no tendrían ningún impedimento para ser aplicado a través de TRIZ.

Imagen 1 - Imagen de referencia

La primera pregunta que surge después de pensar en este modelo, es aplicable a software? La respuesta es sí, podemos aplicar recursivamente el modelo en varios niveles jerárquicos .En el nivel del software subrutina, por ejemplo, podríamos pensar en el 'motor' como los algoritmos que figuran en la rutina, la transmisión como la llamada a la subrutina, la herramienta como los resultados calculados por la rutina y el control, las diferentes líneas de código en el software que asegurarse de que las cosas sucedan en la secuencia correcta y con la lógica deseada. El ‘campo (interface)' es un poco más grande, pero si pensamos en él como un "campo de la comunicación” la lógica sigue intacta. La misma analogía se puede aplicar en forma progresiva a los niveles jerárquicos más altos en que nos fijamos en los sistemas desde la perspectiva del sistema operativo, idioma, etc. Ya sea cualquier nivel que veamos, en última instancia el "sistema" tiene que interactuar con algo fuera de la sistema (‘campo (interface)'). Siendo esto cosa fuera del sistema ser otra rutina de programa o el usuario mismo.

Problemas de Software

Los 'Problemas de Software' quizás a diferencia de los sistemas o ciencias convencionales es que sólo empezarán a ocurrir cuando se examinan los vínculos entre el software y el mundo exterior. Por lo tanto la única práctica, entonces, cuando nos encontramos en la identificación de modelos funcionales que contienen relaciones negativas es cuando llegamos a la interfaz con el mundo exterior. Ya que un fragmento de código no interacciona «Inadecuadamente» con otro, pero un pedazo de código muy a menudo interactúa inadecuadamente con una pieza de hardware o con un usuario.

Es probable que esto significa que vamos a estar pensando en como TRIZ como herramienta en la resolución de problemas, en un instrumento algo a un diferente nivel de detalle en el punto de inicio de un modelo de análisis de la función.

Triz para Software

Bajo los aspectos mencionados anteriormente, Darrell Mann, lo obtuvo. Bajo los mismos procedimientos y analogías efectuadas a los 40 principios de TRIZ es posible resolver un problema de software mediante TRIZ.

De esta manera a continuación se expondrá las ideas y procedimientos para efectuar tal resultado.

Darrel Mann propone la siguiente estructura, de desarrollo y análisis del problema.

Definición:

1. Resultado Ideal Final.

2. Explorar el problema.

3. Subversión análisis.

4. Matriz de contradicciones.

Generación de Solución:

1. Principios Inventivos.

2. Tendencias/Evolución Potencial.

Nota: Si bien la estructura anterior de procedimiento fue propuesta por Mann puede ser aplicada bajo cualquier ciencia; solo la matriz y los principios inventivos conforman obra de Mann y su utilización es única para “Problemas de Software”.

Definición

Para esta primera aproximación Mann, baso su propuesta bajo dos perspectivas esenciales, en primer lugar bajo la utilización de siete pilares de exploración del problema y en segundo lugar las contradicciones en relación con los factores y/o parámetros que la conforman.

Siete Pilares de “TRIZ para Software”

Esta aproximación responde a las características y entendimiento del problema en cuestión. Es decir apoya a situarse en el problema y observar las características de este último, de manera que al momento de encontrar una solución a través de los principios inventivos por medio de la matriz de contradicciones resulte la más apropiada.

Idealidad: atenta a encontrar cada vez mayor acerca de lo bueno, la disminución de lo malo.(“Si mismo”,autorepararse,autodaptarse,etc)

· Emergente: producir un a solución o atentar o situación relevante en el contexto de la situación del problema.

Funcional: en el contexto de un software, esta existe para el software proporcionar una función útil, ya sea a otras piezas de software o de una pieza de hardware o un ser humano indep. del producto como tal.
Contradicción: La contradicción de la eliminación de estrategias se puede utilizar para acelerar la evolución de cualquier sistema. Las contradicciones tienden a ocurrir en las interfaces entre software y el mundo exterior en su totalidad mas que en lugar de «dentro» del software.
Recursos: Todo dentro y alrededor de un sistema que no se utiliza al máximo de su potencial es un recurso.
Espacio/Tiempo/Interface: la comprensión efectiva de un problema requiere conocimiento de cómo un sistema se ve afectado por efectos espaciales, temporales y cuestiones interfaciales.
Recursion: se refiere al fenómeno según el cual ciertos fenómenos de sistema se repiten en los diferentes niveles jerárquicos.

Subversión Análisis

Atenta a generar los errores que pudiera tener el sistema y de esta manera “Si el fallo ocurre, entonces los recursos necesarios para hacerlo suceder deben estar presentes en el sistema”

Por lo que Subversión es el análisis sobre la búsqueda de esos recursos, se trata de «inventar fracaso";¿Qué podría ir mal, irá mal, ¿Qué podría ir mal en el futuro, va a salir mal. Para así dar paso a las contradicciones y resolver el problema en cuestión.

Identificar el Problema- donde y cuando.
Amplificar el problema.(como hacer que ocurra todo el tiempo)
Formula el problema invertido.
Identificar los componentes necesarios.
Identificar los recursos en el sistema.

Matriz de Contradicciones

El clásico TRIZ Contradicción Matrix ha sido objeto de actualizaciones muchas veces en los últimos tiempos, primero a través de la publicación de “Matrix 2003[5]” (para negocios) y, a continuación, más recientemente, un matriz de problemas empresariales. A pesar de pasar por varios pasos hacia
lo que es relevante para los problemas que enfrentan los ingenieros de software y la búsqueda de muchas las patentes de software que había algo que aportar a la construcción de la herramienta, Matrix 2003 contiene mucho de lo que se consideró fuera de poner a los usuarios de software. De ahí que en 2003 se decidió que era necesario crear una matriz a medida para problemas de software. Esto matriz ya se ha concluido, y se convertido a disposición del público por primera vez cuando el libro "TRIZ para ingenieros de software" se público.

La tabla de continuación ilustra los parámetros que componen las partes de la nueva Matriz.

Size (Static)

Size (Dynamic)

Amount of Data

Interface

Speed

Accuracy

Stability

Ability to Detect/Measure

Loss of Time

Loss of Data

Harmful Effects Generated By System

Adaptability/Versatility

Compatibility/Connectability

Ease Of Use

Reliability/Robustness

Security

Aesthetics/Appearance

Harmful Effects On System

System Complexity

Control Complexity

Automation

Parámetros de la nueva, Software Matrix

El método de funcionamiento de la nueva Matriz es exactamente el mismo que el utilizado en las demás Matrices; el usuario tiene que identificar lo que ellos desean mejorar en su sistema, entonces que es lo que les impide hacer la mejora. Desde aquí es necesario entonces traducir los detalles del conflicto (el par mejora y empeoramiento) de la Matriz de la lista de parámetros con mi problema que corresponde mas estrechamente con los detalles. A partir de ahí, la matriz apreciara los más probable principios de inventiva utilizados por otros para solucionar el desafío con éxito del par conflictos.

Esta nueva Matriz es el resultado del estudio de alrededor de 40000 patentes de software y el diseño soluciones. No obstante el número está limitado por el hecho de que actualmente sólo los EE.UU. es la concesión de software las patentes.

Un ejemplo sencillo, sin embargo, ha de servir al doble propósito de demostrar cómo la matriz fue compilada (patentes) y cómo un usuario puede hacer uso de la herramienta.

US6, 785.819

Esta patente se concedió a Mitsubishi Denki Kabushki Kaisha el 31 de agosto de 2004 (en realidad algún tiempo después de la Matriz de trabajo se completó). Los antecedentes de la patente como descrito en la divulgación es el siguiente (extracto):

“Recientemente, los sistemas informático que utiliza LAN se están adoptando en las organizaciones. Comúnmente, una pluralidad de LAN ubicadas en diversos lugares en una organización de la red entre oficinas están conectadas por completo para formar una intranet. La extensión de más, una extranet que incluye la organización aliada a las empresas a formar una red total también se está convirtiendo en generalizada. Hay varias formas de conectar una pluralidad de LAN ubicadas en diversos lugares. Para dar un ejemplo, hay un caso de utilizar a bajo costo a Internet en lugar de una línea arrendada. En este caso, el acceso desde el exterior debe ser regulado, por lo que un servidor de seguridad general, se recurre a una frontera de fuera y dentro de la red. Esto ayuda a aumentar el factor de seguridad dentro de la LAN. El firewall es una técnica que sólo permite el acceso desde el exterior a una ubicación específica o para una aplicación específica de la LAN………. En un sistema de red informática, los servicios bajo un entorno LAN como el uso compartido de archivos, impresión a la impresora común, o el uso de la CPU del servidor no puede ser aprobado debido al firewall. En consecuencia, en los casos en que se desea obtener un ciertos datos o un programa a partir de otros ubicación, a continuación, uno sólo puede confiar en alguien en el otro lugar para datos requeridos utilizando un canal independiente, o sólo puede basarse en un método de envío de medios de comunicación como una cinta “.

El problema de este modo identificados por los inventores es un conflicto entre los deseos paralelo a mejorar la capacidad de transferencia de datos y mantener la seguridad.

Traduciendo estos requisitos en los términos de la Matriz de Software, se pone en manifiesto el conflicto en la pareja ilustrada a continuación:

US6, 785,819 conflicto traducido en términos de, The Software Matriz.

Los inventores de la patenten ocuparon un Agente de software para lograr la solución.(en la figura se puede apreciar a través del principio 24,que es Intermediario, por lo que ahora cualquier problema de esta índole concurre a esta patente de Agentes).

Generación de Solución

La primera cosa que decir sobre el tema de los principios de inventiva es que el autor (Darrel Mann) confirmó la existencia de los mismos 40 principios como los que se encuentran en el TRIZ clásico. Como se dio en el caso con la técnica de conversión a los principios de gestión, se tuvieron que modificar algunos de los términos del principio para que las descripciones se adaptaran de mejor manera al contexto de software, pero más allá de eso, se han mantenido las mismas.

Esto último se apoya ya que no ha habido a la fecha ingenieros de software que hayan identificado estrategias de inventiva que no encajen en los principios existentes. La lista de principios que presenta la modificación de los títulos se ilustra a continuación:

1. Segmentation

2. Extraction

3. Local Quality

4. Asymmetry

5. Combination

6. Universality

7. ‘Nested Doll’

8. Counterbalance

9. Prior Counter-Action

10. Prior Action

11. Prior Cushioning

12. Remove Tension

13. ‘The Other Way Round’

14. Loop

15. Dynamics

16. Slightly Less/Slightly More

17. Another Dimension

18. Vibration

19. Periodic Action

20. Continuity of Useful Action

21. Hurrying

22. ‘Blessing in Disguise’

23. Feedback

24. Intermediary

25. Self-Service

26. Copying

27. Cheap/Short Living

28. Another Sense

29. Fluidity

30. Thin & Flexible

31. Holes

32. Colour Changes

33. Homogeneity

34. Discarding and Recovering

35. Parameter Changes

36. Paradigm Shift

37. Relative Change

38. Enrich

39. Calm

40. Composite Structures

40 Principios de Inventiva.

También conviene señalar a este respecto es el hallazgo adicional de la investigación hecha por Mann, que la mayoría de los problema de software las soluciones parecen fusionar las ideas de varios principios.

Para efectos prácticos de ejemplificación se muestran solo algunos principios respecto a su analogía clásica hacia la de software. (no obstante se anexan al final en un tabla todos los principios con su descripción de inglés)

1. Segmentation

Software Analogy: Dividir un sistema en componentes autónomos.

5. Combination

Software Analogy: Hacer ejecutar procesos en paralelo.

7. Nesting (Matrioshka)

Software Analogy: Heredar la funcionalidad de otros objetos de sus respectivas clases dentro de una clase base.

18.Vibration

Software Analogy: cambiar el ritmo de ejecución de un algoritmo en el contexto de tiempo, hasta lograr. el resultado deseado.

Secuencia de uso (frecuencia) de los Principios de Inventiva

El análisis aquí descrito se basa en los mismos 40000 soluciones de software utilizado para compilar la Matriz de software. El método de presentar nuestras conclusiones es exactamente el mismo que recientemente se ha utilizado para la actualización de la matriz técnica y de. El software Principio de frecuencia de secuencia, es el siguiente:

Secuencia de frecuencia de los 40 Principios de Inventiva.

En comparación con la matriz clásica de triz, es la siguiente (por efectos de procesador de textos, la tabla quedo en la página siguiente):

La columna cambio (change) indica que se han producido algunos cambios muy importantes que han tenido lugar entre la matriz clásica y la nueva matriz de software. En menor medida también ha habido algunos cambios en. Los mayores subidas en la lista la oferta muestran de manera más interesante las diferencias entre estrategias de resolución de conflictos de software y problemas técnicos:

Las subidas de los Principios 37 ( «Cambio relativo" en nuestra aplicación de software) y 7 ( 'Muñeca Rusa ') son más indicativos de la facilidad con que estas dos estrategias pueden ser desplegadas en un contexto de software. Agrupamiento (Muñeca rusa) en particular, puede ser algo que añade una considerable complejidad en un sistema físico, pero en una pieza de software el uso de esta estrategia se limita solamente a exigir la creación de nuevas líneas de código. El aumento del principio “Cambio relativo” es también debido a la facilidad con que este estrategia puede ser desplegado en un entorno digital.

En cuanto a los Principios que caen en la lista, parece claro que hay algunos de los Principios que son más difíciles de interpretar en el contexto de software. Por ejemplo el Principio 18 («vibraciones»), 30 (”Flexible y delgado”), 31 ('Holes') y 36 («la fase de transición»). Si bien todos los ejemplos de software de estos principios pueden ser encontrados, su existencia es poco frecuente y, a veces, la imaginación necesaria es muy alta. El análisis detallado de la secuencia de prioridad se ilustra en mostrada anteriormente, de hecho, muestran que hay una gran diferencia en la frecuencia del uso de los 16 principales principios en comparación con el 24 inferiores.

Comparación entre la matriz de Software y la Clásica.

Idealidad y Tendencias

Pasando de contradicciones, otro instrumento importante en el contexto del software parece ser La Idealidad y las Tendencias parte de TRIZ.

Una gran parte de la investigación subyacente para TRIZ-Software de ha examinado los patrones que existen en la evolución del software como los sistemas de salto discontinua de una manera de hacer las cosas a otro. Esto se debe a que esperamos que el conocimiento de esas tendencias nos permitirá acelerar considerablemente la evolución de las actuales sistemas de la misma manera que está empezando a suceder con los sistemas técnicos que estamos participando.

Si bien este punto escapa al desarrollo de la investigación, nos pareció interesante mencionarlo ya que forma de una herramienta de gran apoyo para triz, especialmente para problemas de software. Ya que permite observar las tendencias a futuro de en un área tan volátil como la informática que permanece en constante evolución. De esta manera al momento de utilizar los principios observaremos nuestra tendencia de acuerdo a nuestra solución propuesta.

Radar de Comparación, Actual y Potencial de Tendencias.

Diseñando Patrones de Software con Triz

Triz como ya mencionamos anteriormente, aparte de ser ocupado para la física, química, y otras ciencias, también puede ser aplicado a los procesos de negocios y a los procesos de software. Es así como el análisis de Triz y los patrones de diseño, visualizamos ciertas analogías que pueden ser estructuradas para mejorar y ayudar a los ingenieros de software.

Para entrar en contexto un patrón de diseño es:

• una solución estándar para un problema común de programación

• una técnica para flexibilizar el código haciéndolo satisfacer ciertos criterios

• un proyecto o estructura de implementación que logra una finalidad determinada

• un lenguaje de programación de alto nivel

• una manera más práctica de describir ciertos aspectos de la organización de un programa

• Conexiones entre componentes de programas

• La forma de un diagrama de objeto o de un modelo de objeto.

Así describiremos un subconjunto de los 23 patrones de diseño que fueron desarrollados por los Gang of Four [1] como instancias de los principios de resolución de problemas encontrados por la teoría TRIZ de Genrich Altshuller´s. Nosotros podemos ver en un análisis temprano, las similaridades entre los patrones de diseño y Triz, esto es que ambos sistemas son un conjunto de heurísticas, derivados desde observaciones de soluciones exitosas para problemas comunes.

Luego de un profundo análisis, nosotros podemos encontrar fuertes links entre los patrones estructurales del grupo de los Gang of Four y un conjunto especifico de principios de TRIZ.

Contradicciones Espacio-Tiempo

Los científicos de la computación tienen dos bien conocidas fuerzas que son el espacio y el tiempo (dos características de los sistemas). Así el problema general es que tal como la característica del sistema del tiempo decrece (se mejora), la característica del sistema de espacio se incrementa (se empeora). En cambio, tal como la característica del sistema del espacio decrece (mejora), la característica del sistema de tiempo decrece (se empeora).

Un ejemplo ilustrativo de contradicciones de espacio-tiempo:

Se encuentra un problema con las bases de datos que mientras más información ellos guardan, más lento el sistema se pone.

Sin embargo, mientras más información ellos tienen, más comúnmente podemos encontrar la información que nosotros queremos, debido a una pregunta realizada.

Si identificamos en la matriz de contradicciones de 39x 39 TRIZ sería lo siguiente:

Problemas	Principios de Triz
"el acceso a mas respuestas e información"	Volumen de un objeto estático (Característica del sistema 8)
"incremento de tiempo necesario para encontrar una respuesta"	Tiempo de acción de un objeto estacionario ( Característica del sistema 16)

La intersección de tiempo de acción de un objeto estacionario a lo largo del eje horizontal (se empeora) y volumen de un objeto estático (se mejora) nos indica 3 potenciales soluciones desde los 40 principios:

· 35 - Transformación de Propiedades

· 34 - Rechazo y regeneración de las partes

· 38 - Oxidación acelerada.

El principio 34 incluye: " Después de completar esta función o llegar a ser útil, un elemento del objeto es rechazado (descartado, disuelto, evaporado, etc.) o modificado durante el proceso de trabajo". Esta descripción contiene la esencia de la definición de CACHE, el cual es una solución común a un problema inicial con base de datos.

Examinando el problema general de mas y mas tiempo (empeora) tomando un orden a través de una sobre-abundancia de información (se mejora), la solución de TRIZ encuentra muy bien descrito en el principio 34 la idea de un FAQ, o una lista de Preguntas frecuentemente hechas - otro ejemplo de un CACHE.

Diseño de Patrones y TRIZ

1. Adapter Pattern y el principio Mediador (Mediator Principle)

El patrón adaptador, como su propio nombre nos puede hacer ver, se usa para convertir el interface de una clase a la de otra, entendiendo en este caso interface como el conjunto de métodos que ofrece una clase para su manipulación por código, no la herramienta que usa el usuario final de nuestra aplicación. Lo que haremos será escribir métodos con nuestra interface deseada que deleguen el trabajo en los de la interface ya existente.

Las razones para querer hacer algo así pueden ser de muy distinta naturaleza, y pueden ir desde:

Querer integrar una clase ya existente pero que no podemos modificar en una nueva jerarquía de clases, que por ejemplo implemente una nueva interfaz, podemos querer limitar el interface de una clase.

Querer hacerlo simplemente porque la convención de nombres usada en la clase original, que tampoco podemos o queremos cambiar, no se ajusta a la nuestra.

§ Esta última razón puede parecer un poco absurda pero puede ser bastante frustrante recibir miles de errores de compilación por trabajar con métodos del estilo GetName en lugar de getName.

o Esta adaptación se puede hacer de dos formas :

Adaptación por herencia

Adaptación por composición.

1.3 Adaptación por herencia

Aquí haremos que la clase que implementa la nueva interface extienda de la original y añadiremos a esta los métodos que consideremos oportunos.

Por ejemplo:

public class Usuario{

protected String nombre;

protected String password;

. . .

public Usuario (String nombre, String password){

. . .

}

public String GetNombre (){

return nombre;

}

public String GetPassword (){

return password;

}

. . .

}

Según las convenciones de programación, nos damos cuenta de que esas dos G de Getxxx darán muchos problemas. Entonces suponiendo que esta clase ya esta en sistemas productivos y por tanto no podemos hacer algo tan simple como cambiar esa letra, optamos por extender esa clase, de forma que el sistema siga trabajando correctamente con las clases antiguas, para así evitarnos errores de compilación innecesarios.

public class BuenUsuario extends Usuario{

public BuenUsuario (String nombre, String password){

super (nombre, password);

}

public String getNombre (){

return GetNombre();

}

public String getPassword (){

return GetPassword();

}

Al hacerlo así, nos aprovechamos aparte de las ventajas de la herencia, haciendo que los métodos de otras clases que usen la clase usuario puedan seguir funcionando sin retocarlos.

1.2 Adaptación por Composición

Esta ocurre en algunos casos donde no podemos usar la herencia, ya sea porque queremos integrar esa clase en una jerarquía nueva y ya estemos heredando de otra clase, o ya sea por causa de modificadores de acceso como private o final que impidan que se hereden algunas características de la clase, o simplemente que no queramos que la nueva clase tenga el interface completo de la original. En ese caso tendremos que usar la composición, es decir, incluir la clase a adaptar como un atributo de la adaptadora.

2. Composite and Iterator Pattern y el principio de Universalidad (Universality Principle)

Como desarrollador se tienen variadas listas para utilizar. Cada una de éstas pueden estar y lo más probable es que así sea, en distintos formatos. Es útil para crear una interfaz a través de la cual los objetos en las diferentes listas puedan sea accesados. Una segunda interfaz es creada para moverse a través de las listas (en el formato entregado por la interfaz de la lista). Esta interfaz, a través de la cual los objetos de la lista son accesados, es llama iterator (iterador). La representación (implementación) de la lista no es de ninguna consecuencia, el retorno de la siguiente lista de objetos de importancia primaria.

PRINCIPIO 6 - UNIVERSALIDAD

Promueve uniformidad de función, uso uniforme de un objeto para distintos propósitos, o la aplicación de los mismos requerimientos o características para distintos objetos, situaciones o acciones.

3. Decorator Pattern y los principios de Agrupamiento y/o Membranas Flexibles

El decorator pattern dinámicamente agrega funcionalidad a un objeto. Usando éste patrón, es una forma de evitar crear subclases (clases hijas) para proveer funcionalidad extendida. Este patrón comienza con una superclase de un componente particular, C. El objeto actual que vamos a “decorar”, es una subclase de C, el que llamaremos c. El objeto decorador, d, en realidad referencia valores en c. Una subclase del decorador en realidad crea la funcionalidad adicional provista por la clase decorador.

PRINCIPIO 7 – AGRUPAMIENTO

Aplica cuando un objeto cabe dentro o pasa a través de otro.

PRINCIPIO 30 – MEMBRANAS FLEXIBLES

Receta el reemplazo de las construcciones tradicionales con construcciones de peliculas delgadas o membrana flexibles. Además, un objeto puede ser aislado de su ambiente con una película delgada.

4. Facade Pattern y el principio de la consolidación

Dada una colección de interfaces, un cliente (usuario) debería sólo tener que tratar con un sistema de interfaz unificada cuando trata de acceder a los datos. La interfaz de mayor nivel es el llamado patrón fachada. Es una implementación directa de la Ley de Remeter, la que encapsula el principio de mínimo conocimiento (“los amigos solo hablando con amigos”).

PRINCIPIO 5 – CONSOLIDACION

Entrega funciones o partes de un sistema a una relación que crea nuevos resultados. Un ejemplo es combinar la habilidad para reproductor de reproducir múltiples formatos (DVD, mp3, etc).

5. Flyweight Pattern y el principio de transición hacia una nueva dimensión

Existen momentos en los que uno necesita tener, literalmente, miles de instancias de un objeto. Cada objeto es relativamente simple, usualmente llamando a unos pocos métodos. Un ejemplo de esto, podría ser un procesador de palabras basado en web que talvez tiene 2560 lugares para poder ubicar caracteres. Caracteres cualquiera pueden aparecer o desaparecer (dos métodos). El patrón flyweight entrega un administrador para organizar cada uno de los pequeños objetos (configurando los caracteres en 80 por columna y 32 por fila por cada página). Los objetos carácter son responsables de su propia administración. (Mostrando o no una letra, número, símbolo o estando en blanco).

PRINCIPIO 17 – TRANCISION HACIA UNA NUEVA DIMENSION

Sugiere cambiar la orientación de un sistema agregando una dimensión. Esta nueva dimensión puede poner menor tensión en una dimensión ya existente, o puede agregar una dimensión de control.

6. Proxy Patterm y los principios de Cambio de parámetro y/o transición de fase

El patrón Proxy es usado para controlar el acceso a un objeto. Como ejemplo, hay momentos en lo que un usuario querrá solicitar que una imagen sea mostrada. Si el tamaño de ésta es un poco grande, entonces debería tomar un tiempo no mínimo en aparecer (quizás una animación flash). Prácticas de buena usabilidad recomendarían que un pequeño cartel animado que diga “Cargando” aparezca mientras se carga en memoria para reproducirse un gran archivo flash. Introduzca el patrón comentado para poder realizar esto, poner un cartel de “cargando” mientras la imagen está lista para ser mostrada, y luego mostrarla.

PRINCIPIO 35 – CAMBIOS DE PARAMETRO

Sugiere cambiar el estado físico de un objeto (de gas a líquido por ejemplo). Cambiar la concentración o consistencia. Cambiar el grado de flexibilidad. Cambiar la temperatura.

PRINCIPIO 36 – TRANSICION DE FASE

Sugiere usar el fenómeno que ocurre durante el cambio de fase (cambio de volumen, ganancia o pérdida de calor)

Ejemplos de Patrones

Proxy pattern

Se desea guardar una lista de usuarios registrados, pero no sé exactamente donde. La idea es que dependiendo del valor de un checkbox ( en el que el usuario elige si está conectado a internet o no ), debo mandar los datos a servidor ( en formato XML ) o guardarlos en disco en un Shared Object

Esta es una misión para el Patrón Proxy, debido a que se quiere aislar el proceso de guardar los datos del resto del programa, simplemente hacerlo y olvidarse de cómo o dónde se guarda.

Eso es lo que hace este patrón. El proxy guarda una referencia a un objeto, que es quien realmente se encargará de ejecutar la acción. Pero es el proxy el que crea ese objeto, por lo que puede crear una instancia de una u otra clase dependiendo de ciertas condiciones en tiempo de ejecución

Por tanto, todas las clases que puedan ser instanciadas por el proxy, deben implementar el mismo interfaz. Y dependiendo del tipo de proxy, puede ser una buena idea que incluso él mismo implemente ese interfaz, para que se pueda eliminar si es necesario.

Decorator Pattern

Supongamos que tenemos una clase existente Ventana y queremos añadirle funcionalidad para que muestre un borde alrededor. Podemos crear una subclase VentanaConBorde que herede de Ventana.

Hasta aquí todo bien, pero supongamos que surge la necesidad de crear una ventana que muestre un pequeño botón de ayuda con un signo de interrogación (?) en su parte superior. Entonces tenemos las siguientes opciones:

· Crear otra subclase de Ventana: VentanaConBotónDeAyuda.

Problema: No cubre la necesidad de tener ventanas con bordes y botón de ayuda a la vez.

· Crear una subclase de VentanaConBorde: VentanaConBordeYBotonDeAyuda.

Problema: No tenemos una ventana con botón de ayuda y sin borde.

· Crear clases para todas las combinaciones posibles de funcionalidades.

Problema: Con este ejemplo tendríamos cuatro clases: Ventana, VentanaConBorde, VentanaConBotonDeAyuda y VentanaConBordeYBotonDeAyuda; con tres funcionalidades tendríamos ocho clases y con cuatro, ¡dieciséis!

El patrón Decorator soluciona este problema de una manera mucho más sencilla y extensible. Se crea a partir de Ventana la subclase abstracta VentanaDecorator y, heredando de ella, BordeDecorator y BotonDeAyudaDecorator. VentanaDecorator encapsula el comportamiento de Ventana y utiliza composición recursiva para que sea posible añadir tantas "capas" de Decorators como se desee. Podemos crear tantos Decorators como queramos heredando de VentanaDecorator.

Flyweight Pattern

Crear una clase PelotaFlyweight, que contendrá la información común (radio y color) y otra clase PelotaConcreta, que contendrá las coordenadas concretas de cada pelota y una referencia a un objeto de tipo PelotaFlyweight.

Al crearse instancias de PelotaConcreta, se les deberá proveer de referencias a la instancia de PelotaFlyweight adecuada a nuestras necesidades.

En este caso solamente tendríamos una instancia de PelotaFlyweight, puesto que hemos dicho que todas nuestras pelotas tienen el mismo radio y color, pero pensando en un ejemplo en el que tuviéramos varios grupos de pelotas, y dentro de cada uno de los cuales se compartieran el radio y el color, se puede utilizar Flyweight conjuntamente con el patrón Factory, de tal modo que este último, en el momento en que se le soliciten instancias de PelotaConcreta con determinadas características (mismo radio y color que el solicitado), compruebe si ya existe un PelotaFlyweight con ese radio y color, y devuelva esa referencia o, en caso de que no exista, la cree y la registre.

Facade Pattern

class UserfriendlyDate

    GregorianCalendar gcal;

    public UserfriendlyDate(String isodate_ymd) {

        String[] a = isodate_ymd.split("-");

        gcal = new GregorianCalendar(Integer.valueOf(a[0]).intValue(),

              Integer.valueOf(a[1]).intValue()-1 /* !!! */, Integer.valueOf(a[2]).intValue());

    public void addDays(int days) { gcal.add(Calendar.DAY_OF_MONTH, days); }

    public String toString() { return new Formatter().format("%1$tY-%1$tm-%1$td", gcal).toString();}

/** Cliente */

class FacadePattern

    public static void main(String[] args)

        UserfriendlyDate d = new UserfriendlyDate("1980-08-20");

        System.out.println("Date: "+d);

        d.addDays(20);

        System.out.println("20 days after: "+d);

Bridge Pattern

public class Abstraccion

        private Implementador implementador;

        public void setImplementador(Implementador implementador)

                this.implementador = implementador;

        public Implementador getImplementador()

                return implementador;

        public void operacion()

                implementador.operacion();

public class AbstraccionRefinada extends Abstraccion

        public void operacion()

                super.operacion();

public interface Implementador

        public abstract void operacion();

public class ImplementacionA implements Implementador

        public void operacion()

                System.out.println("implementacion A");

public class ImplementacionB implements Implementador

        public void operacion()

                System.out.println("implementacion B");

public class PruebaBridge

        public static void main(String arg[])

                Abstraccion abstraction = new AbstraccionRefinada();

                abstraction.setImplementador(new ImplementacionA());

                abstraction.operacion();

Composite Pattern

Imaginemos que necesitamos crear una serie de clases para guardar información acerca de una serie de figuras que serán círculos, cuadrados y triángulos. Además necesitamos poder tratar también grupos de imágenes porque nuestro programa permite seleccionar varias de estas figuras a la vez para moverlas por la pantalla.

En principio tenemos las clases Círculo, Cuadrado y Triángulo, que heredarán de una clase padre que podríamos llamar Figura e implementarán todas la operación pintar(). En cuanto a los grupos de Figuras podríamos caer en la tentación de crear una clase particular separada de las anteriores llamada GrupoDeImágenes, también con un método pintar().

Problema.

Esta idea de separar en clases privadas componentes (figuras) y contenedores (grupos) tiene el problema de que, para cada uno de los dos atributos, el método pintar() tendrá una implementación diferente, aumentando la complejidad del sistema.

El patrón composite da una solución elegante a este problema, de la que además resulta en una implementación más sencilla.

A la clase Figura la llamaríamos Gráfico y de ella extenderían tanto Círculo, Cuadrado y Triángulo, como GrupoDeImágenes. Además, ésta última tendría una relación todo-parte de multiplicidad * con Gráfico: un GrupoDeImágenes contendría varios Gráficos, ya fuesen éstos Cuadrados, Triángulos, u otras clases GrupoDeImágenes.

Así, es posible definir a un grupo de imágenes recursivamente. Por ejemplo, un objeto cuya clase es GrupoDeImágenes podría contener un Cuadrado, un Triángulo y otro GrupoDeImágenes, este grupo de imágenes podría contener un Círculo y un Cuadrado. Posteriormente, a este último grupo se le podría añadir otro GrupoDeImágenes, generando una estructura de composición recursiva en árbol, por medio de muy poca codificación y un diagrama sencillo y claro.

Adapter Pattern

El patrón adaptador, como su propio nombre nos puede hacer ver, se usa para convertir el interface de una clase a la de otra.

Implementación:

En otras palabras, un adaptador es típicamente implementado utilizando herencia múltiple, al crear una subclase del adaptador que herede los métodos privados y, permitiendo que herede además, la interfaz pública de las clases que definen la interfaz requerida.

Conclusiones

Se ha demostrado con este informe que la mayoría de las patentes de software y la implementación de nuevos principios pueden ayudar a formar una nueva matriz y generar la base para una nueva investigación para una Matriz totalmente limpia solo para software. Es así como el autor Darell Mann ha introducido una investigación importante respecto a este tema, por lo que un próximo trabajo estaría en crear y formar Triz para el software implementando nuevas matrices y generando nuevas soluciones con patentes de software innovadoras.

Referencias

http://www.systematic-innovation.com

Ikovenko, S., ‘Laws Of Engineering System Evolution In Software Development’,keynote paper at TRIZ Centrum, 3rd European TRIZ-Conference, ETH Zurich, March 2003.

Karasik, Y., editorial comment, Anti-TRIZ Journal, Vol.2, No.2, and private email correspondence, 8 September 2004.

[Kev-01] Rea, K., ‘TRIZ and Software - 40 Principle Analogies, Partes 1 and 2’, TRIZ Journal, Septiembre y Noviembre 2001.

Mann, D.L., ‘Hands-On Systematic Innovation’, CREAX Press, June 2002.

Espejo, R., Harnden, R., ‘The Viable System Model’, John Wiley & Sons, New York, 1989.

Mann, D.L., ‘Hands-On Systematic Innovation For Business & Management’, IFR Press, August 2004.

Mann, D.L., ‘TRIZ For Software Engineers’, IFR Press, October 2004.

Mann, D.L., Dewulf, S., Zlotin, B., Zusman, A., ‘Matrix 2003: Updating The TRIZ Contradiction Matrix’, CREAX Press, Belgium, July 2003.

Mann, D.L., ‘Comparing The Classical And New Contradiction Matrix, Part 2 – Zooming In’, TRIZ Journal, July 2004.

Paulk, M.C., Weber, C.V., Garcia, S.M., Chrissis, M.B., Bush, M., ‘Key Practices Of The Software Maturity Model’, Software Engineering Institute, Carnegie Mellon University, Pittsburgh, Pennsylvania.

Mann, D.L., Dewulf, S., ‘Evolutionary Potential In Technical And Business Systems’, TRIZ Journal, June 2002.

Mann, D.L., ‘Ideality And Self-X’, paper presented at 1st ETRIA TRIZ Future Conference, Bath, November 2001.

Rea, K., ‘Applying TRIZ to Software Problems’, TRIZ Journal, October 2002.

Anexos

Resumen, Analogía 40 principios de Inventiva TRIZ (1-20).

Resumen, Analogía 40 principios de Inventiva TRIZ (21-40).

Patentes en el software

Patentar una idea o un producto no es algo nuevo, es más, ésta se lleva a cabo hace mucho tiempo, si bien en algunos casos puede ser vista como una medida arbitraria, también premiar de alguna forma al inventor de un producto u objeto que añada funcionalidad a alguno existente, o éste tenga funcionalidad por si sólo.

Una patente, al igual que un derecho de autor (copyright), entrega a un autor un derecho exclusivo o monopólico respecto a su creación o invención intelectual.

El problema nace al afirmar que está sujeto a patente y que no.

Por ejemplo, el autor de un libro tiene el derecho de autor respecto a éste, ese derecho le otorga protección literaria como artística sobre su obra, pero es de un índole más estético. Con esto nos referimos a que el uso de frases o el argumento de la obra está protegido, tanto para su copia como reproducción, pero no así el género de ésta. Osea, puede tener derecho sobre su obra, pero no sobre el género “crimen/suspenso”, esto permite que existan más escritores que se dediquen a escribir obras de ésa índole, y protege al autor de una copia.

Dentro de las cosas no patentables están por ejemplo; variedades vegetales o animales, inventos en biotecnología y microbiología, productos farmacéuticos y medicamentos esenciales en la lista de la OMS, descubrimientos, teorías científicas ni métodos matemáticos, descubrimiento de materias existentes en la naturaleza, etc.

El software cae en el medio de la polémica, y es a su vez un caso emblemático.

Si bien existen miles de patentes de software, existe un gran número de detractores de éstas, haciendo que en Europa se lleve discutiendo durante varios años el si es posible o no patentar el software.

Respecto al tema que nos atañe, si bien existen grandes cantidades de productos de software patentados, también existe un número mayor de productos que no lo están, siendo un tema complicado y delicado la patentabilidad o no.

Existen a nivel internacional distintas oficinas que conceden patentes y las administra.

Entre éstas está la Oficina Europea de Patentes (OEP), quien presenta una gran cantidad de detractores respecto a nuestro tema. En el caso de Estados Unidos, la práctica de patentar software es realizada comúnmente.

Finalmente en éste sentido, si bien existe una gran controversia, respecto a la patentabilidad o no del software, en éstos momentos, existen una gran cantidad de patentes, lo que permitiría avanzar en el análisis de éstas, trabajo ya iniciado por Darrel Mann, y formular finalmente una teoría de TRIZ pero aplicada directamente al desarrollo o la búsqueda de innovación en el software.

[1] Ikovenko, S, “Laws of Engineering System Evolution In Software Development”,·3rd European TRIZ- Conference, ETH Zurich, March 2003.

[2] Karasik, Y., editorial comment, Anti-TRIZ Journal, Vol.2, No.2, and private email correspondence, 8 September 2004.

[3] Rea, K., ‘TRIZ and Software - 40 Principle Analogies, Parts 1 and 2’, TRIZ Journal, September and November 2001.

[4] Mann, D.L., ‘Hands-On Systematic Innovation’, CREAX Press, June 2002.

[5] Mann, D.L., Dewulf, S., Zlotin, B., Zusman, A., ‘Matrix 2003: Updating The TRIZ Contradiction Matrix’, CREAX Press, Belgium, July 2003.

Metodología TRIZ

2008-10-02T09:05:00.001-07:00

Resumen

TRIZ es una teoría sobre la cual se ha desarrollado una metodología, un conjunto de herramientas basados en modelos para la generación de ideas y soluciones innovadoras para resolver problemas; proveyendo de herramientas y métodos para usarse en formulación de problemas, análisis de sistemas, entre otros. Respecto a lo que aquí compete este documento tiene por objeto proporcionar un análisis y una comprensión del método TRIZ a fin de aportar ideas a fin de esclarecer el funcionamiento de esta última para asegurar una interpretación y una implementación futura de manera adecuada.

1 Introducción.

TRIZ es el acrónimo ruso de Teoría para la Resolución de Problemas Inventivos. A grandes rasgos TRIZ es un método sistemático para incrementar la creatividad, basado en el estudio de los modelos de evolución de patentes y en otros tipos de soluciones a problemas. Donde independientemente de la forma de como se resuelven los problemas ya sea de forma intuitiva y/o estructurada, encontrarán que el método les proporciona ideas adicionales y en el caso contrario encontrarán que les proporciona estructuras adicionales con el fin de las personas que resuelven los problemas encuentren soluciones totalmente innovadoras e ingeniosas.

Este método surge del análisis que inició y consolidó Genrich S. Altshuller y que sus discípulos han continuado hasta el estudio de más de 2,5 millones de patentes de todo el mundo. Basándose en la lógica y los datos, y no la intuición, lo que hace que el equipo del proyecto tenga la capacidad para resolver estos problemas con creatividad.

2 Descripción.

Hemos podido observar que el razonamiento discurre por unos caminos ya establecidos por nuestro cerebro y por ende siendo muy difícil que surjan ideas o soluciones novedosas. Así pues para la invención de una solución a partir de una necesidad y/o para resolución de un problema, generalmente se aplica el conocimiento que dominamos. Por lo que si la solución ideal al problema cae fuera de nuestro dominio o experiencia propia, resulta imposible acertar con ella.

Una manera es que se tiende a imaginar y a evaluar distintas alternativas a modo de ensayo/error. Donde dicha forma depende del azar para encontrar antes o después una solución, por consiguiente es aquí donde Altshuller con su metodología TRIZ trata de evitar y/o evita esto último con su sistema.

Bajo esta premisa TRIZ se inicia con la hipótesis de que hay principios universales de la creatividad. Si estos principios pudieran ser identificados y codificados, podrían ser enseñado a la gente para hacer que el proceso de creatividad al encontrar una solución sea más previsible. En otras palabras como se refiere en el medio TRIZ funciona bajo la premisa: “Alguien en algún lugar ya ha resuelto este problema (o uno muy similar a él.)...La creatividad radica en que ahora la búsqueda de esa solución y su adaptación a al problema en particular”.Es decir si la solución existe adecuarla de manera creativa a mi problema en cuestión.

Gráficamente esto se ve representado de la siguiente manera:

Figura 1. Método Resolución, TRIZ.

En la figura anterior se puede observar que las flechas representan la transformación de una formulación del problema o solución a otro. Estas últimas representan el análisis tangente de los problemas y la utilización de la bases de datos de TRIZ. Exponiendo el pensamiento por analogía a desarrollar la solución específica. Este paso de cuatro enfoques de la resolución de problemas que fuerza al usuario a superar los prejuicios inherentes psicológicos suele ser el fundamento psicológico de las técnicas de ideación bajo el cual trabaja la metodología TRIZ. Es decir Aquí, el problema particular es elevado hacia un problema estándar de naturaleza análoga o similar para encontrar la solución respectiva.

Por ejemplo, Supongamos que necesitemos diseñar un dispositivo rotatorio cuya salida es 100 rpm, a partir de un motor eléctrico de CA 2300 rpm.

El problema estándar análogo es como reducir la velocidad del motor.

La solución estándar análoga es un reductor de velocidad o caja de transmisión a engranaje, luego este reductor será diseñado con apropiadas dimensiones, peso, torque, etc.

Sin embargo el problema radica en problemas inventivos, es decir, donde la solución causa otros problemas, es decir que cuando algo se mejora, otras condiciones empeoran, cayendo en una contradicción técnica. Dependiendo de la complejidad del problema, el número de prueba y error variará enormemente.

No obstante si la solución cae dentro de nuestro conocimiento, el número de prueba y error será algo menor pero aun así no deja de ser un método irracional.

Es decir TRIZ se sustenta, si la solución no se alcanza se debe ser capaz de buscar más allá de su experiencia y conocimiento, es decir deberá incursionar en otros campos. Luego el número de pruebas crecerá dependiendo de lo bien que pueda manejar las herramientas psicológicas como el brainstorming, intuición y la creatividad.

No obstante el problema más patente y/o la desventaja más visible que presenta TRIZ es que la mayoría de estas herramientas psicológicas tales como la experiencia y la intuición, son difíciles de transmitir a otra persona dentro de una organización ( sección 2.1,condiciones - ü).

Ya que las soluciones consideradas están dentro de la propia experiencia de uno, sin embargo se puede extrapolar en buscar en tecnologías alternativas para desarrollar nuevos conceptos de solución que sean familiares a los demás participantes dentro de la organización. Ejemplo: un ingeniero mecánico puede encontrar una solución a su problema fuera del campo de su experiencia.

2.1 Condiciones de TRIZ

Su autor Geinrich Altshuller, construye una teoría bajo la cual TRIZ se debe apoyar bajo las siguientes condiciones:

· Ser un procedimiento sistemático paso a paso.

· Ser una guía a través de amplios espacios de solución para dirigir los pasos a la solución ideal.

· Ser repetitible y confiable y no dependiente de las herramientas psicológicas.

· Debe permitir el acceso al cuerpo del conocimiento inventivo.

· Debe permitir agregar elementos al cuerpo de conocimiento inventivo.

· Ser lo suficientemente amigable para los diseñadores siguiendo la aproximación general para la resolución de los problemas inventivos. (ü)

Además Altshuller, menciona que para alcanzar una solución ideal se deben eliminar las soluciones de compromiso o trade off, es decir eliminar totalmente las causas.

Donde todas estas patentes inventivas se clasificaron en 5 niveles:

NIVEL	GRADO NOVEDAD	Nº PATENTES	FUENTE CONOCIMIENTO
1	Solución Aparente	32%	Conocimiento Personal.
2	Mejora moderada	45%	Conocimiento dentro de la empresa.
3	Mejora importante	18%	Conocimiento dentro del sector.
4	Concepto Nuevo	4%	Conocimiento fuera del sector.
5	Descubrimiento	1%	Todo el conocimiento.

Altshuller se dio cuenta de que la mayoría de problemas ( niveles 1 y 2 ) se podían resolver aplicando correctamente los conocimientos habituales , sin embargo los niveles 3 y 4, cuya solución está fuera del conocimiento habitual o implican una percepción novedosa, podrían beneficiarse de TRIZ.

Finalmente generalmente un 90 % de los problemas que se encaran fueron ya resueltos en algún lugar bajo un cierto tipo de conocimiento, de modo que si se pudiese seguir un camino hacia la solución ideal, arrancando desde el nivel más bajo de su experiencia y conocimiento personal y llegar a trabajar hacia los niveles más altos, la mayoría de las soluciones podrían ser deducidas rápido desde la Gestión de los Conocimientos.

Estos Conocimientos son las patentes que tanto menciona Altshuller y que son indispensables pare el desarrollo y descubrimientos de soluciones en la actualidad bajo TRIZ exponiéndose bajo base teórica con ciertos postulados de los cuales los tres principales son:

1. “La mayoría de los sistemas hechos por el hombre evolucionan siguiendo pautas predeterminadas, en vez de modo aleatorio. Estas pautas se pueden conocer a través del estudio de la evolución de varios sistemas y el conocimiento adquirido y se las puede utilizar para acelerar la evolución de otros sistemas”.

2. “La mayoría de los sistemas técnicos que existen tienen recursos redundantes, es decir, tienen mas recursos de los necesarios para realizar las funciones para las que fueron concebidos. Como consecuencia, casi todos los sistemas pueden realizar su función de forma más efectiva o realizar funciones adicionales, sin necesidad de ser modificados”.

3. “Se pueden encontrar formas comunes de resolver problemas o de mejorar un sistema, basadas en las etapas de evolución predeterminadas, mediante el análisis histórico de las invenciones. Esto permite que el conocimiento para la innovación pueda ser recogidos y transferidos”

3 Área de Aplicación.

Dentro de las actividades en que se desarrollan los procesos de creación de ideas o soluciones nuevas es necesario introducir actividades que permitan incorporar planteamientos innovadores. Las acciones innovadoras podrán estar dentro del ámbito de modificaciones, las innovaciones increméntales o las radicales dependiendo del alcance y dimensión del proceso específico de un producto y/o actividad determinada. No se contemplan las acciones innovadoras propias de procesos de producción, montaje y calidad por ser de tipo horizontal y no específico de un tipo de producción concreto.

Por lo que su área de aplicación abarca cualquier ámbito donde se requieren soluciones innovadoras a problemas de cualquier índole en cuestión. Donde en las fases iniciales del proceso es dónde las acciones innovadoras deben estar potenciadas y apoyadas por técnicas y metodologías específicas (TRIZ) que deben, por lo general, desarrollarse de manera simultánea, aunque las valoraciones y conclusiones, además de efectuarse de manera individualizada, deberán relacionarse globalmente interrelacionando conceptos y orientaciones para confirmar y obtener líneas de acción en el desarrollo, evitando al máximo la incertidumbre y el riesgo.

Áreas más destacadas de aplicación de la metodología TRIZ:

Reducir costes.
Simplificar el producto

- Reducir número de piezas y subconjuntos.

- Facilitar el montaje, desmontaje y reparaciones.

· Mejorar las prestaciones de la función.

· Permitir elevar los niveles de calidad y acabados.

· Incorporar tecnologías no aplicadas hasta ese momento en el sector.

· Dar respuesta a las necesidades del consumidor mediante una solución de producto radicalmente diferente.

· Benchmarking.

· Análisis de tendencias.

· Estudios económicos, antropológicos y sociales.

· Estudios mercados y análisis de productos.

4 Referencias Bibliográficas.

http://www.triz-journal.com/

http://www.triz.net/

“TRIZ, La metodología mas moderna para inventar o innovar tecnológicamente de manera sistemática”; Enrique Rico Arzate, 2004.

Pancho Riveros

Seminario de JAVA (2006)

Delitos E-legales en el Mundo

“Política Cambiaria en Chile”

Aplicaciones de SVD en Biología

1 Resumen

2 Introducción

3 Tema de Aplicación

3.1 Dinámica de Proteínas

3.2 Análisis de Micro-Arreglos de Datos.

3.3 Ingeniería Inversa en Redes Genéticas

3.4 Otros Problemas

4 Aporte Grupal

5 Conclusiones

BANCO CENTRAL E INFLACION

( TRABAJO ESCRITO EN EL 2006 PARA ECONOMIA I/A)

Fotos Antiguas

Mi Oficina!! …cuando tenia mi empresa :(

Ayudantía 6

Problema

Arreglos Unidimensionales

Ayudantía I de Pascal

Ayudantía desarrollada en la UTFSM. Este documento es un draft o sea falta modificar algunas cosas yo solo ocupaba esto como apoyo.

VI.a TIPOS ENTEROS

VI.b TIPOS REALES

Sin ELSE

Video Explicativo y Didáctico De la Crisis Económica de Hoy en Día.

Aquí navegando por la web, encontré un video súper bueno que explica de manera didáctica y fácil como y que sucede con la crisis económica que esta tan en boga hoy en día, espero que pueda servir de algo. (Video lo saque de http://www.dreig.eu/caparazon/ – Blog Muy bueno):

Fotos

Recopilación de Fotos de ayer y hoy aquí:

Fotos de mi Intercambio en Austria (PARTE I)

Fotos de mi Intercambio en Austria (PARTE II)

agregare otras fotos…

TRIZ para Software ( TRIZ for Software)

Analogía de Patrones de Software

Metodología TRIZ

1 Introducción.

2 Descripción.

2.1 Condiciones de TRIZ

3 Área de Aplicación.

4 Referencias Bibliográficas.