The Code Line

De regreso!

2013-02-03T10:48:00.002-08:00

Hola queridos amigos!

Mis más sinceras disculpas, la verdad que hace cerca de un año que ya dejé de publicar por motivos de trabajo y de estudios, pero ya estoy de vuelta y con mayores conocimientos!

Estos días publicaré algunas nuevas entradas de programación, estén atentos!

PDTA: Les dejo mi nueva web!
http://www.buenosconsejos.dx.am

Lenguaje Java - Comunicaciones II

2012-01-12T05:41:00.000-08:00

Comunicación Serial

Otro tipo de comunicación es la de tipo Serial, una de las más conocidos es la comunicación por cable RS-232, este tipo de conexión tiene un rango de transmisión de 10 metros como máximo, y pues solo hay 1 punto de inicio y 1 punto de destino, a diferencia del cable ethernet que al pasar por el router puede irse a donde sea, y que además aguanta una distancia de hasta 100 metros, pero la comunicación serial es la más usada para dispositivos electrónicos y pues es comunmente encontrada en programas industriales.

Hoy les mostraré como implemente uno de mis programas más usados para probar conexiones, se llama EasySend, el cual es un programa que lee los datos enviados por dispositivos de manera serial y los envia a un servidor ethernet como el que realizamos anteriormente para posteriormente pasarselos a un cliente que se conecte a este.

Construimos una clase Principal (JFrame):

Caja de texto COM-PUERTO = com

Caja de texto COM-Baudios= baud

Caja de texto Puerto servidor = puertos

Area de texto= consola

Antes de usar la librería para leer los puertos seriales, debemos importar su .jar muchas librerias que encontramos en internet se importan con sus .jar :

1) bajamos el archivo aqui

2) lo importamos

La librería que usaremos para leer puertos serial se llama SerialPort:

import app.Com;
import app.Parameters;
import core.SerialPort;

En total las librerías que usaremos son:

import java.util.List; // para leer los puertos seriales disponibles
import app.Com;
import app.Parameters;
import core.SerialPort;
import java.io.DataOutputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;

Luego lo mismo de siempre, ponemos implementes Runnable para el thread de comunicación:

public class Principal extends javax.swing.JFrame implements Runnable

Los siguientes atributos

        public Com c2;
        public ServerSocket servidor;
        public Socket skCliente;
        public OutputStream outstream;
        public DataOutputStream flujo;
        public Thread t;
        public Principal p;
        public String datos="";
        public String a;
        public String sensada="0.0";
        public int iden=3317;
        public boolean parte=false;

El método constructor:

public Principal() {
        initComponents();
        this.setVisible(true);
        try{

        SerialPort free = new SerialPort();
        List<String> portList = free.getFreeSerialPort();
            consola.setText("Puertos Libres");
        for (String string : portList) {
            consola.setText(consola.getText()+"\n"+string);
        }


        }catch(Exception g){
            g.printStackTrace();
        }
    }

La función parte, que se encargaba de identificar el "codigo y el valor", por ejemplo si recibí "1 123", el código es 1 y el valor es 123, esto se hace porque por el mismo puerto podemos recibir varios tipos de variables, por eso se necesitaba de un código para identificar cual era.

public static boolean parte(String s){
        try{
        int f=s.indexOf(" ");
        iden = Integer.parseInt(s.substring(0,f));
        sensada =s.substring(f+1);
        System.out.println("iden "+ iden);
        System.out.println("sensada " + sensada);
        parte = true;

        }catch(Exception j){
         parte = false;
        }
        return parte;

   }

Ahora implementamos el método Run:

public void run(){

          System.out.println("ok");
            try {
                skCliente=servidor.accept();
                consola.setText(consola.getText()+"\n"+"Cliente :"+skCliente.getInetAddress());
                outstream = skCliente.getOutputStream();
                flujo= new DataOutputStream( outstream );
                while(true){

   a= c2.receiveSingleString(); // método para leer un dato por Serial
                while(!a.equals("\n") ){
                a =c2.receiveSingleString();
                if(a.equals("\n") || a.equals(null) || a.equals("") ){

                }else{
                 datos += a;
                }

                }

                  System.out.println(" !"+datos+"! ");
                  parte(datos);
                 datos ="";
                 if(parte){
                   flujo.writeUTF(Integer.toString(iden) +" "+Double.parseDouble(sensada));
                   consola.setText(consola.getText()+"\n"+"Se envia : "+iden +" "+sensada);
                 }

              }
            } catch (Exception ex) {
                ex.printStackTrace();
            }

}

El evento de click del boton aceptar("boton"), para iniciar todo:

private void botonActionPerformed(java.awt.event.ActionEvent evt) {
        try {
            Parameters settings = new Parameters();
            settings.setPort(com.getText());
            settings.setBaudRate(baud.getText());
            c2 = new Com(settings);
            consola.setText(consola.getText()+"\n"+"Se instala puerto :"+com.getText());
            servidor=new ServerSocket(Integer.parseInt(puertos.getText()));
            t=new Thread(p);
            t.start();
            // TODO add your handling code here:
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }

El evento del boton enviar ("jButton1")

private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {


            try{
                double d = Double.parseDouble("2.0");
                flujo.writeUTF("1" +" "+d);
                consola.setText(consola.getText()+"\n"+"Se envia : "+d);
            }catch(Exception sd){
                sd.printStackTrace();
            }

    }

Lenguaje Java - Comunicaciones I

2012-01-12T04:55:00.000-08:00

Sockets

Bien, los denominados sockets son los que nos permiten enviar datos y recibir datos a travez de una conexión de red, es el denominado protocolo TCP/IP, generalmente cuando se trabaja con comunicaciones, se usan algoritmos dentro de un bucle infinito, por lo tanto necesitaríamos de los threads para poder implementar el algoritmo de comunicación.

Para programar en la comunicación Ethernet (TCP/IP) hay que entender el concepto de cliente y de servidor, el cliente es el que se conecta al servidor, es decir, para que halla comunicación el servidor se levanta primero y luego es capaz de aceptar 1 o más clientes a la vez según esté programado, a continuación les mostraré un simple ejemplo de un Messenger en Java usando la librería Sockets:

El cliente:

Creamos una clase Cliente de tipo JFrame, para poder hacer la ventana de Messenger:

Area de texto: area2

Caja de texto: area1

Ahora vamos a implementar la librería Sockets colocando:

import java.net.*;

También usaremos las siguientes librerías:

import java.io.*; // para poder usar los try catch

Seguido de esto vamos a hacer que la clase Cliente implemente el método run de Runnable para poder usar los threads:

Colocamos implements Runnable :

public class Cliente extends javax.swing.JFrame implements Runnable

Ahora declaramos los siguientes atributos que nos ayudarán en el funcionamiento del programa

    public InputStream sIn; // para recibir datos
    public DataInputStream flujo; // para convertir datos recibidos
    public OutputStream salida; // para escribir datos ( enviar)
    public DataOutputStream flujo2; // para convertir los datos a enviar ( escribir )
    public Socket skCliente; // el objeto socket que nos permite conectarnos
    public Thread j; // el thread que usaremos en la comunicacion

Ahora el método constructor:

public Cliente() {
        initComponents();

        j=new Thread(this);
        try{
            j.start();
        }catch(Exception ds){
            System.out.println(ds.getMessage());
        }

}

implementamos el método run:

public void run(){


           try{
           skCliente=new Socket("192.168.6.36",5000); // ip y puerto del servidor
           sIn=skCliente.getInputStream();
           salida=skCliente.getOutputStream();
           flujo2=new DataOutputStream(salida);
           flujo = new DataInputStream(sIn );
           area2.setText("Conectado a Servidor : "+skCliente.getInetAddress());
           int aux6;
           while( true ){
             aux6=flujo.read(); // se lee un byte como entero
               //el byte es convertido en caracter y luego se pone en la caja de texto "area2"
                area2.setText(area2.getText()+"\n"+(char)aux6);

              }else{

              }


             }

              }catch( Exception e ) {

              System.out.println( e.getMessage() );

               }

    }

Ahora programaremos el boton de click, para ello usaremos los denominados eventos, es decir el comportamiento de los componentes si sucede un "evento" como click, presionar tecla, recibir dato, cerrar componente, etc. En este caso usaremos el mouse clicked ( clic de mouse ).

Luego implementamos el siguiente codigo dentro del evento, les debe quedar así:

private void jButton1MouseClicked(java.awt.event.MouseEvent evt) {
        try {

            for(int i=0;i<area1.getText().length();i++){
                flujo2.write(area1.getText().charAt(i));

             // enviamos caracter por caracter de la palabra escrita en area1
            }

        } catch (IOException ex) {
            ex.printStackTrace();
        }


    }

Hasta aquí ya tenemos el cliente listo para conectarse al servidor, ahora vamos a programar la otra parte, el servidor:

Creamos una clase Servidor, igual que la anterior que sea JFrame:

Area de texto: area1

Caja de texto: texto

Al igual que el cliente, el servidor usará las mismas librerías:

import java.io.* ;
import java.net.* ;

Colocamos implements Runnable para usar los threads:

public class Servidor extends javax.swing.JFrame implements Runnable

Usaremos los siguiéntes atributos:

public ServerSocket skServidor; // el servidor
public InputStream sIn;
public Thread ss; // el thread
public Socket skCliente; // el cliente que acepta
public DataInputStream flujo2;
public InputStream instream;
public DataOutputStream flujo;

public String aux="";

public OutputStream outstream;

El método constructor:

public Servidor() {

        initComponents();
        try {

        skServidor = new ServerSocket( 5000); // crea servidor con puerto 5000
        ss=new Thread(this);
       ss.start();
            } catch( Exception e ) {
                System.out.println( e.getMessage() );
            }


    }

El método run para la comunicación:

public void run(){

            try {

              skCliente=skServidor.accept();
              area1.setText("Cliente Aceptado: "+skCliente.getInetAddress());
              outstream = skCliente.getOutputStream();
              instream = skCliente.getInputStream();
              flujo2 = new DataInputStream(instream);
              flujo= new DataOutputStream( outstream );

            String aux="";
          int a;
             while( true ){

             a=flujo2.read();

             if(a==10){
              area1.setText("\n"+aux); // si recibe salto de linea pone el texto
             }

             if(a<15){

             }else{
               aux= aux+ (char)a; // concatena los caracteres recibidos y al formar una palabra la pone

             }

             }

               }catch( Exception e ) {

              System.out.println( e.getMessage() );

               }

    }

El evento del boton enviar:

private void botonActionPerformed(java.awt.event.ActionEvent evt) {

        String p;
        p=texto.getText()+"\n";
        try {

          for(int k=0;k<p.length();k++){
          flujo.write(p.charAt(k));
           }

        } catch (IOException ex) {
            ex.printStackTrace();
        }

}

Lenguaje Java - Threads

2012-01-08T06:04:00.000-08:00

Hilos en Java (Threads)

Bueno, me tomé un tiempo para arreglar unos asuntos con mi carrera, pero ya estoy de regreso, el tema de hoy es un tema muy importante para la programación avanzada, en muchos casos nos es útil o necesario realizar procesos en parelelo, pero hasta ahora solo podíamos hacerlos consecutivamente 1 tras otro, pero los lenguajes de programación actuales tienen un sistema de "hilos" de procesos, que manejan una serie distintas de procedimientos y se pueden ejecutar y detener según nuestras necesidades.

En java usaremos la clase Runnable

Al declarar una clase que va usar un hilo, tenemos que hacerla implementar ( sobreescribir el método run), para lograrlo, primero tenemos que poner import Runnable:

public class Test implements Runnable{

public static void main(String args[]){

}

}

Una vez hecho esto ya tenemos que escribir el método run() en el cual tendremos que poner el código que queremos que se ejecute en paralelo.

