Últimas entradas del blog

Java Medio 3: Clases abstractas

2012-10-28 - Categorías: Java

Continuando con la herencia y polimorfismo de las clases vamos a ver qué son los métodos y clases abstractas. Cuando una clase va a ser la base para otras, pero no van a codificarse las funciones que tiene, sino que se van a hacer en las clases que la extienden, entonces declaramos la clase como abstract.

Vamos a ver con un ejemplo cómo se usa, es muy sencillo:

package javaMedio;

public class JavaMedio3Abstract {
public static void main(String[] args) {
claseBase objeto1, objeto2;

// ésto no lo podemos hacer porque es abstract
// objeto1 = new claseBase();
objeto1 = new claseA();
objeto2 = new claseB();

objeto1.cadena = «cadena del objeto1»;
objeto2.cadena = «cadena del objeto2»;

objeto1.escribir();
objeto2.escribir();
}
}

abstract class claseBase {
public byte x, y;
public String cadena;

public abstract void escribir();
}


class claseA extends claseBase {
public void escribir() {
System.out.println(«Esto es un objeto de la claseA: » + cadena);
}
}

class claseB extends claseBase {
public void escribir() {
System.out.println(«Esto es un objeto de la claseB: » + cadena);
}
}

Como vemos, no podemos reservar memoria para un objeto de tipo claseBase, porque éste tipo de objeto es base de otros, es decir, que al ser abstract sólo se puede usar para construir a partir de ellos otros.

¿Sencillo verdad? No tiene más complicaciones el tipo abstract.

Queda decir que la salida del programa anterior es:

Esto es un objeto de la claseA: cadena del objeto1
Esto es un objeto de la claseB: cadena del objeto2

Un saludo


Java Medio 2: Extendiendo clases a partir de otras clases

2012-10-27 - Categorías: Java


Sábado sabadete, aquí va otro tutorialete… xD para los que esten siguiendo estos minitutoriales para aprender a programar en Java, vamos a continuar con los conocimientos indispensables antes de empezar a hacer programas más o menos grandes. O si ya te has enfrascado con alguno y necesitas saber ésto de los extends espero que aclare las cosas.

Ésta vez voy a explicar cómo reutilizar código, para no tener que hacer una y otra vez lo mismo o para mantener el código bien organizado utilizando la herencia y polimorfismo.

Vamos a ver cómo crear clases reutilizando el código de clases ya creadas, de manera que podremos ampliar su uso añadiendo nuevas funciones o miembros de la clase, o podremos modificar los existentes. Todo ésto se hace con la palabra reservada extends.

A saber, al utilizar extends, la clase que extiende a otra hereda todas las variables y funciones de la otra. A ésto se le llama herencia. Y por otro lado, en la clase que ha heredado, por ejemplo una función, podemos volver a declararla en la clase que extiende, de manera que haga otra cosa. A ésto otro se le llama polimorfismo.

Ésto es todo lo que hay que saber, ahora lo vamos a ver todo de una vez con un ejemplo sencillo que incluya todo ésto que hemos visto. Al grano:

package javaMedio;

public class JavaMedio2Extends {

public static void main(String[] args) {

Circulo ci = new Circulo();
ci.coordenadaX = 0;
ci.coordenadaY = 1;
ci.color = «verde»;
  ci.radio = 2;

Cuadrado cu = new Cuadrado();
cu.coordenadaX = 2;
cu.coordenadaY = 3;
cu.color = «rojo»;
  cu.lado = 2;

ci.escribir();
cu.escribir();

}

}

class Objeto {
byte coordenadaX, coordenadaY;
String color;

public void escribir() {
System.out.println(«(» + coordenadaX + «, » + coordenadaY + «) «
+ color);
}
}

class Circulo extends Objeto {
int radio;
}

class Cuadrado extends Objeto {
int lado;

public void escribir() {
System.out.println(«Esto es un cuadrado de color » + color);
}
}

Éste programilla nos va a dar de resultado:

(0, 1) verde
Esto es un cuadrado de color rojo

Vamos a ver ahora el porqué por ejemplo podemos escribir ci.escribir(); si la clase Circulo no tiene una función escribir(). En el main hemos declarado la variable ci de tipo Circulo:

Circulo ci = new Circulo();


… y en la clase Circulo tenemos:

class Circulo extends Objeto {
int radio;
}

… notad que sólo hay una variable llamada radio, y en el main estamos utilizando la siguiente instrucción:

ci.escribir();

… y no nos da error. Esto es porque Circulo extiende la clase Objeto y la clase Objeto SÍ que tiene la función escribir():

class Objeto {
byte coordenadaX, coordenadaY;
String color;

public void escribir() {
System.out.println(«(» + coordenadaX + «, » + coordenadaY + «) «
+ color);
}
}

Podemos ver que la clase Circulo ha heredado la función escribir(), de igual manera del resto de variables coordenadaX, coordenadaY y color. Estan declaradas en la clase Objeto pero se usan con la variable ci que es de tipo Circulo:

  ci.coordenadaX = 0;
  ci.coordenadaY = 1;
ci.color = «verde»;

ci.escribir();

Círculo ha heredado todo de la clase Objeto y le ha añadido la variable radio. Sin embargo Cuadrado he heredado también pero en vez de tener radio, lo que tienes es lado.

Ahora vamos con el polimorfismo, que en ejemplo lo tenemos con el Cuadrado. Ya tenemos una función escribir() en la clase Objeto, al declarar Cuadrado que hereda de Objeto tendrá la función escribir() ya de por sí, pero al haberla declarado dentro de Cuadrado y haber hecho que haga algo diferente entonces está ocurriendo el llamado polimorfismo. Poli-morfismo, que significa varias formas, viene a decir que el Cuadrado y Circulo, aunque los dos sean Objetos tienen distinta forma porque la función escribir funciona  de diferente manera. Por ésto cuando en el main pusimos:

  ci.escribir();
cu.escribir();


Nos escribe cosas diferentes, porque el Circulo utiliza la función escribir() de Objeto, mientras que Cuadrado utiliza la suya propia que se ha reprogramado:

(0, 1) verde <- resultado de ci.escribir();
Esto es un cuadrado de color rojo <- resultado de cu.escribir();

Ya a partir de aquí hay que seguir con las interfaces, las clases abstractas y otras cosas más, pero no es objetivo de éste post. Tal vez más adelante en otro.

Espero que sirva para aprender si eres nuevo, o te haya aclarado algo si estas refrescando la memoria.

Un servidor se va a ver una peli…
Saludos


Java Medio 1: Clases y paquetes, organización en ficheros

2012-10-25 - Categorías: Java

