TUTORIAL DE JAVA

Estaba mirando por internet, el ranking de lenguajes de programación, y el número 1 era el java, y por eso me vine la idea de crear entre todos un tuto de java.
Bueno voy a empezar...

Java se convierte como lenguaje de programacion para computadoras se da en 1995 con la versión 2 del Netscape. En 1997, saca la version 1.1 y luego en 1998 se rebautiza como java 2.

Sun describe a Java como "simple, orientado a objetos, distribuido, interpretado, robusto, seguro, de arquitectura neutra, portable, de altas prestaciones, multitarea y dinámico", que describen bastante bien a este lenguaje.

Java 2 es la tercera version del lenguaje siendo igual a la 1.1 pero ampliandola.
Un programa Java puede ejecutarse como:
-Stand alone: aplicacion independiente.
-Applet: Aplicación especial que se ejecuta en el navegador del visitante.
-Servlet: Aplicacion sin interfaz que se ejecuta en el servidor.

Un desarrollo java nunca empeza desde 0, java, implementa consigo un gran numero de clases para una gran cantidad de necesidades.

Sun distribuye utilidades java en su web con estas siglas: SDK,JDK y J2SE, que incluyen el paquete de utilidades java.El JRE tambien se puede descargar, siendo este el J2SE.

El JRE incluye los elementos necesarios para hacer funcionar programas java en nuestro ordenador. Principalmente nos instala la Maquina Virtual de Java y los plugins necesarios para el/los navegador/es instalados en nuestro sistema. El JRE también se puede descargar independientemente del entorno de desarrollo, pues se distribuye en un paquete llamado J2RE.

¿Y que es la Máquina Virtual de Java? Pues bien, como hemos comentado antes, Java está pensado para ser independiente de la arquitectura sobre la que funcione y la manera que tiene Java para conseguirlo es a través de la emulación de una máquina software sobre la que funcionan los programas compilados con Java.

Es decir, un programa eecho con java solo lo puede procesar la maquina virtual de java.


Espero que vosotros me ayudeis con información y asi aprendemos juntos.

Bueno vamos un poco a la practica, ya que tanta teoria...jeje.

Podemos descargar el software gratuitamente http://www.eclipse.org/ .
1.-Vamos donde dice DOWNLOADS.
2.- Y seleccionamos Eclipse Classic 3.6.0 y descargamos windows 32 bits.
3.-Clicar donde dice A3 system (http).
4.-Es un archivo en zip que lo guardamos en una carpeta y lo descomprimimos.

Bueno a mi nuca me ha ido bien asi k si me podeis ayudar...XD
Porque yo sé menos que vosotros pero mira leyendo pues se aprende pero no se mas de momento que esto jeje :D

Vamos a crear nuestro primer programa, el mitico Hola Mundo.

Creamos el archivo hola-mundo.java
Y escribimos el codigo:

public class Ejemplo {
   public static void main ( String argumentos[] )
    {
       System.out.println ("Hola Mundo\n");
    }
} 

Para ejecutarlo hemos de usar el compilador bajado en la leccion2. (necesito info sobre este tema)

Después utiliza el comando javac poniendo javac Ejemplo.java , nos creará un archivo .class y es el que funciona la maquina virtual. Con el comando ejemplo java

Si todo ha ido bien te debería de haber mostrado: "Hola mundo" como habrías podido suponer.

El codigo de mas adelante os lo explicare.

COMENTARIOS:

En java hay tres tipos de comentarios:

//Esto es un comentario de una sola linea
/*Esto es un comentario de una linea o mas*/
/**Esto es un comentario de documentacion*/

IDENTIFICADORES:

Un identificador es un "nombre" que nos permite dirigirnos específicamente a uno de los nombres que podemos ponerles a nuestros/as variables, métodos, clases, interfaces y objetos.

Los identificadores tienen que empezar por letra, subrayado, o por el signo $, pudiendoles seguir letras o numeros. Hay que tener en cuenta que java distinge las mayusculas y minusculas.

Hay normas muy recomendables para crear identificadores: ponerlos siempre en minusculas.

1. Si en un identificador queremos incluir un nombre compuesto se pone el primer nombre entero en minúscula y el resto con la primera letra en mayúscula y el resto en minúscula. Por ejemplo:

miNuevaVariable = 3;

2. Los identificadores de clases e interfaces siempre empiezan en mayúscula siguiendo la anterior norma en caso de tratarse de un nombre compuesto. Por ejemplo:

MiNuevaClase();

