frameworks en java

FrameWork es un concepto sumamente genérico, se refiere a “ambiente de trabajo, y ejecución”, por ejemplo “.Net” es considerado un “framework” para desarrollar aplicaciones (Aplicaciones sobre Windows). En general los framework son soluciones completas que contemplan herramientas de apoyo a la construcción (ambiente de trabajo o desarrollo) y motores de ejecución (ambiente de ejecución).
Siguiendo con el ejemplo: “.Net” ofrece el “Visual Studio .net” (ambiente construcción o desarrollo) que le permite a lo desarrolladores construir aplicaciones, y su motor es el “.Net framework” que permite ejecutar dichas aplicaciones. El motor de “.net” es una anexo al sistema operativo (un componente que se instala sobre el sistema operativo), y que ahora viene incluido en la mayoría de los sistema operativos de Microsoft.
FrameWork puede ser algo tan grande como “.NET” o Java (también es un framework), pero también el concepto se aplica a ámbitos mas específicos, por ejemplo; dentro de Java en el ámbito especifico de aplicaciones Web tenemos los framework: Struts, “Java Server Faces”, o Spring. Estos frameworks de Java en la practica son conjuntos de librerías (API’s) para desarrollar aplicaciones Web , más librerías para su ejecución (o motor), y más un conjunto de herramientas para facilitar esta tarea (debuggers, ambientes de desarrollo como Eclipse, etc).
Otros ejemplos de frameworks para ámbitos específicos:
· Ámbito: Webservices => FrameWork: Axis.
· Ámbito: Interfaz de Usuario Web Dinámica => FrameWork: Ajax – DWR
· Ambito: Procesos de Negocio => BPMS (WebSphere, AquaLogic, o Oracle)
Por eso antes se debe acotar que ámbito se desea “apoyar” con un FrameWork.
El ámbito más común es el de desarrollo de aplicaciones o sistemas (genérico), bajo el cual algunos buenos ejemplos de Framework sobre Java son:
· Spring en combinación con Eclipse (eclipse es el equivalente a Visual Studio .NET pero para Java)

Ejemplo del Pintado de Pintado de Figuras

package programita2;
import java.awt.*;
import java.awt.event.*;