public class Test implements Runnable{
int i=0;
public Test(){
}

public static void main(String args[]){

}

public void run(){

i=i+1;

}

}

Para empezar a ejecutar el método run, debemos tener un objeto Thread ( hilo ), en este caso lo pondré como atributo, lo inicializaré en el main y le pondré a correr el método run.

public class Test implements Runnable{
int i=0; // contador desde 0

Thread hilo; // el hilo

public Test(){
                               t.hilo=new Thread(this); // se inicializa el hilo
                               hilo.start(); // se empieza el hilo ( llamamos al método run)

}

public static void main(String args[]){
   Test t=new Test(); // llamamos al constructor

    while(true){ // este es el while-true normal, con el main

      System.out.println("_________________");
}

}

public void run(){ // método run del hilo

while(true){ // este es el while-true en paralelo , lo logramos en el método run del hilo

i=i+1; // lo que hace este método es ir sumando la variable "i" e imprimiéndola infinitamente

System.out.println(i);

}
}

}

Con el ejemplo anterior logramos hacer 2 bucles infinitos (while-true) en paralelo, lo cual nos es muy útil en determinadas situaciones, y por cada clase que creemos tedríamos otro proceso en paralelo para agregar, los threads o hilos se usan mucho en sistemas de comunicacion, dispositivos, actualizaciones rápidas, conteos, etc.

Feliz Año Nuevo

2011-12-31T16:36:00.000-08:00

Bien, paso para desearles un feliz año nuevo muchachos, le deseo de todo corazón que los éxitos les sigan llegando y que siempre den lo mejor de ustedes para seguir adelante.

Un agradecimiento en éste el primer mes de mi blog a todos los usuarios que leen mis lecciones, cada vez somos más lectores y más seguidores, recibí un correo de un amigo desde suiza saludos a toda la gente por ese lado del globo! y pues saludos a todos y que lo pasen de lo mejor hoy en la noche !!!

Saludos.
David

Lenguaje Java - JList y JComboBox

2011-12-29T20:18:00.000-08:00

Listas y ComboBox

Los componentes JList y JComboBox son muy importantes en sistemas de ventas, paneles de opciones, paneles de administracion de datos, es importante aprender a manejarlos tanto desde el diseño como en el código, generalmente estos componentes se manejan alimentándolos con datos de una base de datos o de manera manual, por ello veremos como hacerlo desde ambos lados.

Primero agregamos un JComboBox al JFrame:

Podemos llenar los "items", osea las palabras que están dentro de ese componente, en la propiedad model.

Desde código se hace de la siguiente manera:

String a[]=new String[] { "Item 1", "Item 2", "Item 3", "Item 4" };
jComboBox1.setModel(new javax.swing.DefaultComboBoxModel(a));

Selected Index nos dice la posición del elemento que está seleccionado en el componente, por ejemplo si queremos el primero pondremos 0, si ponemos el segundo será un 1.

La propiedad font le da las propiedades de formato a las palabras que van dentro del componente:

Bien ahora las propiedades del JList:
De la misma manera podemos editar los "items" en model:

En código se haría de la siguiente manera:

String[] a= { "Item 1", "Item 2", "Item 3", "Item 4", "Item 5" };
jList1.setModel(new javax.swing.AbstractListModel() {
            String[] strings = a;
            public int getSize() { return strings.length; }
            public Object getElementAt(int i) { return strings[i]; }
        });

Si queremos cambiar el color de fondo a la lista:

Bien uno de las cosas importantes cuando se programa con interfaz gráfica, es setear el Layout, esto quiere decir que define la manera de reaccionar al movimiento, clic, ingreso de datos (eventos), por ejemplo si agrandamos un componente puede que el Layout agrande también los demás o los cambie de posición, pues bien para que no pase esto personalmente uso Layout null :

Lenguaje Java - JLabel y JButton

2011-12-28T09:25:00.000-08:00

Etiquetas y Botones

Siguiendo con el estudio de los componentes gráficos en Java, tenemos las etiquetas (labels), que generalmente se usan para poner un texto indicando algo o para poner una imagen en un frame.

Bien entonces, agregamos a nuestro proyecto un JLabel.

Le pueden poner el texto que quieran en la propiedad text, igual que el JTextBox....

Le pueden poner un cursor definido, en la propiedad cursor.....

Igualmente que el JTextArea y el JTextField, podemos ponerle borde....

Podemos ponerle formato a la letra que está dentro del label.

Bien, como les mencioné también podemos usar el JLabel para mostrar una imágen, en la propiedad icon.

Borramos el texto para que quede solo la imagen

Otro componente que generalmente se usa en Java, son los botones, JButton:

Tiene similares propiedades a los demás componentes, por ejempo el texto....

También tiene su propio cursor....

Le cambiaremos el nombre para poder editar algunas cosas desde código:

Si ponemos el nombre del botón en el código y luego ponemos el . (punto) saldrá un menú de propiedades del botón:

Cambiándole el texto al boton desde código.....

Lenguaje Java - JTextField y JTextArea

2011-12-28T08:52:00.000-08:00

Cajas de Texto y Áreas de Texto

Bien son 2 controles los básicos para manejar el texto dentro de un JFrame (ventana), los cuales son la caja de texto (JTextField) y el área de texto (JTextArea), ahora veremos algunos comandos básicos para editar sus propiedades y también como se hace desde el NetBeans.

JTextField y JTextArea tienen propiedades comunes, JTextArea tiene un poco más de propiedades por lo que permite mayor número de filas.

Primero agregamos al proyecto un nuevo JTextField, le ponemos de texto el nombre que deseamos, en este caso David.

Desde código sería así: jTextField1.setText("David");

Si deseamos podemos ponerle un nombre al componente para su facil manejo desde código....

Le podemos poner borde....

Si queremos ponerle algún color de fondo a la cajita de texto....
Desde código sería así: jTextField.setBackground(Color.red);

Si queremos cambiarle el formato a la letra dentro de la caja de texto...

Si queremos cambiar el color de la letra dentro de la caja de texto....

Desde código sería así: jTextField1.setForeground(Color.white);

