Linea de Codigo

Segunda entrega del resumen en los grupos de conversación de Facebook sobre lenguajes de programación en español. La verdad es que no dejo de estar sorprendido de la cantidad y calidad de las conversaciones en los grupos. Y muy agradecido de toda la gente que está participando en ellos.

Esta semana hemos lanzado uno nuevo, el grupo de conversación sobre Bases de Datos. Y así, de la nada, ya hay 100 miembros conversando. Una pasada.

Pero echemos un vistazo a las últimas conversaciones de los grupos sobre programación en español...

HTML5 en Español
https://www.facebook.com/groups/html5.es/
106 miembros (+31)

• Documento de trabajo HTML Polyglot, o lo que quiere hacer la W3C para que los documentos sean multi-idioma.
• Un artículo que habla de las 7 tecnologías que sostienen Facebook, de los chicos de Genbeta.
• Pregunta sobre cómo poner el Favicon en una página web.
• ¿Alguién conoce un hosting con soporte de Phyton con Django?
• Dudas sobre cómo subir un fichero con un input file y el lenguaje Perl.

Java en Español
https://www.facebook.com/groups/java.es/
156 miembros (+66)

Lo más importante es que hemos lanzando una encuesta sobre qué IDE utilizarías para empezar a aprender el lenguaje de Java. No dejes de contestar y añadir tus comentarios.

• Cómo resolver el método de ordenación de Arrays con el método burbuja
• Páginas con tutoriales para empezar con Java (y 2)
• Se pedía ayuda sobre cómo resolver el algoritmo del Número Feliz.... y ya está resuelto y publicado.
• Se ha comentado y resuelto como construir un programa para calcular la serie de Taylor.
• Ayuda para encontrar información y ejemplo de la anotación @Intercepts.
• Pablo Ruiz está publicando artículos muy interesantes con los ejercicios de la Certificación Java en su blog.
• ¿Sirven los tutoriales de Eclipse para Netbeans?
• Primeros pasos de JSF, Primera pantalla con JSF y Manejando ManageBean en JSF por Julio Pari.
• Ing Guillermo Gonzalez propone ir publicando algoritmos básicos e irles resolviendo para ayudar a la gente que empieza. (y 2)
• ¿Quieres material de certificación Java?... Ya se ha publicado algunos ejemplos.
• Un poco de ayuda en un código con el manejo de Scanner.
• Ayuda con Java Server Faces.
• ¿Qué arquitectura seguir para construir una aplicación web?
• Pastebin una buena aplicación para compartir código fuente.
• Algoritmos y cia, un buen blog para compartir algoritmos básicos.
• Ayuda para declarar un array dónde puedas  insertar cualquier tipo de objeto.
• Crear ventanas personalizadas con Substances
• Aunque no te lo creas, se busca un emulador de MSDOS.
• Cómo separar a un número en dígitos.
• Capas de persistencia de datos que no sean el típico manejo de sentencias de un modelo E/R.

Javascript en Español
https://www.facebook.com/groups/javascript.es/
84 miembros (+18)

• Una chuleta sobre Javascript, bastante interesante.

jQuery en Español
https://www.facebook.com/groups/jquery.es/
99 miembros (+17)

• El Hola Mundo con jQuery Mobile

PHP en Español
https://www.facebook.com/groups/HypertextPreprocessor.es/
89 miembros (+26)

• Un vídeo sobre la gente de Linux.
• El framework CodeIgniter.
• Ayuda a Raúl para montar el código que consulta una base de datos y muestra un listado de libros. (y 2)
• ¿Cómo configurar el PHP en Aptana?
• Programación Orientada a Aspectos en PHP
• Problemas con el localhost y Drupal.
• Algunas novedades de lo que encontramos en PHP 5.4.0

Bases de Datos en Español
https://www.facebook.com/groups/basesdedatos.es/
100 miembros

Una gran acogida del grupo sobre bases de datos en español con una cifra de 100 usuarios desde el inicio.

• ¿Cual es la mejor forma de extraer datos de una base de datos?
• Algunas tablas para practicar con Oracle por Pablo Ruiz
• Ayuda para manejar links e imágenes en una base de datos.
• Dónde encontrar Microsft SQL Server.
• Como empezar en el mundo de los modelos y las bases de datos.

Esta es la pregunta que formulábamos en el grupo de conversación de Java en Español. ¿Con qué IDE empezarías a aprender Java?

