sábado, 1 de diciembre de 2012

Imágenes.♥

Formulario 



Linea de Código


Factura en Java


Paleta Java




Formulario Java



Formulario básico con Java Swing





En este ejemplo vamos a crear un formulario básico con Java Swing . En este formulario introduciremos una etiqueta, un campo de texto y un botón.
Lo primero que vamos a hacer es extender nuestra clase de JFrame , para poder tener una ventana que represente a nuestra aplicación.

  1. public class FormularioBasicoSwing extends JFrame  {...}

En el constructor de la clase será donde crearemos el formulario básico utilizando los elementos de Java Swing . Pero antes de instanciar los elementos del formulario vamos a llamar al constructor de JFrame mediante el método super().

  1. public FormularioBasicoSwing() {
  2. super("Formulario Basico");
  3. }

Antes de añadir los elementos al formulario vamos a dar un layout al contenedor. El layout es la forma en la que se van a posicionar los elementos en el contenedor. En este caso vamos a utilizar un FlowLayout . El FlowLayout posiciona los elementos de izquierda a derecha y de arriba a abajo.
El método .setLayout()  nos ayudará a asociar el FlowLayout  a nuestro contenedor.
  1. getContentPane().setLayout(new FlowLayout ());
Los elementos del formulario a utilizar serán:
  • Etiqueta, la cual instanciamos mediante la clase JLabel .
  • Campo de texto, será representado por un JTextField .
  • Botón, que será de la clase JButton .
La creación de estos elementos es muy sencilla.

  1. JLabel  label = new JLabel ("Introduce tu nombre:");
  2. JTextField  textfield = new JTextField ("nombre",20);
  3. JButton  boton = new JButton ("Enviar");

Una vez creados hay que añadirlos al contenedor mediante el método .add()

  1. getContentPane().add(label);
  2. getContentPane().add(textfield);
  3. getContentPane().add(boton);

Ya solo nos quedará definir el tamaño de la ventana y hacerla visible. Es decir, invocar a los 
métodos.setSize()  y .setVisible()

  1. setSize(400,300);
  2. setVisible(true);

Instrucción


             INSTRUCCIÓN


Estamos preparados para ver los constructores principales del lenguaje Java. Ya vimos los comentarios, que no se pueden ocultar, es decir, que el siguiente comentario no es posible: /* +Éste es seguramente un comentario /* Éste también lo es */ */ Sin embargo, se pueden introducir comentarios de una línea en los comentarios de más de una línea porque son distintos. Por ejemplo, es posible escribir lo siguiente: /* Éste es seguramente un comentario // Éste también lo es */ aunque realmente resulte bastante inútil. Las primeras instrucciones de Java que vamos a ver son las instrucciones de declaración, que son las declaraciones de variables locales. Se utilizan para declarar variables y darles un posible valor inicial. Estas instrucciones ya las vimos y se parecen a las declaraciones de los atributos, excepto por la falta de los modificadores. Las variables locales, antes de ser utilizadas, se tienen que inicializar.
Las variables locales se pueden declarar en un punto cualquiera de un bloque y no necesariamente al inicio, además existen sólo en los bloques en los que se declaran. Un bloque es como una instrucción, lo único es que empieza por { y acaba por }, y en él puede tener muchas instrucciones, incluso posiblemente de otros bloques.

{
instrucción 1;
instrucción 2;
….
instrucción j-1;
{
subinstrucción1;
subinstrucción2;
…..
subinstrucción;
}; // es la instrucción j
instrucción j+1;
….
instrucción n;
}// Este bloque puede ser el cuerpo de un método o un bloque
Pensad en el método:
void tribilín()
{
ent j=0;
{
ent k=0;
k++; // instrucción A
};
j++; // instrucción B
k++; // instrucción C
}