Vamos a ver cómo organizar los programas Java, en clases u objetos como prefiramos llamarlos. Cómo dividir los códigos fuentes en distintos ficheros o cómo plantearse la creación de un programa bien grande estructurándolo para poder hacerlo poco a poco, repartiendo el trabajo o haciéndolo en partes más simples.

Todo son clases en Java, y estas clases se organizan packetes, llamados packages en inglés. Podemos crear clases a partir de otras clases utilizando el extends. Y cada clase la podemos separar individualmente en cada fichero. Por otro lado los paquetes de clases los podemos importar para usarlos en una clase mediante la instrucción import. Resumiendo ésto es todo, a continuación lo veremos explicado.


Cada fichero se debe nombrar con el nombre de la clase principal. Un ejemplo que nos va a servir para comprender varios conceptos es el siguiente:


package javaMedio;

import java.util.Date;

public class JavaMedio1ClasesPaquetes {

public static void main(String[] args) {
Persona p = new Persona();
p.nombre = «Pepito»;
p.escribir();
}

}

class Persona {
String nombre = new String();
Date fechaCreacion = new Date();

public void escribir() {
String aux = new String();
aux = «Objeto de tipo Persona con nombre: » + nombre + «n» 
+ «Creado en fecha: » + fechaCreacion;
System.out.println(aux);
}
}

Éste programa de aquí arriba debemos guardarlo en un fichero llamado JavaMedio1ClasesPaquetes.java para que funcione y no nos de error. Para empezar escribimos el paquete al que pertenece una clase mediante una línea como la que sigue:

package JavaMedio;

Podemos tener muchas clases dentro del paquete JavaMedio, y si queremos usar todas las clases del paquete en una nueva clase deberemos importar el paquete mediante la instrucción import. En el ejemplo, a continuación, vemos que se ha importado la clase fecha (Date en inglés), que está dentro del paquete de utilidades que proporciona Java de la siguiente manera:

import java.util.Date;

Si queremos importar todas las utilidades de Java, lo haríamos de la forma siguiente:

import java.util.*;

A continuación se declara la clase principal con la función main principal, porque es una aplicación de consola, es decir, se ejecuta en línea de comandos:


public class JavaMedio1ClasesPaquetes {

public static void main(String[] args) {
Persona p = new Persona();
p.nombre = «Pepito»;
p.escribir();
}

}

Podemos leer la clase JavaMedio1ClasesPaquetes es una clase pública, es así porque tiene el main. Y dentro del main tenemos que se declara la variable p de tipo Persona, se reserva memoria, se le pone el nombre Pepito y a continuación se llama a la función escribir() de la clase Persona.

Hay varios tipos de clases que son: abstract, final, public y synchronizable. Abstract son clases que se usan para hacer otras con ellas. Final son clases con las que no se pueden hacer otras a partir de ellas. Las public son las normales. Y las synchronizable son clases que no se pueden usar en paralelo desde dos hilos de ejecución distintos. Para más información sobre las clases de tipo synchronizable acudir a la programación multihilos de Java.

En la declaración de la clase Persona podemos ver que no es una clase pública, esto se hace así porque la he puesto dentro del mismo fichero, y no debe haber más que una clase pública en cada fichero. Vamos a analizar el código de la clase:


class Persona {
String nombre = new String();
Date fechaCreacion = new Date();

public void escribir() {
String aux = new String();
aux = «Objeto de tipo Persona con nombre: » + nombre + «n» 
+ «Creado en fecha: » + fechaCreacion;
System.out.println(aux);
}
}

Vemos que la clase Persona tiene dos variables: nombre y fechaCreacion. Y tiene una función pública: escribir(). La función lo que hace es escribir las variables internas de Persona. La variable nombre podemos acceder a ella desde fuera, es decir, es pública, como podemos observar en el main:

p.nombre = «Pepito»;

Ésta instrucción nos lo permite. Siempre que una variable no se le ponga el tipo de control de acceso permitido, se supone pública. Podríamos haber escrito mejor en la clase Persona:


class Persona {
public String nombre = new String();
public Date fechaCreacion = new Date();

Así estaría más claro el nivel de acceso desde fuera de la clase.

El control de acceso dentro de una clase se especifica mediante las palabras public, protected y private. Public indica que la variable o función se puede usar desde fuera. Private es lo contrario que public, protected indica que sólo acceder si la clase que accede es del mismo paquete.

Si queremos usar la clase Persona desde otras clases o ficheros deberíamos separar en un fichero la clase, quedaría un fichero llamado Persona.java que tendría lo siguiente:

package javaMedio;

import java.util.Date;

public class Persona {
public String nombre = new String();
public Date fechaCreacion = new Date();

public void escribir() {
String aux = new String();
aux = «Objeto de tipo Persona con nombre: » + nombre + «n»
+ «Creado en fecha: » + fechaCreacion;
System.out.println(aux);
}

}

Entonces el primer fichero llamado JavaMedio1ClasesPaquetes.java quedaría:
package javaMedio;

public class JavaMedio1ClasesPaquetes {

public static void main(String[] args) {
Persona p = new Persona();
p.nombre = «Pepito»;
p.escribir();
}

}

Podemos ver que tanto la clase JavaMedio1ClasesPaquetes como Persona están en el mismo paquete, entonces para usar Persona en el fichero JavaMedio1ClasesPaquetes.java no hace falta usar el import.

Para terminar, saber que algunos de los paquetes principales que proporciona Java son los siguientes para el que quiera continuar investigando:

java.applet Para la creación de Applets.
java.io Para manejo de la entrada y salida.
java.lang Paquete de clases variadas.
java.net Aquí tenemos clases que usan TCP/IP.
java.util Utilidades variadas.
java.awt Para hacer interfaces de usuario con botones, ventanas, etcétera.
java.swing Más compatible con los distintos Sistemas Operativos que la AWT, yo usaría ésta en vez de la AWT porque te aseguras de que tu programa va a funcionar en más plataformas.

Por ahora queda terminado este minitutorial sobre clases y paquetes.
Saludos;}


Cómo hacer una plantilla para Joomla

2012-10-21 - Categorías: General

Hablando sobre la creación de páginas web con CMSs. Podemos llegar a ver que la cantidad de CMSs que hay para poner en marcha una web sin programar nada de código fuente es muy grande. He visto que los principales vienen siendo WordPress, Drupal y Joomla. Y en orden de gente que los usa, Joomla viene ganando, o por lo menos eso es lo que he leido en varias páginas de habla hispana y a fecha de hoy.

Me decidí a aprender Joomla en un principio, pero acabé probando WordPress y Drupal también. El Joomla para el que va éste post es la versión 2.5 y tal vez sirva también para los de la 1.5 y en futuro. Yo de momento la versión que tengo instalada es la 2.5 y es la que he usado para escribir éste tutorial.

