INSTALAR ECLIPSE Y MI PRIMER PROGRAMA




Para empezar en el mundo de Java lo primero que debemos de instalar es eclipse, para poder escribir y probar el código que escribamos.


Para ello tenemos que ir a la página oficial de Eclipse, es totalmente gratuito y la verdad
es que no va nada mal.


Nos descargamos la versión que esté en .zip y una vez descargada lo único que tenemos quehacer es descomprimirla donde nosotros queramos y ya la tenemos totalmente funcional.


La primera vez que ejectuamos eclipse nos va a preguntar cual va a ser nuestro espacio de
trabajo por defecto (workspace), que, por defecto es C:/Users/Workspace.


Podemos decirle otra ruta, o dejar esa, y si queremos que no lo vuelva a preguntar más
tan solo tenemos que desactivar la casilla que viene más abajo.




Una vez dentro de eclipse, se puede ver que tenemos el Navegador de proyectos a la izquierdal os distintos menús arriba y a la derecha tenemos las clases que vamos usando (yo siempre lo quito) y arriba a la derecha nos saldrá en que lenguaje o plataforma estamos trabajando actualmente (Java, JavaEE, JSP, Android, etc...)






ABRIENDO UN NUEVO PROYECTO.


Para abrir un nuevo proyecto tenemos que ir a Archivo / Nuevo / Java proyect  --


File / New / Proyecto Java




Le ponemos el Nombre HolaMundo al proyecto y luego a terminar, Finish.

Creando nuestro primer proyecto.

Ahora a la izquierda en nuestro navegador tendremos HolaMundo, si lo desplegamos podremos
ver que tenemos dos carpetas


SRC- Source, donde tendremos todos los paquetes, clases y elementos o archivos indispensables
para poder funcionar nuestro proyect.


JRE SYSTEM LIBRARY - Librerias jar por defecto para usar en nuestro proyecto.




CREANDO NUESTRA PRIMERA CLASE.


Ahora vamos a escribir nuestro primer código, pero va a ser solamente mostrar por consola
el típico primer programa que usamos todos los informáticos o cuando probamos nuestro
primer programa. Es sencillo pero sirve para ver si funciona.


Nos vamos a SRC, le hacemos click derecho y nueva clase. Vamos a crear la clase Principal
como main y en el paquete principal.


Para ello lo indicamos como en la siguiente imagen

Primera configuración de nuestro proyecto.

Ahora hacemos doble click sobre nuestra recién creada clase Principal (Main). Doble click.


Podemos ver que nos crea el encabezado y el constructor como main con un Array de String
como argumento del mismo.


Los comentarios generados se pueden borrar.


Ahora para escribir Hola Mundo tan solo tendremos que escribir entre las llaves del constructor
(public static void main(String[] args)) un System.out.println("Hola Mundo");




Pulsamos sobre el botón Play y seleccionamos Aplicacion Java si nos lo preguntase.


Ya ejecutamos el programa y nos saldrá un mensaje en la Consola de Hola Mundo.



Si queremos mostrarlo como una ventana emergente escribiremos en vez de System.out.println lo siguiente JOptionPane.showMessageDialog(null, "Hola Mundo");

Hola Mundo en 

Recordad que cada vez que ejectemos el programa tendremos que darle al botón Parar
Rectangulo rojo y luego al doble aspa. Si no lo hacemos cuando ejecutemos el programa o
varios programas 40 veces por ejemplo, tendremos en ejecución 40 programas, lo que puede
hacer casi seguro ralentizarnos incluso dejarnos el pc colgado.


EXPORTAR NUESTRO PROYECTO A UN EJECUTABLE JAR


Por último si queremos que nuestro proyecto se pueda ejecutar en cualquier otra máquina
que disponga de la máquina virtual de java instalada tendremos que hacer lo siguiente:


File / Export / Java /Runnable JAR File


Le damos a siguiente y luego indicamos el nombre del proyecto (En nuestro caso HolaMundo).
Luego la ruta donde vamos a generar nuestro fichero .jar.

Exportar proyecto a un archivo JAR

Ya tendremos en la ruta dicha el archivo .jar, podremos ejecutarlo como si de un programa
normal se tratase (Doble click).


¡¡CUIDADO!!


Si estamos en eclipse bajo cualquier distro de Linux (Ubuntu, Fedora, OpenSuse...) nos
creará un archivo .jar igualmente como en Windows o Mac, pero luego tendremos que aplicarle
los permisos de ejecución desde consola o desde las propiedades del archivo.


DESDE LAS PROPIEDADES DEL ARCHIVO .JAR.