• Utilizarías un IDE más o menos completo como puede ser Eclipse o NetBeans
• Realizarías un aprendizaje más espartano con el JDK y un editor de texto o con un IDE más sencillo como jCreator o BlueJ
• ¿Conoces algún IDE orientado directamente al aprendizaje?

Puedes contestar la encuesta en el grupo de conversación de Java en Español.

Publicaremos el resultado y las respuestas más adelante.

Suelo utilizar los grupos de Facebook sobre tecnologías y programación de forma habitual (así como los de LinkedIn) para compartir experiencias, publicar ejemplos y encontrar ejemplos nuevos, coger ideas,... creo que la conversación que se crea en ellos es bastante útil.

Si bien, hace un mes o algo más un grupo de personas (evitaré dar nombres) indicaron en algunos de los grupos que o bien solo se podía hablar en ingles (yo ya lo hacía) o bien los enlaces solo podían estar en inglés (yo compartía enlaces en español).

Después de una serie de conversaciones con ciertos administradores parte accedieron a que los artículos estuviesen en español y otros no. Ese fue el momento en el que me dí cuenta que no existía una comunidad de grupos de conversación sobre programación en Facebook que fuesen en español.

Es por ello que me decidí a crearlos. Sus reglas son fáciles y sencillas. Se recomienda que la conversación sea en español (da igual la nacionalidad de la que seas) y los enlaces que compartas pueden estar en cualquier idioma. Si están en español mejor que mejor, si no, pues tenemos muchos traductores en la web para traducirlos.

Hay que asumir que la lengua casi materna de Internet es el inglés. Aunque desde Línea de Código y todas las webs de Aulambra siempre hemos intentado crear una comunidad hispanoparlante alrededor de la tecnología y la programación. Por eso, seguimos buscando colaboradores que se quieran embarcar en esta aventura.

Los grupos que hemos creado son:

• HTML5 en Español
• Java en Español
• jQuery en Español
• CSS en Español
• Javascript en Español
• PHP en Español
• SVG en Español
• XML en Español

Si se te ocurre alguno más solo tienes que ponerlo en estos comentarios y lo crearemos.

En el paso de las semanas iremos asignando administradores a las personas que más activas se muestren (no es nuestra intención el coartarlos, queremos que crezcan libres) y en Línea de Código intentaremos ir haciendo un resumen de la actividad que la conversación de los grupos de Facebook sobre programación en español genere.

Sin más, animaros a participar en ellos. Están teniendo muy buena aceptación.

El directorio de trabajo de Java es el directorio dónde se está ejecutando el programa Java. Si queremos conocer cual es el directorio de trabajo del programa Java podemos utilizar las propiedades del sistema.

Para manejar las propiedades del sistema tenemos la clase System y en concreto el método .getProperty().

La propiedad del sistema que nos permite conocer el directorio de trabajo de Java es "user.dir". Así el código será el siguiente:

String sDirectorioTrabajo = System.getProperty("user.dir");
System.out.println("El directorio de trabajo es " + sDirectorioTrabajo);

¿Qué otras propiedades del sistema conoces y crees que puedes ser útiles?

La posibilidad de contectarse a un FTP con Java no es una utilidad que nos den las librerías base de Java. Es por ello que para poder acometer esta tarea y conectarnos a un FTP con Java deberemos de utilizar las librerías de Apache Commons. En concreto el componente Net.

Así que lo primero que hay que hacer para pode crear nuestro programa que se conecte a un FTP con Java es decargarnos la librería Net de Apache Commons.

En nuestro código fuente deberemos de realizar un import de esta librería:

import org.apache.commons.net.ftp.FTPClient;

La clase de Apache Commons que nos permitirá crear un cliente FTP con Java es FTPClient. Por lo tanto la primera línea de nuestro programa creará una instancia de esta clase.

FTPClient client = new FTPClient();

Una vez creado el cliente deberemos de conocer tres cosas para poder conectarnos a un FTP con Java. Estas serán:

• Servidor FTP
• Usuario
• Password

Estos datos los utilizaremos en el método .connect y .login del cliente FTP

String sFTP = "ftp.miservidor.com";
String sUser = "usuario";
String sPassword = "password";
 
try {
  client.connect(sFTP);
  boolean login = client.login(sUser,sPassword);
} catch (IOException ioe) {}

