mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-12-24 15:51:41 +03:00
Java file translated to spanish
This commit is contained in:
Camilo Garrido
parent
6db6606d2e
commit
191552ad49
410
es-es/java-es.html.markdown
Normal file
410
es-es/java-es.html.markdown
Normal file
@ -0,0 +1,410 @@
|
||||
---
|
||||
language: java
|
||||
contributors:
|
||||
- ["Jake Prather", "http://github.com/JakeHP"]
|
||||
translators:
|
||||
- ["Camilo Garrido", "http://www.twitter.com/hirohope"]
|
||||
lang: es-es
|
||||
filename: LearnJava.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());
|
||||
|
||||
} // 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)
|
||||
Loading…
Reference in New Issue
Block a user