// Clase de control del ejemplo
class java1516 extends Frame {

// Función de control de la aplicación
public static void main( String[] args ) {
// Se instancia un objeto de la clase
new java1516();
}

// Contructor de la clase
public java1516() {
this.setTitle( "Hecho en la cafe unoooooooooo" );
this.setSize( 510,290 );
this.setVisible( true );

// Clase anidada que permite terminar la ejecución de la animación
this.addWindowListener(
// Definición de la clase anónima para controlar el cierre de
// la ventana
new WindowAdapter() {
@Override
public void windowClosing( WindowEvent evt ) {
// Se concluye el programa
System.exit( 0 );
}
} );
}

// Se sobrecarga el método paint()
@Override
public void paint( Graphics g ){
g.setColor( Color.green );

// Trasladamos el origen de coordenadas que se sitúa en la
// esquina superior izquierda, para evitar el problema que se
// produce con insets. De este modo el origen de coordenadas sí
// que lo dejamos situado en la zona cliente del objeto Frame
// que es la que se utiliza para pintas
g.translate( this.getInsets().left,this.getInsets().top );

// Línea simple
g.drawLine( 10,0,50,50 );
g.setColor( Color.BLUE );
g.drawString( "linea",10,62 );
g.setColor( Color.magenta );

// Se crean dos arrays de coordenadas para pintar una
// polilínea
int x1Datos[] = {80,130,80,130};
int y1Datos[] = {0,50,50,0};
g.drawPolyline( x1Datos,y1Datos,4 );
g.setColor( Color.BLUE );
g.drawString( "polilinea",70,62 );
g.setColor( Color.magenta );

// Rectángulo
g.drawRect( 150,0,50,50 );
g.setColor( Color.BLUE );
g.drawString( "rectangulo",150,62 );
g.setColor( Color.magenta );

// Rectángulo relleno
g.fillRect( 220,0,50,50 );
g.setColor( Color.BLUE );
g.drawString( "rect relle",225,62 );
g.setColor( Color.magenta );

// Rectángulo redondeado
g.drawRoundRect( 300,0,50,50,10,10 );
g.setColor( Color.BLUE );
g.drawString( "Rect redondeado",280,62 );
g.setColor( Color.magenta);

// Rectángulo redondeado relleno
g.fillRoundRect( 385,0,50,50,10,10 );
g.setColor( Color.BLUE );
g.drawString( "Rect redond relleno",375,62 );

// Pinta un rectángulo 3D, sobresaliendo de la pantalla
// No parece demasiado 3D
g.setColor( Color.yellow );//draw the 3D stuff in gray
g.draw3DRect( 10,90,55,25,true );
// Rectángulo 3D, pulsado
g.draw3DRect( 70,90,50,25,false );
g.setColor( Color.BLUE );
g.drawString( "Rect 3D",30,140 );

// Rectángulo 3D relleno. Se ha puesto un fondo gris
// con lo cual se puede apreciar mucho mejor el efecto
// de tres dimensiones
// Fondo gris
g.setColor( Color.yellow );
g.fillRect( 145,75,130,55 );
g.fill3DRect( 155,90,50,25,true );
// Rectángulo 3D relleno, pulsado
g.fill3DRect( 215,90,50,25,false );
g.setColor( Color.magenta );
// De todos modos, la apariencia de tres dimensiones
// con 3DRect no es demasiado buena, porque es necesario
// seleccionar muy bien la paleta de colores para que
// se genere la ilusión de 3D
g.setColor( Color.BLUE );
g.drawString( "Rect 3D relleno",180,140 );
g.setColor( Color.magenta );

// Pinta un ángulo de 255 grados inscrito en un rectángulo
g.drawRect( 300,77,50,50 );
g.drawArc( 300,77,50,50,0,225 );
g.setColor( Color.BLUE );
g.drawString( "arco",305,140 );
g.setColor( Color.magenta );

// Angulo relleno de 255 grados inscrito en un rectángulo
g.drawRect( 385,77,50,50 );
g.fillArc( 385,77,50,50,0,225 );
g.setColor( Color.BLUE );
g.drawString( "arco relleno",395,140 );
g.setColor( Color.magenta );

// Elipse, con el eje grande horizontal
g.drawOval( 10,165,50,25 );
// Círculo
g.drawOval( 70,150,50,50 );
g.setColor( Color.BLUE );
g.drawString( "circulo",35,218 );
g.setColor( Color.magenta );

// Elipse rellena, con el eje grande vertical
g.fillOval( 170,150,25,50 );
// Círculo relleno
g.fillOval( 210,150,50,50 );
g.setColor( Color.BLUE );
g.drawString( "fillOval",185,218 );
g.setColor( Color.magenta );

// Polígono
int x2Datos[] = {300,350,300,350};
int y2Datos[] = {150,200,200,150};
g.drawPolygon( x2Datos,y2Datos,4 );
g.setColor( Color.BLUE );
g.drawString( "poligono",290,218 );
g.setColor( Color.magenta );

// Polígono relleno
int x3Datos[] = {385,435,385,435};
int y3Datos[] = {150,200,200,150};
g.fillPolygon( x3Datos,y3Datos,4 );
g.setColor( Color.BLUE );
g.drawString( "poligono relleno",385,218 );
}
}

1º UNIDAD. Agregación de Datos (Struct)

Un tipo struct es un tipo de valor que se suele utilizar para encapsular pequeños grupos de variables relacionadas, como las coordenadas de un rectángulo o las características de un elemento de un inventario. En el ejemplo siguiente se muestra una declaración de estructura sencilla.