Cuando hagamos el login para conectarnos al FTP, este devolverá en un valor booleano si se ha podido conectar o no. Si todo va correctamente ya estaremos conectados.

Una vez que hagamos la operativa que necesitemos con el FTP (lo veremos en otros artículos sobre FTP y Java) deberemos de desconectarnos del FTP.

Para desconectarnos del FTP haremos dos cosas. En primer lugar haremos un logout del usuario y luego nos desconectaremos del servidor. Los método .logout() y .disconnect() nos ayudarán en esta tarea.

client.logout();
client.disconnect();

Ya tendremos todo nuestro código para conectarse (y desconectarse a un FTP con Java).

Hay que tener en cuenta que todo el proceso de conexión al FTP puede generar una excepción IOException. Es por ello que deberemos de tomar las medidas necesarias en una estuctura try-catch.

Si quieres estar al tanto de todas las novedades sobre Java, creo que @java es una cuenta de Twitter que no debes de perderte.

En la cuenta @java de Twitter podemos encontrar publicaciones de artículos, podcast, información de conferencias del mundo Java, preguntas y respuestas, URL de interés,...

Así que ya estás haciéndote follower de @java en Twitter.

¿Qué otra cuentas de Twitter recomendarias sobre Java, HTML, PHP, CSS,...? Comentanoslo e iremos añadiéndolas a nuestro listado.

Si estamos haciendo una aplicación Java normal hay que saber que se le pueden pasar parámetros de inicialización.

Seguro que muchos habéis reparado en el método main, qué es el método principal de una aplicación Java, y en cómo se describen sus parámetros.

public static void main(String[] args) { ... }

En ese array de String es dónde vamos a encontrar los parámetros de inicialización. Estos parámetros se pasan en la invocación de nuestro programa Java. Así, si tenemos un programa Java que se llama ParametrosJava, la forma de invocarlo desde la línea de comando será la siguiente:

java ParametrosJava parametro1 parametro2 ... parametroN

No existe un orden estandar para los parámetros, si no que según se pongan en la línea de comando, así le llegarán al programa.

Si queremos listar los parámetros que le llegan a la aplicación lo podemos hacer con un bucle for-each

for (String arg : args)
  System.out.println(arg);

Así tendremos el listado entero de parámetros que se le han pasado al programa.

El RUT es el Rol Único Tributario es un número único Chileno que sirve como identificador tributario.

El RUT consta de dos partes, el número y el dígito verificador separados por un guión. En el siguiente ejemplo se toma como RUT el número 30.686.957-X, donde 30.686.957 es el número del RUT y X es el dígito verificador que no conocemos o que queremos verificar:

Se procede a tomar el número de RUT de derecha a izquierda, multiplicando cada dígito por los números que componen la serie numérica 2,3,4,5,6,7; y sumando el resultado de estos productos, como se muestra a continuación (si se ha aplicado la serie hasta el 7 y quedan dígitos por multiplicar, se comienza la serie nuevamente):

7 × 2 = 14,
5 × 3 = 15,
9 × 4 = 36,
6 × 5 = 30,
8 × 6 = 48,
6 × 7 = 42,
0 × 2 = 0,
3 × 3 = 9

Entonces la suma de los productos es

14+15+36+30+48+42+0+9 = 194

Para poder hacer con Java esto tenemos que invertir el número:

public static Object[] invertir(Object[] array) {
  Object[] invertir_int = new Object[array.length];
  int maximo = array.length;
 
  for (int i = 0; i < array.length; i++) {
    Object j = array[maximo - 1];
    invertir_int[maximo - 1] = array[i];
    maximo--;
    }
  return invertir_int;
}

Ahora, vamos multiplicando por la serie de números y acumulando la suma en rutSumado.

int a = 2;
for (int i = 0; i < array.length; i++) {
  array[i] = Integer.parseInt((String) array[i]) * a;
  rutSumado += Integer.parseInt(String.valueOf(array[i]));
  if (a == 7) {
    a = 1;
  }
  a++;
}

Al número obtenido por la suma del producto de cada dígito por la serie ya mencionada, se le aplica módulo 11, o sea, se divide por 11 y se determina el resto de la división.

194: 11 = 17
Resto: 7

Ahora a 11 se le resta el resto:

11 - 7 = 4

El código Java sería

int resto = rutSumado % 11;
String Digito = String.valueOf(11 - resto);

Con el valor obtenido:

