Curso gratuito de programación para principiantes en java. (1.Lenguaje java)

1.1 Objetivos del tema.
Con el fin de empezar con un lenguaje de programación vamos a ver en este tema una introducción a JAVA.
En cuanto al tema de la historia de Java, en Internet hay muchas versiones.

1.2 Introducción.
Creado por Sun Microsystems.
En cuanto a su nacimiento existen distintas versiones, así que no entremos en ese apartado y mejor escribir en un buscador Historia de Java y quedarse con la que más nos guste.

Es un lenguaje de programación que intenta salvar todos los inconvenientes de C y C++ y que respeta muchas de sus características, lo que facilita un rápido aprendizaje a los que conocen C.

El código escrito en Java cuando se compila crea un 'ejecutable' llamado bytcode, que es independiente de la máquina en la que se va a ejecutar.
Ejecutable entre comillas, porque en realidad ese archivo es necesario que sea interpretado por la máquina virtual correspondiente al Sistema Operativo que está instalado en el ordenador del usuario final.
Esta característica, que hoy incorporan otros lenguajes de programación, convierte a Java en un lenguaje portable.



1.3 Características.
Es un lenguaje orientado a objetos.
Tiene distintos entornos de desarrollo.
El ejecutable es independiente del Sistema Operativo, ya que se ejecuta sobre una máquina virtual que salva dicha situación, por lo que solo es necesario escribir una versión del programa, en lugar de una para cada Sistema Operativo.

No dispone de punteros, de variables globales.

Soporta sincronización de múltiples hilos de ejecución (multithreading), especialmente útiles en la creación de aplicaciones de red distribuidas. Así, mientras un hilo se encarga de la comunicación, otro puede interactuar con el usuario mientras otro presenta una animación en pantalla y otro realiza cálculos.

Permite generar programas y applets, que son pequeños programas que aparecen embebidos en las páginas Web, como aparecen los gráficos o el texto, pero con la capacidad de ejecutar acciones muy complejas, como animar imágenes, establecer conexiones de red, presentar menús y cuadros de diálogo para luego emprender acciones.

1.4 Advertencias.
La principal advertencia, es un lenguaje de programación en el que no es lo mismo “Class” que “class” - la C mayúscula-, por lo que a partir de aquí, ya podemos darnos por enterados, de la exquisita precaución que hay que tener a la hora de escribir el programa.

Además debido al editor de textos, hay que tener presente, que si algún ejemplo no funciona correctamente, buscar la posibilidad de que alguna variable o instrucción tenga su primera letra cambiada a mayúsculas de forma accidental, por parte del presente editor de textos.
Java es un lenguaje de programación que toma muchas de sus peculiaridades de C.

1.5 Entornos utilizados.
En ésta documentación se ha utilizado los entornos de programación de Netbeans, pero se podría utilizar también Eclipse.

Podeis descargar el IDE Netbeans con todo lo necesario desde Aquí.

1.6 El entorno de programación NetBeans.
La labor de programación es una tarea más, como otro de los trabajos que hay en la vida, el problema es cuando el trabajo se hace a gusto o no.
Por lo tanto a la hora de realizar cualquier trabajo hay que intentar disponer de las mejores situaciones posibles.

Para programar, disponer de un entorno de programación potente es importante, dado que te facilita en buena medida la labor.

NetBeans es un editor de texto, pero claro, un editor de texto para escribir programas en Java.
Por lo tanto está preparado para facilitar toda una serie de tareas del día a día en la escritura de un programa.

Depuración. Organización. Ayudas Corrector sintáctico Compilación.

El entorno en si es muy amplio, y explicarlo en su totalidad no es el motivo de ésta documentación, vamos a abordar solamente la parte que nos interesa para ésta fase de iniciación en éste lenguaje.



