Download Repaso de Java

Repaso de Java
[Tema 1]
1 / 31
¿Cuáles son las características de Java?
2 / 31
Características
Estas son las principales características de Java
Orientado a Objetos: Salvo los tipos primitivos (char, int, short...) el resto
de elementos son objetos que heredan de Object.
Semi Intreptetado: El código es compilado a bytecode, un lenguaje
intermedio que es ejecutado sobre la máquina virtual.
Fuertemente tipado: Las variables han de ser declaradas especificando
un tipo y solo podrán asignarse valores de dicho tipo.
Memoria Autogestionada: Al crear una variable de asigna
automáticamente la memoria y cuando no hay ninguna referencia a esta
es eliminada por el recolector de basura.
Herencia Simple: Java solo permite heredar desde una clase. Para
mantener el polimorfismo se hace uso de las interfaces.
3 / 31
Variables y Constantes
Variables
Las variables referencia a un valor que puede cambiar con el tiempo siempre
y cuando mantenga el tipo. Han de ser declaradas e inicializadas para
utilizarse.
Constantes
Puede ser variables cuyo valor no cambia una vez asignado o valores
incluídos en el propio código y que forman parte del programa.
4 / 31
Ejemplos
Variables
Declaración de un variable
int entero;
Declaración y asignación
int entero = 1;
Declaración, asignación y cambio.
int entero = 1;
entero = 2;
5 / 31
Ejemplos
Constantes
Declaración usando la palabra reservada final
final int ENTERO = 1;
Si intentamos modificar una constante dará error.
final int ENTERO = 1;
ENTERO = 2; //Error
6 / 31
Tipos Primitivos
Llamamos tipos primitivos a aquellos tipos que hacen referencia a una
cantidad atómica de información:
byte: enteros de -128 a 127.
short: enteros de -32.768 a 32.767.
int: números enteros de -2.147.483.648 a 2.147.483.647.
long: enteros de 9.223.372.036.854.775.808 a +9.223.372.036.854.775.807.
boolean: valores verdaderos y falsos (true, false).
char: carácter Unicode con valor de 0 a 65.535 (casi todo UTF8). Se
escriben con comillas simples: 'a'.
float: números con decimales con poca precisión. Se pueden escribir
como 1.0f.
double: números decimales con alta precisión.
7 / 31
Objetos
Llamamos objetos a ideas más complejas.
Un objeto es una entidad que contiene información y funcionalidad propias.
Un ejemplo de objeto podría ser un Avión, el cual contiene Alas y acciones
como despegar.
Avion avion1 = new Avion();
avion.despegar();
8 / 31
Objetos y Clases
En Java, cada archivo .java es una clase.
Una clase es un molde o una idea. Siguiendo el ejemplo anterior, tendríamos
la clase Avion y el objeto avion ALM-MAD.
La clase Avion podría tener la siguiente forma:
public class Avion {
public Ala alaDerecha;
public Ala alaIzquierda;
public Turbina turbina;
public String origen;
public String destino:
public void despegar() {
}
}
9 / 31
Objetos y Clases
Podríamos crear un nuevo avión de la siguiente forma
Avion avionALMMAD = new Avion();
avion.origen = "Almería";
avion.destino = "Madrid";
Cómo se puede ver, tras crear el objeto le hemos asignado valores a sus
propiedades origen y destino.
Sin embargo, podemos usar métodos especiales denominados constructores
para asignar los valores en el momento de inicialización del objeto
10 / 31
Objetos y Clases
public class Avion {
public Ala alaDerecha;
public Ala alaIzquierda;
public Turbina turbina;
public String origen;
public String destino:
public Avion(String ori, String dest) {
origen = ori;
destino = dest;
}
public void despegar() {
}
}
Avion avionALMMAD = new Avion("Almería", "Madrid");
11 / 31
Métodos
Los métodos permiten dotar de funcionalidades a las clases.
Cada método tiene:
Tipo de valor a devolver: Cada método puede devolver un único valor o
ninguno como salida. En caso de devolver un valor ha de especificarse el
tipo y asegurase que se devuelve.
Parámetros: Los métodos pueden contener parámetros de entrada
Operaciones a realizar: El método ha de contener una serie de
operaciones a realizar antes de devolver el valor.
Ejemplo
public int suma(int enteroA, int enteroB) {
int resultado = enteroA + enteroB;
return resultado;
}
12 / 31
Paquetes e imports
Cada clase Java deberá estar contenida dentro de un paquete del tipo:
mi.nombre.de.paquete
Y para ello hay que declalarlo en el archivo Java de la siguiente forma:
package mi.nombre.de.paquete;
Para que una clase pueda usar otra contenida en un paquete diferente, esta
deberá importarlo.
13 / 31
Paquete e imports
package mi.nombre.de.paquete;
import paquete.de.otro.ClaseAjena;
import paquete.de.otro.OtraClase;
class MiClase {
...
}
14 / 31
Visibilidad y modificadores
Las clases pueden contener variables y métodos como vimos anteriormente.
Todos ellos tienen visibilidad la cual indican quien pueden acceder a ellos.
Pública public: El método o variable es visible para cualquier otra clase
que pueda acceder al objeto.
Privada private: El método o variable es visible sólo para el propio objeto o
clase. Si cualquier otra clase intenta acceder a él habrá un error de
compilación.
Protegida protected: Sólo es visible para la propia clase u objeto y para
aquellos que desciendan de él (lo veremos más adelante).
De paquete - sin modificador: si no añadimos ningún modificador, dicha
variable o método será accesible para clases que se encuentren en el
mismo paquete que la que lo contiene.
Así mismo, las propias clases pueden ser públicas o privadas.
Finalmente, tenemos el modificar estático static el cual determina que una
variable o método es común a todos los objetos de la misma clase.
15 / 31
Visibilidad y modificadores
public class MiClase {
// Creamos una constante accesible mediante MiClase.NOMBRE;
public static final String NOMBRE = "MiClase";
// Se llama con MiClase.metodoEstatico();
public static void metodoEstatico() { ... }
// Se llamaría con miObjeto.metodoInstanciaPublico() siempre que se esté en el mismo paquete
int metodoInstanciaPublico() {
int result = metodoInstanciaPrivado();
return result;
}
// No podría llamarse desde fuera
private int metodoInstanciaPrivado() { ... }
}
16 / 31
Herencia
Una clase puede heredar de otra. Esto es, que una clase puede tener
información y funcionalidad común de una clase además de información y
funcionalidad propia.
Un ejemplo sería que Ave sería un Animal puesto que tiene comportamientos
comunes con todos los animales. Además, Animal puede ser un Organismo.
Cuando una clase hereda de otra, además de adquirir su información y
funcionalidad, también adquirirá su tipos, pudiendo asignar a una variable de
tipo Organismo tanto otro Organismo, como un Animal como un Ave.
Para hacer uso de la herencia se utiliza la palabra extends.
17 / 31
Herencia
public class Organismo {
...
}
public class Animal extends Organismo {
...
}
public class Ave extends Animal {
...
public void vuela() {
}
}
Organismo aguila = new Ave("Águila");
18 / 31
Herencia
Sin embargo, si intentamos acceder a algún método o variable de una clase
que no corresponde con la declarada, el compilador nos dará error. Para
solucionarlo, deberemos castear la variable.
Organismo aguila = new Ave("Águila");
aguila.vuela(); // Daría error, ya que un Organismo no tiene el comportamiento "volar"
Ave aveAguila = (Ave) aguila;
aveAguila.vuela(); // Funcionaría sin problema
((Ave) aguila).vuela(); // También funcionaría
19 / 31
Herencia
Al heredar es posible modificar parcial o totalmente los métodos de la clase
padre. Para ello, basta con escribir el método con el mismo nombre, retorno y
parámetros y añadir la anotación @Override.
Si deseamos llamar al método original podremos hacerlo con els sufijo super..
public class ClasePadre {
public int operacion(int intA, int intB) {
return intA + intB;
}
}
20 / 31
Herencia
public class ClaseHija extends ClasePadre {
@Override
public int operacion(intA, intB) {
// La clase hija, además de hacer la suma, le suma uno al resultado
return super.operacion(intA, intB) + 1;
}
}
public class OtraClaseHija extends ClasePadre {
@Override
public int operacion(intA, intB) {
// En este caso, queremos que "operacion" multiplique, no sume
return intA * intB;
}
}
21 / 31
Interfaces
Una interfaz es un contrato, una serie de comportamientos que la clase que la
implemente debe tener obligatoriamente.
public interface MiInterfaz {
public int operacion(String parametro) {
}
}
De esta forma, cualquier clase que implemente la interfaz MiInterfaz tendrá que
tener un método void operacion(String parametro).
22 / 31
Interfaces
public class MiClase implements MiInterfaz {
@Override
public int operacion(String parametro) {
...
return valorEntero;
}
}
Puesto que MiClase implementa MiInterfaz podremos asignar elementos del tipo
MiClase a variables MiInterfaz y usar las funcionalidades definidas en estas
última:
// De cara al código, operador es de tipo MiInterfaz
MiInterfaz operador = new MiClase();
operador.operacion("Uno");
23 / 31
Clases Abstractas
Por último, existen un tipo de clases llamadas abstractas, que están a medio
camino entre una interfaz y una clase normal:
public abstract class ClaseAbstracta {
public abstract void operacion();
public void otraOperacion() {
...
}
}
public class MiClase extends ClaseAbstracta {
@Override
public void operacion() {
...
}
}
24 / 31
Estructuras de Datos
En Java, se pueden tener listas de 2 formas:
Listas inmutables (arrays):
Se debe conocer el tamaño que quieren que se tengan de antemano para
inicializarlo con él. Se notan como Tipo[]:
// Lista de 3 strings
String[] arrayStrings = new String[2];
arrayStrings[0] = "Hola";
arrayStrings[1] = "Mundo";
arrayString.length() // 2
arrayStrings = new String[] {"Hola", "Mundo"};
25 / 31
Listas modificables:
// El tipo de variable se escribe entre < > y DEBE SER UNA CLASE (no primitivos)
// No tiene por qué saberse el tamaño final
// Ponemos ArrayList porque "List" es una interfaz
List<String> miLista = new ArrayList<String>();
miLista.add("Hola");
miLista.add("Mundo");
miLista.remove(1);
miLista.add(1, "Mundo");
miLista.size(); // 2
Mapas o diccionarios:
Toman parejas de ["clave", "valor"] para guardar los datos:
Map<String, Integer> mapa = new HashMap<String, Integer>();
mapa.put("Uno", 1);
int valor = mapa.get("Uno");
mapa.remove("Uno");
26 / 31
Genéricos
Para guardar cualquier dato y recuperarlo sin tener que hacer casteo se usan
tipos genéricos.
public class <Tipo extends Object> MiClase<Tipo> {
public Tipo operacion(int arg) {
Tipo resultado = ...
return Tipo;
}
}
Esto le dice a la clase que se usará el tipo genérico "Tipo", que será al menos de
tipo Object. Si quisiéramos usar sólo strings:
public class <T extends String> MiClase<T> {
public T operacion(int arg) {
T resultado = ...
return T;
}
}
27 / 31
Condicionales y bucles
Para hacer comprobaciones usaremos las sentencias if/else:
int valor;
...
if(valor > 5) {
if(valor == 10) {
...
}
} else {
...
}
También es posible usar else if para evitar que se "aniden" demasiado los ifs
unos dentro de otros.
Una forma más corta de hacer un if es con ?:
(valor > 5) ? operacionSiTrue : operacionSiFalse;
28 / 31
Si tenemos valores de tipo entero (o Strings en Java 7 o mayor), podemos usar
switch como si fuera un if:
int valor;
...
switch(valor) {
case 0:
break;
case 1:
break;
// Si el valor no coincide con ninguno de los superiores
default:
...
}
Es necesario utilizar break entre un caso y otro ya que de lo contrario:
switch(valor) {
case 0:
...
case 1:
break;
}
Si valor fuera 0, se ejecutaría el caso 0 y luego el 1 hasta encontrar un break.
29 / 31
Bucles
Para hacer bucles podemos usar while, que ejecutará el código que contenga
mientras que se cumpla la condición establecida:
int i = 0;
while(i < 5) {
i++; // i = i + 1;
}
// Aquí i valdría 5
Este mismo código podría haberse escrito con un for. for tiene 3 partes:
Declaración de la variable
Declaración de la comprobación
Declaración de la operación a realizar tras cada iteración:
for(int i = 0; i < 5; i++) {
...
}
30 / 31
Si tenemos una estructura que implemente la interfaz Iterable, además
podremos hacer lo siguiente:
List<String> lista;
...
for(String string : lista) {
string.replaceAll("a", "e");
}
Si quisiéramos salir rápidamente de un bucle podemos hacerlo con la
instrucción break, como en los switch:
for(int i = 0; i < 5; i++) {
if(i == 2) {
// Saldría en la 3º iteración
break;
}
}
31 / 31