• Si el resultado es 11, el dígito verificador será 0.
• Si el resultado es 10, el dígito verificador será K.
• En otro caso el resultado será el dígito verificador.

Para hacer esto con Java:

if (Digito.equals("11")) {
  Digito = "0";
}

if (Digito.equals("10")) {
  Digito = "K";
}

Como en el ejemplo el resultado de la resta es 4, el dígito verificador es 4. Por ende, el RUT del ejemplo es el 30.686.957-4.

Saludos, Espero que les sea de ayuda

Hoy explicaré en simples pasos cómo usar Substance en nuestras aplicaciones, que de hecho es una muy buena forma de darle estilo a nuestras ventanas

¿Que haremos?

Crearemos una ventana simple(JFrame, JTextField, JButton) a código. Sin ayuda de Netbeans u otro programa que solo tienes que arrastrar componentes, que de hecho es una muy buena forma, pero el motivo es enseñar.

Primero que todo haremos una nueva clase llamada "JVentana" que como el nombre lo indica tendrá lo suficiente para crear una ventana y también incluiremos un evento al botón:

public final class JVentana{
...}

Ahora agregamos 3 atributos de tipo JFrame, JTextField, JButton:

private JFrame Frame_principal;
private JTextField textField_texto;
private JButton button_saludo;

Siguiendo de lo antes realizado agregaremos un método llamado "inicializar", que inicializará los atributos que declaramos anteriormente:

public void inicializar(){
  Frame_principal = new JFrame("Sethcrofts para http://www.lineadecodigo.com");
  textField_texto = new JTextField();
  textField_texto.setColumns(40);
  button_saludo = new JButton("Saludar");
}

Explicación del método inicializar:

1. Creamos el JFrame asigándole un nombre en su constructor
2. Creamos el JTextField
3. Seteamos el JTextField para que sea mas largo (por columnas)
4. Creamos el JButton

Siguiendo lo anterior iremos a crear otro método llamado "agregarComponentes":

public void agregarComponentes(){
  Frame_principal.add(textField_texto);
  Frame_principal.add(button_saludo);
  Frame_principal.setLayout(new FlowLayout());
  Frame_principal.setVisible(true);
  Frame_principal.setResizable(false);
  Frame_principal.pack();
}

Explicación del método agregarComponentes:

1. Agregamos el JTextField creado al FramePrincipal
2. Agregamos el JButton creado al FramePrincipal
3. Seteamos nuestra ventana principal al modo FlowLayout (Alterará la forma en que se ubicarán los componentes en el Frame)
4. Hacemos visible la ventana principal
5. Seteamos la opción de redimensionar la ventana (true=SI, false=NO)
6. Seteamos la ventana principal, para que se adapte al tamaño de nuestros componentes para evitar espacios innesesarios

Ahora lo que nos queda hacer por último es programar nuestro evento para que al hacer click en el botón se genere un mensaje:

public void asignarEventos(){
  button_saludo.addActionListener(new ActionListener() {
    public void actionPerformed(ActionEvent e) {
        if(textField_texto.getText().equalsIgnoreCase("")){
            JOptionPane.showMessageDialog(null, "Ingrese un nombre.");
        }else{
            JOptionPane.showMessageDialog(null, "Hola: "+textField_texto.getText());
        }
    }
  });
}

Explicación del método asignarEventos:

1. Asignamos un evento (ActionListener) al botón (button_saludo), como su nombre lo indica escuchará cada vez que se presione.
2. Agregamos el método actonPerformed (Si usas Netbeans esa parte se hace por defecto, así que solo tendrás que asignar instrucciones)
3. Preguntamos que si el textField_texto está vacio que realize la siguiente acción
4. Desplegamos un mensaje en pantalla (como un alert() en Javascript, MessageBox en .NET )
5. Si no es así, entonces saludará al nombre ingresado en el text

Y bueno ya casi terminando crearemos nuestro constructor:

public JVentana(){
  inicializar();
  agregarComponentes();
  asignarEventos();
}

Explicación del constructor:

1. Llamamos al método inicializar
2. Llamamos al método agregarComponentes
3. Llamomos al método asignarEventos

Es importante la posición en que pones las llamada a los métodos, porque si pones por ejemplo agregarComponentes se generará un error ya que aún no se han creado los componente

Nuestra clase sería verse algo así :

 
package ejemplosubstance;
 
import java.awt.FlowLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JOptionPane;
import javax.swing.JTextField;
 