3. Los nombres de variables finales ( las mas habitualmente llamadas "constantes") se escriben íntegramente en mayúscula. Por ejemplo: "PI"

No poner palabras como estas:

abstract continue for new switch boolean default goto null synchronized
break do if package this byte double implements private threadsafe
byvalue else import protected throw case extends instanceof public transient
catch false int return true char final interface short try
class finally long static void const float native super while

TIPOS PRIMITIVOS:

Como tipos primitivos entendemos aquellos tipos de información mas usuales y básicos. Son los habituales de otros lenguajes de programación. Os describo algun dato a tener en cuenta:

Boolean: No es un valor numérico, solo admite los valores true o false.
Char: Usa el código UNICODE y ocupa cada carácter 16 bits.
Enteros: Difieren en las precisiones y pueden ser positivos o negativos.
o Byte: 1 byte.
o Short: 2 bytes.
o Int: 4 bytes.
o Long: 8 bytes.
Reales en punto flotante: igual que los enteros también difieren en las precisiones y pueden ser positivos o negativos.
o Float: 4 bytes.
o Double: 8 bytes.
:arrow: :arrow: :arrow: :arrow:

VARIABLES:

Ahora que tenemos las piezas necesarias(identificador, tipo), ya podemos explicar las variables.
Una variable referenciará siempre a un tipo primitivo de Java o a cualquier otro objeto creado en nuestro programa. Veamos algunas declaraciones:

Int a ; // declaración de una variable 'a'
         //inicializada a 0 (valor por defecto).

Int b = 8; // declaración de una variable 'b' inicializada a 8.

NombreClase referencia; // declaración de una variable 'referencia' preparada //para llevar un objeto de la clase 'NombreClase'.

NombreClase referencia2; // lo mismo que en la variable anterior.

Referencia = new NombreClase; // se crea un nuevo objeto de la clase
         //'NombreClase',y es asignado a la variable
         //'Referencia'

Referencia2 = referencia; // Ahora también 'referencia2' tiene el mismo
         // objeto a su cargo que 'referencia'

Una vez sabemos un poco como declarar variables, tenemos que saber en que sitio del programa podemos acceder a ellas, es lo que llamamos ambito de la variable.

Una variable tiene validez dentro del bloque encerrado por llaves donde ha sido declarada, ya sea dentro de una funcion o de la sentencia 'if', que la aprendereos mas adelante.

public class AmbitoVariables {

    public static void main(String[] args) {
       if (true) {
          int y=5;
       }
       System.out.println(y);
    }
} 

Si intentaramos ejecutar este programito, nos daria error, ya que la variable esta en un bloque distinto de donde la queremos utilizar.

Para acceder a ellas depende si en la clase está declarada como 'public' o como 'private'. Las variables declaradas en una clase como 'public' se acceden directamente a través de 'NombreClase.nombreVariable'. En caso de una variable 'private' solo podemos utilizarla mediante los métodos de esa clase.

Por otro lado desde la declaración de cualquier función propia de una clase podemos acceder a las variables internas de esa clase directamente.

Los operadores son muy similares a los de C++.
OPERADORES ARITMETICOS: Los habituales; Suma + ; Resta - ; MUltiplicacion * ; Division / ; Resto division % .

OPERADORES DE ASIGNACION: El principal es '=', pero hay mas:

'+=' : op1 += op1+op2
'-=' : op1-= op1-op2
'*=' : op1 *= op1 * op2
'/=' : op1 /= op1 / op2
'%=' : op1 %= op1 % op2

OPERADORES UNARIOS: El + (mas) y el - (menos) para cambiar el signo del operando.

Operador Instanceof: Nos permite saber si un objeto pertenece a una clase o no.

* NombreObjeto instanceof NombreClase

Operadores Incrementales: Son los operadores que nos permiten incrementar las variables en una unidad. Se pueden usar delante y detrás de la variable dependiendo de lo que queramos, es decir, si queremos que incremente o viceversa antes de utilizar o lo contrario.

* '++'
* '--'

Operadores Relacionales: Permiten comparar variables según relación de igualdad/desigualdad o relacción mayor/menor. Devuelven siempre un valor boolean.

* '>': Mayor que
* '<': Menor que
* '==': Iguales
* '¡=': Distintos
* '>=': Mayor o igual que
* '<=': Menor o igual que

Operadores Lógicos: Nos permiten construir expresiones lógicas.

* '&&' : devuelve true si ambos operandos son true.
* '||' : devuelve true si alguno de los operandos son true.
* '!' : Niega el operando que se le pasa.
* '&' : devuelve true si ambos operandos son true, evaluándolos ambos.
* '|' : devuelve true uno de los operandos es true, evaluándolos ambos.

