PDF de programación - Referencia Java

Referencia Java

Variables

Constantes

final

final <tipo> <CONSTANTE> = <valor>;

donde <valor> se escribe: byte:(byte)64, short:(short)64, int: 64, long: 64L,
float: 64.0f, double: 64.0, char: ‘@’ ó ‘\u0040’, boolean: true / false
objetos: null, String: “64”, vectores: {<valor>, <valor>, …}

Tipos simple o
primitivos

Ejemplo: final int MAX_ELEM = 20;

<tipo_simple> <variable> [= <valor>];

Ejemplo: int i = 0;

tipo

tamaño

rango

envolvente

byte

8 bits

-128

127

short

16 bits

-32.768

32.767

int

32 bits

long

64 bits

float

32 bits

double

64 bits

-2.147.483.648
-9.223.372·1012
-3.4·1038
-1.8·10308

boolean



false

2.147.483.647

9.223.372.036.854.775.807
3.4·1038 (mínimo 1.4·10–45)
1.8·10308(mínimo 4.9·10-324)

true
Unicode 216-1

char

void

16 bits

Unicode 0

0 bits

-

-

Byte

Short

Integer

Long

Float

Double

Boolean

Character

Void

Tipos
compuestos

new

<tipo_compuesto> <variable> = new <tipo_compuesto>(<param>);

Pueden ser: arrays o clases. Dentro de las clases existen algunas especiales:
envolventes, String, colecciones y enumerados



Son referencias (punteros)

Arrays

YouTube

<tipo><array>[]..[] = new <tipo>[<num>]..[<num>];

El primer elemento es el 0, al crearlos (new) hay que saber su tamaño

float v[] = new float[10]; //Una dimensión y 10 elementos
float M[][]= new float[3][4]; //Dos dimensiones
String s[] = {"hola", "adios"}; // elementos inicializados
for (int i = 0; i < M.length; i++)
for (int j = 0; j < M[i].length; j++)
M[i][j] = 0;

Envolventes

(wrappers)

YouTube

Cadena
caracteres

Para cada uno de los tipos simples existe una clase equivalente, con constantes
y métodos que nos pueden ser útiles. Ver tabla en variable simple. Ver
conversión de tipos.

String <nombre_variable> [= "<cadena de caracteres>"];

Ejemplo: String s = "Hola"; ó String s = new String("Hola");

String

Métodos de la clase String:

.equals(String s2) //compara dos Strings



© Jesús Tomás Gironés - www.androidcurso.com

.clone() //crea una copia de un String

.charAt(int pos) //retorna el carácter en una posición

.concat(String s2) //concatena con otro Strings

.indexOf(char c, int pos) //devuelve posición de un carácter

.length() //devuelve la longitud del String

.replace(char c1, char c2) // reemplaza un carácter por otro

.substring(int pos1, int pos2) // extrae una porción del string

.toLowerCase() // convierte el String a minúsculas

.toUpperCase() // convierte el String a mayúsculas

.valueOf(int/float/… numero) // convierte un número a String

Colecciones

YouTube



El API de Java nos proporciona colecciones donde guardar series de datos de
cualquier tipo. Dichas colecciones no forman parte del lenguaje, sino que son
clases definidas en el paquete java.util.

<tipo_colecc><<tipo>> <colección> = new <tipo_colecc><<tipo>>();

Hay tres tipos, cada uno con un interfaz común y diferentes implementaciones:

Listas – estructura secuencial, donde cada elemento tiene un índice o posición:
interfaz: List<E> implement.: ArrayList<E> (acceso rápido), LinkedList<E>
(inserciones/borrado rápidas) , Stack<E> (pila) , Vector<E> (obsoleto)

Conjunto – los elementos no tienen un orden y no se permiten duplicados:
interfaz: Set<E> implement.: HashSet<E> (implementación usa tabla hash),
LinkedHashSet<E>(+doble lista enlazada), TreeSet<E> (implem. usa árbol)

Diccionario o Matriz asociativa – cada elemento tiene asociado una clave que
usaremos para recuperarlo (en lugar del índice de un vector): interfaz: Map<K,V>
implement.: HashMap<K,V>, TreeMap<K,V>, LinkedHashMap<K,V>

interfaces Iterator y ListIterator

Los
facilitan recorres colecciones.
La clase estática Collections nos ofrece herramientas para ordenar y buscar
en colecciones.

ArrayList<Complejo> lista = new ArrayList<Complejo>();

lista.add( new Complejo(1.0, 5.0) );

lista.add( new Complejo(2.0, 4.2) );

lista.add( new Complejo(3.0, 0.0) );

for (Complejo c: lista) {

System.out.println( c.getNombre() );

}

Enumerados

enum

(Java 5)

enum <nombre_enumeracion> { <CONSTANTE>, ..., < CONSTANTE> }

Ejemplo: enum estacion { PRIMAVERA, VERANO, OTOÑO, INVIERNO };

estacion a = estacion.VERANO;

Ámbito Indica la vida de una variable, se determina por la ubicación de llaves { } donde

se ha definido.

{
int a = 10; // sólo a disponible
{
int b = 20; // a y b disponibles
}
// sólo a disponible
}



© Jesús Tomás Gironés - www.androidcurso.com