public final class JVentana{
 
  private JFrame Frame_principal;
  private JTextField textField_texto;
  private JButton button_saludo;
 
  public JVentana(){
    inicializar();
    agregarComponentes();
    asignarEventos();
  }
 
  public void inicializar(){
    Frame_principal = new JFrame("Sethcrofts para http://www.lineadecodigo.com");
    textField_texto = new JTextField();
    textField_texto.setColumns(40);
    button_saludo = new JButton("Saludar");
  }
 
  public void agregarComponentes(){
    Frame_principal.add(textField_texto);
    Frame_principal.add(button_saludo);
    Frame_principal.setLayout(new FlowLayout());
    Frame_principal.setVisible(true);
    Frame_principal.setResizable(false);
    Frame_principal.pack();
  }
 
  public void asignarEventos(){
    button_saludo.addActionListener(new ActionListener() {
      public void actionPerformed(ActionEvent e) {
        if(textField_texto.getText().equalsIgnoreCase("")){
          JOptionPane.showMessageDialog(null, "Ingrese un nombre.");
        }else{
          JOptionPane.showMessageDialog(null, "Hola: "+textField_texto.getText());
        }
      }
    });
  }
}

Luego que tengamos todo listo viene la parte principal de éste tutorial por así decirlo "darle estilo a nuestras ventanas". Para ellos vamos a utilizar Substances.

Lo primero que tenemos que hacer es descargarnos el jar de Substances.

Descargar Substances Version: 5.3

Luego que lo tenemos descargado lo añadimos al proyecto, desconosco la manera en que algunas aplicaciones hacen éste proceso pero Netbeans lo hace de la siguiente manera

1. Botón derecho sobre Libraries
2. Add Jar/Folder (Agregar JAR / Carpeta)
3. Buscamos y seleccionamos nuestro JAR descargado

Luego lo único que tenemos que hacer es nuestro honorable MAIN que quedaría de la siguiente manera:

public static void main(String[] args) {
  java.awt.EventQueue.invokeLater(new Runnable() {
    public void run() {
      try {
        Frame.setDefaultLookAndFeelDecorated(true);
        SubstanceLookAndFeel.setSkin("org.jvnet.substance.skin.OfficeSilver2007Skin");
        new JVentana();
      } catch (Exception e) {
        JOptionPane.showMessageDialog(null, "Error: "+e);
      }
    }
  });
}

Explicaré la dos lineas que son nuevas para ustedes. Sí, "JFrame.setDefaultLookAndFeelDecorated" y "SubstanceLookAndFeel.setSkin"

1. La primera setea el Frame que vendrá luego a que adopte el decorado de Subtances y que decorado tendrá.
2. Bueno la segunda linea de encarga del decorado en éste caso es "officeSilver2007Skin"

Si todo va bien deberíamos ver algo así

Por un punto la respuesta, palabras que empiecen por "ca"... Quién no ha jugado a este juego de niños... Vamos a ver como podemos codificar este juego mediante el lenguaje Java.

Lo primero de todo será pedirle al usuario que inserte palabras por consola. Palabras que empiecen por... Para ello utilizamos la clase Scanner, la cual nos permite capturar el dato introducido por el usuario de forma sencilla.

Scanner reader = new Scanner(System.in);
System.out.println("Escribe palabras que empiecen por '" + sInicio + "'");
sTexto = reader.next();

Hemos utilizado una variable sInicio para poder configurar al gusto la palabra que empiece por...

El método .next() nos permite cargar en la variable sTexto lo que el usuario haya escrito.

Ahora hay que comprobar que lo que ha introducido el usuario es una palabra que empieza por... Para ello utilizamos el método .startsWith() de la clase String. Este método devolverá true cuando el inicio de la palabra corresponda al valor pasado como parámetro.

while(sTexto.startsWith(sInicio)) {
  System.out.println("Correcto... " + sTexto);
  System.out.println("Dime otra palabra...");
  sTexto = reader.next();
}

Vemos que si el método .startsWith() devuelve true, felicitamos al usuario y le volvemos a pedir otra palabra. Nuevamente con el método .next()

Solo nos quedará el tener un contador de aciertos para darle una puntuación al usuario

while(sTexto.startsWith(sInicio)) {
  System.out.println("Correcto... " + sTexto);
  contador++;
  System.out.println("Dime otra palabra...");
  sTexto = reader.next();
}