Si queremos cambiar la posición y el tamaño:

Desde código sería así: jTextField1.setBounds(20,20, 300,100); // x,y,ancho,alto

Ahora agregamos un JTextArea, y veremos a continuación algunas propiedades especificas de este componente ( las que vimos anteriormente se repiten para el JTextArea).

Si queremos que sea transparente.....

Desde código sería así: jTextArea1.setOpaque(false);

Si queremos que baje automáticamente de linea al llegar a límite derecho del área de texto...
Desde código sería así: jTextArea1.setLineWrap(true);

En el caso que no queremos que nos deje escribir nada, solo para visualizar datos....

Desde código sería así: jTextArea1.setEditable(true);

Lenguaje Java - JFrame

2011-12-27T06:41:00.000-08:00

La Ventana - JFrame

Un frame, en netbeans es una clase también, es decir podemos crear un formulario JFrame llamado, Cliente, eso quiere decir que en esa ventana vamos a hacer todo lo referido al Cliente, si le ponemos de nombre por ejemplo Venta, en esa ventana pondremos una interfaz para vender productos, cobrar, etc.

Ahora veremos algunas de las propiedades más comunes de los JFrame, para ello creamos un proyecto con un JFrame:

Nos vamos a la pestaña source, que es la parte donde podemos editar parte del código:

En la parte source, encontramos la clase (el frame), encontramos la definición del método constructor de esa clase y el main.

También encontramos que en el método costructor se llama al método initComponents

Ese método es automáticamente generado por NetBeans al momento de jalar un componente, elimianarlo o cambiarle alguna propiedad en la pestaña Diseño (Design):

Bien si queremos cambiarle por ejemplo que cuando le demos clic en el X roja de cerrar, no se cierre por ejemplo, lo podemos configurar en :

Si queremos que cuando el cursor parse por arriba de la ventana se ponga una manito, haremos lo siguiente:

También podemos editar las propiedades desde el código, de la siguiente manera:

Lenguaje Java - Interfaz Gráfica

2011-12-27T06:18:00.000-08:00

GUI

(Graphic User Interface)

Bien, continuando con nuestro curso después de las recientes festividades les tengo un tema muy interesante, el cual es el manejo de las "ventanitas" como muchos les llaman, mejor dicho los JFrames, si ahora si vamos a hacer programas como los que suelen ver.

Bien lo primero que hacemos es abrir el netbeans y añadir un proyecto nuevo.

Le agregamos un formulario JFrame

Le ponemos un nombre cualquiera, en este caso Ventana

Y aquí tenemos nuestra primera ventana en Java, lista para editarse

Hay muchos componentes gráficos que java nos perrmite usar, los podemos ver en la parte derecha de la pantalla, en este caso jalaré un panel y lo pondré.

Luego jalaré 2 paneles y les pondré color ( propiedades salen abajo de los componentes, tienen que darle clic al componente para cambiar sus propiedades), también agregaré 1 JLabel, para poner el texto.

Ejecutamos....

Aqui les presento algunos de los más comunes componentes (controles) usados en Java para programar las ventanas gráficas, la caja de texto, el panel, el boton, las etiquetas (labels), las listas , los checkbox, combobox, areas de texto, etc. incluso se pueden descargar componentes extras de internet que no vienen con el java original.

Aquí esta la parte de las propiedades que les mencioné, desde aquí pueden editar las propiedades del componente que hallamos seleccionado.

Bien espero que les halla gustado la introducción a la interfaz gráfica de Java espero que le den un buen uso y que sigan desarrollando sus aplicaciones, recuerden que el esfuerzo siempre va la pena.

Feliz Navidad!!!

2011-12-24T20:19:00.000-08:00

Bueno hacemos un breve descanso por las festividades, les deseo que pasen una feliz navidad a todos mis lectores y a los futuros lectores tmb jaja, que los éxitos sigan viniendo y que la paz llene sus hogares. Les desea su amigo David.

PDTA: Llegamos a las 1000 primeras visitas! Gracias a todos ustedes por visitar mi blog y estar siempre al tanto de mis publicaciones! Gracias nuevamente y que la sigan pasando muy bien en estas festividades y que tengan un próspero año nuevo...

Lenguaje Java - Ejercicios 1

2011-12-24T07:05:00.000-08:00

Ejemplo de manejo de Archivos

El común ejemplo de yacaré!, si es el caso de un cocodrilo que puede estar en 10 posiciones y que tiene un dispositivo que le envia una señal a un computador y la posición la guarda en un archivo de texto, usted debe leer el archivo de texto y hallar la moda, contar cuantos dias estuvo en cada posición, etc.

Bueno la implementación es la siguiente:

import java.io.File;
import java.util.Scanner;

public class Yacare {
    public static void main(String ags[]){

        try{

          File archivo=new File("yacare.txt");
          Scanner scanner=new Scanner(archivo);
          int aux;
          int pos[]={1,2,3,4,5,6,7,8,9,10};
          int dias[]={0,0,0,0,0,0,0,0,0,0}; // contadores empiezan con 0 dias
          while(scanner.hasNext()){
              aux=scanner.nextInt(); // leo un token del archivo
              for(int i=0;i<10;i++){
                if(aux==pos[i]){// busco la posicion del token en pos[]
                  dias[i]=dias[i]+1; // si lo encuentro le sumo 1 dia
                }
              }
          }
          int moda=dias[0]; // hallamos moda
          int posmoda=1;
           for(int i=0;i<10;i++){
                 if(dias[i]>moda){ // si se repite más q la moda
                     moda=dias[i];
                     posmoda=pos[i];

                 }
           }


        System.out.println("Pos"+"      "+"Dias");
            for(int i=0;i<10;i++){
                 System.out.println(pos[i]+"           "+dias[i]);
              }


          System.out.println("Moda"+"      "+moda);
          System.out.println("Pos Moda"+"      "+posmoda);
        }catch(Exception s){

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

        }


    }
}

Lenguaje Java - Leccion 10

