Applets

Después de esas aplicaciones básicas para familiarizarme con el lenguaje, llegó la hora de probar a hacer applets. Buscando por Google, he llegado a un blog que leía hace tiempo, y que ya ni me acordaba que era una mina de códigos de aplicaciones Java. El blog en cuestión es Casidiablo, el cual me parece que lo conocí en la época en la que foreaba por ElHacker.net.
A lo que iba. Que en el blog de Casidiablo he estado mirando códigos de Applets. Para saber si iba a tener problemas con la compilación, construcción o ejecución de los applets. Para ello, he cogido directamente el código de un applet ( de los tantos que tiene aquí ) y lo he pegado en NetBeans:

// Nuestro primer subprograma en Java.
// Paquetes de Java
import java.awt.Graphics; // importar la clase Graphics
import javax.swing.JApplet; // importar la clase JApplet
public class SubprogramaBienvenido extends JApplet
{
    // dibujar texto en el fondo del subprograma
    public void paint( Graphics g )
    {
        // llamar a la versión del método paint de la superclase
        super.paint( g );
        // dibujar un String en la coordenada x 25 y la coordenada y 25
        g.drawString( "¡Bienvenido a la programación en Java!", 25, 25 );
    }// fin del método paint
}
// fin de la clase SubprogramaBienvenido

Este applet, en teoría, debería mostrar el mensaje "¡Bienvenido a la programación en Java!". Le doy para compilar, construir, y me dice que no hay errores BUILD SUCCESSFUL. Medio camino hecho. Ahora, creo un archivo HTML en el mismo directorio que el archivo  .class con el siguiente codigo:

<html>
<head>
<title>Java Applet</title>
</head>

<body>
<applet code="SubprogramaBienvenido.class" height="200" width="200">
</applet>
</body>
</html>

El resultado al abrir el HTML en el navegador es el siguiente:


Para la siguiente, intentaré hacer alguna aplicación básica en forma de applet

Números primos de 2 a 1000

Una simple aplicación que imprime en pantalla números primos entre 2 y 1000.

Creo un ArrayList donde almaceno el número 2. Despues, creo un bucle de 3 a 1000 de dos en dos (por que no merece la pena mirar si un número par es primo, porque todos son divisibles por 2). Cada número es pasado como argumento a una función que evalua si un número es o no primo, si lo es, lo añade al ArrayList primos, si no lo es, simplemente no hace nada. Para terminar, imprime en pantalla cada uno de los elementos del ArrayList primos, y para terminar, cuantos hay.

En la función isPrimo, se coge como parámetro un número entero. Crea un bucle que va desde el primer elemento hasta la raíz cuadrada del número pasado como parámetro. Sé que el código está hecho de tal forma que siempre evaluará un número más de lo que debería (para 3, evaluaría el 2, que es mayor a sqrt(3). Para 5, evaluaría el 3 que es mayor a sqrt(5). Para 7, evaluaría el 3 también, ...). Si en algún momento, el resto de la división entre el número y alguno de los números primos es 0 (que el número primo es uno de las factores del número a analizar), devuelve false. Si después de hacer todas las comprobaciones, ninguno ha sido factor, señal de que el número a analizar era primo, por lo que devuelve true.


import java.util.ArrayList;
import java.util.Iterator; 

public class Main {
    static ArrayList primos;
    public static void main(String[] args) {
        int i;
        primos = new ArrayList();
        primos.add(2);
        for (i=3;i<1000;i+=2)
        {
            if (isPrimo(i))
                primos.add(i);
        }
        Iterator iter = primos.iterator();
        while (iter.hasNext())
            System.out.println(iter.next());
        System.out.println(primos.size());
    }
    static boolean isPrimo(int num)
    {
        Iterator<integer> iter=primos.iterator();
        boolean fin = false;
        int valor;
        while (iter.hasNext() && !fin)
        {
            valor = iter.next();
            fin = valor >= Math.sqrt(num);
            if ((num % valor) == 0)
                return false;
        }
        return true;
    }
}

De momento, esto no tiene más misterios. La cosa va bien, no me quejo. Todavía no entiendo porque primos e isPrimo tienen que ser abstract, ni qué hace que lo sean. Pero ya lo descubriré.

Palíndromos

Aplicación que comprueba si una palabra o frase se lee igual de derecha a izquierda y viceversa:

public class Palindromo {
    public static void main(String[] args) {
        String[] palabras = {"Palindromos","asdfdsa","AsDdSa","Sale El As","No palindromos","Cualquier frase","O palabra","Que no sea palindromo"};
        int indice = (int)(Math.random() * palabras.length);
        System.out.println("Palabra utilizada: "+ palabras[indice]);
        //Quitar espacios y convertirlo a minusculas para hacer las comparaciones
        String modificado = palabras[indice].replaceAll(" ","").toLowerCase();
        System.out.println("Palabra modificada: "+ modificado);
        int i=0;
        boolean palin = true;
        while (palin && i < modificado.length() / 2)
        {
            if (modificado.charAt(i) != modificado.charAt(modificado.length() -1 -i))
                palin = false;
            i++;
        }
        if (palin)
            System.out.println("Palindromo");
        else
            System.out.println("NO Palindromo");
    }
}

Implementación del mismo como función:

public class Palindromo {
    public static void main(String[] args) {
        String[] palabras = {"Palindromos","asdfdsa","AsDdSa","Sale El As","No palindromos","Cualquier frase","O palabra","Que no sea palindromo"};
        int indice = (int)(Math.random() * palabras.length);
        System.out.println("Palabra utilizada: "+ palabras[indice]);
        if (palindromo(palabras[indice]))
            System.out.println("Palindromo");
        else
            System.out.println("NO Palindromo");
    }
    static boolean palindromo(String palabra)
    {
        //Quitar espacios y convertirlo a minusculas para hacer las comparaciones
        String modificado = palabra.replaceAll(" ","").toLowerCase();
        int i=0;
        while (i < modificado.length() / 2)
        {
            if (modificado.charAt(i) != modificado.charAt(modificado.length() -1 -i))
                return false;
            i++;
        }
        return true;
    }
}

Primeros ejercicios en Java

Todavía puede que sea temprano para echar fuegos artificiales, pero en una semanita he conseguido más de lo que consegui en mis anteriores intentos. Como todavía sigo con la espinilla del scanf de C, por lo que los "lee un número del teclado" lo interpretaré como "número aleatorio":

public class Main {
    public static void main(String[] args) {
        int num1, num2;
        num1 = (int)(Math.random() * 100) + 1;
        num2 = (int)(Math.random() * 100) + 1;
        System.out.println("Num1: "+ num1 +"\tNum2: "+ num2);
    }
} 
Para las cadenas de caracteres, me basaré en la misma idea. Añadir unas palabras a un array de Strings, y acceder a ellos mediante un numero aleatorio:


public class Main {
    public static void main(String[] args) {
        String[] palabras = {"Intentando","aprender","JAVA","de","momento","la cosa","pinta","bastante","bien","la verdad","SaLuDoS"};
        int indice = (int)(Math.random() * 10);
        System.out.println("Palabra utilizada: "+ palabras[indice]);
    }
}

Y weno, el primer ejercicio que he realizado a partir de aquí, ha sido el de escribir una palabra formando un cuadro, lo que sería lo siguiente:

public class CuadroPalabra {
    public static void main(String[] args) {
        String[] palabras = {"Intentando","aprender","JAVA","de","momento","la cosa","pinta","bastante","bien","la verdad","SaLuDoS"};
        int indice = (int)(Math.random() * 10);
        System.out.println("Palabra utilizada: "+ palabras[indice]);
        
        int i,j;
        System.out.println(palabras[indice]);
        for (i=1;i<palabras[indice].length()-1;i++)
        {
            System.out.print(palabras[indice].charAt(i));
            for (j=1;j<palabras[indice].length()-1;j++)
                System.out.print(" ");
            System.out.print(palabras[indice].charAt(palabras[indice].length()-i-1));
            System.out.print("\r\n");
        }
        for (i=palabras[indice].length()-1;i>=0;i--)
        {
            System.out.print(palabras[indice].charAt(i));
        }
        System.out.println("");
    }
}

Primeros pasos con el Netbeans

Mas bien, diría que gateando. Despues de ponerme a leer unos cuantos tutoriales y cursos de Java desde cero, esta vez creo que la cosa pinta mejor que en mis anteriores fracasos. Seguramente se deba a que esta vez lo estoy tomando con mas calma, sensatez y paciencia. Por mucho que lo intente, no consigo familiarizarme con tanto static, abstract, interface, ... en C todo parecía taaaan bonito... Pero supongo que este tema lo solucionará el tiempo y la experiencia.

Bueno, lo dicho, el HelloWorld y las pruebas con las instrucciones básicas de control de flujo no me han dado ningún problema. Sólo me faltaría que no consiguiera compilar un while. Ahora toca buscar enunciados del estilo de los ejercicios que nos mandaban hacer en las clases de programación. Mirando por Google, he dado con un par de páginas donde aparecen unos ejercicios que parecen ser adecuados (algunos incluso absurdamente fáciles, pero prefiero hacerlos e ir acomodandome en el lenguaje, a fracasar estrepitosamente de nuevo).

Próximamente, más y esperemos que mejor

Presentación y declaración de intenciones

Como todo nuevo blog, este debería comenzar por una presentación. Soy un jovenzuelo que lleva unos cuantos años (más de los que quisiera) dedicándose al mundo de la infórmatica.
Mi historia con Java comenzó hace ya un par de años, y fue un auténtico fracaso, era joven e insensato. En aquel entonces, tenía conocimientos en C/C++, VB, PHP y algunos lenguajes poco usados. A medida que empecé a realizar programas básicos, llegó el momento en el que necesitaba meter los datos por teclado, y la impotencia que sentí al no conseguir hacer un "scanf" en Java, me llevo a aparcarlo temporalmente. Ahora, me ha entrado de nuevo el gusanillo de aprender Java, más que nada para realizar programillas para Android y algún que otro applet para las páginas que vaya haciendo.
En este blog, comenzaré desde lo más básico, redactando mis andaduras a medida que vaya aprendiendo. Agradecería que si algún gurú de Java pasa por aquí, me de algúnos consejos siempre que no le suponga un tremendo esfuerzo.
En resumen, en este blog voy a despotricar sobre Java debido a mi ignoracia. Saludos