Simplemente hacemos click derecho sobre el fichero .jar y luego en propiedades. Le damos a
la pestaña permisos y activamos los permisos de ejecución.


EN CONSOLA


Nos vamos a la ruta donde está el fichero .jar y luego simplemente le añadimos los permisos de ejecución:


$ chmod +x fichero.jar


Si no estamos en la ruta como siempre


$ chmod +x Ruta_del_fichero/fichero.jar




Si queremos darle todos los permisos es simplemente poner chmod 777, ¡ojo con esto!


Espero que os haya servido de ayuda y si tenéis cualquier duda escribirme cualquier duda
o comentario.


Un saludo.

Ventana con imagen de Fondo

Buenas a todos.

Con esta entrada os quiero a enseñar a crear una simple ventana que contendrá un fondo que será una imagen, la que nosotros queramos.

Para este caso vamos a usar las siguientes clases:

Principal()
Ventana()
FondoVentana()

Las tres clases las vamos a poner en el mismo paquete, el paquete por defecto.

Empezamos por Principal:


Principal tendrá que llamar a Ventana, crearla, decirle que se haga visible y en este caso he puesto que cuando cerremos dicha ventana
se cierre todo el proceso del JFRAME.

El código sería el siguiente:


import javax.swing.JFrame;

public class Principal {

public static void main(String[] args) {

Ventana v = new Ventana();
v.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
v.setVisible(true);
}

}


Seguro que nos va a saltar varios errores, el primero de ellos puede ser que no hayáis importado swing.JFrame. El otro y más claro va a ser que no
podemos instanciar o crear Ventana, puesto que todavía no la hemos creado.

Ahora vamos con Ventana.

Para usar las propiedades de una Ventana, poder crearla, etc.., en Java necesitamos crear una clase que herede de JFrame. Tenemos que indicarle un
tamaño, un título (opcional), también podemos indicarle pero ya es también opcional si queremos bordes, si el usuario puede maximizar o minimizar, etc...
pero no voy a profundizar mucho más puesto que si estamos en una clase que hereda de JFRAME con poner this. saldrá todas las propiedades, funciones, procedimientos
y argumentos que puede admitir JFRAME.

El código sería algo así:


import javax.swing.JFrame;

public class Ventana extends JFrame {

private FondoVentana fondo;

public Ventana(){

this.setLayout(null);
this.setTitle("Mi ventana de entrada");
this.setBounds(40,40,600,400);
//quitar marcos (adornos)
//this.setUndecorated(true);


//pone la ventana en el centro
this.setLocationRelativeTo(null);

fondo = new FondoVentana();
this.add(fondo);

}
}


Simplemente heredamos de JFRAME, le indicamos que el layout se nulo, un título, un tamaño, lo centramos y luego le añadimos el fondo que todavía no hemos
creado.

Decir que con setBounds siempre los valores son para posicionar en X, Y y luego para Anchura, Altura. En nuestro caso da igual poner 40,40 como coordenadas
X.Y ya que luego aplicamos el setLocationRelativeTo(null) que nos crentrará la ventana sin preocuparnos de saber la resolución de nuestra pantalla.


Ahora vamos con el tercer paquete, pero antes vamos a nuestro Proyecto y creamos la carpeta Imagenes en nuestro proyecto. Buscamos una imagen para nuestro
fondo, lo suyo sería que tuviera las mismas proporciones que la ventana (600x400 pixeles) para que encaje bien, aunque si es mayor no pasa nada, cubrirá
solo la parte que pueda.

Ahora vamos con FondoVentana().

FondoVentana será un JDesktopPane. Es decir un panel de escritorio, o lo que es más conocido para nosotros un papel tapiz. Lo único que haremos en esta clase
es heredar de JDestopPane y cargar una imagen que estará en "/imagenes/nombrefondo.extension"


Vamos con su código:


import java.awt.Graphics;
import java.awt.Image;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JDesktopPane;

public class FondoVentana extends JDesktopPane {

private Image imagen;

public FondoVentana() {

this.setLayout(null);
this.setToolTipText("Ventana Principal");
this.setBounds(0, 0, 600, 400);

try {
imagen=ImageIO.read(getClass().getResource("/imagenes/fondoppal.png"));
}
 catch (IOException e) {
e.printStackTrace();
}

}

public void paintComponent(Graphics g){

super.paintComponent(g);
g.drawImage(imagen, 0, 0, getWidth(), getHeight(), this);
setOpaque(false);
}

}


Con esto ya tendremos nuestra Ventana lista con un fondo.

Espero que os haya servido de ayuda.

Un saludo.