Vamos a comenzar por ver la estructura en líneas generales de Joomla, si vamos al directorio, por los nombres podremos hacernos una idea de que la carpeta templates/ (plantillas en castellano) es la carpeta en cuestión que nos interesa.

administrator/
cache/
cli/
components/
images/
includes/
language/
libraries/
logs/
media/
modules/
plugins/
templates/
tmp/
uploads/
configuration.php
favicon.ico
htaccess.txt
index.php
LICENSE.txt
README.txt
robots.txt
web.config.txt

Dentro de la carpeta tenemos las carpetas correspondientes a todas las plantillas que tenga instaladas nuestro Joomla. Podemos editarlas directaremente de aquí, o a través del administrador de Joomla, actualizamos la página y los cambios se verán.

La plantilla ‘atomic’ es una plantilla básica, sin muchas florituras, para que hagamos a partir de ella, la nuestra propia. Pero mirando los archivos que la componen podemos ver que hay demasiado código fuente si es que estas haciendo tu primera plantilla, así que vamos a crear otra más simple todavía y luego le podrás añadir todo lo que quieras.

La plantilla básica ‘atomic’ que proporciona Joomla tiene la siguiente estructura:

css/      <- aquí van las hojas de estilo
html/    <- páginas html peladas
images/     <- imágenes de la plantilla

js/      <- scripts de javascript

language/     <- archivos para las traducciones
component.php   <- para mostrar el contenido de los componentes
error.php    <- página de error
favicon.ico   <- el icono de la web
index.html    <- el index en html
index.php    <- el index en php
template_preview.png    <- vista previa de la plantilla
template_thumbnail.png    <- imagen pequeña de la vista previa
templateDetails.xml      <- descripción de la plantilla, para uso interno

Hay plantillas muy grandes, con muchos añadidos, pero ésta que suponemos básica vamos a reducirla de la manera siguiente. Sólo necesitamos lo siguiente para nuestra nueva plantilla:

css/      
favicon.ico   
index.php   
template_preview.png  
template_thumbnail.png  
templateDetails.xml    

Todo ésto lo creamos en una carpeta nueva, yo la he llamado mynew/ dentro de la carpeta templates/ 
Y dentro de la carpeta css/ vamos a crear un archivo llamado ‘template.css’ para hacer la presentación mediante CSS. No se recomienda poner la estructura de una página web mediante tablas ni directamente formateando el archivo index.php. Ésto es porque no todos los navegadores interpretan exactamente igual las etiquetas HTML, sin embargo mediante CSS tenemos un control mucho mejor, afinando incluso pixel a pixel las posiciones y tamaños de todo. Así que vamos con esto y veremos que simple va a quedar y se va a entender cómo funciona todo.
El archivo index.php de ejemplo que vamos a usar es:
<?php defined( ‘_JEXEC’ ) or die( ‘Restricted access’ );?>
<!DOCTYPE html PUBLIC «-//W3C//DTD XHTML 1.0 Transitional//EN»
  «http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd»>
<html xmlns=»http://www.w3.org/1999/xhtml» 
   xml:lang=»<?php echo $this->language; ?>» lang=»<?php echo $this->language; ?>» >
<head>
<jdoc:include type=»head» />
<link rel=»stylesheet» href=»<?php echo $this->baseurl ?>/templates/mynew/css/template.css» type=»text/css» />
</head>
<body>

<div id=»arriba»><jdoc:include type=»modules» name=»arriba» /></div>
<div id=»izquierda»><jdoc:include type=»modules» name=»izquierda» /></div>
<div id=»derecha»><jdoc:include type=»modules» name=»derecha» /></div>
<div id=»contenido»><jdoc:include type=»component» /></div>
<div id=»abajo»><jdoc:include type=»modules» name=»abajo» /></div>

</body>
</html>
No voy a explicar en éste minitutorial cómo se maqueta con CSS porque es muy extenso. La idea es que hay que poner todo con DIVs y esos DIVs se posicionan en el navegador mediante el archivo CSS que luego veremos.
Si queremos usar un archivo desde el index.php debemos usar la instrucción PHP: <?php echo $this->baseurl ?> como se usa en el ejemplo anterior, por ejemplo, para incluir el archivo template.css
Las posiciones vienen definidas por: <jdoc:include type=»modules» name=»nombrePosicion» /> y podemos poner tantas posiciones como queramos.
La posición principal que va a mostrar el contenido viene definida por: <jdoc:include type=»component» /> que sólo la vamos a poner una vez.
Ahora nos queda hacer el CSS y el templateDetails.xml. El favicon.ico y los archivos PNG, son imágenes, el favicon es el icono que sale en el navegador cuando alguien nos visita en la página, y los archivos PNG son los vistas previas, en grande y pequeño, que muestra Joomla dentro del gestor de plantillas. Así que seguimos con el CSS (hoja de estilo para los amigos) llamado ‘template.css‘, por ejemplo ponemos:
#arriba {
  position: fixed;
  left: 0px;
  top: 0px;
  width: 100%;
  height: 30px;
  background-color: blue;
}
#izquierda {
  position: fixed;
  left: 0px;
  top: 30px;
  width: 100px;
  height: 100%;
  background-color: green;
}
#derecha {
  position: fixed;
  right: 0px;
  top: 30px;
  width: 100px;
  height: 100%;
  background-color: red;
}
#contenido {
  margin: 40px 110px 40px 110px;
  background-color: grey;
}
#abajo{
  position: fixed;
  left: 0px;
  bottom: 0px;
  width: 100%;
  height: 30px;
  background-color: blue;
}
El archivo templateDetails.xml es el archivo que define todo lo que necesita Joomla para poner las cosas en las posiciones en concreto y los contenidos. Un ejemplo para mi plantilla que he hecho llamada ‘mynew’ es:
<?xml version=»1.0″ encoding=»utf-8″?>
<extension version=»1.6″ type=»template»>
<name>mynew</name>
<creationDate>2012-10-21</creationDate>
<author>Yo mismo</author>
<authorEmail>Aquí v@ tu email .com</authorEmail>
<authorUrl>http://elblogdejnj.blogspot.com</authorUrl>
<copyright>http://elblogdejnj.blogspot.com 2012</copyright>
<license>GNU/GPL</license>
<version>1.0.0</version>
<description>My New</description>
<files>
<filename>index.php</filename>
<filename>templateDetails.xml</filename>
<filename>favicon.ico</filename>
<filename>template_preview.png</filename>
<filename>template_thumbnail.png</filename>
<folder>css</folder>
</files>
<positions>
<position>arriba</position>
<position>izquierda</position>
<position>derecha</position>
<position>abajo</position>
<position>contenido</position>
</positions>
</extension>

