Programación Orientada a Objetos en Java Parte II 7ff0697cf5d24e45b23a8a1c0d3e75a4

Jose Ignacio Zaballos
*
Implantación de Aplicaciones Web
*
Índice
!
Excepciones
!
Clases y objetos
!
Herencia
!
Interfaces
*Excepciones
¿Qué es una excepción?
!
La compilación no encuentra todos los errores en un código
!
Una excepción es un evento que ocurre durante la ejecución
de un programa y que interrumpe el flujo de instrucciones
!
Para tratar una excepción se utiliza el bloque try-catch:
try {
// código que puede provocar una excepción
} catch (tipo_de_excepcion e) {
// lo que se hace si se lanza la excepción
}} catch (otro_tipo_de_excepcion e) {
// lo que se hace si se lanza la excepción
}…
*Excepciones
¿Qué es una excepción?
!
Uso del bloque finally
o
Cerrar recursos usados previamente
try {
// código que puede provocar una excepción
} catch (tipo_de_excepcion e) {
// lo que se hace si se lanza la excepción
} finally {
/* siempre se ejecutan estas instrucciones que
resuelven los problemas encontrados en el
bloque try */
}
*Excepciones
¿Qué es una excepción?
!
Uso de throws
void lecturaDeTeclado() throws IOException {
BufferedReader lectura;
InputStreamReader ier;
ier = new InputStreamReader(System.in);
lectura = new BufferedReader(ier);
String frase = lectura.readLine(); //lectura de una línea desde teclado
}
*
Índice
!
Excepciones
!
Importar clases
!
Clases y objetos
!
Herencia
!
Interfaces
*Importar clases
Importación de clases
Import [nombre del paquete].[nombre del subpaquete].nombre de la clase;
Import [nombre del paquete].[nombre del subpaquete].*;
class <nombre de clase> {
I M P O R TA U N A Ú N I C A
CLASE CONCRETA
…
…
}
…
public class <nombre de clase> {
…
public static void main(String[] arg) {
…
}
}
I M P O R TA TO D A S L A S
CLASES DE DENTRO DEL
SUBPAQUETE
*
Índice
!
Excepciones
!
Importar clases
!
Clases y objetos
!
Herencia
!
Interfaces
*Clases y objetos
Declaración de clases
import <nombre de paquetes o clases>;
class <nombre de clase> {
…
CLASES PREDEFINIDAS
<nombre de paquete>.<nombre de clase>
…
}
…
public class <nombre de clase> {
CLASES DEFINIDAS POR
EL PROGRAMADOR
…
public static void main(String[] arg) {
…
CLASE PRINCIPAL
}
}
!
!
!
En un archivo sólo puede haber una clase pública
El nombre del archivo coincide con el de la clase pública
La clase raíz en Java es la clase Object que está en java.lang
*Clases y objetos
Clases de variables
LOCALES
DECLARADA DENTRO DE UN MÉTODO Y SÓLO SE CONOCE
EN EL MÉTODO
DE INSTANCIA
DECLARADA DENTRO DE UNA CLASE (FUERA DE SUS
MÉTODOS). PERTENECE A LOS OBJETOS
DE CLASE O
ESTÁTICAS
DECLARADA DENTRO DE UNA CLASE (FUERA DE SUS
MÉTODOS). PERTENECE A LA CLASE
VARIABLES MIEMBROS
static
public
private
protected
sin modificador
!
[modificador] tipo nombre_variable;
primitivos
no primitivos
*Clases y objetos
Clases de variables
class MiClase {
private float a,b;
public boolean var;
private static int suma;
public static double
total;
protected char opcion;
protected static String
dato;
int paso;
...
// métodos de la clase
...
}
!
Variables de instancia:
!
a, b, var, opcion, paso
Variables estáticas:
suma, total, dato
*Clases y objetos
Declaración de métodos
DATOS
<nombre de clase>
[modificadores] class <nombre_clase> {
// variables (de instancia)
// variables (estáticas)
[modificadores] tipo <nombre_metodo>
([parámetros]) {
//variables locales
MÉTODOS
static
public
private
protected
sin modificador
abstract
//sentencias
}
}
primitivos
no primitivos o clases
void
*Clases y objetos
Declaración de métodos
[modificadores] tipo <nombre_metodo> ([parámetros]) { … }
Tipo
Ejemplo de declaración del
método
Ejemplo de llamada al
método
void
void metodoVoid() { … }
??
Tipo primitivo
(byte,short,int,lon
g,float,double,
boolean,char)
int metodoPr() { … }
??
Tipo no primitivo
(clase)
MiClase metodoNoPr() { … }
??
*Clases y objetos
Declaración de métodos: métodos constructores
!
Toda clase en Java tiene uno o más métodos constructores
(como mínimo uno por defecto)
!
Los métodos constructores son públicos, no devuelven un tipo
de dato y tienen el mismo nombre de la clase
public MiClase()
public MiClase(int p1,double p2,OtraClase p3)
public MiClase(String p1,NuevaClase p2)
!
Los métodos constructores se utilizan para CREAR objetos de
la clase y para iniciar las variables de instancia y estáticas
*Clases y objetos
Declaración de métodos: métodos constructores
class MiClase {
variables de instancia
variables estáticas
MiClase objeto1=new MiClase();
MiClase objeto2=new MiClase(dato1,dato2);
String
métodos no estáticos
y métodos estáticos
NuevaClase
variables y métodos estáticos
}
variables de instancia
variables de instancia
cada objeto
utiliza su copia
de las variables de instancia
y métodos no estáticos
métodos no estáticos
objeto 1
métodos no estáticos
objeto 2
*Clases y objetos
Llamada a métodos
LA LLAMADA A UN MÉTODO DE UNA CLASE SE PUEDE HACER DESDE:
• UN MÉTODO DE LA MISMA CLASE
• UN MÉTODO DE OTRA CLASE
¡¡¡
P E R O E S TA L L A M A D A E S
DIFERENTE SI LOS MÉTODOS
(LLAMADO Y LLAMADOR) SON O
NO ESTÁTICO
!!!
*Clases y objetos
Llamada a métodos
LLAMADA A LOS MÉTODOS NO ESTÁTICOS DE UNA CLASE (Clase1) DESDE
OTRO MÉTODO NO ESTÁTICO DE LA MISMA CLASE
Tipo
Ejemplo de declaración del método
Ejemplo de llamada al
método
void
void metodoVoid() { … }
metodoVoid();
Tipo primitivo
(byte,short,int,lon
g,float,double,
boolean,char)
int metodoPr() { … }
int dato;
dato=metodoPr();
Tipo no primitivo
(clase)
MiClase metodoNoPr() { … }
MiClase dato;
dato=metodoNoPr();
*Clases y objetos
Llamada a métodos
class MiClase {
int suma(int a,int b) {
int resultado=a+b;
return resultado;
}
int resta(int a,int b) {
int resultado=a-b;
return resultado;
}
void calcular(char operacion,int a,int b) {
int resultado;
if (operacion==‘+’) {
resultado=suma(a,b);
System.out.println(“La suma es: “+resultado);
} else
if (operación==‘-’) {
resultado=resta(a,b);
System.out.println(“La resta es: “+resultado);
}
}
}
*Clases y objetos
Llamada a métodos
LLAMADA A LOS MÉTODOS NO ESTÁTICOS DE UNA CLASE (Clase1) DESDE
OTRO MÉTODO ESTÁTICO DE LA MISMA CLASE
Tipo
Ejemplo de declaración del método
Ejemplo de llamada al
método
void
void metodoVoid() { … }
obj.metodoVoid();
Tipo primitivo
(byte,short,int,long,
float,double,
boolean,char)
int metodoPr() { … }
int dato;
dato=obj.metodoPr();
Tipo no primitivo
(clase)
MiClase metodoNoPr() { … }
MiClase dato;
dato=obj.metodoNoPr();
obj es un objeto de la clase Clase1
*Clases y objetos
Llamada a métodos
class MiClase {
int suma(int a,int b) {
int resultado=a+b;
return resultado;
}
int resta(int a,int b) {
int resultado=a-b;
return resultado;
}
static void calcular(char operacion,int a,int b) {
int resultado;
MiClase obj=new MiClase();
if (operacion==‘+’) {
resultado=obj.suma(a,b);
System.out.println(“La suma es: “+resultado);
} else
if (operación==‘-’) {
resultado=obj.resta(a,b);
System.out.println(“La resta es: “+resultado);
}
}
}
*Clases y objetos
Llamada a métodos
LLAMADA A LOS MÉTODOS ESTÁTICOS DE UNA CLASE (Clase1) DESDE
OTRO MÉTODO DE LA MISMA CLASE
Tipo
Ejemplo de declaración del método
Ejemplo de llamada al
método
void
static void metodoVoid() { … }
metodoVoid();
Tipo primitivo
(byte,short,int,lon
g,float,double,
boolean,char)
static int metodoPr() { … }
int dato;
dato=metodoPr();
Tipo no primitivo
(clase)
static MiClase metodoNoPr() { … }
MiClase dato;
dato=metodoNoPr();
*Clases y objetos
Llamada a métodos
PUEDE SER static
class MiClase {
static int suma(int a,int b) {
int resultado=a+b;
return resultado;
}
static int resta(int a,int b) {
int resultado=a-b;
return resultado;
}
void calcular(char operacion,int a,int b) {
int resultado;
if (operacion==‘+’) {
resultado=suma(a,b);
System.out.println(“La suma es: “+resultado);
} else
if (operación==‘-’) {
resultado=resta(a,b);
System.out.println(“La resta es: “+resultado);
}
}
}
*Clases y objetos
Llamada a métodos
LLAMADA A LOS MÉTODOS NO ESTÁTICOS DE UNA CLASE (Clase1) DESDE
UN MÉTODO DE OTRA CLASE (Clase2)
Tipo
Ejemplo de declaración del método
Ejemplo de llamada al
método
void
void metodoVoid() { … }
obj.metodoVoid();
Tipo primitivo
(byte,short,int,long,
float,double,
boolean,char)
int metodoPr() { … }
int dato;
dato=obj.metodoPr();
Tipo no primitivo
(clase)
MiClase metodoNoPr() { … }
MiClase dato;
dato=obj.metodoNoPr();
obj es un objeto de la clase Clase1
*Clases y objetos
Llamada a métodos
import java.io.*;
public class Bienvenida {
public static void main(String[] arg) throws IOException {
String tuNombre,tuApellido;
BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in));
System.out.println( Introduce tu nombre: );
tuNombre=entrada.readLine();
System.out.println( Introduce tu apellido: );
tuApellido=entrada.readLine();
System.out.println( Soy +tuNombre+ +tuApellido+ y estoy aprendiendo Java );
}
}
*Clases y objetos
Llamada a métodos
LLAMADA A LOS MÉTODOS ESTÁTICOS DE UNA CLASE (Clase1) DESDE UN
MÉTODO DE OTRA CLASE (Clase2)
Tipo
Ejemplo de declaración del método
Ejemplo de llamada al
método
void
static void metodoVoid() { … }
Clase1.metodoVoid();
Tipo primitivo
(byte,short,int,long,
float,double,
boolean,char)
static int metodoPr() { … }
int dato;
dato=Clase1.metodoPr();
Tipo no primitivo
(clase)
static MiClase metodoNoPr() { … }
MiClase dato;
dato=Clase1.metodoNoPr();
*Clases y objetos
Llamada a métodos
import java.io.*;
public class Bienvenida {
public static void main(String[] arg) throws IOException {
String tuEdad;
int edad;
BufferedReader entrada=new BufferedReader(new InputStreamReader(System.in));
System.out.println( Introduce tu edad: );
tuEdad=entrada.readLine();
edad=Integer.parseInt(tuEdad);
System.out.println( Mi edad es: +edad);
}
}
*Clases y objetos
Llamada a métodos
class MiClase {
void miMetodoVoid(int a,double b,Vector obj) {
...
}
...
miMetodoVoid(x,y,miObjeto);
}
DECLARACIÓN
DEL MÉTODO SI SE
DECLARAN LOS
PARÁMETROS
int miMetodoPr( ) {
...
EN LA
EN LA LLAMADA
AL MÉTODO NO SE
DECLARAN LOS
PARÁMETROS
}
• Los parámetros siempre se pasan por VALOR
• Las variables de instancia y estáticas NO se pasan
por parámetros (lo mismo ocurre con las constantes)
*Clases y objetos
Entrada/Salida
!
Corresponde con las operaciones que se encargan del flujo de
información con el exterior
!
Pueden ser: estándar y a través de archivo
!
La entrada/salida estándar se controla mediante la clase
System y tres objetos de esta clase, que se crean
automáticamente al iniciar la aplicación:
!
!
!
System.in
System.out
System.err
*Clases y objetos
Entrada/Salida
!
System.in implementa la entrada estándar
!
Los métodos que proporciona para controlar la entrada de
datos son:
!
!
read(): devuelve el byte leído a la entrada
skip(n): ignora los n caracteres siguientes en la entrada
try {
System.in.read();
} catch (IOException ex) {
// tratamiento del problema
}
Importar java.io
*Clases y objetos
Entrada/Salida
!
System.out implementa la salida estándar
!
Los métodos que proporciona para controlar la salida de datos
son:
!
!
print(a): imprime el dato a en la salida (a puede ser de cualquier
tipo de dato primitivo. Java convierte a String)
println(a): igual que el anterior, pero hace salto de línea después
System.out.println( Hola Mundo );
System.out.print( El resultado es: +resultado);
System.out.println();
*Clases y objetos
Sobrecarga de métodos
class Sobrecarga {
void prueba ( ) {...}
void prueba(int x) {...}
void prueba(int x,double y) {...}
}
el concepto de SOBRECARGA
se puede aplicar a cualquier
método de una clase
class DemostracionSobrecarga {
void pruebaSobrecarga() {
Sobrecarga obj=new Sobrecarga();
obj.prueba();
obj.prueba(3);
obj.prueba(3,10.3);
}
}
*Clases y objetos
Acceso a los miembros
Desde la
clase
Desde otra
clase o
subclase en el
mismo paquete
Desde una
subclase de
fuera del
paquete
Desde otra
clase de
fuera del
paquete
public
Si
Si
Si
Si
protected
Si
Si
Si/No(*)
No
sin
modificador
Si
Si
No
No
private
Si
No
No
No
Modificador
(*): sólo los miembros estáticos son visibles, los de instancia no lo son
*
Índice
!
Excepciones
!
Clases y objetos
!
Herencia
!
Interfaces
*Herencia
Declaración de clases
[modificadores] class <nombre_clase>
[extends <nombre_superclase>]
[implements <nombre_inferface1>,<nombre_interface2>,...] {
// variables (de instancia)
// variables (estáticas)
// métodos
}
Los descendientes de una clase tienen visibilidad sobre todos
los miembros públicos y protegidos de la clase
*Herencia
Acceso a los miembros
ClaseBase
class ClaseBase {
SUPERCLASE
private ...; // miembros privados
...
public ...; // miembros públicos
...
}
class NuevaClase extends ClaseBase {
NuevaClase
SUBCLASE
// variables y métodos heredados
private ...; // miembros privados
...
public ...; // miembros públicos
}
CARACTERÍSTICAS
PARTICULARES
CARACTERISTICAS
COMUNES
Los constructores no son
heredados
por las subclases
*Herencia
Clases abstractas
!
Una clase que tenga métodos abstractos es una clase abstracta
!
Una clase abstracta puede tener métodos abstractos y no abstractos
abstract class ClaseAbstracta {
abstract void miMetodo(int a,float b);
Vector miOtroMetodo() { ... }
}
Método abstracto que
no se implementa
Método no abstracto
que se tiene que
declarar
!
Una clase abstracta no se puede instanciar (no pueden crearse
objetos de esa clase mediante la cláusula new). Se usa como
superclase
!
Las clases hijas deben redeclarar los métodos abstractos y darles
funcionalidad
*
Índice
!
Excepciones
!
Clases y objetos
!
Herencia
!
Interfaces
*Interfaces
Declaración de clases
[modificadores] class <nombre_clase>
[extends <nombre_superclase>]
[implements <nombre_inferface1>,<nombre_interface2>,...] {
// variables (de instancia)
// variables (estáticas)
// métodos
}
Toda clase que implemente una interfaz DEBE redefinir sus métodos
*Interfaces
Declaración de interfaces
!
Una interfaz (a ser implementada) es una variante de clase
abstracta
!
Todos los métodos son, por defecto, públicos y abstractos
!
Si existen variables no locales, éstas deben llevar los
modificadores static final
interface MiInterfaz {
public static final int MIVARIABLE=...;
void miMetodo();
}
*Interfaces
Interfaces y eventos
!
Las interfaces definen los métodos que se llaman cuando ocurre un
evento
!
A través de los argumentos se pasa información sobre el evento
!
El programador debe crear la clase que implementa la interfaz, y por
tanto, al método (o métodos)
Constructor:
Registrar el notificador de eventos
1
Nuestra clase
Método callback:
Procesa el evento
Código externo
Register callback
Espera por el evento:
Llama al método callback
2
*Interfaces
Ejemplo de interfaz
!
Ejemplo de especificación de una interfaz:
public Interface CommandListener {
void commandAction(Command c,Displayable d);
}
!
Ejemplo de implementación de una interfaz:
class Prueba implements CommandListener {
...
public void commandAction(Command c,Displayable d) {
// acciones asociadas
}
}
LOS MÉTODOS
DE UNA
INTERFAZ A SER
IMPLEMENTADA
SON PÚBLICOS
Y ABSTRACTOS
POR DEFECTO