1.7 Descarga.
Para poder utilizar NetBeans previamente hay que instalar el entorno del lenguaje Java, y posteriormente NetBeans.
Los ejemplos que se muestran en ésta guía están realizados con la versión de Java y de NetBeans que se muestran a continuación.

Cita:

Product Version: NetBeans IDE 6.0 (Build 200711261600) Java: 1.6.0_04; Java HotSpot(TM) Client VM 10.0-b19

Por lo tanto hay que descargar ambos productos desde la página de Sun y realizar la instalación, primero de Java y después de NetBeans.
Los archivos a descargar son:

Cita:

netbeans-6.0-javase-windows.exe, para NetBeans y jdk-6u4-windows-i586-p.exe para Java.

O bien la versión existente en el momento de realizarla.

1.8 Iniciar NetBeans.
Finalizada la descarga y la instalación, podemos empezar nuestro primer proyecto en Java.

En el escritorio de Windows dispondremos de un icono, con el nombre que hayamos gustado ponerle, pero similar al que vemos, como siempre, hacemos doble clic en el mismo e iniciaremos la suite de programación.

El inicio de NetBeans da lugar a la siguiente ventana, o a la
carga del último proyecto con el que estábamos trabajando.



1.9 Crear un nuevo proyecto.
Para iniciar un proyecto nuevo seleccionaremos la opción File -> new project, de la barra de herramientas.



En ese momento se pone en marcha un asistente, como no, y nos pedirá el tipo de proyecto que deseamos crear.
Para los ejemplos que vamos a ir viendo seleccionaremos la opción que vemos en la imagen, Java -> Java Application.



En el siguiente paso nos pedirá el nombre del proyecto, y su ubicación será la que él tiene por defecto, podemos dejarla o bien crear la nuestra propia.
Hay que tener presente que cada proyecto de Java se ubica en un directorio, donde estarán todos los archivos que se creen para dicho proyecto.

Al pulsar Finish, una vez facilitado el nombre del proyecto, NetBeans, nos crea la estructura básica del proyecto que hemos seleccionado, y ya podemos empezar a escribir nuestro primer programa.



Lo que sigue es lo que nos veremos cuando el asistente haya finalizado su tarea:

Código:

1. /*
2. * To change this template, choose Tools | Templates
3. * and open the template in the editor.
4. */
5. package primerprograma;
6. /**
7. *
8. * @author
9. */
10. public class Main {
11.    /**
12.    * @param args the command line arguments
13.    */
14.    public static void main(String[] args) {
15.    // TODO code application logic here
16.    }
17. }

En éste punto podríamos añadir unas líneas de código: 

Código:

1. int dato1, dato2, resultado;
2. dato1 = 20;
3. dato2 = 10;
4. resultado = dato1 + dato2;
5. System.out.println("dato1 + dato2 = " + resultado);

Por lo que nuestro programa quedaría: 

Código:

1. package primerprograma;
2.   public class Main
3.   {
4.     public static void main(String[] args)
5.   {
6.     int dato1, dato2, resultado;
7.     dato1 = 20;
8.     dato2 = 10;
9.     resultado = dato1 + dato2;
10.     System.out.println("dato1 + dato2 = " + resultado);
11.   }
12. }

Como se puede observar, la llave de inicio en éste ejemplo se ha desplazado a la siguiente línea al inicio del código, en la documentación de Java suele encontrarse como la deja el asistente, manías, gustos, lo que queramos, pero funciona igual y es una forma de enfocar la escritura de un programa.

Los ejemplos que aquí pongamos estarán todos bajo esa estructura, que cada cual decida como más le guste hacerlo.

1.10 Estructura de un programa Java.
Independientemente del lenguaje que utilicemos para programar, todos los programas tienen un punto de inicio, una fase de ejecución y una finalización.
En Java la fase de inicio es el denominado Main del programa, desde donde empieza la ejecución del mismo, siguiendo las instrucciones que en él hayamos escrito.