Llegado éste punto, acabamos de crear la nueva carpeta dentro de templates/ y hemos puesto todos estos archivos. Ahora resulta que tal cual Joomla no ve la plantilla dentro del administrador de plantillas. Podemos ir al Gestor de Extensiones y darle a Encontrar, con lo que Joomla buscará todo lo que hayamos puesto manualmente sin usar el instalador de Joomla. Ahora ya veremos la nueva plantilla en el Gestor de Plantillas, la ponemos como plantilla del sitio y nuestro sitio tendrá la apariencia que acabamos de hacer.

Ahora podemos editar éstos archivos directamente, añadirles imágenes, cambiar la hoja de estilos CSS, las posiciones, etc.. y sólo con refrescar la página veremos los cambios.

Otra opción para usar ésta plantilla, es comprimir el directorio donde está, y después instalarlo con el gestor de extensiones. Es decir, en el ejemplo anterior, hemos creado el directorio mynew/ dentro de templates/, comprimimos el directorio mynew/ con todos los archivos que hemos puesto y nos quedará, en éste caso, el archivo mynew.zip con toda la plantilla. Éste archivo comprimido es el que usamos en el gestor de extensiones para instalar la plantilla.

Para terminar, si todo ha ido bien, entonces tenemos que ver algo parecido a lo siguiente en nuestro navegador:

Sólo queda poner en cada posición los módulos que queramos usando Joomla. En las posiciones ahora tendremos: arriba, izquierda, derecha, contenido y abajo; que son los valores que hemos usado en el index.php y hemos puesto también en el ‘templateDetails.xml’. Ahora todo es imaginación y con buena documentación sobre CSS podremos hacer que nuestra página con Joomla tenga una apariencia única, totalmente personalizada, con efectos 3D o cualquier otra cosa que se pueda hacer con HTML, Javascript, CSS, etcétera…

Ésto es todo un mundo, las plantillas, los editores de plantillas, maquetación, etcétera… hay mucha información por Internet. Espero que haya servido.

Un saludo.
Hasta la próxima


Java Básico 6: Matrices y vectores

2012-10-14 - Categorías: Java

Ya estamos a domingo de nuevo, parece que va siendo costumbre los domingos de nuevo escribir un post. Vamos a empezar con un tipo de variables que vamos a usar para almacenar muchos datos de igual naturaleza, es decir, los llamados vectores y matrices. Algunos llaman a los vectores matrices también porque son matrices de una sola fila.

Imaginemos pues que queremos guardar 3 elementos de tipo entero. Para ello usaremos lo siguiente:

package javaBasico;

public class JavaBasico6Matrix {

public static void main(String[] args) {

// declaración de la variable ‘vector’
int vector[];

// se reserva memoria para guardar los 
// valores, es decir, guardamos 3 posiciones
// de memoria de tipo entero
vector = new int[3];

// guardamos en la posición 0 el número 2
vector[0] = 2;

// guardamos…
vector[1] = 3;

// guardamos…
vector[2] = 4;

// escribimos en el out (pantalla) el vector
System.out.println(vector[0] + «, » + vector[1] + «, » + vector[2]);

}

}

En Java siempre los vectores y matrices, también las clases que hagamos primero hay que declararlas y luego se les reserva memoria para poder usarlas. Es decir, la primera parte es decirle al programa que vamos a usar una variable, que le llamamos ‘vector’, y que va a ser un vector de enteros. Lo siguiente es realmente reservar una parte de la memoria del ordenador para guardar esos números enteros.

Internamente el Sistema Operativo se encarga de la reserva de memoria, generalmente es en memoria principal (la RAM o caché). Hay que acordarse, siempre se declara, luego se reserva memoria. La memoria se libera automáticamente porque Java tiene un sistema por el que todas las variables usadas en una clase se borran en memoria cuando la vida de la clase ha terminado.

Los tipos de datos primitivos sólo se declaran y directamente se utilizan sin tener que reservar memoria, ésta es una diferencia básica.

Vamos ahora con las matrices.

Si queremos por ejemplo almacenar valores como hacemos en una hoja de Excel, ordenando por filas y columnas, podemos usar una variable ‘matriz’ de la forma siguiente:


package javaBasico;

public class JavaBasico6Matrix {

public static void main(String[] args) {

// declaración de la variable
int matriz[][];

// se reserva memoria 
matriz = new int[2][2];

// guardamos…
matriz[0][0] = 2;

// guardamos…
matriz[0][1] = 3;

// guardamos…
matriz[1][0] = 4;

// guardamos…
matriz[1][1] = 5;

// escribimos en el out 
System.out.println(matriz[0][0] + «, » + matriz[0][1]);
System.out.println(matriz[1][0] + «, » + matriz[1][1]);

}

}

Es igual que un vector pero ahora tenemos dos coordenadas, donde pone: matriz[a][b]
a y b son las coordenadas.

Hay que fijarse en que en la reserva de memoria se le dice el tamaño o número de posiciones, pero a la hora de usar la variable, comenzamos por la posición 0 como primera posición. Ésto puede llevar a confusión porque la última posición de la matriz por ejemplo, no es matriz[2][2], sino es matriz[1][1], porque hemos empezado por matriz[0][0].

Falta decir que en un vector o en una matriz podemos poner enteros, decimales, o incluso objetos de la clase que queramos, por ejemplo:

package javaBasico;

class Persona {
// ésta es una clase que
// de momento son
String nombre;
int edad;
}

public class JavaBasico6Matrix {

public static void main(String[] args) {

// declaración de la variable 
Persona personas[];

// se reserva memoria 
personas = new Persona[20];

}

}

Podemos ver que con éste código hemos hecho un vector para guardar nombre y edad para 20 personas.
Un saludo

Java Básico 5: Clases comunes

2012-10-07 - Categorías: Java

¡Hola de nuevo! Estoy cogiendo carrerilla con ésto de los tutoriales, me siento fresco, será el buen tiempo, que es fin de semana, los pájaros cantan, el indice Ibex sube, la prima de riesgo baja aquí en España. La cosa no está para echar cohetes pero bueno, si necesitas hacer cosas en Java, que ya están hechas, sólo tendrás que usarlas y entonces sí que vas a hechar cohetes. Vamos a ver unas clases de Java que nos facilitan la vida mucho, sobre todo si estas siguiendo el tutorial desde cero.

Para empezar, si vamos a utilizar cadenas de caracteres, Java nos proporciona la clase String. Podemos declarar variables de tipo String de la forma:

String cadena;
cadena = «Aquí va la cadena de caracteres que queramos»;
cadena = cadena + cadena;
System.out.println(cadena);

Ésto anterior nos va a imprimir:

Aquí va la cadena de caracteres que queramosAquí va la cadena de caracteres que queramos