public struct Book
{
public decimal price;
public string title;
public string author;
}
La palabra clave struct define una estructura. Por tratarse de un tipo de datos puede utilizarse directamente para definir una variable. La variable aparece entre corchetes puesto que puede ser omitida. Si se especifica una variable, estaremos definiendo una
variable cuyo tipo será la estructura que la precede. Si la variable no es indicada definimos un nuevo tipo de datos (struct Nombre_de_la_estructura), que podremos utilizar posteriormente. Si es el nombre de la estructura lo que se omite, tendremos que especificar obligatoriamente una variable que tendrá esa estructura y no podremos definir otras variables con esa estructura sin tener que volver a especificar todos los campos. Lo que se encuentra dentro de las llaves es una definición típica de variables con su tipo y su identificador.

Ejemplo (en C#):
Class Ejemplo Struct
{
Public Struct Alumno
{
public String Nombre;
public int Edad;
public char Sexo;
public DateTime Fecha;
}; // Cuando ya se ha declarado el tipo de dato, se crean las variables para este nuevo tipo de dato

Public string Nombre;
Public int Edad;
Public char sexo;
Public Datetime fecha;
};
Alumno alumnos;
Alumos.Nombre= “Paty”;
Alumnos.Edad=20;
Alumnos.Sexo=ˈFˈ;
Alumnos.fecha=new Datetime (01/Julio);
};

1º UNIDAD. Uniones de Datos (unión)

Las uniones son similares a las estructuras, con la diferencia de que las uniones se almacenan en los campos solapándose unos con otros, al contrario de con las estructuras, donde los campos se almacenan unos a partir de otros. En esencia, las uniones sirven para ahorrar espacio y memoria para almacenar los miembros de una unión y se requiere una zona de memoria igual a la del miembro más grande. Todos los miembros son almacenados en el mismo espacio de memoria y comienzan con la misma dirección.
En si la unión de datos como su nombre lo dice, une o enlaza dos registros de variables para que puedan ser utilizados de una sola forma, pero en distintos métodos y obtener una salida de dos en una

Estructura de una union:

struct tipo_union {

int discriminante;

union {

declaración 1;

declaración 2;

…………..

declaración N;

}

tipo_union_u;

};

