Download Iniciación a Java

Iniciación a Java
1.Introducción a Java
2.Programación Orientada a Objetos
3.Fundamentos del lenguaje Java
4.Trabajando con Objetos
5.Manejo de Clases, Métodos y Variables
6.Conceptos Avanzados de Java
1. Introducción a Java
1.1.Introducción
1.6.El API del SDK
1.2.Orígenes e historia del lenguaje Java
1.7.Cómo compilar archivos
1.3.Características de Java
1.4.El Software Development Kit de Java
1.5.Instalación y configuración del J2SE 1.4.2
1.8.El Classpath
1.9.Ejecución de Programas en Java
1.10.Resumen
1.1. Introducción
Hablaremos de:
● origen e historia de Java
● características que lo diferencian de otros lenguajes
● instalación de la plataforma ● consejos de compilación y ejecución 1.2. Orígenes e historia del lenguaje Java
●
Desarrollado por Sun Microsystems en 1991
●
Destinado a electrodomésticos domésticos
●
Independiente de la plataforma
●
Basado en C++
●
El proyecto se disolvió en 1994
●
Sun desarrolla HotJava con soporte de applets
●
Netscape da soporte a los applets
1.3. Características de Java
●
Simplicidad: Basado en C++ para fácil aprendizaje
●
Orientado a Objetos: Ventajas frente a procedural
●
Distribuido: Trabajo en red
●
Robusto: Elimina problemas comunes en C
●
Seguro: sandbox
●
Independencia de Plataforma (WORE): JVM
●
Multithreaded: Múltiples hilos de ejecución
1.4. El Software Development Kit de Java
●
JDK ó SDK: Herramientas para compilar y ejecutar
●
J2SE (Java 2 Standard Edition)
●
J2ME (Java 2 Mobile Edition)
●
J2EE (Java 2 Enterprise Edition)
1.5. Instalación y configuración del J2SE 1.4.2
Descarga: http://java.sun.com/j2se/1.4.2/download.html
Una vez instalado:
● W98/ME: Añadir al Autoexec.bat
SET PATH=c:\j2sdk1.4.2\bin;%PATH%
● WNT/200/XP: Panel de control/ Sistema/ Avanzado/ Variables de Entorno/ Variables del Sistema añadir a PATH la ruta del SDK
● Linux: Añadir $HOME/.bashrc ó $HOME/bash_profile
export PATH=/usr/local/j2sdk1.4.2/bin:$PATH
1.6. El API del SDK
http://java.sun.com/j2se/1.4.2/docs/api/
1.7. Cómo compilar archivos
javac ­d dir_dest ­classpath cp1:cp2 archivo.java
Ej: javac ­d . MiClase.java
1.8. El Classpath
●
●
Caminos de búsqueda de clases utilizadas
Como mínimo las del Java Run Time: jdk1.4/jre/lib/rt.jar
1.9. Ejecución de Programas en Java
java MiClase
Fallos típicos:
● método main() tiene que estar definido
● java MiClase.class (sobra .class)
● si salta java.lang.NoClassDefFoundError y nuestra clase define package paquete.clases hay que ejecutar:
java paquete.clases.MiClase
1.10. Resumen
Diseñado para electrodomésticos, actualmente para aplicaciones de servidor
●Simplicidad, orientación a objetos, distribución, robustez, seguridad, independencia de plataforma, multihilo
●Al compilar se genera bytecode interpretado por la JVM
●SDK: herramientas para compilar y ejecutar. J2SE, J2EE, J2ME
●API: conjunto de clases
●Compilador: javac; ejecución: java; classpath define camino de búsqueda
●
2. Programación Orientada a Objetos
2.1.Introducción
2.4.Herencia
2.2.Orientación a objetos 2.5.Paquetes
2.3.Clases en Java. Atributos y Métodos
2.6.Resumen
2.1. Introducción
●
Que son clases y objetos
●
Atributos y métodos en las clases
●
Herencia
●
Paquetes
2.2. Orientación a objetos
(1/2)
Ordenador: placa, procesador, memoria, disco duro, etc.
●
Disco duro: discos superpuestos, cabeza lectora, circuito controlador, etc.
●
“El todo está compuesto por piezas y cada pieza por partes más pequeñas”
●
Si se estropea un disco duro y existen estándares para la conexión (indep. fabricante) sin problema.
●
Objeto (disco duro), función (almacenar datos), atributos (los datos), interfaz (IDE, SCSI)
●
2.2. Orientación a objetos
(2/2)
Objetos:
● Realizan una tarea por sí solos
● Proporcionan encapsulación
● Son reutilizables
● Proporcionan escalabilidad (el programa puede crecer) y modularidad (división en bloques para fácil comprensión)
2.3. Clases en Java. Atributos y Métodos (1/4)
Escribimos clases (abstracción, plantilla) no objetos (realización)
2.3. Clases en Java. Atributos y Métodos (2/4)
class Coche {
boolean estadoMotor = false;
String color;
String modelo;
...
2.3. Clases en Java. Atributos y Métodos (3/4)
...
void arrancar() {
if (estadoMotor == true)
System.out.println(“Coche ya arrancado”);
else {
estadoMotor = true;
System.out.println(“Arrancado”);
}
}
...
2.3. Clases en Java. Atributos y Métodos (4/4)
...
void detener() {
if (estadoMotor == false)
System.out.println(“Coche ya detenido”);
else {
estadoMotor = false;
System.out.println(“Detenido”);
}
}
} // fin de la clase Coche
2.4. Herencia
(1/2)
●
●
●
●
●
Toda clase existe dentro de una jerarquía
En Java, toda clase tiene una y solo una clase por encima (herencia simple)
La clase hereda métodos y propiedades de su superclase
Cada subclase extiende y concreta la funcionalidad y características de su superclase, se “especializa”
En Java todas las clases heredan de Object
2.4. Herencia
(2/2)
class Animal {
float peso;
void comer(){}
}
class Memifero extends Animal {
boolean sangreCaliente;
void parir() {}
void amamantar() {}
}
2.5. Paquetes
●
conjunto de clases e interfaces relacionados
●
una forma de crear librerías
●
API Java, package java
●
import
●
Por defecto siempre se incluye java.lang sin necesidad del import
2.6. Resumen
●
●
●
●
●
Programas Java: compuestos por objetos independientes que se comunican entre sí
Objetos: tienen atributos (sus variables) y métodos (comportamiento)
Clases: abstracción de objetos (plantillas)
Toda clase hereda atributos y métodos de su superclase (cabeza de pirámide java.lang.Object)
Paquetes: agrupación de clases
3. Fundamentos del lenguaje Java
3.1.Introducción
3.5.Instrucciones
3.2.Comentarios
3.6.Expresiones y Operadores
3.3.Variables y Tipos de Datos
3.7.Control de Flujo
3.4.Literales
3.8.Resumen
3.1. Introducción
●
●
Introduciremos la herramientas para escribir programas en Java
Veremos la sintaxis de las instrucciones, variables, tipos de datos, literales, operadores y flujo de programa
3.2. Comentarios
●
●
●
/* Comentarios de
varias líneas */
int variable; // Comentario de final de línea
/**
* Comentario de Javadoc
* @param parametro Descripción
*/
3.3. Variables y Tipos de Datos
●
Zonas de memoria donde almacenar valores
●
Tienen: tipo, nombre y valor
●
Antes de utilizarlas hay que definirlas
3.3.1. El nombre de la variable
●
Se pueden definir en cualquier parte (pero mejor al principio)
●
Primer carácter: letra, guión bajo (_) o dólar ($)
●
A partir del segundo: también permite números
●
Case­sensitive
●
Por norma, la primera letra en minúscula
●
Separar palabras con letra mayúscula
3.3.2. La asignación
●
int numroEntero, numero2Entero = 3;
●
int x=4, y=5, z=6;
●
boolean motorEnMarcha = true;
●
String texto;
texto = “Esto es una cadena de texto”;
3.3.3. El tipo
●
Tipo primitivo (boolean, char, byte, short, int, long, float, double)
●
Clase o interfaz
●
Array de elementos (distinto de la clase Array)
3.4. Literales
●
●
Forma de especificar un valor
Tipos: de entero, de punto flotante, de caracteres, de cadenas, etc
3.4.1. Literales de enteros
●
int entero = 65535; // Valor decimal
●
int entero = 0xFFFF; // Valor hexadecimal (0x)
●
int entero = 0177777; // Valor octal (0)
●
long enteroLargo = 22L; // Entero 64 bits (L)
3.4.2. Literales de punto flotante
●
double flotanteLargo = 5.34; // Notación decimal
●
double flotanteLargo = 3.00e+8; // Notación científica
●
float flotanteCorto = 5.34F; // Notación decimal 32 bits
●
float flotanteCorto = 3.00e+8F; // Científica de 32 bits
●
Por defecto cualquier literal de punto flotante es de tipo double. Si queremos que sea float hay que especificarlo con F
3.4.3. Literales de caracteres
●
●
Se definen utilizando comillas simples
char carácter = 'a';
Admiten caracteres de escape ASCII o Unicode
char saltoLinea = '\n';
3.4.4. Literales de cadena
●
●
Conjunto de caracteres y secuencias de escape entre comillas dobles
Normalmente serán instancias de la clase String
String cadena = “Esto es una cadena”;
String cadena = “Cadena con \”comillas\” dentro”;
3.5. Instrucciones
(1/2)
●
Sintaxis muy similar a C o C++
●
Todas las instrucciones aparecen dentro de un bloque
●
Un bloque es todo aquello que esté entre “{“ y “}”
●
●
Todas las instrucciones finalizan con “;” con excepción de las sentencias de control de flujo
Alcance de variables limitado a su bloque
3.5. Instrucciones
(2/2)
class ClaseEjempo {
int variable=1;
void metodo() {
if (variable == 1)
System.out.println(“La variable vale 1”);
else {
System.out.println(“La variable vale 0”);
}
}
}
3.6. Expresiones y Operadores. Preferencia (1/2)
●
●
Expresión = instrucción que devuelve un valor
Las expresiones utilizan operadores (definen la operación a realizar entre los operandos)
●
Existe una relación de prioridad entre operandos
●
A igual prioridad se evalúan de izquierda a derecha
●
Para cambiar la prioridad se utilizan los paréntesis
3.6. Expresiones y Operadores. Preferencia (2/2)
Pri. Operador Operandos
1
++,­­ Aritméticos
1
!
Booleano
1
~
Entero
1
(tipo) Cualquiera
2
*,/,% Aritméticos
3
+,­
Aritméticos
3
+
String
4
<<
Entero
4
>>
Entero
5 <,<=,>,>= Aritméticos
5 instanceof Objeto
6
==,!= Tipos primitivos
Descripción
Incremento y decremento
Complemento Lógico
Complemento en binario
Casting
Multiplicación, división, módulo o residuo
Adición y sustracción
Concatenación de cadenas
Desplazamiento de bits hacia la izqueirda
Desplazamiento de bits hacia la derecha
Comparación numérica
Comparación de tipo
Igualdad o desigualdad de valor
3.7. Control de Flujo
●
Sentencias que permiten modificar el flujo de ejecución de los programas
3.7.1. if­else
(1/2)
if (condicion)
instrucción o bloque de instrucciones;
else
instrucción o bloque de instrucciones;
Donde:
condición: Expresión booleana
3.7.1. if­else
(2/2)
class ControlFlujo {
public static void main(Sring args[]) {
String cadena1 = “hola”;
String cadena2 = “hola”;
String cadena3;
if (cadena1.equals(cadena2)) {
System.out.println(“Cadenas iguales”);
cadena3 = cadena2;
System.out.println(“Cadena3: “ + cadena3);
}
else
System.out.println(“Cadenas distintas”);
}
}
3.7.2. El condicional switch
(1/2)
●
●
●
●
Permite comparar una variable con varios valores
La variable es comparada con cada uno de los valores y se ejecutan las sentencias de aquellos que coincidan
Se admite el valor por defecto default que coincide con cualquier cosa
La variable debe ser de un tipo primitivo que pueda ser convertido a int
●
La sentencia break fuerza la salida del switch
●
Los valores deben ser constantes (o variables final)
3.7.2. El condicional switch
(2/2)
class UsoDeSwitch{
public static void main(String args[]) {
int a=3;
switch(a) {
case 1:
System.out.println(“Es 1”);
break;
case 2:
System.out.println(“Es 2”);
break;
default:
System.out.println(“No es 1 ni 2”);
}
}
}
3.7.3. Bucles while y do­while
(1/2)
class UsoDeWhile {
public static void main(String args[]) {
int a=0, b=10;
while (a<10 && b>0) {
System.out.println(“a: “ + a + “ y b: “ + b);
a++; b­­;
}
}
}
3.7.3. Bucles while y do­while
(2/2)
class UsoDeDoWhile {
public static void main(String args[]) {
int a=0, b=10;
do {
System.out.println(“a: “ + a + “ y b: “ + b);
a++; b­­;
} while (a<10 && b>0);
}
}
3.7.4. Bucles for
class UsoDeFor {
public static void main(String args[]) {
int a,b=10;
for(a=0; a<10; a++) {
System.out.println(“a: “ + a + “ y b: “ + b);
b­­;
}
}
}
7.8. Resumen
●
●
●
Toda variable tiene tipo, nombre y valor
Los tipos pueden ser: uno de los 8 primitivos, una clase, un array de elementos
Los literales definen la forma en que especificamos un valor de una variable
●
Las instrucciones se agrupan en bloques
●
Una expresión es una instrucción que devuelve un valor
●
Se pueden concatenar cadenas mediante el +
●
Sentencias condicionales: if­else, switch
●
Sentencias repetitivas: while, do­while, for
4. Trabajando con Objetos
4.1.Introducción
4.5.Conversión mediante Casting
4.2.Creación y Destrucción de Objetos 4.6.Arrays
4.3.Invocación de Variables y Métodos
4.7.Trabajando con cadenas de caracteres
4.4.Métodos Constructores de una Clase
4.8.Resumen
4.1. Introducción
●
●
Aprenderemos a crear, destruir y trabajar con objetos.
Aprenderemos a invocar a los métodos y atributos, veremos que es el casting y estudiaremos los arrays y las cadenas de caracteres
4.2. Creación y Destrucción de Objetos
●
●
●
Instancia = Objeto
Instanciar una clase = crear un objeto a partir de dicha clase
Coche ferrari = new Coche();
Define una variable de tipo Coche, de nombre ferrari y que almacena una instancia de la clase Coche.
El constructor de la clase puede admitir parámetros.
●
Recolector de basura: no se necesita destruir objetos
4.3. Invocación de Variables y Métodos
●
●
●
●
Una clase, por sí sola, no puede ejecutarse. Debe tener un método main que cree un objeto de la clase o debe ser llamada desde otra clase
Todos los métodos hay que definirlos dentro de la clase, incluso el main
Podemos acceder a una propiedad mediante objeto.propiedad
Podemos invocar un método mediante objeto.metodo(parámetros)
4.4. Métodos Constructores de una Clase
●
●
Inicializa un nuevo objeto
El operador new:
reserva memoria para el objeto
inicializa las variables de instancia del objeto
invoca al método constructor
●
Java define un constructor por defecto sin parámetros
●
Un constructor no devuelve ningún tipo (ni void)
●
Un constructor tiene el mismo nombre que su clase
4.5. Conversión mediante Casting
●
●
●
●
El casting permite cambiar el valor de un objeto o tipo primitivo a otro tipo diferente
Para tipos primitivos si la conversión es de un tipo “más grande” a uno “más pequeño” está implícita:
int x = 3;
float y = x;
En caso contrario hay que especificar el casting:
float x = 100f;
int y = (int)x;
Las conversiones entre Objetos solamente se permiten si existen relaciones de herencia
4.6. Arrays
(1/2)
●
Colección de elementos ordenados
●
En Java, los arrays son objetos
●
Todos sus elementos deben ser del mismo tipo
●
●
Se definen como:
String cadenas[];
o
String[] cadenas;
Se pueden inicializar en la definición:
String cadenas[] = {“cadena1”,”cadena2”};
o inicializar solamente el número de elementos
String cadenas[] = new String[2];
4.6. Arrays
(2/2)
●
●
●
●
●
Las posiciones van de 0 al número de eltos menos uno
A los elementos se accede por índice:
cadenas[2] = “cad1”;
Para saber su longitud se utiliza el atributo length:
int logitud = cadenas.length;
Para copiar un array podemos utilizar:
System.arraycopy(oriben,iniceorigen,destino,indicedestino,num
eroelementos)
Arrays multidimensionales: int matriz[][] = new int[10][10];
4.7. Trabajando con cadenas de caracteres
●
Las cadenas son secuencias de caracteres
●
Se utiliza la clase String
●
Se pueden concatenar con el operador +
●
●
●
Cualquier objetos se puede convertir a String
int edad = 27;
String informe = “La edad es “ + edad;
Para comparar cadenas se utiliza el método equals() o equalsIgnoreCase()
En el API hay muchas funciones útiles (substring, length, ...)
4.8. Resumen
●
●
Para instanciar una clase se utiliza new
Para acceder a sus propiedades y métodos se utiliza la notación de puntos
●
El constructor es un método especial para inicializar un objeto
●
Se puede utilizar la conversión de tipos (casting)
●
●
Un array es una colección de objetos ordenados y en Java se un Objeto
Todas las cadenas de caracteres son instancias de String
5. Manejo de Clases, Métodos y Variables (1/2)
5.1.Introducción
5.2.Tipos de Variables
5.3.Alcance de las Variables
5.4.Modificadores
5.5.Control de Acceso. Tipos de protección
5.6.Finalización de clases, métodos y variables
5.7.Métodos
5.8.Pasando argumentos desde la línea de comandos
5. Manejo de Clases, Métodos y Variables (2/2)
5.9.Métodos de clase e instancia
5.14.Superposición de Métodos
5.10.Análisis del método 5.15.Sobrecarga de main
constructores
5.11.Polimorfismo
5.12.This y Super
5.13.Sobrecarga de Métodos
5.16.Superposición de constructores
5.17.Resumen
5.1. Introducción
●
●
Veremos que, según su ubicación en el código, existen varios tipos de métodos y variables con un tipo u otro de alcance
Estudiaremos el control de acceso a clases, métodos y variables
●
Veremos la definición formal de métodos
●
Explicaremos el concepto de polimorfismo
5.2. Tipos de Variables
●
●
●
Local: dentro de la definición de un método. Sólo válida para el código contenido en ese método
De Instancia: se declaran fuera de los métodos (generalmente al principio). Válida para toda la instancia (se puede usar desde cualquier método)
De Clase: se declara al principio de la clase. Válida para todas las instancias. Se utiliza la palabra reservada static en su definición
5.3. Alcance de las Variables
●
●
Alcance = zona del código donde se puede usar
Al llamar a una variable:
Java busca la definición en el ámbito (bloque) actual, como puede ser un bucle
Si no la encuentra va subiendo hasta llegar a la definición del método (variable local)
Si no la encuentra busca una de instancia o de clase
Si no la encuentra sube a la superclase a buscarla
5.4. Modificadores
●
●
Son palabras reservadas que permiten modificar la definición y el comportamiento de las clases, métodos y variables
Los más importantes:
public, protected, private para el control de acceso
static para crear métodos y variables de clase
abstract para crear clase, métodos y variables abstractas
final para indicar que finaliza la implementación de una clase, método o variable
5.5. Control de Acceso. Tipos de protección
●
●
●
El control de acceso se refiere a la visibilidad de una clase, variable o método.
Encapsulación
Cuatro niveles de protección:
público
paquete
protegido
privado
5.5.1. Protección Friendly o de Paquete
●
●
Son visibles a todas las demás clases del mismo paquete, pero no fuera de él
Es la protección por defecto cuando no se especifica
5.5.2. Protección Pública
●
●
●
Son visibles a todas las demás clases, dentro o fuera de la clase o paquete actual
Se utiliza la palabra reservada public
NOTA: cuando tengamos más de una definición de clase en el mismo archivo java, solamente una de ellas podrá ser pública y el archivo java deberá llamarse igual que esa clase
5.5.3. Protección Privada
●
●
●
Son accesibles únicamente por métodos de la misma clase.
Se utiliza la palabra reservada private
Existe un tipo especial de clases que pueden ser privadas, las clases internas
5.5.3.1. Clases Internas
●
●
●
Es aquella que está definida dentro de otra clase
Pueden acceder a la implementación de la clase creadora (incluyendo los privados)
Pueden ocultarse a otras clases del mismo paquete
class ClasePrincipal {
private atributo1;
public metodo() {}
private class ClaseInterna {
// desde aquí podemos acceder a atributo1
}
}
5.5.4. Protección Protegida
●
●
Son accesibles por todas las clases dentro del paquete y por sus subclases, aunque estén fuera de él
Se utiliza la palabra reservada protected
5.6. Finalización de clases, métodos y variables
●
●
La finalización permite bloquear la implementación de una clase, variable o método.
Se especifica utilizando la palabra reservada final generalmente a continuación de un modificador de protección.
5.6.1. Finalización de variable
●
Se convierte en una constante
final int a = 6;
5.6.2. Finalización de método
●
Evita que un método pueda ser “superpuesto”
public final void metodoInmutable() {}
●
La utilización de métodos finales acelera la ejecución del programa porque el compilador no tiene que buscar la definición de ese método en las subclases
5.6.3. Finalización de clase
●
Evita que una clase tenga subclases
public final class ClaseFinal{}
●
●
El API Java tiene clases finales para evitar que se puedan extender
Salvo por eficiencia no lo haremos
5.7. Métodos
(1/2)
●
Definen la funcionalidad de un objeto
●
Constan de:
–
uno o varios modificadores (public, static, final, etc)
–
el Objeto o Tipo Primitivo que devuelve
–
el Nombre del método
–
un conjunto de Parámetros
–
la palabra reservada throws (se verá más adelante)
–
el Cuerpo del método
5.7. Métodos
(2/2)
●
●
●
Firma (signature) del método: nombre del método + conjunto de parámetros
Cuando un método no devuelve nada debe especificarse el tipo void
Paso de parámetros:
Los tipos primitivos se pasan por valor
Los objetos se pasan por referencia
5.8. Pasando argumentos desde la línea de comandos
●
public static void main (String args[]) {...}
●
args.length: Número de argumentos
●
args[0]: Primer argumento
●
if (args[0].equals(“­version”))...
5.9. Métodos de clase e instancia
●
Los métodos de clase están disponibles para cualquier instancia de esa clase o para otras clases, independientemente de si existe, o no, una instancia de esa clase
●
public static int calculaDerivada(String ecuacion) {}
●
double coseno = Math.cos(Math.PI);
5.10. Análisis del método main
●
●
●
●
●
●
En toda aplicación, al menos debe de existir una clase que tenga un método main
public static void main(String args[])
public: el método main debe estar accesible desde fuera de la clase para poder invocarlo al arrancar la aplicación
static: es un método de clase, está disponible independientemente de que esté o no instanciada la clase
void: no devuelve nada
main: siempre se llama así (ya se explicaron los parámetros de la línea de comandos)
5.11. Polimorfismo
●
●
Es la capacidad de utilizar un objeto de una subclase como si fuera un objeto de la clase base
Permite escribir código que desconoce parcialmente las características de los objetos con los que trabaja (código desacoplado)
5.12. This y Super
●
●
●
Relacionadas con la herencia y el alcance de las variables
this: permite referirse a las variables y métodos de la instancia así como pasar el propio objeto como argumento
super: similar a this, pero se refiere a la superclase del objeto
5.13. Sobrecarga de Métodos
●
Consiste en crear varios métodos con el mismo nombre pero con distintas firmas (signature) o definiciones
5.14. Superposición de Métodos
●
●
●
●
Son métodos de subclases con la misma firma que los correspondientes de la superclase
Permite amplicar la funcionalidad de los métodos de la superclase
Java, al igual que con las variables, buscará primero el método en la clase y si no lo encuentra subirá a buscarlo a la superclase
Para llamar a la implementación de la superclase:
super.metodo(parametros);
5.15. Sobrecarga de constructores
●
●
●
●
Se utiliza igual que el resto de métodos
Si no se define ningún constructor, existe el constructor por defecto (sin parámetros)
Si se define algún constructor, únicamente están disponibles los definidos (ya no está el constructor por defecto si no se define explícitamente)
Para ejecutar un constructor desde otro:
this(parametros);
5.16. Superposición de constructores
●
●
Como los constructores deben tener el mismo nombre de la clase es imposible realizar la superposición
Pero podemos aprovechar el constructor de la clase:
super(argumentos);
5.17. Resumen
●
●
Tipos de variables: locales, de instancia y de clase
Modificadores: modifican la definición y comportamiento. Destacan los de control de acceso (public, private, protected y friendly)
●
Finalización: permite bloquear la implementación
●
Firma: tipo devuelto + nombre método + parámetros
●
Polimorfismo: usar un objeto de subclase como si fuese de la clase base (código desacoplado)
●
this: se refiere al objeto actual
●
super: ser refiere a la superclase
●
sobrecarga: varios métodos con el mismo nombre pero distinta firma
●
superposición: permite redefinir los métodos en las subclases
6. Conceptos Avanzados de Java
6.1.Introducción
6.4.Interfaces
6.2.Abstracción de clases 6.5.Entrada­Salida (E/S)
y métodos
6.6.Resumen
6.3.Excepciones
6.1. Introducción
●
En este capítulo veremos la abstracción de clases, las interfaces, el control y gestión de interrupciones y la entrada­salida (E/S)
6.2. Abstracción de clases y métodos
(1/2)
●
●
Clases abstractas: –
no pueden tener instancias
–
sirven de “referencias”
–
generalmente en la parte superior de la jerarquía de clases de Java.
–
pueden contener métodos concretos y abstractos
Métodos abstractos:
–
firma del método únicamente, sin su implementación
–
no pueden existir fuera de una clase abstracta
6.2. Abstracción de clases y métodos
(2/2)
●
●
●
Si una clase contiene un método abstracto deberá ser definida como abstracta
Para su definición se antepone abstract
Sirven para “obligar” a que las subclases implementen los métodos
6.3. Excepciones
●
●
●
Sirven para permitir a un programa recuperarse de los errores de una forma “elegante”
Permiten a los programas ser tolerantes a fallos
Las excepciones son clases (Exception y Error heredan de Throwable)
6.3.1. Captura de excepciones
(1/2)
●
●
●
●
Todas las excepciones heredan de java.lang.Exception
El código susceptible de generar excepciones se encierra entre try y catch
catch admite como parámetro el tipo de excepción a capturar
finally: es un bloque opcional después del catch. Permite realizar tareas que deben ser ejecutadas independientemente del comportamiento de errores (como cerrar una conexión de base de datos)
6.3.1. Captura de excepciones
(2/2)
try { // Código que pueda generar Errores ("Exception's")
} catch(Tipo1 id1) {
// Manejar "Exception's" para la Clase Tipo1
} catch(Tipo2 id2) {
// Manejar "Exception's" para la Clase Tipo2
} catch(Tipo3 id3) {
// Manejar "Exception's" para la Clase Tipo3
} finally { // Actividades que siempre ocurren } 6.3.2. Lanzando Excepciones
(1/2)
●
●
En la firma del método debe especificarse la o las excpciones que puede lanzar utilizando la palabra reservada throws
Dentro del cuerpo del método se lanzarán utilizando la palabra reservada throw
6.3.2. Lanzando Excepciones
(2/2)
public String leerFichero(String fichero) throws IOException, FileNotFoundException {
...
throw new FileNotFoundException(“No se ha encontrado el archivo”);
}
6.3.3. Creando nuestras propias excepciones (1/2)
public class MiExcepcion extends Exception {
public MiExcepcion() {}
public MiExcepcion(String mensaje) {
super(mensaje);
System.out.println(“Saliendo del sistema”);
// Otras acciones
}
}
6.3.3. Creando nuestras propias excepciones (2/2)
class UsoDeExcepciones {
void funcion(int a) throws MiExcepcion {
if (a==1) throw new MiExcepcion(“Se ha producido una excepción propia.”);
}
public static void main(String args[]) {
UsoDeExcepciones uso = new UsoDeExcepciones();
try {
uso.funcion(1);
} catch (MiExcepcion m) {
System.out.println(“Excepción: “ + m.getMessage());
}
}
}
6.3.4. Transfiriendo excepciones
class UsoDeExcepciones2 {
void funcion (int a) throws MiExcepcion {
if (a==1) throw new MiExcepcion(“error”);
}
void pasarMarron(int var) throws MiExcepcion{
funcion(var); // Otro código
}
public static void main(String args[]) {
UsoDeExcepciones2 uso = new UsoDeExcepciones2();
try {
uso.pasrMarron(1);
} catch (MiExcepcion m) {
System.out.println(m.getMessage());
}
} }
6.4. Interfaces
(1/2)
●
●
●
●
Solución a la herencia simple
Interfaz: Clase en la que solo se especifica comportamiento, únicamente se definen firmas de métodos y constantes
Se dice que una clase implementa una interfaz cuando implementa todos sus métodos (está obligada)
Para definir una interfaz, se antepone la palabra interface al nombre de la clase
●
Solamente pueden ser públicas o con protección de paquete
●
Los métodos son public y abstract (no se especifica)
●
Las variables son public, static y final (no se especifica)
6.4. Interfaces
(2/2)
●
●
●
●
No se pueden crear instancias de una interfaz (al igual que en las clases abstractas)
Una interfaz puede heredar de una o varias interfaces (extends Interfaz1, Interfaz2) ­herencia múltiple de interfaces­.
La implementación se indica con implements (similar al extends de la herencia). Múltiples implementaciones se separan por comas
La subclase de una clase que implementa una interfaz, también implementa la interfaz
6.5. Entrada­Salida (E/S)
●
●
●
La clase System:
–
clase final (no se puede instanciar) del paquete java.lang
–
in: flujo de entrada (InputStream)
–
err: flujo donde se redireccionan los errores (OutputStream)
–
out: flujo de salida (OutputStream)
Salida por pantalla
System.out.println();
Entrada por teclado
String texto = (new BufferedReader(new InputStreamReader(System.in))).readLine();
6.6. Resumen
●
●
●
●
Las clases y métodos abstractos no pueden instanciarse. Se utiliza el modificador abstract
Cuando un programa Java falla lanza excepciones. Capturándolas mediante try­catch podemos crear código tolerante a fallos
Las interfaces son clases que especifican un comportamiento
Java posee funciones de E/S