Expresiones y sentencias

Comentarios

Operadores

Conversión
de tipos

YouTube

Sentencias
condicional

if
else
switch
case default


Sentencias
iterativas

while
do
for



// Comentario de una línea
/* Comentario de
varias líneas */
/** Comentario javadoc: para crear automáticamente la
documentación de tu clase */
asignación:
aritméticos:
comparación: ==, ¡=, <, <=, >, >=, !, &&, ||, ?:
manejo bits:
conversión:

&, |, ^, ~, <<, >>, >>>
(<tipo>)

=
++, --, +, -, *, /, %

Entre tipos compatibles se puede hacer asignación directa o utilizar un typecast.

byte b = 3;
int i = b; float f = i; //int a byte y float a int
b =(byte)i; // hay que hacer un typecast
String s = Integer.toString(i);
b = Byte.parseByte(s);

if (<condición>) {

<instrucciones>;

} else {

<instrucciones>;

}

switch (<expresión>) {

case <valor>:
<instrucciones>;

[break;]

case <valor>:
<instrucciones>;

[break;]

...

[default:
<instrucciones>;]

}

while (<condición>) {

<instrucciones>;

}

do {

<instrucciones>;

} while (<condición>)

if (b != 0) {
System.out.println(
"x= "+a/b);
} else {
System.out.println("Error");
}

switch (opcion) {
case 1:
x = x * Math.sqrt(y);
break;
case 2:
case 3:
x = x / Math.log(y);
break;
default:
System.out.println("Error");
}



i = 0;
while (i < 10) {
v[i]=0;
i++;
}
i = 0;
do {
v[i]=0;
i++;
} while (i < 10)

for (<inicialización>;
<comparación>; <incremento>) {

<instrucciones>;

}

for (<tipo> <variable>
:<colección>) {

<instrucciones>;

} //(Java 5)

for (i = 0; i < 10; i++) {
v[i]=0;
}

for (Complejo c: lista) {
c.toString();
}

Sentencias
de salto

break; fuerza la terminación inmediata de un bucle ó de un switch

continue; fuerza una nueva iteración del bucle y salta cualquier códigolabel:

return [<valor>]; sale de la función, puede devolver un valor

exit([int código_retorno]); sale del programa, puede devolver un código



© Jesús Tomás Gironés - www.androidcurso.com

Clases y objetos

Clases

Cada clase ha de estar en un fichero separado con el mismo nombre de la clase
y con extensión .class. Por convenio los identificadores de clase se escriben en
mayúscula.

class

poli[Media]

class <Clase> [extends <Clase_padre>][implement <interfaces>] {

//declaración de atributos

[visibilidad] [modificadores] <tipo> <atributo> [= valor];

...

//declaración de constructor

public <Clasee>(<argumentos>) {

<instrucciones>;

}

//declaración de métodos

[visibilidad] [modificadores] <tipo> <método>(<argumentos>) {

<instrucciones>;

}

...

}

donde:

[visibilidad] = public, protected o private



[modificadores] = final, static y abstract

class Complejo {

private double re, im;

public Complejo(double re, double im) {

this.re = re; this.im = im;

}

public String toString() {

return(new String(re + "+" + im + "i"));

}

public void suma(Complejo v) {

re = re + v.re;

im = im + v.im;

}

}

Uso de objetos:

Complejo z, w;

z = new Complejo(-1.5, 3.0);

w = new Complejo(-1.2, 2.4);

z.suma(w);

System.out.println("Complejo: " + z.toString());

Sobrecarga

podemos escribir dos métodos con el mismo nombre si cambian sus parámetros.

YouTube



public <tipo> <método>(<parámetros>) {

<instrucciones>;

}

public <tipo> <método>(<otros parámetros>) {

<otras instrucciones>;

}

ejemplo:

public Complejo sumar(Complejo c) {

return new Complejo(re + c.re, im + c.im);

}

public Complejo sumar(double r, double i) {



© Jesús Tomás Gironés - www.androidcurso.com

return new Complejo(re + r, im + i);

}

Herencia:

extends

@Override

class <Clase_hija> extends <Clase_padre> {

...

}

super.
poli[Media]

La clase hija va a heredar los atributos y métodos de la clase padre. Un objeto
de la clase hija también lo es de la clase padre y de todos sus antecesores.

La clase hija puede volver a definir los métodos de la clase padre, en tal caso es
recomendable (no obligatorio) indicarlo con @Override; de esta forma evitamos
errores habituales cuando cambiamos algún carácter o parámetro. Si un método
ha sido sobrescrito podemos acceder al de la clase padre con el siguiente prefijo
super.<método>(<parámetros>). Ver ejemplo del siguiente apartado.

Constructor

super()

YouTube



Método que se ejecuta automáticamente cuando se instancia un objeto de una
clase. Ha de tener el mismo nombre que la clase. Cuando se crea un objeto
todos sus atributos se inicializan en memoria a cero. Las referencias serán null.

Una clase puede tener más de un constructor (ver sobrecarga).



Un constructor suele comenzar llamando al constructor de la clase padre, para
ello escribiremos como primera línea de código: super(<parámetros>);

class ComplejoAmpliado extends Complejo {

private Boolean esReal;

public ComplejoAmpliado(double re, double i