2011-12-24T06:57:00.000-08:00

Archivos en Java

Con java también podemos procesar archivos de todo tipo, leerlos y escribir en ellos, en la lección de hoy veremos como procesar los archivos ".txt", si los archivos planos ( de texto ), para ello usaremos las librerías.

java.io.*;

java.util.Scanner;

En el manejo de archivos se usan las estructuras Try-Catch, nos indican que el código dentro del Try se debe intentar hacer y si ocurre un problema, hacer la parte del Catch.

try{

// hacer algo y si pasa algo pasar al catch

}catch(Exception obj){ // pongan siempre Exception para cualquier error que ocurra

// en caso de error en el try hacer lo que esta aqui

}

Escribiendo archivos:

public void creaData(){
         //Crear un archivo
        try{
             File f=new File("Archivo1.txt");
            FileOutputStream fo=new FileOutputStream(f,true); // ese true es para ver si se apila o se

//crea un archivo nuevo

            PrintWriter escribe=new PrintWriter(fo); // el objeto llamado escribe es el que usaremos

            escribe.println("1 2 3 4 5 6"); // escribimos los valores 1,2,3,4,5,6 separados por un espacio

//de linea y luego damos un salto de linea (println).

            escribe.println("Terminado"); // escribimos terminado
          for(int i=0;i<10;i++){
              escribe.println(""+(i+1)); // escribimos los numeros del 1 al 10
          }
        escribe.close(); //cerrar el archivo es necesario porque si no cierras no guarda
        //también puede usarse el método escribe.flush(); para guardar pero seguir editando
        }catch(Exception a){
            System.out.println("Error!");
        }
    }

*Los archivos se crean en la carpeta del proyecto del netbeans, en el caso que pongamos la ruta del archivo, lo encontraremos en esa ruta, ejm: File f=new File("C:\Archivo1.txt"); en ese caso el archivo estará en C:\, pero si lo dejamos asi File f=new File("Archivo1.txt"); el archivo respectivo estará en la carpeta del proyecto del netbeans.

Leyendo data de un archivo: Hablamos de token cuando nos referimos a 1 palabra separada por un espacio en blanco o un salto de linea, por ejemplo en " 2 3 4 5 asd 4234" hay 6 tokens.

public void leeArchivo(){
        //Lectura de archivos
         try{
             File f=new File("Archivo1.txt"); // leemos el archivo creado anteriormente
             Scanner sca=new Scanner(f); // declaramos el objeto Scanner para leer
             String aux;
             while(sca.hasNext()){ // mientras tenga 1 token el archivo
                 aux=sca.next(); // leemos el primer token
                 System.out.println(aux); // lo imprimimos en consola
             }


         }catch(Exception as){
             System.out.println("Error");
         }

    }

Lenguaje Java - Leccion 9

2011-12-23T19:16:00.000-08:00

Métodos de Búsqueda y Ordenamiento

En la lección de hoy veremos como implementar los métodos de búsqueda secuencial y búsqueda binaria y los ordenamientos por selección:

Búsquedas:

Búsqueda Secuencial: Recorre todo el arreglo comparando elemento por elemento, el método implementado nos da la posición del elemento en el arreglo.

public int BusquedaSecuencial(String[] a, String dato){ // recibe un arreglo de String y el dato a buscar

        for(int i=0;i<a.length;i++){
            if(a[i].equals(dato)){ // recorre todo el arreglo y si el elemento es igual al dato
                return (i); // retorna la posición buscada
            }
        }
      return -1;
    }

Búsqueda Binaria: El arreglo debe estar ordenado antes de entrar al método, lo que hace es dividir el arreglo en 2 y ver si el dato se encuentra a la izquierda o a la derecha y así sucesivamente ir dividiendo hasta que lo encuentre o la longitud del salto sea 0 y no exista el elemento, el método implementado nos da la posición del elemento en el arreglo.

public int BusquedaBinaria(int[] a, int dato){
       //Suponiendo el arreglo ordenado
       int pos;
         int pos1=0;
       int pos2=a.length;
       int salto=pos2-pos1;
       salto =salto/2;
       while(salto>0){

           if(a[pos1+salto]==dato){
               return (pos1+salto);
           }else{
               if(a[pos1+salto]<dato){
                   pos1=pos1+salto;
               }else{
                   pos2=pos2-salto;
               }
           }
           salto=pos2-pos1;
           salto=salto/2;
       }

       return -1;
    }

Ordenamientos:

Burbuja: El método consiste en comparar todos los elementos contra todos, hace comparaciones y va intercambiando valores, el método da como resultado el arreglo de Strings ordenado.

public String[] OrdenaPorBurbuja(String a[]){
        String aux;
        for(int i=0;i<a.length;i++){
                 for(int e=i;e<a.length;e++){
                     if(a[i].compareTo(a[e])>0){
                         aux=a[i];
                         a[i]=a[e];
                         a[e]=aux;
                     }

                }
            }
        return a;
    }

Ordenamiento por Selección:

public int[] OrdenamientoSeleccion(int b[]){
         int c[]=new int[b.length];
         int d[]=new int[b.length];
         int ultimomenor=0;
         for(int i=0;i<d.length;i++){
            d[i]=0;
         }
        int menor;
        int mayor=b[0];
        for(int i=0;i<d.length;i++){
            if(mayor<b[i]){
                mayor=b[i];
            }
         }
        for(int i=0;i<b.length;i++){
            menor=mayor;
            for(int e=0;e<b.length;e++){
                if(menor>b[e] && d[e]==0){
                    menor=b[e];
                    ultimomenor=e;
                }
            }
            d[ultimomenor]=1;
            c[i]=menor;
        }

        return c;
    }

Lenguaje Java - Leccion 8

2011-12-23T07:12:00.000-08:00

Trabajando con Consola

En java trabajamos con la consola con 2 métodos:

El popular System.out.println("---")
El Scanner para ingreso de Datos ( aunque hay varios para ingreso de datos, yo uso Scanner)

Salida de Datos por Consola:

Bien si queremos imprimir o mostrar por consola Java algunos datos, solo tenemos que invocar la siguiente linea de codigo:

System.out.println("Hola Amigos"); // es igual que el printf de C y el cout<< de C++

También se puede imprimir sin salto de linea: System.out.print("Hola Amigos");

Si queremos imprimir una variable entera concatenada con una cadena usamos el +:

String e="Mi edad es: ";
int edad=21;

System.out.println(e+edad);

Ingreso de Datos por Consola:

Usaremos la librería java.util.Scanner, esta librería trabaja igual que el scanf() de C y el cin>> de C++.

import java.util.Scanner;
public class Test{

public static void main(String args[]){

Scanner lector=new Scanner(System.in);

String dato=lector.next(); // leemos 1 palabra por consola

int datoentero=lector.nextInt(); // leemos 1 número entero por consola

double datodecimal=lector.nextDouble(); // leemos 1 número decimal por consola

String linea=lector.nextLine(); // leemos 1 linea de palabras escrita en la consola

}

}

De esta manera controlamos los flujos de entrada y salida en Java, usando el System.out.println() y el Scanner.

Lenguaje Java - Leccion 7

2011-12-23T07:00:00.000-08:00

Arreglos en Java

En Java encontramos diferentes tipos de arreglos, ya que hay infinitos objetos que podemos crear, por ejemplo si definimos una clase llamada "Alumno", podemos crear un ArrayList de alumnos, si creamos la clase "Cliente" podemos crear un arreglo de objetos de la clase Cliente, por otro lado también podemos crear arreglos de datos "primitivos" (int, double, char,boolean,etc).

Para los arreglos normales podemos definir el arreglo de esta manera:

int arreg[] =new int[14]; // arreglo con longitud 14

double arreg2[]=new double[15]; // arreglo de decimales con longitud 15

char arreg3[]={'a','e','i','o','u'}; // arreglo de caracteres

int arreg4[]={1,2,3,4,5,6,7,8}; // podemos definir el arreglo ya con sus elementos

arreg.length => para obtener el número de elementos del arreglo normal.

Para los arreglos de objetos usaremos la clase ArrayList y podemos definirlos de la siguiente manera:

-Necesitaremos esta libreria java.util.ArrayList;

Imaginemos que tenemos un programa para controlar los usuarios de una empresa:

Definimos la clase Usuario:

public class Usuario{

String usuario;
String clave;

public Usuario(){
}

}

----------------------------------------------------------

import java.util.ArrayList;
public class Test{

public static void main(String args[]){

ArrayList<Usuario> usuarios=new ArrayList<Usuario>();

Usuario u=new Usuario(); // creamos 2 usuarios
Usuario u2=new Usuario();

usuarios.add(u); // añadimos los 2 usuarios al arrayList
usuarios.add(u2);

usuarios.get(0).usuario="David"; // modificamos el primer usuario
usuarios.get(0).clave="12345";

usuarios.get(1).usuario="Gerardo"; // modificamos el segundo usuario
usuarios.get(1).clave="12345";

System.out.println("La cantidad de usuarios en el arreglo es: "+usuarios.size());

// usuarios.size() es igual al arreglo.length que nos da la longitud.

}

}

La diferencia en un arreglo normal y un ArrayList, es que el arreglo normal se tiene que definir su longitud al momento de declararlo, encambio un ArrayList te permite ir agregando y removiendo los elementos de una manera mucho más sencilla y que permite el manejo de Objetos de un modo muy deductivo.

Lenguaje Java - Leccion 6

2011-12-20T21:18:00.000-08:00

Métodos

Segunda Parte

Bien, continuando con los métodos de un objeto ( de una Clase ), tenemos que pueden ser según su accesibilidad como privados y públicos, también pueden ser protected ( protegidos) pero eso lo veremos más adelante.

por ejemplo, si tenemos la siguiente clase:

public class Alumno {

String nombre;

public Alumno(){
}

public setNombre(String n){ // un método que toma una variable n y se la pone en el atributo

//nombre

nombre=n;

}

}

Se puede llamar desde otra clase ya que el método setNombre es público:

public class Test{

public static void main(String args[]){

Alumno a1=new Alumno();
a1.setNombre("David");

}

}

Sin embargo si fuera definido el método así:

private setNombre(String n){
nombre=n;
}

En el método main no se podría llamar al método setNombre, pues Test es una clase que no se encuentra dentro de Alumno.

public static void main(String args[]){

Alumno a1=new Alumno();
a1.setNombre("David"); ->error

}

Bien esa es la diferencia de usar los métodos como públicos o privados, espero que les quede claro la diferencia y que bueno en mi opinion, si tienes claro la estructura de tu sistema, los métodos públicos te garantizan un periodo de programación menor.

Lenguaje Java - Leccion 5

2011-12-19T22:13:00.000-08:00

Métodos

Bien, en Java los métodos son parecidas a las funciones, solo que las funciones no estaban ligadas a los objetos, encambio los métodos si, solo pertenecen al objeto que los invoca, pero si lo quieren ver como una simple pieza de código, si lo es, pero quiero que se entienda que solo puede ser llamado si creamos un objeto de la clase en donde se encuentra el método.

Existen diversos tipos de métodos, según su función:

-Constructor
-Procedimiento

Según su tipo de dato de retorno:

-Vacio
-Entero
-Cadena
-Decimal
-Objeto
-Etc.

Según su accesibilidad:

-Private (privado)
-Public (público)
-Protected (protegido)

El más importante de todos es el método constructor, o es almenos el primero que deben aprender, pues el el método que nos permite crear objetos, sin él no tendría sentido la programación orientada a "Objetos", la forma más simple de definir (declarar) uno es solo poner el nombre de la clase.

public class Indio(){ // definimos la clase

String nombre; // un atributo string "nombre"

public Indio(){ // el constructor más simple que puede haber, solo poniendo el nombre de la clase

// nada por aqui

}

public static void main(String args[]){

Indio indio1=new Indio(); // aquí se llama al método constructor y se crea el objeto.

}

}

