Lenguaje Java - Comunicaciones II

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

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

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.

Lenguaje Java - JFrame

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

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.

Lenguaje Java - Ejercicios 1

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

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

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

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

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

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

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

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

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.