learnxinyminutes-docs/es-es/java-es.html.markdown

---
language: java
contributors:
    - ["Jake Prather", "http://github.com/JakeHP"]
translators:
    - ["Camilo Garrido", "http://www.twitter.com/hirohope"]
lang: es-es
filename: LearnJava-es.java
---

Java es un lenguage de programación de propósito general, concurrente, basado en clases y
orientado a objetos.
[Lee más aquí.](http://docs.oracle.com/javase/tutorial/java/index.html)

```java
// Comentarios de una sóla línea comienzan con //
/*
Comentarios multilínea lucen así
*/
/**
Comentarios JavaDoc lucen así. Suelen describir la clase o varios atributos
de una clase.
*/

// Importa la clase ArrayList dentro del paquete java.util
import java.util.ArrayList;
// Importa todas las clases dentro del paquete java.security
import java.security.*;

// Cada archivo .java contiene una clase pública, con el mismo nombre del archivo.
public class AprendeJava {

    // Un programa debe tener un método 'main' como punto de entrada
    public static void main (String[] args) {

        // Usa System.out.println para imprimir líneas
        System.out.println("¡Hola mundo!");
        System.out.println(
            "Entero (int): " + 10 +
            " Doble (double): " + 3.14 +
            " Booleano (boolean): " + true);

        // Para imprimir sin el salto de línea, usa System.out.print
        System.out.print("Hola ");
        System.out.print("Mundo");


        ///////////////////////////////////////
        // Tipos & Variables
        ///////////////////////////////////////

        // Declara una variable usando <tipo> <nombre> [
        // Byte - Entero complemento a dos con signo de 8-bit
        // (-128 <= byte <= 127)
        byte fooByte = 100;

        // Short - Entero complemento a dos con signo de 16-bit
        // (-32,768 <= short <= 32,767)
        short fooShort = 10000;

        // Integer - Entero complemento a dos con signo de 32-bit
        // (-2,147,483,648 <= int <= 2,147,483,647)
        int fooInt = 1;

        // Long - Entero complemento a dos con signo de 64-bit
        // (-9,223,372,036,854,775,808 <= long <= 9,223,372,036,854,775,807)
        long fooLong = 100000L;
        // L es usado para denotar que el valor de esta variable es del tipo Long;
        // cualquier cosa sin ella es tratado como un entero por defecto.

        // Nota: Java no tiene tipos sin signo

        // Float - Número de coma flotante IEEE 754 de precisión simple de 32-bit
        float fooFloat = 234.5f;
        // f es usado para denotar qeu el valor de esta variable es del tipo float;
        // de otra manera es tratado como un double.

        // Double - Número de coma flotante IEEE 754 de precisión doble de 64-bit
        double fooDouble = 123.4;

        // Boolean - true & false
        boolean fooBoolean = true;
        boolean barBoolean = false;

        // Char - Un simple carácter unicode de 16-bit
        char fooChar = 'A';

        // Usa 'final' para hacer inmutable las variables
        final int HORAS_QUE_TRABAJO_POR_SEMANA = 9001;

        // Strings
        String fooString = "¡Mi String está aquí!";

        // \n es un carácter escapado que inicia una nueva línea
        String barString = "¿Imprimiendo en una nueva linea?\n¡Ningun problema!";
        // \t es un carácter escapado que añade un carácter tab
        String bazString = "¿Quieres añadir un 'tab'?\t¡Ningun problema!";
        System.out.println(fooString);
        System.out.println(barString);
        System.out.println(bazString);

        // Arreglos
        //El tamaño del arreglo debe decidirse en la declaración
        //El formato para la declaración de un arreglo es la siguiente:
        //<tipo_de_dato> [] <nombre_variable> = new <tipo_de_dato>[<tamaño_arreglo>];
        int [] arreglo_de_enteros = new int[10];
        String [] arreglo_de_strings = new String[1];
        boolean [] arreglo_de_booleanos = new boolean[100];

        // Otra forma de declarar & inicializar un arreglo
        int [] y = {9000, 1000, 1337};

        // Indexación de un arreglo - Accediendo un elemento
        System.out.println("arreglo_de_enteros @ 0: " + arreglo_de_enteros[0]);

        // Arreglos comienzan su indexación en cero y son mutables
        arreglo_de_enteros[1] = 1;
        System.out.println("arreglo_de_enteros @ 1: " + arreglo_de_enteros[1]); // => 1

        // Otros para echar un vistazo
        // ArrayLists - Son como arreglos excepto que ofrecen más funcionalidades
        //              y el tamaño es mutable
        // LinkedLists
        // Maps
        // HashMaps

        ///////////////////////////////////////
        // Operadores
        ///////////////////////////////////////
        System.out.println("\n->Operadores");

        int i1 = 1, i2 = 2; // Abreviación para múltiples declaraciones

        // La aritmética es directa
        System.out.println("1+2 = " + (i1 + i2)); // => 3
        System.out.println("2-1 = " + (i2 - i1)); // => 1
        System.out.println("2*1 = " + (i2 * i1)); // => 2
        System.out.println("1/2 = " + (i1 / i2)); // => 0 (0.5 truncado)

        // Módulo
        System.out.println("11%3 = "+(11 % 3)); // => 2

        // Operadores de comparación
        System.out.println("3 == 2? " + (3 == 2)); // => false
        System.out.println("3 != 2? " + (3 != 2)); // => true
        System.out.println("3 > 2? " + (3 > 2)); // => true
        System.out.println("3 < 2? " + (3 < 2)); // => false
        System.out.println("2 <= 2? " + (2 <= 2)); // => true
        System.out.println("2 >= 2? " + (2 >= 2)); // => true

        // ¡Operaciones a nivel de bits!
        /*
        ~       Complemento unario bit a bit
        <<      Deplazamiento hacia la izquierda con signo
        >>      Deplazamiento hacia la derecha con signo
        >>>     Deplazamiento hacia la derecha sin signo
        &       AND lógico
        ^       OR lógico exclusivo
        |       OR lógico inclusivo
        */

        // Incrementos
        int i = 0;
        System.out.println("\n->Incrementos y reducciones");
        System.out.println(i++); //i = 1. Post-incremento
        System.out.println(++i); //i = 2. Pre-incremento
        System.out.println(i--); //i = 1. Post-reducción
        System.out.println(--i); //i = 0. Pre-reducción

        ///////////////////////////////////////
        // Estructuras de Control
        ///////////////////////////////////////
        System.out.println("\n->Estructuras de Control");

        // Condiciones 'if' son como en c
        int j = 10;
        if (j == 10){
            System.out.println("Me imprimieron");
        } else if (j > 10) {
            System.out.println("A mi no");
        } else {
            System.out.println("A mi tampoco");
        }

        // Ciclos 'while'
        int fooWhile = 0;
        while(fooWhile < 100)
        {
            //System.out.println(fooWhile);
            //Incrementar el contador
            //Iteró 99 veces, fooWhile 0->99
            fooWhile++;
        }
        System.out.println("Valor fooWhile: " + fooWhile);

        // Ciclos 'do while'
        int fooDoWhile = 0;
        do
        {
            //System.out.println(fooDoWhile);
            //Incrementar el contador
            //Iteró 99 veces, fooDoWhile 0->99
            fooDoWhile++;
        }while(fooDoWhile < 100);
        System.out.println("Valor fooDoWhile: " + fooDoWhile);

        // Ciclos 'for'
        int fooFor;
        //Estructura del ciclo 'for' => for(<declaración_de_inicio>; <condicional>; <paso>)
        for(fooFor=0; fooFor<10; fooFor++){
            //System.out.println(fooFor);
            //Iteró 10 veces, fooFor 0->9
        }
        System.out.println("Valor fooFor: " + fooFor);

        // Switch Case
        // Un 'switch' funciona con un tipo de dato byte, short, char e int
        // También funciona con tipos enumerados (discutido en tipos Enum),
        // la clase String y unas pocas clases especiales que envuelven
        // tipos primitivos: Character, Byte, Short e Integer.
        int mes = 3;
        String mesString;
        switch (mes){
            case 1:
                    mesString = "Enero";
                    break;
            case 2:
                    mesString = "Febrero";
                    break;
            case 3:
                    mesString = "Marzo";
                    break;
            default:
                    mesString = "Algun otro mes";
                    break;
        }
        System.out.println("Resultado switch Case: " + mesString);


        ///////////////////////////////////////
        // Convirtiendo Tipos de Datos y Conversión de Tipos
        ///////////////////////////////////////

        // Convirtiendo datos

        // Convertir String a Integer
        Integer.parseInt("123");//retorna una versión entera de "123"

        // Convertir Integer a String
        Integer.toString(123);//retorna una versión string de 123

        // Para otras conversiones fíjate en las siguientes clases
        // Double
        // Long
        // String

        // Conversión de tipos
        // También puedes convertir objetos java, hay muchos detalles
        // con unos pocos conceptos intermedios
        // No dudes en verlos acá
        // http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html


        ///////////////////////////////////////
        // Clases y Funciones
        ///////////////////////////////////////

        System.out.println("\n->Clases & Funciones");

        // (A continuación la definición de una clase Bicicleta)

        // Usa 'new' para instanciar una clase
        Bicicleta excursion = new Bicicleta();

        // Llama métodos del objeto
        excursion.aumentarVelocidad(3); // Siempre deberías usar metodos 'set' (establecer) y 'get' (obtener)
        excursion.setRitmo(100);

        // 'toString' es una convención para mostrar los valores de este objeto.
        System.out.println("informacion de la excursion: " + excursion.toString());

        ///////////////////////////////////////
        // Genéricos
        ///////////////////////////////////////

        // Utilizando genéricos (a partir de Java 1.5) es posible detectar en tiempo de
        // compilación errores de tipado (en versiones anteriores se detectarían como error
        // de ejecución)

        List<String> v = new ArrayList<String>();
        v.add("test");
        String s = v.get(0); // Si intentamos recuperar s como otro tipo diferente a String
                             // (por ejemplo, un Integer) obtendríamos un error de compilación

    } // Fin del método 'main'
} // Fin de la clase AprendeJava


// Puedes incluir otras clases no públicas en un archivo .java


// Sintaxis de declaración de clases:
// <public/private/protected> class <nombre_de_la_clase>{
//    //variables_de_clase, constructores, todas las funciones.
//    //las funciones son llamadas como métodos en Java.
// }

class Bicicleta {

    // Campos/Variables de Bicicleta
    public int ritmo; // Public: Puede ser accedido desde cualquier parte
    private int velocidad;  // Private: Accesible sólo desde esta clase
    protected int engranaje; // Protected: Accesible desde esta clases y sus subclases
    String nombre; // default: Sólo accesible desde este paquete

    // Constructores son la manera de crear clases
    // Este es un constructor por defecto
    public Bicicleta() {
        engranaje = 1;
        ritmo = 50;
        velocidad = 5;
        nombre = "Bontrager";
    }

    // Este es un constructor específico (contiene argumentos)
    public Bicicleta(int ritmoInicial, int velocidadInicial, int engranajeInicial, String nombre) {
        this.engranaje = engranajeInicial;
        this.ritmo = ritmoInicial;
        this.velocidad = velocidadInicial;
        this.nombre = nombre;
    }

    // Sintaxis de función:
    // <public/private/protected> <tipo_de_retorno> <nombre_funcion>(<argumentos>)

    // Las clases de Java usualmente implementan métodos 'get' (obtener) y 'set' (establecer) para sus campos

    // Sintaxis de declaración de métodos
    // <alcance> <tipo_de_retorno> <nombre_metodo>(<argumentos>)
    public int getRitmo() {
        return ritmo;
    }

    // Métodos void no requieren retornar
    public void setRitmo(int nuevoValor) {
        ritmo = nuevoValor;
    }

    public void setEngranaje(int nuevoValor) {
        engranaje = nuevoValor;
    }

    public void aumentarVelocidad(int incremento) {
        velocidad += incremento;
    }

    public void disminuirVelocidad(int reduccion) {
        velocidad -= reduccion;
    }

    public void setNombre(String nuevoNombre) {
        nombre = nuevoNombre;
    }

    public String getNombre() {
        return nombre;
    }

    //Método para mostrar los valores de los atributos de este objeto.
    @Override
    public String toString() {
        return "engranaje: " + engranaje +
                " ritmo: " + ritmo +
                " velocidad: " + velocidad +
                " nombre: " + nombre;
    }
} // fin clase Bicicleta

// PennyFarthing es una subclase de Bicicleta
class PennyFarthing extends Bicicleta {
    // (Penny Farthings son esas bicicletas con una gran rueda forntal.
    // No tienen engranajes.)

    public PennyFarthing(int ritmoInicial, int velocidadInicial){
        // Llama al constructor del padre con super
        super(ritmoInicial, velocidadInicial, 0, "PennyFarthing");
    }

    // Deberías marcar un método que estás sobre escribiendo con una @anotacion
    // Para aprender más sobre que son y el propósito de las anotaciones
    // echa un vistazo acá: http://docs.oracle.com/javase/tutorial/java/annotations/
    @Override
    public void setEngranaje(int engranaje) {
        engranaje = 0;
    }

}
```

## Más Lectura

Estos links son sólo para tener un entendimiento del tema, no dudes en
usar Google y encontrar ejemplos más específicos

Otros temas a investigar:

* [Java Tutorial Trail from Sun / Oracle](http://docs.oracle.com/javase/tutorial/index.html)

* [Java Access level modifiers](http://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html)

* [Object-Oriented Programming Concepts](http://docs.oracle.com/javase/tutorial/java/concepts/index.html):
    * [Inheritance](http://docs.oracle.com/javase/tutorial/java/IandI/subclasses.html)
    * [Polymorphism](http://docs.oracle.com/javase/tutorial/java/IandI/polymorphism.html)
    * [Abstraction](http://docs.oracle.com/javase/tutorial/java/IandI/abstract.html)

* [Exceptions](http://docs.oracle.com/javase/tutorial/essential/exceptions/index.html)

* [Interfaces](http://docs.oracle.com/javase/tutorial/java/IandI/createinterface.html)

* [Generics](http://docs.oracle.com/javase/tutorial/java/generics/index.html)

* [Java Code Conventions](http://www.oracle.com/technetwork/java/codeconv-138413.html)