La instrucción A no da problemas porque usa una variable local que está inicialidada, declarada en su mismo bloque.
Con la instrucción B ocurre lo mismo, mientras la instrucción C está equivocada porque la variable que utiliza se ha declarado en un bloque entero y no se puede ver externamente. Si en el bloque interno hubiera escrito j++; no tendría ningún problema porque la variable j se habría declarado en un bloque externo. (Dentro se ve lo que hay fuera, pero fuera no se puede ver lo que hay dentro, lo cual ocurre en todos los lenguajes de programación por bloques).
Acabamos de ver en el ejemplo que también j++ es tanto una instrucción como una expresión, como su otra forma e ++j, y es su imagen especular de disminución. Hay otras operaciones que se pueden tener en cuenta a la hora de analizar las instrucciones. Se trata tanto de la implementación de los métodos que pueden devolver o no un valor, como de las instrucciones de creación de objetos, las que llevan new. Por ejemplo, new Object(), es una instrucción correcta.
Otra instrucción muy parecida a una expresión es la instrucción de asignación, la del tipo:

NombreVariable = expresión;

Por lo tanto, hasta ahora hemos visto las seis instrucciones:

  • Declaración de una variable local;
  • Bloque;
  • Formas de incremento y disminución de las variables, prefijas y postfijas;
  • Creación de los objetos;
  • Solicitud de los métodos;
  • Asignación de las variables;

    Todas las instrucciones terminan por ;

    Las demás instrucciones se llaman constructos y son muy parecidas a las de los demás lenguajes de programación. Las vamos a ver detalladamente.

    Instrucción condicional
    if (EXPBOOL) IST
    Esta instrucción pone en marcha la instrucción llamada IST que puede ser una cualquier instrucción del lenguaje sólo si la expresión booleana EXPBOOL es verdadera, de lo contrario se salta. Una variedad es la en que pone en marcha otra instrucción si EXPBOOL es falsa, es:

    if (EXPBOOL) IST
        else
        IST2


    Fijaos que IST y IST2 son instrucciones generales, por lo tanto también los bloques o las demás instrucciones condicionales. En este último caso hablamos de if ocultos.

    Instrucción switch

    Switch (EXP)
    {
    case CST11: …. :case CST1n: IST1
    case CST21: …. : case CST2n: IST2
    ….
    case CSTm1: …. : case CSTmn: ISTm
    default ISTm+1;
    };


    Si EXP es una expresión, CSTij son unas constantes del mismo tipo que la expresión. EXP y ISTi son unas instrucciones.
    La instrucción evalúa EXP, y compara el resultado con las constantes de los case; si encuentra otro igual, pone en marcha la instrucción correspondiente. Si, en cambio, no encuentra ninguna constante igual, pone en marcha la instrucción después del default, lo que es una opción. En el caso de que esté ausente y ningún case tenga la constante igual al valor de EXP, se salta el switch.
    Analizamos, por ejemplo, el siguente mando:

    switch (5+1)
    {
    case 6 : System.out.println ("Muy bien");
    default : System.out.println ("Burrp, es seis");
    };


    Instrucción for for (exp de inicialización; exb booleana; exp de incremento) ISTR
    pone en marcha la instrucción ISTR que es un número de veces igual a los valores contenidos en un intervalo. Normalmente la instrucción de inicialización pone en marcha una variable en un valor; la variable se incrementa (o disminuye) a partir de la instrucción de incremento y en la expresión booleana se controla que la variable tenga los valores que queremos. En efecto, si la expresión booleana es falsa, enseguida se sale del ciclo for.
    Voy a poner un ejemplo: quiero inicializar los valores de un vector de 100 enteros todos a cero. En lugar de escribir 100 asignaciones, escribiré:

    ent v = new ent[100];
    for (ent e = 0 ; e<100; e++) v[e] = 0 ;


    Como acabamos de ver la variable también se puede declarar en la instrucción de inicialización. De esta forma, sólo se puede ver en el for.

    Instrucción while
    while (EXPBOOL) IST
    Pone en marcha IST simulando que EXPBOOL es verdadera, por ejemplo, la inicialización del ejemplo anterior se puede llevar a cabo con el while de la siguiente forma:

    ent v = nuevo ent[100];
    ent e=0;
    while (e<100) {
    v[e]=0;
    e+=1;
    };


    o de forma comprimida, aprovechando el incremento de forma comprimida:

    ent v = nuevo ent[100];
    ent e=0;
    while (e<100) v[e++]=0;


    Instrucción do-while do IST while (EXPBOOL);
    ES como el while, sólo que antes ejecuta la instrucción y luego controla el EXPBOOL, de nuevo la inicialización precedente se convierte en:

    ent v = nuevo ent[100];
    ent e=0;
    do {
    v[e]=0;
    e+=1;
    } while (e<100);

    o también de forma todavía más comprimida:

    ent v = nuevo ent[100];
    ent e=0;
    do v[e++] = 0 while (e<100);

    Etiquetas
    Es posible poner etiquetas a las instrucciones, como ocurre con el código assembler. Esto resulta muy útil en combinación con las instrucciones de break y de continue:

    etiqueta: instrucción;

    instrucción de break
    La instrucción de break se utiliza para salir de un bloque o de un switch; cuando se encuentra un break se sale del bloque más interno, mientras que si se pone una etiqueta, se sale hasta donde la etiqueta se ha declarado.

    Ejemplo:

    {
    while ( COND )
    {
    while (COND2)
    {
    if (ALGO) break;
    }
    }
    }
    En este caso se sale del while interior, mientras:
    {
    tribilín: while ( COND )
    {
    while (COND2)
    {
    if (ALGO) break tribilín;
    }
    }
    }


    se sale de los dos while.

    Instrucción de continue
    En un ciclo se salta todas las instrucciones que le siguen y evalúa directamente la expresión booleana, por ejemplo:

    while (Condición)
    {
    instrucciones;
    if (GolpeDeEfecto) continue;
    otras instrucciones;
    };


    Se entra en el ciclo, se ponen en marcha las instrucciones. Si GolpeDeEfecto es verdadero, salta otras instrucciones y llega a evaluar Condición. Si ésta también es verdadera, continúa el ciclo poniendo en marcha las instrucciones, etc..

    Instrucción de return
    Produce la conclusión de la ejecución del método en el que se encuentra y el retorno a la llamada. Si el método es void basta con escribir return, si no tiene que contener una expresión del mismo tipo del método, por ejemplo

    ent tribilín()
    {
    return 10;
    }


    con la instrucción return es posible también bloquear la puesta en marcha de un constructor o de un método static.

    Con esto acabamos nuestro examen de las instrucciones. Ahora estamos preparados para construir cualquier aplicación a consola.
    Pongamos un par de ejemplos: empecemos escribiendo un pequeño programa que imprima los primeros números, los menores de 500 de la famosa serie de Fibonacci. Para los que no la conozcan, la serie de Fibonacci es una secuencia infinita de números cuyos dos primeros elementos son: 1, 1, y los demás elementos se calculan como la suma del e-1 ésimo número y del e-2 ésimo, formalmente, reconociendo Fibo come una función:

    Fibo ( e ) = Fibo ( e - 1 ) + Fibo ( e - 2 );

    El programa que hay que escribir en Fibo.java es el siguiente:

    class Fibo
    {

    public static void main (Cadena[] args)

    {

    ent bajo=1, alto=1;

    // ent alto=1;

    System.out.println (bajo);

    while (alto<500)
    {

    System.out.println(alto);

    alto+=bajo;

    bajo = alto - bajo;

    };

    }

    }


    Para que os entrengáis, podéis intentar hacer un programa que calcula 10 ! , sabiendo que 1! = 1 y que establecido n entero, n! = n * ((n-1)!). La solución se encuentra en el archivo Fatt.java.
    Ahora, intentamos escribir nuetra criba de Eratóstenes hecho en casa, es decir, una forma para calcular todos los números primos hasta un número establecido, digamos 100;
    El algoritmo procede así,

    1 es un número primo.
    2 es un número primo, le quito sus múltiplos
    3 es un número primo, le quito sus múltiplos


    etcétera hasta encontrar mi máximo.

    clase Eratóstenes
    {
    static ent MÁX=1000;

    ent [] números = nuevo ent[MÁX];

    boolean [] primos = nuevo boolean[MÁX];

    public Eratóstenes()
    {

    ent e;

    for (e=0;i<MAX;e++)
    {
    números[e]=e+1;

    primos[e]=verdaderos;

    };

    }

    void elMul(ent a)
    {

    for (ent j=2;j*a<=MÁX;j++)
    primos[(j*a)-1]=falso;

    }

    ent siguiente(ent n)
    {
    ent tmp=n;

    while (!primos[tmp]) {
    tmp++;
    if (tmp>=MÁX) break;
    }

    return tmp+1;

    }

    void calculaPrimos()
    {
    ent núm=2;

    while (núm<=MÁX)
    {
    elMúl(núm);
    núm=siguiente(núm);
    };

    }

    void escribaPrimos()

    {

    System.out.println("Los números primos hasta "+MÁX+" son:");

    for (ent e=0; e < MÁX ; e++)
    if (primos[e]) System.out.print(números[e]+" ");

    }

    public static void main(Cadena[] args)
    {

    Eratóstenes e = nuevo Eratóstenes();

    e.calculaPrimos();

    e.escribaPrimos();

    }

    }
     
  • Historia


                                                                               Historia 


    En Diciembre de 1950 Patrick Naughton, ingeniero de Sun Microsystems, reclutó a varios colegas entre ellos James Gosling y Mike Sheridan para trabajar sobre un nuevo proyecto conocido como "El proyecto verde".
    Con la ayuda de otros ingenieros, empezaron a trabajar en una pequeña oficina en Sand Hill Road en Menlo Park, California. Y así interrumpió todas las comunicaciones regulares con Sun y trabajó sin descanso durante 18 meses.
    Intentaban desarrollar una nueva tecnología para programar la siguiente generación de dispositivos inteligentes, en los que Sun veía un campo nuevo a explorar. Crear un lenguaje de programación fácil de aprender y de usar. 

    En un principio se consideraba C++ como lenguaje a utilizar, pero tantoGosling como Bill Joy lo encontraron inadecuado. Gosling intentó primero extender y modificar C++ resultando el lenguaje C++ ++ - (++ - porque se añadían y eliminaban características a C++), pero lo abandonó para crear un nuevo lenguaje desde cero al que llamo Oak (roble en inglés, según la versión mas aceptada, por el roble que veía através de la ventana de su despacho).
    El resultado fue un lenguaje que tenía similitudes con C, C++ y Objetive C y que no estaba ligado a un tipo de CPU concreta. 

    Mas tarde, se cambiaría el nombre de Oak a Java, por cuestiones de propiedad intelectural, al existir ya un lenguaje con el nombre de Oak. Se supone que le pusieron ese nombre mientras tomaban café (Java es nombre de un tipo de café, originario de Asia), aunque otros afirman que el nombre deriva de las siglas de James Gosling, Arthur Van Hoff, y Andy Bechtolsheim.

    En Agosto de 1991 Oak ya corría sus primeros programas.
    Para 1992, el equipo ya había desarrollado un sistema en un prototipo llamado Star7 (*7), dispositivo parecido a una PDA, cuyo nombre venía de la combinación de teclas del teléfono de la oficina del Proyecto Green que permitía a los usuarios responder al teléfono desde cualquier lugar.
    Por su parte, el presidente de la compañía Sun, Scott McNealy, se dio cuenta de forma oportuna y estableció el Proyecto Verde como una subsidiaria de Sun.
    Después de mostrar a Scott McNealy y Bill Joy los prototipos de bajo nivel del sistema, continuán con el desarrollo, incluyendo sistema operativo, Green OS; el lenguaje Oak, las librerías, alguna aplicación básica y el hardware, hasta que el 3 de septiembre de 1992 se termina el desarrollo y con ello elProyecto Verde.
    De 1993 a 1994, el equipo de Naughton se lanzó en busca de nuevas oportunidades en el mercado, mismas que se fueron dando mediante el sistema operativo base.
    La incipiente subsidiaria fracasó en sus intentos de ganar una oferta con Time-Warner, sin embargo el equipo concluyó que el mercado para consumidores electrónicos smart y las cajas Set-Up en particular, no eran del todo eficaces. La subsidiaria Proyecto verde fue amortizada por la compañía Sun a mediados de 1994.
    Afortunadamente, el cese del Proyecto Verde coincidió con el nacimiento del fenómeno mundial WEB. Al examinar las dinámicas de Internet, lo realizado por el ex equipo verde se adecuaba a este nuevo ambiente.

    Patrick Naughton procedió a la construcción del lenguaje de programaciónJava que se accionaba con un browser prototipo. El 29 de septiembre de 1994 se termina el desarrollo del prototipo de HotJava. Cuando se hace la demostración a los ejecutivos de Sun, esta vez, se reconoce el potencial de Java y se acepta el proyecto.

    Con el paso del tiempo HotJava se convirtió en un concepto práctico dentro del lenguaje Java y demostró que podría proporcionar multiplataformas para que el código pueda ser bajado y corrido del Host del World Wide Web y que de otra forma no son seguros.
    Una de las características de HotJava fue su soporte para los "applets", que son las partes de Java que pueden ser cargadas mediante una red de trabajo para después ejecutarlo localmente y así lograr soluciones dinámicas en computación acordes al rápido crecimiento del ambiente WEB.

    El 23 de mayo de 1995, en la conferencia SunWorld `95, John Gage, de Sun Microsystems, y Marc Andreessen, cofundador y vicepresidente de Netscape, anunciaban la versión alpha de Java, que en ese momento solo corría en Solaris, y el hecho de que Java iba a ser incorporado en Netscape Navigator, el navegador mas utilizado de Internet.
    Con la segunda alpha de Java en Julio, se añade el soporte para Windows NT y en la tercera, en Agosto, para Windows 95. 

    En enero de 1995 Sun formá la empresa Java Soft para dedicarse al desarrollo de productos basados en la tecnologías Java, y así trabajar con terceras partes para crear aplicaciones, herramientas, sistemas de plataforma y servicios para aumentar las capacidades del lenguaje. Ese mismo mes aparece la versión 1.0 del JDK.

    Netscape Communications decide apoyar a Java applets en Netscape Navigator 2.0. Ese fue el factor clave que lanzó a Java a ser conocido y famoso. 

    Y como parte de su estrategia de crecimiento mundial y para favorecer la promoción de la nueva tecnología, Java Soft otorgó permisos para otras compañías para que pudieran tener acceso al código fuente y al mismo tiempo mejorar sus navegadores. 

    También les permitía crear herramientas de desarrollo para programación Java y los facultaba para acondicionar máquinas virtuales Java (JVM), a varios sistemas operativos.
    Muy pronto las licencias o permisos contemplaban prestigiosas firmas como: IBM, Microsoft, Symantec, Silicon Graphics, Oracle, Toshiba y Novell.

    Los apples Java (basados en JDK 1.02) son apoyados por los dos más populares navegadores web (Nestcape Navigator 3.0 y Microsoft Internet Explorer 3.0. I.B.M./Lotus, Computer Asociates, Symantec, Informix, Oracle, Sybase y otras poderosas empresas de software están construyendo Software 100% puro JAVA, por ejemplo el Corel Office que actualmente está en versión Beta.

    Los nuevos proyectos de Java son co-patrocinados por cientos de millones de dólares en capital disponible de recursos tales como la Fundación Java, un fondo común de capital formado el verano pasado por 11 compañías, incluyendo Cisco Systems, IBM, Netscape y Oracle.

    Hoy en día, puede encontrar la tecnología Java en redes y dispositivos que comprenden desde Internet y superordenadores cientifícos hasta portátiles y teléfonos móviles; desde simuladores de mercado en Wall Street hasta juegos de uso doméstico y tarjetas de crédito: Java está en todas partes.

    ¿Qué es Java?




                                        Java  
    Java es un lenguaje de programación de alto nivel orientado a objetos, desarrollado por James Gosling en 1995. El lenguaje en sí mismo toma mucha de su sintaxis de C y C++, pero tiene un modelo de objetos más simple y elimina herramientas de bajo nivel, que suelen inducir a muchos errores, como la manipulación directa de punteros o memoria. La memoria es gestionada mediante un recolector de basura.
    Las aplicaciones Java están típicamente compiladas en un bytecode, aunque la compilación en código máquina nativo también es posible. En eltiempo de ejecución, el bytecode es normalmente interpretado o compilado a código nativo para la ejecución, aunque la ejecución directa porhardware del bytecode por un procesador Java también es posible.

    La implementación original y de referencia del compilador, la máquina virtual y las bibliotecas de clases de Java fueron desarrollados por Sun Microsystems en 1995. Desde entonces, Sun ha controlado las especificaciones, el desarrollo y evolución del lenguaje a través del Java Community Process, si bien otros han desarrollado también implementaciones alternativas de estas tecnologías de Sun, algunas incluso bajo licencias de software libre.