Ejemplo (en C#):
Union ejemplo
{public char chval;
public int intval;
}ejemplo valores=new ejemplo();
valores.intval=65;

console.writeline(“chval:{0}”,valores.chval);

Al darle al entero el valor de 65, cuando mandamos a imprimir se imprime según el código ASCII, asi que por ejemplo en este caso se imprimiría la letra A.

1º UNIDAD. Apuntadores

Un puntero (o apuntador) es una variable que referencia una región de memoria; en otras palabras es una variable cuyo valor es una dirección de memoria. Si se tiene una variable ' p ' de tipo puntero que contiene una dirección de memoria en la que se encuentra almacenado un valor ' v ' se dice que p apunta a v.
Trabajar con punteros implica la no manipulación de las variables en sí, sino manejar direcciones de memoria en la cuales residen los datos
Ejemplo en C# (C Sharp): //Suma de dos números enteros
private unsafe int Suma(int* a, int* b)
{
return *a + *b;
}
// Su uso (El método llamador también debe tener la palabra clave 'unsafe'):
// int x, y;
// int *ptr1 = &x;
// int *ptr2 = &y;
// Suma(ptr1, ptr2);

Ejemplo(paso por valor de un dato):
{
Public static Main (string [] Arp)
{
Int numero =9;
Prueba (&numero);
}
Public void prueba (int *dato)
{
(*dato)=12;
}
}

1ºUNIDAD.Registros Variantes

Los registros variantes son registros (campos de memoria) tales que en un momento dado sólo uno de sus campos, o colecciones de campos, es válida en un momento dado. En algunos lenguajes de programación es tomada como un tipo de unión, ya que, como veremos a continuación en nuestro ejemplo, se utiliza una misma localidad de memoria para almacenar distintos campos que pudiese tener cualquier tipo de objeto, ya sea el objeto de una clase o el de una estructura, o una unión misma.
En Java y en C#, se utiliza el tipo de dato Object, que al ser inicializado como una instancia de una clase, estructura o unión, toma el valor de ese objeto, el uso de este tipo de dato es muy útil cuando no se sabe qué tipo de objeto se va a capturar, mas sin embargo necesitamos de capturarlo para poder mostrar el valor de sus diversas variables o campos.

Ejemplo en (C#):
class Ejemplo Object{

public int lado;

Cuadrado(int x){lado=x;

}}

class Triangulo{

public int base,altura;

Triangulo(int b,int h){

base=b;altura=h;

}}

class Circulo{

public int radio;

Circulo(int r){radio=r;

}}

1º UNIDAD. Tipos Enumerados

Un tipo enumerado o enumeración está construido por una serie de constantes simbólicas enteras. Los tipos enumerados se tratan de modo ligeramente diferente en C++ que en ANSI C. El nombre de la etiqueta enum se considera como un nombre de tipo igual que las etiquetas de struct y union. Por tanto se puede declarar una variable de enumeración, estructura o union sin utilizar las palabras enum, strcut o union. C define el tipo de enum de tipo int. En C++, sin embargo, cada tipo enumerado es su propio tipo independiente. Esto significa que C++ no permite que un valor int se convierta automáticamente a un valor enum. Sin embargo, un valor enumerado se puede utilizar en lugar de un int.

Ejemplo (en C++):
enum lugar {primero,segundo,tercero};
lugar pepe=primero; //correcto
int vencedor=pepe; //correcto
lugar juan=1; //incorrecto La última sentencia de asignación es aceptable en C pero no en C++, ya que 1 no es un valor definido en lugar.
Elementos Basicos.
Tipo: Define el conjunto de valores que puede tomar un determinado
Objeto: Determina las operaciones que se pueden aplicar a un objeto. • Define el espacio que será necesario reservar en memoria para albergar a un objeto. • Define la interpretación del valor almacenado en memoria.
Cardinalidad: Es el número de valores que tiene un tipo de datos. La simbolizaremos con ‘#’.

Los tipos de datos enumerables o enum tienen un uso más específico: el de relacionar variables con un número indicado por el programador, para así poder acceder a estos valores numéricos a partir de su correspondiente string, o viceversa. El uso correcto de este tipo de datos puede ahorrar muchos ciclos y el uso de switch.

Ejemplo (en C#):
Class prueba Enum{

Public enum Dia_d_la_semana{

Lunes=1;

Martes=2;

Miércoles=3;

Jueves=4;

Viernes=5;}

Dia_d_la_semana Dias;

Dias=Dias_d_la_semana.Lunes;

Int i;=(int)Dias;}

1º UNIDAD. Manejo de Bits

El manejo de bits hace referencia al manejo de algunos datos o variables, pero a un nivel de bit, es decir, si se está hablando de una variable de tipo char o de tipo int, a la hora de manejarla no se les hará referencia como char o como int, sino como una serie de 0s y 1s para modificarlos numero por numero, siendo el resultado algo que no se esperaría de manejar los datos como lo que aparentemente son.
El manejo de bits es muy útil para diversas tareas, como la codificación de archivos, o en materia de seguridad y consistencia de los datos. El manejo de bits es posible gracias a una serie de operadores muy parecidos a los de la lógica, de los cuales se hará mención más adelante.

1º UNIDAD. Campos de Bits

Los campos de bits, o simplemente campos, son grupos de un número determinado de bits, que pueden o no tener un identificador asociado. Representan un artificio que permite utilizar miembros de tamaño arbitrario en estructuras, uniones y clases; independiente de la posibilidad que proporcionan los tipos básicos cuyo tamaño está predeterminado por el lenguaje. Por ejemplo, en ocasiones es necesario almacenar semáforos (flags) con determinados estados del programa, para los que en realidad solo hace falta un bit, pero incluso una variable bool ocupa un octeto. Los campos de bits permiten utilizar cada bit de un octeto independientemente, aumentando así su capacidad de representación.

Nota: esta técnica, de manejo independiente de bits en una palabra, ha sido ampliamente utilizada desde siempre en la programación, no solo de C/C++; casi todos los lenguajes ofrecen la posibilidad de operadores "bitwise", que permiten esto de forma más o menos artesanal.