¡Descarga Introducción a la programación orientada a objetos y más Apuntes en PDF de Informática solo en Docsity!
Laboratorio de Tecnología de Objetos I-
Introducción a la Programación
Orientada a Objetos
¾Evolución de los Lenguajes de Programación
¾Factores, criterios y principios de la calidad del sw.
¾Conceptos básicos de la P.O.O.
9 Introd. a la POO El lenguaje Java Estruct. Biblioteca Excepciones Colecciones Entrada y salida GUIs
Índice
Laboratorio de Tecnología de Objetos I-
Evolución de los lenguajes de
A programación
B S T R A C C I Ó N O P E R A C I O N A L
A B S T R A C C I Ó N
D E
D A T O S
Lenguajes Máquina / Ensamblador
Cód.Inst.Simb. Macros
Id = Dir Mem. Manip.Total de Datos
Subrutinas FORTRAN Funciones
Id. Simb. Tipos Oper. restring.
Anidamiento PASCAL Subprogramas
Registros Tipos definidos Gest. Din. Mem
MODULA- ADA
Encapsulam. Octult. Inform. Espec - Impl
Tipo Abstracto de Datos
Lenguajes Orientados a Objetos
Métodos Objetos Mensajes
Laboratorio de Tecnología de Objetos I-
Evolución de los lenguajes de
programación
COMPONENTES
ASPECTOS
SERVICIOS
AB TS R AC CI ÓN OP ER AC I ON AL
A B S TR A C C I ÓN
D E DA T O S
Lenguajes Máquina / Ensamblador
Cód.Inst.Simb. Macros
Id = Dir Mem. Manip.Total de Datos SubrutinasFunciones FORTRAN Id. Simb. Tipos Oper. restring.
SubprogramasAnidamiento PASCAL
Registros Tipos definidos Gest. Din. Mem MODULA- ADA
Encapsulam. Octult. Inform. Espec - Impl
Tipo Abstracto de Datos Lenguajes Orientados a Objetos
Métodos Mensajes Objetos
IDLs Invocación remota Componentes
Laboratorio de Tecnología de Objetos I-
Factores, criterios y principios de
calidad del Software
FACTORES
P R I N C I P I O S
CRITERIOS
CORRECCIÓN
EXTENSIBILIDAD
COMPATIBILIDAD
REUTILIZACIÓN
ROBUSTEZ
Descomposición y Refinamientos
Modularidad
COMPRENSIÓN
COMPOSICIÓN
DESCOMPOSICIÓN
CONTINUIDAD
PROTECCIÓN
Interfaces Explícitas
Unidad Modular Lingüíst
Ocultación Informac.
Pocas interfaces
Interfaces pequeñas
Conceptos básicos de la P.O.O.
¾Clases y Objetos.
¾Métodos y Mensajes.
¾Clases versus Tipos Abstractos de Datos.
¾Herencia.
¾Polimorfismo y Vinculación Dinámica.
¾Clases abstractas.
¾Clases genéricas.
Clases y Objetos
• CLASE = MÓDULO + TIPO
9 Criterio de Modularización 9 Estado + Comportamiento 9 Entidad estática (en general)
• OBJETO = Instancia de una CLASE
9 Objeto (Clase) = Valor (Tipo) 9 Entidad dinámica 9 Cada objeto tiene su propio estado 9 Objetos de una clase comparten su comportamiento
Laboratorio de Tecnología de Objetos I-
ANIMAL
VEHÍCULO
FIGURA
PUNTO
Laboratorio de Tecnología de Objetos I-
(Punto) x = 1 y = 3
(Punto) x = 2 y = 2
• Métodos : definen el comportamiento de una
clase
• Invocación de métodos : Paso de mensajes
obj.mens(args) mens(obj, args)
Punto
x, y: double trasladar(a, b) distancia(pto)
Estado
Comportamiento
pto.trasladar(1, -1) pto
Métodos y Mensajes
Laboratorio de Tecnología de Objetos I-
• Los mensajes que se envían a un determinado objeto deben
“corresponderse” con los métodos que la clase tiene definidos.
• Esta correspondencia se debe reflejar en la signatura del método:
nombre, argumentos y sus tipos.
• En los lenguajes orientados a objetos con comprobación de tipos,
la emisión de un mensaje a un objeto que no tiene definido el
método correspondiente se detecta en tiempo de compilación.
• Si el lenguaje no realiza comprobación de tipos, los errores en
tiempo de ejecución pueden ser inesperados.
Paso de mensajes
Laboratorio de Tecnología de Objetos I-
Clases
• Estructuras que encapsulan datos y métodos
class Punto { private double x, y; public Punto() { x = y = 0; } public Punto(double a, double b) { x = a; y = b; } public double abscisa() {return x;} public double ordenada() {return y;} public void abscisa(double a){ x = a; } public void ordenada(double b){ y = b; } public void trasladar(double a, double b) { x += a; y += b; } public double distancia(Punto pto) { return Math.sqrt(Math.pow(x - pto.x, 2) + Math.pow(y - pto.y, 2)); } }
“Punto.java
VARIABLES DE ESTADO
Java
CONSTRUCTORES
MÉTODOS
class Punto{
double x, y;
public:
Punto(){x = y = 0);}
Punto(double a, double b): x(a),y(b) {}
double abscisa() {return x;}
double ordenada() {return y;}
void abscisa(double a){ x = a; }
void ordenada(double b){ y = b; }
void trasladar(double a, double b);
double distancia(Punto&);
“Punto.hpp
VARIABLES DE ESTADO
(DATOS MIEMBRO)
MÉTODOS
(FUNCIONES MIEMBRO)
C++
CONSTRUCTORES
#include “Punto.hpp”
#include <math.h>
void Punto::trasladar(double a, double b) {
x += a;
y += b;
double Punto::distancia(Punto& pto){
return sqrt(pow(x - pto.x, 2) +
pow(y – pto.y, 2));
“Punto.cpp
C++
Laboratorio de Tecnología de Objetos I-
Herencia
Exception
IOException
Padres / Ascendientes /
Superclase
Hijos / Descendientes /
Subclase
• Una subclase dispone de los atributos y
métodos de la superclase, y puede
añadir otros nuevos.
• La subclase puede modificar el
comportamiento heredado (por
ejemplo, redefiniendo algún método
heredado).
• La herencia es transitiva.
• Los objetos de una clase que hereda de
otra pueden verse como objetos de esta
última.
Laboratorio de Tecnología de Objetos I-
Java
class Punto { private double x, y;
public Punto() { x = y = 0; } public Punto(double a, double b) { x = a; y = b; } public double abscisa() { return x; } public double ordenada() { return y; } public void abscisa(double a){ x = a; } public void ordenada(double b){ y = b; } public void trasladar(double a, double b) { x += a; y += b; } public double distancia(Punto pto) { return Math.sqrt(Math.pow(x - pto.x, 2)
- Math.pow(y - pto.y, 2)); } }
Laboratorio de Tecnología de Objetos I-
class Partícula extends Punto {^ Java
protected double masa;
final static double G = 6.67e-11;
public Partícula(double m) {
super(0, 0);
masa = m;
public Partícula(double a, double b, double m) {
super(a, b);
masa = m;
public void masa(double m) { masa = m; }
public double masa() { return masa; }
public double atracción(Partícula part) {
double d = this.distancia(part);
return G * masa * part.masa() / (d * d);
Laboratorio de Tecnología de Objetos I-
C++
class Particula: public Punto {
protected double masa;
const double G = 6.67e-11 ;
public:
Particula(double m):
Punto()
{ masa = m; };
Particula(double a, double b, double m):
Punto(a, b)
{ masa = m; };
void masa(double);
double masa();
double atraccion(Particula&);
“Particula.hpp”
#include “Partic.hpp”
void Particula::masa(double m) {
masa = m;
double Particula::masa() {
return masa;
double Particula::atraccion(Particula& part) {
double d = this -> distancia(part);
return G * masa * part.masa() / (d * d);
C++
“Particula.cpp”
Eiffel
class Punto
creation origen, nuevo;
feature
x, y: REAL;
origen is do x := 0; y := 0 end;
nuevo(a, b: REAL) is
do x := a; y := b
end;
abscisa(a: REAL) is do x := a end;
ordenada(b: REAL) is do y := b end;
trasladar(a, b: REAL) is
do x := x + a; y := y + b
end;
distancia(pto: Punto): REAL is
do Result := sqrt(pow(x - pto.x, 2)
+ pow(y - pto.y, 2))
end
end Punto;
Laboratorio de Tecnología de Objetos I-
class Particula
inherits Punto
creation nueva;
feature
nueva(a, b, m: REAL) is
do x := a; y := b; masa := m
end;
masa: REAL;
masa(m: REAL) is
do masa := m
end;
atraccion(part: Particula): REAL is
do d := Current.distancia(part);
Result := G * masa * part.masa / (d * d)
end
end Particula;
Eiffel
Laboratorio de Tecnología de Objetos I-
Object subclass: #Punto instanceVariableNames: ‘ x y ’ classVariableNames: " poolDictionaries: " origen ^(self new) abscisa: 0; ordenada: 0 x: unNum y: otroNum ^(self origen) tras: unNum ladar: otroNum abscisa ^x ordenada ^y abscisa: unNum x := unNum ordenada: unNum y := unNum tras: unNum ladar: otroNum x := x + unNum. y := y + otroNum distancia: unPunto ^ ((x - unPunto abscisa) squared + (y - unPunto ordenada) squared) sqrt
Smalltalk
Laboratorio de Tecnología de Objetos I-
Punto subclass: #Particula
instanceVariableNames: ‘ masa ’
classVariableNames: "
poolDictionaries: "
x: abs y: ord masa: mas
^(self x: abs y: ord) masa: mas
masa
^masa
masa: unNum
masa := unNum
atraccion: unaPart
^ G * masa * (unaPart masa) /
((self distancia: unaPart) squared)
Smalltalk
Laboratorio de Tecnología de Objetos I-
Herencia simple y múltiple
• Existen lenguajes con herencia múltiple, lo que permite
que una clase reutilice la funcionalidad ofrecida por
varias clases.
• Lenguajes con herencia múltiple: C++, Eiffel
• Lenguajes con herencia simple: Java, Smalltalk
Pensionista TrabajadorActivo
MedioPensionista
El problema de la herencia repetida
• La herencia múltiple produce el problema de la herencia
repetida.
• Conflicto por ambigüedad (atributos o métodos)
elAbuelo: MedioPensionista
Pensionista
pensión
calcularIRPF( ): short
TrabajadorActivo
salario
calcularIRPF( ): short
calcularIRPF( )
Herencia repetida: Duplicación de atributos
• Se produce en lenguajes, como C++, en los que la reserva
de memoria al crear instancias se realiza sin tener en
cuenta el grafo de herencia:
Pensionista TrabajadorActivo
MedioPensionista
Persona nombre:String
pensión: Float salario: Float
elAbuelo: MedioPensionista Pensionista::nombre TrabajadorActivo::nombre pensión salario
Laboratorio de Tecnología de Objetos I-
Polimorfismo sobre los datos
• Un lenguaje tiene capacidad polimórfica sobre los datos cuando una
variable declarada de un tipo (o clase) – tipo estático – determinado
puede hacer referencia en tiempo de ejecución a valores (objetos) de
tipo (clase) distinto – tipo dinámico –.
• La capacidad polimórfica de un lenguaje no suele ser ilimitada, y en
los LOOs está habitualmente restringida por la relación de herencia:
¾ El tipo dinámico debe ser descendiente del tipo estático.
• En Smalltalk, como no hay declaración de tipos, se puede pensar en
un polimorfismo total.
• El polimorfismo sobre los datos sólo se aplica a las referencias a
objetos:
¾ En Java, Eiffel y Smalltalk, cualquier variable es una referencia a un objeto. ¾ En C++ se distingue entre objetos y punteros a objetos. El polimorfismo sólo se puede aplicar a estos últimos.
Laboratorio de Tecnología de Objetos I-
Polimorfismo sobre los datos
• Una variable puede referirse a objetos de clases distintas de la que
se ha declarado. Esto afecta a:
¾ asignaciones explícitas entre objetos, ¾ paso de parámetros, ¾ devolución de resultado en una función.
• La restricción dada por la herencia permite construir estructuras
con elementos de naturaleza distinta, pero con un comportamiento
común:
Laboratorio de Tecnología de Objetos I-
Punto pto = new Punto();
Partícula part = new Partícula(2);
Java
(Partícula) x = 0 y = 0 m = 2
(Punto) x = 0 y = 0
part pto
pto = part; // Asignación correcta
part = pto; // Asignación incorrecta
part = (Partícula) pto; // Peligroso
(Partícula) x = 0 y = 0
m = ??
Laboratorio de Tecnología de Objetos I-
Punto *ppto = new Punto();
Particula *ppart = new Particula(2);
C++
ppto = ppart; // Asignación correcta
ppart = ppto; // Asignación incorrecta
ppart = (Particula*) ppto; // Más peligroso que en Java
(Particula) x = 0 y = 0 m = 2
(Punto) x = 0 y = 0
ppart ppto
(Particula) x = 0 y = 0 m = ??
Polígono
Cuadrado
perímetro{^...}
perímetro{^4*lado}
:Polígono
:Cuadrado
obj : Polígono
perímetro?
Vinculación dinámica
• La vinculación dinámica resulta el complemento indispensable del
polimorfismo sobre los datos, y consiste en que:
¾ La invocación del método que ha de resolver un mensaje se retrasa al tiempo de ejecución, y se hace depender del tipo dinámico del objeto receptor.
• En general, todos los lenguajes orientados a objetos establecen por
defecto un mecanismo de vinculación dinámica para resolver los
mensajes.
¾ No obstante, algunos de ellos (C++) necesitan etiquetar de forma explícita las funciones que han de resolverse dinámicamente: funciones virtual.
class PuntoAcotado extends Punto {
private Punto esquinaI, esquinaD;
public PuntoAcotado() { … }
public PuntoAcotado(Punto eI, Punto eD) { … }
public double ancho() { … }
public double alto() { … }
public void trasladar(double a, double b) {
double excesoX, excesoY; excesoX = (abscisa()+a-esquinaI.abscisa()) % ancho(); excesoY = (ordenada()+b-esquinaI.ordenada()) % alto(); abscisa(excesoX + (excesoX>0? esquinaI.abscisa() : esquinaD.abscisa())); ordenada(excesoY + (excesoY>0? esquinaI.ordenada() : esquinaD.ordenada())); } }
Java
Laboratorio de Tecnología de Objetos I-
PuntoAcotado pac = new PuntoAcotado(eI, eD);
PuntoAcotado x= 0 y= 0
PuntoAcotado^ pac
x = 1 y = 1
Java
pto
Punto pto;
pto = pac; pto.trasladar(3, 3);
trasladar(3,
V I N C U L A C I Ó N D I N Á M I C A
class Punto { private double x, y; public Punto() { … } … public void trasladar(double a, double b) { x += a; y += b; } public double distancia(Punto p) { … } };
Punto eI = new Punto(0,0); Punto eD = new Punto(2,2);
Laboratorio de Tecnología de Objetos I-
class PuntoAcotado: public Punto {
Punto esquinaI, esquinaD;
public:
PuntoAcotado(Punto eI, Punto eD);
double ancho();
double alto();
void trasladar(double a, double b);
void Particula::trasladar(double a, double b) { double excesoX, excesoY; excesoX = (abscisa()+a-esquinaI.abscisa()) % ancho(); excesoY = (ordenada()+b-esquinaI.ordenada()) % alto(); if (excesoX > 0) incX = esquinaI.abscisa(); else incX = esquinaD.abscisa(); if (excesoY > 0) incY = esquinaI.ordenada(); else incY = esquinaD.ordenada(); abscisa(excesoX + incX); ordenada(excesoY + incY); }
C++
Laboratorio de Tecnología de Objetos I-
C++
ppto
Punto *ppto; PuntoAcotado *ppac = new PuntoAcotado(eI, eD);
PuntoAcotado x= 0 y= 0
ppac
ppto = ppac;
ppto->trasladar(3, 3);
trasladar(3,
PuntoAcotado x= 3 y= 3
V I N C U L A C I Ó N E S T Á T I C A
class Punto { double x, y; public: Punto(); Punto(double a, double b); ~Punto(); … void trasladar(double a, double b); double distancia(Punto& pp); };
Punto *eI = new Punto(0,0); Punto *eD = new Punto(2,2);
Laboratorio de Tecnología de Objetos I-
C++
ppto
Punto *ppto; PuntoAcotado *ppac = new PuntoAcotado(eI, eD);
PuntoAcotado x= 0 y= 0
ppac
ppto = ppac; ppto->trasladar(3, 3);
trasladar(3,
PuntoAcotado x= 1 y= 1
V I N C U L A C I Ó N D I N Á M I C A
class Punto { double x, y; public: Punto(); Punto(double a, double b); ~Punto(); … void trasladar(double a, double b); double distancia(Punto& pp); };
Punto *eI = new Punto(0,0); Punto *eD = new Punto(2,2);
virtual
Clases abstractas
• Clases con funciones sin implementar
¾ funciones abstractas en Java
¾ funciones virtuales puras en C++
¾ rutinas “deferred” en Eiffel
¾ métodos “implementedBySubclass” en Smalltalk
• No es posible crear instancias, pero sí declarar
variables que puedan referirse a objetos de diversas
clases descendientes
punteros a objetos en C++
= new Polígono();
abstract class Polígono { private Punto vértices[]; public void trasladar(double a, double b){ for (int i = 0; i < vértices.length; i++) vértices[i].trasladar(a, b); } public double perímetro() { double per = 0; for (int i = 1; i < vértices.length; i++) per = per + vértices[i-1].distancia(vértices[i]); return per
- vértices[0].distancia(vértices[vértices.length]); } abstract public double área(); }; MÉTODO ABSTRACTO
Polígono pol
Java CLASE ABSTRACTA