Lo que hemos visto aquí arriba es que la variable cadena le hemos dicho que almacene «Aquí va la cadena de caracteres que queramos», luego al hacer la suma lo que le hemos dicho que haga es que ahora cadena vale cadena + cadena, es decir, pon dos veces el valor de cadena.

Ahora vamos a leer una cadena desde el teclado, usando las clases BufferedReader, IOException e InputStreamReader:

package javaBasico;

import java.io.BufferedReader;

import java.io.IOException;
import java.io.InputStreamReader;

public class JavaBasico5ClasesComunes {

public static void main(String[] args) throws IOException {

String cadena;

// ésto es un lector de buffer
BufferedReader br = new BufferedReader(new
    InputStreamReader(System.in));
// daclarado de forma que br apunta al System.in
// el System.in es la entrada del sistema, 
// que es el teclado

System.out.print(«Escribe una cadena y pulsa
 enter: «);
cadena = br.readLine();
// con el readLine lo que hace el programa es 
// esperar a que
// escribas algo y aprietes enter, y lo 
// guarda en la variable
// cadena

System.out.println(«Has escrito: » + cadena);

}

}

El código fuente anterior habla por sí sólo, es la manera de leer una cadena desde el teclado, aunque es un poco confuso si eres nuevo en Java pero no te preocupes. Tenemos formas más fáciles de leer datos desde el teclado. Las clases System.in, System.out, y System.err son muy comunes. Por ejemplo el siguiente programa lee valores desde el teclado:

package javaBasico;

import java.io.IOException;

public class JavaBasico5ClasesComunes {


public static void main(String[] args) throws IOException {

char b;

System.out.println(«Escribe una letra y pulsa enter: «);
b = (char) System.in.read();
System.out.println(b);

}

}

Queda saber que el System.err es la salida del sistema para los errores. Normalmente lo que escribamos en el System.err se muestra en la pantalla. Es útil usar la salida de errores porque de ésta manera, más adelante podremos diferenciar entre lo que hemos escrito como error y lo hemos escrito en el out normal. Se supone que los errores a lo mejor queremos guardarlos en un fichero y sólo queremos que se vea en la pantalla lo que escribimos en el out. Un ejemplo de uso de out y del err, aunque ya hemos usado el out varias veces, es muy parecido:

System.out.println(«Ésto es salida normal, para el out»);
System.err.println(«Ésto es un error, para el err»);

Más adelante podremos decirle al programa que haga algo concreto con lo que se escribe en la salida o en error, es lo que se llama redireccionar las salidas estándar o de errores.

No me voy a extender demasiado en éste post, así que como última clase de uso común de Java vamos a ver la clase Math. Si algo que tiene Java, es que es muy muy grande, y seguro que hay algo para lo que quieras. Me remito a la documentación de Java oficial a fecha de hoy:

http://docs.oracle.com/javase/6/docs/api/

… por si deseas entrar más en detalle sobre las clases disponibles.

Podemos observar lo rico que es Java en utilidades que tenemos disponibles, mire la siguiente imagen de mi Eclipse funcionando, programando para éste minitutorial con la clase Math, al escribir el punto se me despliega lo siguiente:

Puedes ver la cantidad de funciones matemáticas que tienes disponibles, ahora es cuando tienes que hechar cohetes 🙂 no tienes que reinventar la rueda volviendo a programar cosas que ya tengas hechas. Recomiendo que antes de sentarse a programar funciones nuevas mire a ver si ya lo tenemos disponible listo para usarlo.

Un ejemplo sencillo de uso de la clase Math es:

package javaBasico;

public class JavaBasico5ClasesComunes {

public static void main(String[] args) {

System.out.println(Math.abs(-23));

}

}

Su resultado va a ser que va a escribir en la pantalla 23, que es el valor absoluto de -23.

Bueno con esto ya tienen para hacer unas pruebas o para seguir investigando por otro lado. Hay gran cantidad de funciones dentro de la clase Math: para hacer raices cuadradas, senos, cosenos, tangentes, logaritmos, máximos, mínimos, redondear… y también una gran cantidad de clases de uso común.

Si hay algo que no exista y necesites, puedes hacer tu propia clase de utilidades con las funciones quieras.
Ya lo veremos a lo mejor en otro tutorial.

Un saludo


Java Básico 4: Funciones

2012-10-07 - Categorías: Java

Hola! hoy es domingo, tengo un rato libre, y he pensado avanzar un poco este curso de programación rápido con las funciones. Vamos a ver en líneas generales cómo dividir el código de nuestro programa para que sea más fácil luego leerlo, para desarrollarlo en partes o poco a poco, en fin, es de buena costumbre usar funciones cuando hacemos tareas que usan mas de unas 20 líneas de código.

Es decir, comenzamos escribiendo código en el ‘main’, y llegado el momento de que nuestro ‘main’ ocupa muchas líneas entonces se convierte en un mamotreto de código que es bien complicado de leer. Para evitar ésto lo dividimos con funciones como por ejemplo puede ser el código siguiente:

public class JavaBasico4Funciones {

public static void main(String[] args) {

PrincipioDelPrograma();

HacerCosa1();
HacerCosa2();
HacerCosa3();

FinalDelPrograma();

}

static void PrincipioDelPrograma(){

}

static void HacerCosa1(){

}

static void HacerCosa2(){

}

static void HacerCosa3(){

}

static void FinalDelPrograma(){

}

}

De ésta manera queda más claro todo y podemos centrarnos en hacer los subprogramas declarados en las funciones. Éste es un ejemplo claro de la técnica de programación ‘Divide y vencerás’.

También puede ocurrir que estamos escribiendo un programa y llegamos a un momento en que nos bloqueamos. Por ejemplo:


// un montón de líneas de código..
// llegamos al momento en que imprimimos el resultado
System.out.println(«El resultado es:»);
System.out.println(…

Ahora aquí deberíamos de imprimir el resultado del programa pero no sabemos cómo calcularlo, nos estan saltando chispas del cerebro, entonces ponemos:

System.out.println(ResultadoDelPrograma());

Y ya más adelante cuando tengamos la mente más fresca lo resolvemos programando la función que acabamos de poner aquí arriba:

static String ResultadoDelPrograma() {
// aquí dentro va el subprograma que calcula el resultado
}

Las funciones pueden recibir variables, y también pueden devolver resultados o escribir en dichas variables. Para crear una función que recibe parámetros podemos verlo claro en el siguiente ejemplo:

static void Sumar(int a, int b) {
int resultado;
resultado = a + b;
System.out.println(a + » + » + b + » = » + resultado);
}

La forma de usar ésta función en el main podría ser:

Sumar(1,2);

Lo que escribirá por pantalla: 1 + 2 = 3

Si queremos devolver un valor con una función podríamos modificar la anterior de la forma:

static int Sumar2(int a, int b) {
int resultado;
resultado = a + b;
return resultado;
}


public static void main(String[] args) {
System.out.println(«El resultado vale » + Sumar2(1,2));
}
Lo que escribirá por pantalla: El resultado vale 3
Debemos fijarnos en la declaración de la función, el tipo de dato primitivo ‘int’ es lo que nos dice qué va a devolver la función.
En líneas generales ésto es lo que necesitamos saber para empezar a programar con funciones. Tenemos muchas formas de usar las funciones, dentro de una clase, también se pueden usar desde fuera si las declaramos como public en vez de static. Se puede extender mucho éste y los otros tutoriales de Java Básico que estoy escribiéndoles pero en un principio creo que es suficiente.
Si eres avanzado en el tema, hay algo mal o te gustaría que ampliara la información déjame un mensaje. También son bien recibidas las sugerencias.
Si aún sigues aquí leyendo es que no te he aburrido, me alegro, yo humildemente espero que te haya servido el post xDD. Un saludo

Java Básico 3: Bucles y estructuras de control

2012-10-06 - Categorías: Java

Sábado por la mañana, hace buena temperatura ahora en otoño, ni frio ni calor en Alicante. Así da gusto. Pues hoy voy a darle vueltas a los bucles y a controlar qué se ejecuta en un pequeño programa en Java.

Vamos a ver los bucles y las estructuras principales que se usan. Éstos son los if, else, switch, while, do while, for, break, continue y el try-catch para control de errores de ejecución.

Vamos al grano, si usamos el siguiente código:

// Paquete donde se organiza ésta clase de Java
package javaBasico;


// Declaración de la clase con su nombre
public class JavaBasico3BuclesEstructuras {

// Entrada principal al programa, el main para los amigos
public static void main(String[] args) {

// Aquí va el código que empieza nada más 
// arrancar el programa
System.out.println(«¡Hola Mundo!»);

// declaro la variable a y le doy valor
byte a = 1; 

// el if sirve para comprobar si ocurre
// una cosa…
if (a == 2) {

// si a vale 2 entonces hace ésto
System.out.println(«a sí vale 2»);

} else {

// si a no vale 2 muestra éste mensaje
System.out.println(«a no vale 2»);

}

// switch sirve para hacer una lista de 
// casos posibles
switch (a) {
case 1: // caso de que a valga 1
System.out.println(«a vale 1»);
break;
case 2: // ..
System.out.println(«a vale 2»);
break;
case 3: // ..
System.out.println(«a vale 3»);
break;
default:
break;
}

a = 0;

// el while repite lo que tenemos entre 
// llaves mientras se cumpla la
// condición
while (a != 10) {
a++;
System.out.println(«a = » + a);
}

// éste bucle es parecido al anterior
// pero comprueba si a > 5 después de ejecutar 
// una vez lo que hay entre llaves
do {
System.out.println(«a ahora vale » + a);
a–;
} while (a > 5);

short b;

// ésta parte del código intenta ejecutarse
// try significa ejecutar
try {

b = 0;
a = (byte) ((byte) 1 / b);

} catch (Exception e) {

// si ocurre algún error en el try
// ejecuta
// lo siguiente
System.out.println(«ERROR: « + e.getMessage());

}

// mensaje de fin de programa…
System.out.println(«Ha terminado el programa…»);
}
}

Nos tiene que dar la siguiente salida:
¡Hola Mundo!
a no vale 2
a vale 1
a = 1
a = 2
a = 3
a = 4
a = 5
a = 6
a = 7
a = 8
a = 9
a = 10
a ahora vale 10
a ahora vale 9
a ahora vale 8
a ahora vale 7
a ahora vale 6
ERROR: / by zero
Ha terminado el programa…

El código está comentado, espero que no sea demasiado de golpe, si estas empezando con ésto de la programación y te complicas mucho no dudes en comentar el post y gustoso lo aclaro.

Éstas son las formas sencillas de estructurar los programas para que hagan tareas cuando se cumplan ciertas condiciones de algunas variables. También se utilizan para tareas repetitivas los bucles. Con ésto y las funciones podremos estructurar nuestros programas de manera dividamos el problema en subproblemas más sencillos de solucionar.

Divide y vencerás

Ésta forma de afrontar los problemas de programación se utiliza mucho.

El try-catch necesita de una especial mención porque es una estructura para controlar los posibles que pueden suceder en un programa y evitar así que se queden colgados, terminen inesperadamente y en definitiva la tarea no se termine. El try-catch tiene muchas opciones pero necesitaría de otro post para ello así que tal vez en un futuro.

Espero que sirva para aclarar algo a los nuevos, o para repasar a los veteranos.
Un saludo


Java Básico 2: Tipos de datos

2012-10-04 - Categorías: Java

En éste post vamos a ver los tipos de datos primitivos, los básicos, sobre los que se construirán datos u objetos más complejos o complicados, valga la redundancia. Los más usuales son:

  • byte, que permite almacenar número de 8 bits, negativos y positivos. Es decir desde el -11111111 al +11111111, o que es lo mismo que desde -128 al +127.
  • short, es igual que el byte pero en vez de 8 bits con signo tenemos 16 bits. Aumentan considerablemente la contidad de números posibles que van desde el -32768 al +32767.
  • int, es igual pero ahora tenemos 32 bits.
  • long, ahora tenemos 64 bits.
  • char, guarda valores del 0 al 65535. Los primeros valores corresponden a los caracteres ASCII, que son los caracteres normales que usamos al escribir, es decir, las letras. Por ejemplo el 97 es la ‘a’
  • float, se utiliza para números decimales. Se utilizan 32 bits, con una precisión aproximada de 7 dígitos.
  • double, es un número decimal. Internamente se usan 64 bits, con lo que se tiene una mayor precisión, aproximadamente de unos 16 dígitos.
  • boolean, se usa para almacenar un valor booleano, es decir, verdadero o falso.
Éstos son los mínimos sobre los que se construyen los demás. Junto con éstos, tenemos un tipo de dato no tan básico, el String o cadena de caracteres, que se usa constantemente para almacenar cadenas de caracteres. Se utilizan de la forma:

// Paquete donde se organiza ésta clase de Java
package javaBasico;

// Declaración de la clase con su nombre
public class JavaBasico2TiposDeDatos {

// Entrada principal al programa, el main para los amigos
public static void main(String[] args) {

// Aquí va el código que empieza nada más 
// arrancar el programa
System.out.println(«Éste es un ejemplo de uso de  los tipos de datos primitivos:»);

byte a=127;
short b=32767;
int c=2147483647;
long d=9223372036854775807L; // necesita la L 
// para especificar que es un long
char e=’a’;
float f=2.3f; // también necesita la f
double g=2.3456789d; // usa la d para doubles
boolean h=true;
String cadena=»Esto es una cadena»;

// A continuación se imprimen los resultados 
// por el out del sistema, salida del sistema
// el n lo que hace es un retorno de carro
System.out.print(«a=» + a +
«nb=» + b +
«nc=» + c +
«nd=» + d +
«ne=» + e +
«nf=» + f +
«ng=» + g +
«nh=» + h +
«ncadena=» + cadena);

}

}

La salida del programilla debe de ser la siguiente:
Éste es un ejemplo de uso de los tipos de datos primitivos:
a=127
b=32767
c=2147483647
d=9223372036854775807
e=a
f=2.3
g=2.3456789
h=true
cadena=Esto es una cadena

Con éstos podemos construir casi todo tipo de programas y son los principalmente utilizados. Normalmente no tiene mucha importancia usar un tipo de dato u otro parecido como por ejemplo un int o un short.

Viene a ser muy importante si vas a trabajar por ejemplo con 20 millones de números o más. Si usas el tipo short, vas a usar 16 bits para cada uno, que vienen a ser 320 millones de bits, que son 40 millones de bytes, que viene a ser 39062,5 kBytes, que viene a ser, que viene a ser, que viene a ser, que vienen a ser alrededor de 38 megas xD Si en vez de un short se te ocurre usar un long, esos 38 megas utilizados para almacenar los números se convertirán en unos 153 megas más o menos.

Un saludo

Java Básico 1: ¡Hola Mundo!

2012-09-30 - Categorías: Java

Aquí dejo la estructura básico de un programa mínimo en Java, el clásico ‘Hola Mundo’. Suponemos que ya estamos familiarizados con nuestro IDE de desarrollo favorito, así que iremos al grano. Creamos una nueva clase, yo la he llamado JavaBasico1HolaMundo, está creada dentro del paquete de código javaBasico, con lo que el fichero del programa se llama JavaBasico1HolaMundo.java y su contenido es el siguiente:

// Paquete donde se organiza ésta clase de Java
package javaBasico;
 
// Declaración de la clase con su nombre
public class JavaBasico1HolaMundo {
// Entrada principal al programa, el main para los amigos
public static void main(String[] args) {
// Aquí va el código que empieza nada más 
                // arrancar el programa
System.out.println(«¡Hola Mundo!»);
}
}
Hay que saber que en Java todo son clases, se llaman clases. Es una forma de organizar el código utilizando la programación orientada a objetos (POO). Éstos conceptos trataré de estudiarmelos bien, repasarlos, y a ver si podemos verlos en un post más avanzado. De momento no hace falta saber más que todo son clases en Java. Así que verás la palabra ‘class’ por todos lados…
Ésta es una aplicación de consola, tipo MS-Dos, que cuando arranca escribirá por la salida estándar la cadena escrita dentro del:
System.out.println(»      «); 
Con ésta línea lo que hacemos es escribir una línea (println, que es abreviatura de print line, escribir linea en castellano). Ésta línea la escribimos en el out del System, es decir en la salida estándar del sistema, que es la salida por pantalla de consola.
Con todo ésto cuando ejecutamos deberá mostrarse: ¡Hola Mundo!
Lo siguiente a saber es:
public static void main(String[] args) {
 
}
Con ésto declaramos que ahí dentro es el programa ‘main’, en castellano programa principal. Se ejecuta nada más arrancar todo lo que hayamos escrito entre las llaves. De esta manera si escribimos el siguinte programa:
package javaBasico;
 
public class JavaBasico1HolaMundo {
public static void main(String[] args) {
System.out.println(«¡Hola Mundo!»);
System.out.println(«¡Hola Mundo!»);
System.out.println(«¡Hola Mundo!»);
                // aquí podemos añadir todo el código del
                // programa que queramos
 
}
}

Imprimirá 3 veces ¡Hola Mundo!

La parte donde pone ‘public class JavaBasico1HolaMundo {‘ es la forma de declarar la clase del programa, ya hemos visto que todo son clases en Java, o casi todo. Así que ya nos acostubraremos.

Doy por terminado el Hola Mundo en Java.
Saludos


Java Básico 0: Aterrizando

2012-09-28 - Categorías: Java

Daremos comienzo con éste post a una serie sobre programación para todos aquellos que siempre hemos querido aprender Java pero nos ha costado bastante. No será por la falta de información disponible sino todo lo contrario. Las posibilidades de Java para programar ordenadores, dispositivos móviles, tablets, coches, lavadoras y un largo etcétera… hacen, o por lo menos a mi, me han hecho aprender Java bastante engorroso. No recomiendo empezar con Java como primer lenguaje de programación, pero si lo prefieres tampoco es una mala opción porque tiene mucha salida, es muy completo, tiene de todo y sirve para todo.

Prácticamente se puede hacer de todo en Java aunque a veces no sea lo mejor. Depende de la aplicación que vayamos a desarrollar, la funcionalidad, tiempo disponible, recursos de hardware que tenemos, su tipo, si tenemos un pedazo de ordenador multinúcleo o necesitamos aprovechar al máximo el pequeño núcleo de un pequeño dispositivo, sería mejor un lenguaje u otro, pero ese es otro tema.

Para todo ello tenemos muchas herramientas disponibles, gratuitamente o de pago, a mi me gustan las gratuitas claro: Eclipse, NetBeans, Notepad++… que nos van a hacer la vida más fácil. Algunos programas tienen generadores de código, para crear nuevas clases, servlets, formularios, con diseñadores de formularios. Según yo he visto a fecha de hoy, los dos entornos de desarrollo, también llamados IDE de desarrollo, más utilizados para programar en Java vienen a ser Eclipse y NetBeans. Con el que estoy más familiarizado es Eclipse, así que va a ser Eclipse el que voy a utilizar, o casi siempre utilizaré.

Java es un lenguaje que nos proporciona unas cosas que lo hacen muy atractivo para aprender a programar. Algunas de ellas son:

  • Es independiente de la plataforma: o en la mayoría de los casos, nuestros programas hechos en Java podemos desarrollarlos de manera que se puedan ejecutar en todo tipo de Sistemas Operativos. Lo único necesario para poder ejecutarlos es tener la Máquina Virtual de Java, también llamada JRE para los amigos (Java Runtime Environment).
  • Es un lenguaje de programación muy utilizado, con lo que casi seguro que encontraremos ejemplos para todo tipo de problemas, ya que tarde o temprano repetimos el mismo problema unos programadores y otros y alguien publica la solución en algún foro o blog.
  • Grandes empresas estan implicadas, Sun Microsystems, Oracle, Microsoft es un gran competidor con Java con su C# que sorprendentemente se parece mucho… Las empresas de telefonía, todo tipo de industrias, bancos, etc…
  • Se puede hacer de todo: aplicaciones de escritorio, de servidor, para móviles, tablets.. el archiconocido Android tiene un entorno de desarrollo en el que usamos Java. Los móviles con su J2ME para poder hacer también programas para móviles. Se pueden hacer páginas web. También juegos, sobre todo ahora que los procesadores han mejorado tanto, ya que antes era un problema porque tener una interfaz con el Sistema Operativo, la Máquina Virtual de Java, hacia un poco más lentos los programas. Pero ahora eso no tiene casi importancia, o cada vez menos. Si necesitamos interconexión con Sistemas de Información antiguos seguro que en Java encontraremos la forma de interconectar. Etcétera…
Vamos, que tiene de todo! Ya me siento vendedor de Java.
Antes de empezar a instalar nada en nuestra máquina debemos tener claras unas cosas. Para éste curso rápido de aprendizaje en Java vamos a centrarnos en aprender las bases, en concreto, en aprender o practicar la sintaxis, variables, tipos de datos, bucles, etc… y a ver si podemos llegar a temas más avanzados como clases, objetos, herencia, polimorfismo y otras especies de otros mundos… Necesitaremos el JDK de Java, Eclipse y paciencia. Tenemos disponibles éstos dos aquí a continuación, la paciencia la tendrás que poner tú:
Si has seguido el tutorial o guía espero que con ésto ya tengas instalado Eclipse. Que estés probando o hayas conseguido ya hacer el ‘Hola Mundo’ clásico. Y no hayas tenido un aterrizaje forzoso.
Saludos

Aprender a programar con Eclipse

2012-09-20 - Categorías: General

Parece que va a llover pero luego no llueve, los impuestos suben, el trabajo baja… Todo se complica un poco más aquí en Alicante pero hoy vamos a verlo todo un poco menos complicado, por lo menos para los que quieran comenzar a utilizar éste brillante programa llamado Eclipse. Con el que podremos hacer todo tipo de programas, desde sencillos «hola mundo» en C, HTML, Java… a complicados y enormes programas, colaborando con equipos de desarrollo distribuidos por el mundo usando SVN o GIT.

Para empezar debemos acudir a http://www.eclipse.org/ donde tenemos la página principal del programa con todo tipo de información. Está en inglés, a fecha de hoy no encuentro una versión en castellano, así que seguiremos en inglés. Vamos a la sección de Downloads y podemos ver la gran cantidad de lenguajes de desarrollo que soporta.

Técnicamente Eclipse es un entorno de desarrollo, un IDE de desarrollo de todo tipo de aplicaciones. Está casi por completo desarrollado en Java. Con más de 2 millones de líneas de código fuente a fecha de hoy. Se trata de un programa publicado inicialmente con licencia CPL, posteriormente re-licenciado bajo la Eclipse Public License, como reza en Wikipedia, resumiendo que un software gratuito que podemos usar para nuestros proyectos personales o de negocio sin coste alguno. También hay todo tipo de plugins con los que le añadimos funcionalidad.

A mi me gusta la primera versión, Eclipse IDE for Java EE Developers, es la que conozco más y de las que he probado es la que me ha solucionado los problemas lo más rápido posible. También le he instalado los plugins para desarrollos en PHP, diseño de formularios con Java y alguna otra cosa pero eso es otro tema.

Necesitamos para su buen funcionamiento la JDK de Java instalada en nuestro sistema.

Hay que destacar que Eclipse está disponible en Windows, Mac o Linux, principales sistemas operativos que más veo. Con lo que no estamos atados a utilizar tal o cual sistema operativo.

Una vez que hemos bajado nuestra copia de Eclipse nos damos cuenta de que no tiene instalador, así es, no se instala sino que se descomprime en la carpeta que nosotros prefiramos. Yo lo tengo descomprimido en la carpeta donde tengo mis archivos así que cuando hago una copia de seguridad de mis datos también se me copia el Eclipse y toda su configuración. De ésta manera en caso de catástrofe, y siempre que no haya entrado en la catástrofe la copia de seguridad, tendré mi Eclipse listo para usar de nuevo con un simple copy-paste de la carpeta.

La primera vez que arranquemos nuestro nuevo y flamante Eclipse nos va a preguntar sobre nuestro directorio de trabajo, que va a ser el directorio donde se guardarán nuestros proyectos. Recomiendo también ponerlo en el mismo directorio donde tienes tus datos, así también se copiarán tus proyectos con la copia regular de tus datos. Todo ésto claro suponiendo que estas haciendo copias de seguridad xDD De todas maneras siempre podrás cambiar el Workspace más adelante.

Para empezar a utlizar Eclipse hay que comprender su funcionamiento principal. Tenemos que ir al Workbench, para ello en algunas versiones o según el estado del tuyo tendremos tal vez un botón con una flecha donde pone ‘Go to Workbench’.

Tenemos una serie de proyectos con unos archivos y unos directorios alojados en el disco duro. Éstos proyectos pueden ser de varios tipos: Java, página web con PHP, C/C++, etc.. Entonces dentro de Eclipse tenemos varias perspectivas que podemos nosotros diseñar. En cada perspectiva nosotros podemos configurar, por ejemplo para Java, que nuestro Eclipse nos muestre el explorador de proyectos a la izquierda, los archivos abiertos en medio, las salidas de programa abajo, y así sucesivamente…

Para terminar con el tutorial vamos a hacer un nuevo proyecto «HolaMundoJava» que mostrará el mítico mensaje. Le hacemos click derecho en explorador de proyectos, le damos a nuevo, y nos saldrá una ventana con tooooodos los tipos de proyectos disponibles. Elegimos pues «Java Project», le ponemos de nombre «HolaMundoJava», le damos a siguiente, siguiente, next, finish, siguiente y así sucesivamente hasta que se nos cierre la ventana y en el explorador de proyectos nos aparezca el nuevo proyecto y quede el Eclipse parecido a la imagen de arriba. No voy a ponerlo todo masticado así nos familiarizamos con el programa creando proyectos…

Ahora vamos a hacer nuestro primer programa rápidamente, en el proyecto que acabamos de crear, click derecho y le damos a New -> Class entonces nos sale la ventana para hacer ficheros Java, seleccionamos donde pone «public static void main…» le damos nombre y nos generará la nueva clase Java de ejemplo. Yo he hecho el siguiente programilla:

public class hola {
  public static void main(String[] args) {
    System.out.println(«Hola mundo»);
  }
}

Ahora le damos a F11 y si todo ha ido bien por la ventana de consola tiene que salir: Hola mundo

Tienes una cantidad enorme de opciones, plugins, generadores de código, diseñadores de formularios, es abrumador las posibilidades de que disponemos con éste programa.

Por hoy me despido.
Saludos

© 2021 JnjSite.com - MIT license

Sitio hecho con WordPress, diseño y programación del tema por Jnj.