Otro ejemplo con constructores más complejos:

public class Animal(){

int patas;
int ojos;

public Animal(){
}

public Animal(int a){
patas=a;
}

public Animal(int patas,int ojos){
this.patas=patas; // se usa this para que no se confunda la variable patas con el atributo patas

this.ojos=ojos; // se usa this para que no se confunda la variable ojos con el atributo ojos
}

public static void main(String args[]){

Animal animal1=new Animal (); // aquí se llama al método constructor y se crea el objeto.
Animal animal2=new Animal (4); // aquí se llama al método constructor con datos: 4 patas

Animal animal3=new Animal (4,2); //método constructor con datos: 4 patas y 2 ojos

}
}

Lenguaje Java - Leccion 4

2011-12-19T19:42:00.000-08:00

Variales vs Atributos

Bien un concepto que al comienzo es dificil entender es el concepto de variable y atributo, la diferencia principal es que el atributo es una variable ( simple u objeto ), y que el atributo siempre le pertenece a un objeto, por otro lado una variable ( simple u objeto ) no le pertenece a un objeto solo cumple una función en un algorito o método y eso es todo.

Por ejemplo, si creamos (usamos el método constructor de la clase Persona . ver ejemplo leccion 3 )

Alumno a =new Alumno(); // usamos el método costructor para crear a "a"

Qué pasa si ponemos un punto seguido de "a" asi: a.

A continuación el netbeans nos mostrará la lista de métodos y "atributos" que le corresponden al objeto llamado "a" de la clase Alumno, por ejemplo en el siguiente codigo:

public Class Alumno{ // se define clase Alumno

String nombre; // se define atributo nombre

String apellido; // se define atributo apellido

public Alumno(){ // metodo constructor ( si crea objetos y es asi de simple )
}

}

public Class Test{

public static void main(String args[]){

String nombre;
Alumno alumno1=new Alumno();

alumno1.nombre="David"; //atributo nombre
alumno1.apellido="Aguirre"; //atributo apellido

nombre="David"; // variable nombre, notese que nombre no le pertenece a nadie

}

}

Lenguaje Java - Leccion 2

2011-12-18T17:43:00.000-08:00

En Donde Programar Java

La elección del programa en donde vamos a desarrollar nuestras aplicaciones es de vital importancia, por eso yo recomiendo el mejor IDE ( Desarrollador ) el cual es para mi el NetBeans, muy completo desarrollador de java, para todo tipo de aplicaciones ( no solo java puedes programar, sino también C++,php, celulares , etc.) con su plugin respectivo, pero el que bajas por defecto tiene para programar en java con todas las de la ley.

El link es :

http://netbeans.org/downloads/index.html

Se bajan el de 66 Mb, o si quieren todo el paquete el de 245 Mb, pero con el primero es suficiente.

OJO: Noooo lo instalen todavia, necesitamos bajarnos otra cosa.

Ahora se tienen que bajar la plataforma Java:

http://www.java.com/es/download/windows_xpi.jsp?locale=es

Instalan el el java, solo le dan siguiente siguiente a todo, al final cuando les pide registrarse es solo opcional.

Luego procedemos a instalar el Netbeans, de igualmanera siguiente siguiente siguiente, una vez que sale la opcion de seleccionar la version de Java a usar seleccionan la que instalaron, sale por defecto no se preocupen.

Bueno, una vez que todo lo instalaron correctamente, abrimos el NetBeans y esperamos que cargue...

Una vez que abra, crearemos nuestro primer proyecto siguiendo las siguiéntes imágenes:

Hasta aquí ya tenemos nuestras 2 primeras clases, las cuales las implementaremos en la siguiente lección, gracias por su tiempo su amigo David.

Lenguaje Java - Leccion 3

2011-12-18T17:37:00.000-08:00

Programación Orientada a Objetos

Bien, como les mencionaba anteriormente en este tipo de programación como que las cosas se encuentran de una manera más ordenada, por ejemplo si queríamos un programa que saque el promedio de los alumnos.

En una programación estructurada ( Lenguaje C ), sería de la siguiente manera:

int notas[3]={12,13,14};

double promedio=(notas[0]+notas[1]+notas[2])/3;

-En el ejempo anterior nos damos cuenta que por cada alumno tendríamos que crear un arreglo de notas, y si fueran muchos alumnos, serían igual número de arreglos cada uno con 3 notas, y que pasaria si alguno de ellos solo tiene 1 o 2 notas.

En la programacón orientada a objetos (Lenguaje Java), sería de la siguiente manera:

public Class Alumno{ // aqui definimos todas las propiedades del Alumno

int notas[]; // asi se declaran arreglos de enteros en Java, sin longitud definida.

// el arreglo notas sería un atributo de la clase Alumno

public Alumno(){ // método constructor ( crea objetos de Alumno)

}

public double damePromedio(){ // funcion o método para calcular el promedio de cada alumno

double suma=0;

for(int i=0;i<notas.length;i++){

suma=suma+notas[i];

}

suma=suma/notas.length;

return suma;

}

public Class ClasedePrueba{ // en esta clase va el main en donde empieza el programa

public static void main(String args[]){ // el main en version JAVA

Alumno pepito=new Alumno(); // creamos 1 alumno con 4 notas

pepito.notas=new int[4];

pepito.notas[0]=10; // llenamos sus notas

pepito.notas[1]=11;

pepito.notas[2]=12;

pepito.notas[3]=13;

double promedio=pepito.damePromedio(); // calculamos su promedio

Alumno carlitos=new Alumno(); // creamos 1 alumno con 2 notas

carlitos.notas=new int[2];

carlitos.notas[0]=10; // llenamos sus notas

carlitos.notas[1]=11;

double promedio2=carlitos.damePromedio(); // calculamos su promedio

}

Lenguaje Java - Leccion 1

2011-12-18T12:59:00.000-08:00

Bienvenidos a Java

Java el lenguaje libre por excelencia, uno de los lenguajes más populares en el mundo, se caracteriza por su capacidad de funcionar en diversas plataformas ( muchos Sistemas Operativos ), personalmente yo creo que JAVA es excelente pues en internet encuentras muchisimos recursos, soluciones a problemas, experiencias ya que gran parte de los programadores lo utilizan y postean sus dudas, soluciones en foros y bueno eso nos sirve para solucionar nuestros propios problemas, por otro lado, otro fuerte de JAVA es que encuentras gran cantidad de librerias libres en internet, que te costarían una buena inversión en lenguajes como Visual Basic, C++, etc... y que además dichas librerías estan bien implementadas y su uso es totalmente permitido ( en algunos solo para fines educativos ).

Bien, al igual que los lenguajes C,C++, Java también maneja las variables entero, decimal, cadena, caracter, boleano, etc.

int entero=2;
String cadena="Yo Soy una Cadena";
double decimal=12.87;
boolean boleano=true;
char caracter='C';

Nótese que para el caso de la variable "cadena", el formato de dato es String y que esta palabra está con mayúsculas, esto indica que String es una "Clase", Java introduce el concepto de Clases y Objetos, es decir es un lenguaje orientado a Objetos, los tipos de lenguajes más potentes en la actualidad son OO.

En Java se define:

Clase:

Lugar en donde se define una clase de objetos (por ejemplo la clase persona define todo de 1 persona en general)

Objeto:

Es un "item", digamos es una creación, una entidad de una Clase, por ejempo un objeto de la clase persona sería "miguel", quiero dejar claro este concepto pues es fundamental de ahora en adelante.

Método:

Funciones propias al tipo de Objeto ( depende de la clase )

Atributo:

Variables propias de cada tipo de Objeto ( depende de la clase )

C++ - Leccion 8

2011-12-16T17:31:00.000-08:00

Archivos en C++

Los programas que crearmos manejan datos en "tiempo de ejecucion", es decir esos datos existen mientras el programa corra, pero una vez que los cerramos esos datos se pierden, con lo cual un sistema debe tener un método para almacenar cierta información para poder usar en una futura ejecución, principio en el que se basan las "Bases de Datos".

Hoy aprenderemos como manejar un archivo de texto simple ".txt", las bases de datos las dejaremos de lado por ahora, pero más adelante las veremos.

Para manejar los archivos en C++, necesitamos de la librería #include <fstream>

Para los strings recuerden usamos la librería #include <string>

Bien para ingresar los datos al archivo, necesitamos una variable de tipo ofstream y para leer los datos necesitamos una variable de tipo ifstream.

El siguiente ejemplo trata de que por consola pidamos un dato y que lo guardemos automáticamente en un archivo "Hola.txt" :

#include <cstdlib>
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

int main(int argc, char *argv[])
{

    ofstream salida("Hola.txt",ios::app); // Abre archivo
    string c;
    cin >> c; // pide dato desde consola
    c="\n"+c; // se le pone un salto de linea al string
    salida << c; // se le agrega el string al archivo
    salida.close(); // se cierra el archivo para guardarlo
     string data;           // variable para leer los datos
     ifstream file;      // para leer el archivo

     file.open("Hola.txt");      // se lee el archivo

     while (!file.eof( ))      // mientras tenga data
     {

          file >> data;     // se lee un token (palabras separadas por espacios de linea o saltos de linea)
          cout<<data<<endl;     // imprime token almacenado en data
     }
     file.close( );       //se cierra el stream file


    system("PAUSE");
    return EXIT_SUCCESS;
}

C++ - Leccion 7

2011-12-16T17:20:00.000-08:00

Métodos de Búsqueda

Al igual que existen métodos para ordenar los arreglos, también existen muchos métodos para buscar 1 elemento específico dentro de 1 arreglo, a lo largo de la historia se desarrollan algorítmos cada vez más complejos y eficientes para cumplir su objetivo.

Para buscar un elemento dentro de un arreglo, existe el método de búsqueda secuencial, que es el más básico que existe, pero también hay otros más complejos y más eficientes ( como en todo curso de sistemas, hay muchas soluciones ).

Bien, el método de búsqueda consiste en comparar secuencialmente ( como su nombre lo dice) el elemento buscado con cada elemento del arreglo, con lo cual el argoritmo solo consistiría en 1 for que recorra 1 vez el arreglo.

La implementación del método de búsqueda secuencial sería de la siguiente manera:

string elemento="cardoza";

string cadenas[]={"aguirre","cardoza","flores","garcia","bayona"};

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

           if(cadenas[i] = = elemento){
               cout<<"Elemento encontrado!!"<<endl;
     }
}

C++ - Leccion 6

2011-12-16T17:13:00.000-08:00

Métodos de Ordenamiento

Existen diversos métodos de ordenar un arreglo, tenemos desde el más básico " el método burbuja ", hasta unos de mayro complejidad, como Shell, Gnome, QuickSort, etc.

Hoy veremos un método básico para ordenar cualquier tipo de arreglos (arrays), el método "Burbuja":

Teniendo 1 arreglo:

string cadenas[]={"aguirre","cardoza","flores","garcia","bayona"};

// el arreglo contiene muchos apellidos (strings)

El algoritmo consiste en comparar todas los elementos del arreglo contra todos los elementos del arreglo para así hacer una comparación de NxN donde N es el número de elementos, y así quede el arreglo ordenado.

El código se basa en 2 estructuras de repetición "for" que van recorriendo el arreglo y comparando cada elemento correspondiente.

El código para implementarilo sería el siguiente:

for(int i=0;i<5;i++){ // para el primer elemento a comparar
      for(int e=i;e<5;e++){ // lo comparamos con todos los restantes
           if(cadenas[i]>cadenas[e]){ // analizamos si es mayor( sea numero o cadena)
                aux=cadenas[i]; // realizamos un intercambio
                cadenas[i]=cadenas[e];
                cadenas[e]=aux;
          }
     }
}

y si queremos mostrarlo en consola:

   for(int e=0;e<5;e++){
               cout <<cadenas[e]<<endl;
     }