Código: package primerprograma;   public class Main {     public static void main(String[] args)     {       int dato1, dato2, resultado;       dato1 = 20;       dato2 = 10;       resultado = dato1 + dato2;       System.out.println("dato1 + dato2 = " + resultado);   } }

Comentemos las líneas de nuestro ejemplo:

Código:

1. package primerprograma;

Es el nombre del proyecto que hemos creado, en el proyecto se engloban todos los programas y clases que utilicemos en el mismo.

Código:

1. public class Main {

La clase principal de nuestro proyecto, o punto de inicio de nuestro programa.
Observemos que se abre una llave al final.

Código:

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

La inicialización de la clase con la posibilidad de recibir argumentos como parámetros de inicio.
Observemos que se abre una llave al final, y van dos.

Y si observamos el final del ejemplo veremos otras dos llaves que cierran, todo lo que hay entre ambas es nuestro programa, definición de objetos, variables y llamadas a procedimientos,

Código:

1.   }
2. }

que en nuestro caso es lo siguiente:

Código:

1. int dato1, dato2, resultado;
2. dato1 = 20;
3. dato2 = 10;
4. resultado = dato1 + dato2;
5. System.out.println("dato1 + dato2 = " + resultado);

1.11 Ejecutar el programa.
Para ejecutar el programa solo tenemos que pulsar el icono que tenemos en la barra de herramientas.
Si lo ejecutamos veremos éste resultado:

init: deps-jar: Created dir: C:\Java\Ejemplos\PrimerPrograma\build\classes Compiling 1 source file to C:\Java\Ejemplos\PrimerPrograma\build\classes compile: run: dato1 + dato2 = 30 BUILD SUCCESSFUL (total time: 4 seconds)

Que podremos ver en la ventana de salida de datos, que emerge de forma automática en la ejecución del programa.



Dicha ventana podemos consultarla pulsando sobre su icono en el angulo inferior izquierdo de la ventana de NetBeans.



1.12 Ventanas de NetBeans.
Si observamos el lateral de la ventana de escritura, veremos unas pestañas con las siguientes denominaciones:

Projects Navigator Files Services

El contenido de la ventana Projects es el de los proyectos que tengamos abiertos en ese momento.

En el ejemplo vemos como hay abiertos dos proyectos, Clases y PrimerPrograma.



Podemos alternar de esa forma entre uno y otro sin necesidad de abrir y cerrar proyectos.

La ventana Navigator, nos permitirá acceder con rapidez a los distintos componentes de la clase que en ese momento tengamos abierta en la ventana principal, tanto métodos, como procedimientos, funciones y variables públicas y privadas del componente en cuestión.

La ventana Files, contiene la estructura de archivos que hay en el directorio de nuestro proyecto.
La ventana Services la veremos más adelante.

1.13 Añadir una clase.
En la opción file de la barra de herramientas seleccionamos la opción new file, eso provoca que se active el asistente y que aparezca la ventana:

En esta ventana seleccionamos el tipo de archivo que deseamos añadir, que en éste caso es un archivo de clase de Java.



Podemos observar que tenemos un amplio espectro de posibilidades de archivos para añadir.

Pulsamos siguiente, next, y facilitamos el nombre que deseamos que tenga la clase que queremos crear.

En el ejemplo le hemos dado el nombre de ClaseNueva.



Una vez realizado ese paso ya podemos pulsar finalizar, finís, y el asistente nos crea el esqueleto mínimo de la clase que deseamos escribir.

El resultado de la ejecución del asistente es el que podemos ver a continuación:

Código:

1. /*
2. * To change this template, choose Tools | Templates
3. * and open the template in the editor.
4. */
5. package primerprograma;
6. /**
7. *
8. * @author
9. */
10. public class ClaseNueva {
11. }

Ahora solo nos quedaría escribir el contenido de la misma y utilizarla en nuestra aplicación.

Si nos colocamos en la ventana de proyecto, projects, y desplegamos el contenido de:

PrimerPrograma -> Source Packages -> primerprograma

Y seleccionamos 'primerprograma' al pulsar en el botón derecho del ratón, aparecerá una ventana en la que una de las opciones es new, al seleccionar esa opción, aparecerá la posibilidad de elegir un archivo de entre varios tipos, que son los mismos que nos aparecen en la opción anterior, al seleccionar Java Class, nos aparecerá la segunda de las ventanas anteriores para que indiquemos el nombre de la clase, y obtendremos el mismo resultado.

Y si deseamos que la clase esté en el mismo archivo que el Main, solo hemos de añadir en el Main:

Código:

1. public class Nueva
2. {
3. }

Quedando él fuente como sigue:

Código:

1. package primerprograma;
2. public class Main
3. {
4.    public class Nueva
5.     {
6.     }
7.    public static void main(String[] args)
8.     {
9.       int dato1, dato2, resultado;
10.       dato1 = 20;
11.       dato2 = 10;
12.       resultado = dato1 + dato2;
13.       System.out.println("dato1 + dato2 = " + resultado);
14.      }
15. }

Y para que la clase haga algo, le añadiremos un poco de código:

Código:

1. public class Nueva
2. {
3.   private double dat1 = 1000;
4.   private double dat2 = 2000;
5.   private double resultado;
6. // Constructor de la clase
7.   public Nueva()
8.    {
9.    }
10.   public void Dato1(double dato )
11.   {
12.     dat1 = dato;
13.    } // fin del metodo
14.   public void Dato2(double dato )
15.    {
16.      dat2 = dato;
17.     } // fin del metodo
18.   public double Sumar()
19.    {
20.      resultado = dat1 + dat2;
21.      return resultado;
22.    }  // fin del método
23. } // fin de la clase

Y el Main podría quedar:

Código:

1. public static void main(String[] args)
2.  {
3.    ClaseNueva Objeto = new ClaseNueva();
4.    Objeto.Dato1(35);
5.    Objeto.Dato2(45);
6.    System.out.println(Objeto.Sumar());
7.  }
8. }

Que al ejecutarla daría:

compile: run: 80.0

La adición en el bloque Main ha sido posible porque lo hemos hecho dentro del Main, si lo hacemos antes de:

Código:

1. public class Main
2. {

Entonces nos obligaría a hacerlo en un archivo con el nombre de la clase.

1.14 Renombrar una clase.
Para cambiar el nombre de una clase podemos colocarnos en la ventana projects y teniendo seleccionada la clase a la que deseemos cambiar el nombre, pulsamos el botón derecho del ratón y seleccionamos la opción refactor



Al seleccionar esa opción nos aparece una segunda ventana donde poder seleccionar la opción rename.

Esa opción busca la aparición en el proyecto de dicha clase y realiza el cambio en las líneas donde aparece.

Se puede acceder a través de la opción refactor en la barra de menú.

1.15 Eliminar una clase del proyecto.
Si deseamos eliminar una clase del proyecto, podemos colocarnos en la ventana projects y teniendo seleccionada la clase que deseamos borrar pulsamos el botón derecho del ratón y seleccionamos la opción delete.

En caso de borrado accidental, existe la posibilidad en el mismo menú, de deshacer la acción, dentro de la opción refactor.

El borrado solo se hace del proyecto, no del disco.
Se puede acceder a través de la opción refactor en la barra de menú.



1.16 Establecer proyecto principal.
Cuando tenemos varios proyectos abiertos, puede interesarnos cambiar de uno a otro proyecto como principal, sin necesidad de cerrar, para ello en la opción file -> set main Project, nos permitirá establecer el proyecto actual, de entre los abiertos en ese momento.


1.17 Vídeo de refuerzo.
Por último dejamos un vídeo de refuerzo por si algún concepto no ha quedado claro.

                                   


Autor del curso: Casiopea