Operador de concatenación con cadena de caracteres '+':

* Por Ejemplo: System.out.println("El total es"+ result +"unidades");

Operadores que actúan a nivel de bits: Son mucho menos utilizados por eso los explicamos mas por encima.

* '>>': desplazamiento a la derecha de los bits del operando
* '<<': desplazamiento a la izquierda de los bits de operando
* '&': operador and a nivel de bit.
* '|': operador or a nivel de bit

Espero mas informacion vuestra.

Se tratan igual que otro lenguaje, asi que si ya sabes puedes pasar a la siguiente leccion.

BIFURCACIONES: Permiten ejecutar codigo a traves de una expresion evaluada.

Bifurcaciones IF:

Tienen pueden tener alguna de estas estructura:

if (ExpresionBooleana){conjuntoDeSentencias}

if (ExpresionBooleana) {conjuntoDeSentencias}
else {conjuntoAlternativo}

if (ExpresionBooleana) {conjuntoDeSentencias}
else if {conjuntoAlternativo}
else if {conjuntoAlternativo2}

Quiere decir que primera va el if, después la condicion que es la expresion, si fuera correcta, leeria los conjuntos de sentencia pero en caso que fuese false se iria al otro con else las otras sentencias.

Ejemplo

if (i == 5){ System.out.println(" i vale 5 ");}
else {System.out.println("i no vale 5");}

if (i == 5){ System.out.println(" i vale 5 ");}
else if (i < 5){System.out.println("i es menor que 5");}
else if (i > 5){System.out.println("i es mayor que 5");} 

BIFURCACIONES SWITCH: Son las que pueden realizar varias acciones distintas dependiendo de las variables.

Switch (Expresion){
Case valor1: conjuntoDeSentencias;
break;
Case valor2: SentenciasAlternativas;
break;
Case valor3: SentenciasAlternativas2;
break;
Case valor4: SentenciasAlternativas3;
break;
}

La sentencia break sirve para que se salga de la bifurcacion switch.

Ejemplo:

switch (i) {
    case '1': System.out.println( "i contiene un 1");
    case '2': System.out.println( "i contiene un 2");
    case '3': System.out.println( "i contiene un 3");
} 

Los bucles se utilizan para ejecutar un conjunto de instrucciones varias veces basandose si siguen repitiendose o no.

WHILE (mientras): Normalmente se usan para crear sesiones.

while (expresion) {sentencias}

Las instrucciones dentro de las llaves se ejecutan mientras la expresión sea verdadera.

i=5;
while ( i > 0 ) {i --;}
// las llaves aquí se podían haber omitido, puesto
// que solo hay una sentencia.
System.out.println("Ahora i vale 0");

FOR: Es un bucle mas fijo permite ejecutar el contenido de sentencias un numero determinado de veces fijado al principio del bucle y funciona como un contador. Su estructura es:
for (inicialización, expresionBooleana, incremento) {conjuntoDeSentencias;}

for (int i= 0; i <10; i++){ System.out.println("el valor de i es: " + i); }

Este ejemplo nos mostraría por la pantalla diez líneas diciéndonos el valor creciente de 'i' de cero a nueve.

Bucle do while

Es igual al bucle while anteriormente visto, solo que ahora se evalúa la expresión al final del bucle, por lo que ese conjunto de sentencias se ejecuta al menos una vez:

i=5;
do
{i --;} // las llaves aquí se pueden omitir puesto
while ( i > 0 ) // que solo hay una sentencia.

Este ejemplo similar al anterior para el bucle while se diferencia en que ejecuta una vez mas las sentencias en su cuerpo puesto que comprueba la condición posteriormente.

Sentencias Break, Continue y Return

Antes hemos hablado de la sentencia Break con las bifurcaciones switch. Pues bien, esta sentencia tiene un valor mas amplio. La sentencia break nos permite salirnos del bloque de sentencias (encerrado entre llaves) o el bucle que estamos ejecutando, sin ejecutar las sentencias que resten para el final o las restantes iteraciones del bucle. Por ejemplo:

i=5;
do{
i --;
if (i == 3) break;
} while ( i > 0 )
// En este ejemplo cuando i tenga el valor 3
// se abandonará el bucle.

La sentencia Continue solo es válida para bucles, sirve para no ejecutar las sentencias que restan para la finalización de una iteración de ese bucle, continuando después con las siguientes iteraciones del bucle. Por ejemplo:

i=5;
do{
if (i == 3) continue; i --;
}while ( i > 0 ) // En este ejemplo cuando i tenga el valor 3
// se abandonará la iteración y por tanto el
// bucle no tendrá fin puesto que no se
// ejecutaría la sentencia de decremento.

Tanto la sentencia continue como break se pueden utilizar con etiquetas para poder discriminar los bucles que quieren afectar en caso de que se encuentren en un bucle anidado. Por ejemplo:

Bucle1:
for (int i=0; i<10; i++){
bucle2:
for (int j=0; i<10; j++){
if (j==5) {break bucle2;}
}
} // cuando j llega a 5 el bucle2 deja de
// ejecutarse hasta la siguiente iteracion
// del bloque1

Por último vemos la sentencia return. Esta sentencia nos permite finalizar también un conjunto de sentencias, con la peculiaridad esta vez de que también finaliza el método o función que en el que se encuentre. En el caso de que queramos devolver un valor desde esa función o método lo debemos poner a continuación de return. Por ejemplo:

void funcionEjemplo(){
int i=0;
while (i < 100){ //esta absurda función nos devuelve
i++; //al llamarla el valor 100 como has
} //podido comprobar
return i;
}

Bloque Try – Catch – Finally

Se trata de unas sentencias de control relacionadas con el tratamiento de excepciones, no tiene nada que ver con las estructuras de control de bucle, vistas en este artículo, salvo porque es también una estructura de control. La comentamos a continuación, aunque se verá con ejemplos más adelante.

El tratamiento de excepciones se utiliza para detectar errores cuando se ejecutan nuestros programas y tratarlos del modo que nosotros queramos. Los errores cazados por un sistema de tratamiento de excepciones no bloquean el programa y el manejo de excepciones nos permite hacer cosas cuando esos errores ocurren.

Por ahora solo es bueno que sepas que existen, ya las veremos en otro momento.


Espero vustros comentarios, y vustra informacion y ayuda.

Esta parte de tutorial esta sacada del tutorial de desarrolloweb.com

Vamos a intentar aprender la funcion de un programa en Java. También intentare explicar algo sobre la programacion orientada a objetos. Podeis mirar esta pagina: www.desarrolloweb.com/articulos/499.php

ESTRUCTURA BASICA DE UN PROGRAMA

En Java, igual que en xualquier otro lenguaje orientado a objetos, abandonamos el modo de entender un programa que utilizabamos antes, para canviarlo hacia un modo mas cercano a la vida misma.

Los programas esta divididos en clases. Una clase se puede entender como un programa independiente, tiene sus propios datos y los mneja a su modo.

Vamos a estudiar un poco unas clases que son "fichas" y "tablero" que nos serviran para el juego cuatro en raya.

public class Fichas {
    String color;
    public Fichas(String c){color=c;}
    public String dameColor(){return(color);}
} 

Esta es la clase "ficha", tiene una variable color que es string, que no es un tipo primitivo en java, es una clase que esta dentro del api del java, dentro del paquete "java.lang", y que se incluye siempre en los programas java.
Por tanto lo que estamos haciendo en la segunda linea es declarar un objeto sin valor de la clase string.
En la tercera y cuarta linea, son 2 metodos de la clase "fichas", que estamos definiendo.

El primer método es un constructor. Un constructor es un método que se llama con la sentencia "new", es decir cuando alguien quiera crear un objeto y que nos define bajo que condiciones se crea ese objeto, ya lo entenderás mejor. En este caso para que alguien quiera crear una ficha tiene que pasar un objeto "String" como parámetro y obtendrá a cambio un objeto de la clase "Fichas" del color que ha solicitado.

El segundo metodo, nos devuelve un objeto string, con el valor del color que tiene el elemento ficha en este momento.

public class Tablero {
    Fichas estadoTablero[][];
    public Tablero(){estadoTablero=new Fichas [6][7];};
    public boolean verSiLlena(int indice){
    return(estadoTablero[7][indice]==null);};
} 

Bueno, esta segunda clase que estudiamos tiene también un objeto interno llamado "estadoTablero" que en este caso es un "array" cuyas posiciones son de la clase anteriormente declarada "Fichas".

También tenemos un "constructor" para el objeto "estadoTablero" que crea ese "array" con las dimensiones que queremos.

Y en este caso hay una función que nos dice si la columna por la que nos interesamos con el parámetro de entrada "índice" está llena.

De estos dos ejemplos de clases aún nos quedan algunos conceptos por aprender, como por ejemplo eso del "constructor". Lo veremos con detenimiento más adelante.

Animaros con esto.