1. No category

Herencia
Integrantes:
Sun Guo Hua
Luis Germán Pérez
Edgar Ricardo López Galván
6-1
Introducción
La herencia trata de hacer en el software:
• Los diseñadores pueden crear nuevos módulos de
software, esto evita rediseñar y codificar todo desde
cero
• Heredando el comportamiento, permitimos compartir
código
• La herencia también provee un mecanismo muy natural
para organizar la información
El modelo OO trata de modelar el mundo real.
6-2
Jerarquia de Herencia
Persona
Student
Sales Person
Images
Secretary
Employee
Raster
Vector
Rectangle
Hexagon
• La relación de herencia liga a la clase(class) con la
superclase.
Las clases son organizadas de manera jerárquica, de la
misma manera que la organización taxonómica de un
zoológico en la organización del reino animal.
6-3
Representación de conocimiento
• La herencia es la raíz del “sentido común” del
paradigma de la representación del conocimiento,
usado en la Inteligencia Artificial
• Las redes semánticas consisten en nodos que
representan conceptos “objetos” y ligas representa
relaciones
• Un ejemplo: es el modelo psicológico de Ross Quillian
(1968) de la memoria asociativa, que fue uno de los
primeros modelos de representación de redes
semánticas del conocimiento.
6-4
Jefe de Distrito
Persona
Supervisa
Es un
Es un
Jefe de Ventas
Es un
Cuenta
Supervisa
Tiene como
Personal de Ventas
Tiene como
Orden
Trabaja en
Departamento
Red Semántica para Personal de Ventas
6-5
• La herencia es justo una clase de
relación entre conceptos.
[Setrag 90]
• Las relaciones pueden representar atributos
(componentes) o conceptos (objetos).
[Setrag 1990] Setrag Khoshafian, Object Orientation 1990
6-6
Beneficios de la herencia
Reusabilidad de software: El comportamiento similar no
tiene que ser reescrito.
Compartir código: Muchos programadores pueden usar
la misma clase, dos o mas clases son desarrolladas por
un programador, heredado de una clase padre sencilla
Consistencia de la interfase: Cuando se tiene múltiples
herencias de una misma superclase, podemos asegurar
que el comportamiento de la herencia es la misma en
todas las clases
6-7
Componentes de software: La herencia permite
construir componentes de software reusable.
Prototipos rápidos: Mediante componentes de software
reusable, el tiempo de desarrollo se emplea en la
concepción del sistema.
Polimorfismos: El polimorfismo junto con la herencia
permite al programador generar componentes reusables
en alto nivel que pueden ser usados para diversas
aplicaciones con sólo cambiar algunas partes de bajo
nivel.
6-8
Ocultamiento de la información: Cuando el programador
reutiliza los componentes de software, ellos sólo necesitan
entender la naturaleza del componente y su interfase. No es
necesario que el programador tenga la información detallada
de la clase heredada.
6-9
Herencia
• Es le traslado de información que se pasa entre
componentes de programa.
• Es el mecanismo que permite que una clase A
herede propiedades de una clase B. Decimos que
“A hereda de B”.
• Una forma temprana de herencia se encuentra en
las reglas de alcance para datos estructurados en
bloque.
{int i,j;
{float j,k ;
k = i +j ;}
}
6-10
• Aunque las reglas de alcance son una forma de
herencia el termino se usa mas a menudo para referirse
a el traslado de datos y funciones entre módulos
independientes de un programa.
• Si se tiene A => B, se dice que A es la clase
progenitora o superclase, y B es la clase
dependiente,niña o subclase.
6-11
• Si una clase sólo puede tener un único progenitor, se
dice que tiene herencia sencilla
• Si una clase puede tener múltiples progenitores, se dice
que tiene herencia múltiple.
A
B
U
V
C
W
D
Herencia Sencilla
X
Y
Herencia Múltiple
6-12
Mecanismos de heriencia
• Herencia es el mecanismo de compartir artributos entre
un hijo y su padre o progenitor,en la heriencia el hijo
hereda algunos atributos del padre.
• En los lenguajes OO un mecanismo natural de heriencia
es extensión de atributos entre los objetos existentes.
6-13
Embebido
• Embebido simplemente hace copias de los atributos del objeto
donador. Lo que provee la más simple explicación de la semántica
estándar de self como el receptor de una invocación. La invocación de
un método heredado de esta menera , trabaja exactamente como la
invocación de un método original.
Mira la figura siguiente:
aCell
S
e
t
aReCell
Fijate:en aReCell, los métodos
“set,reset” son redefinidos
0
Content
Get
Code for Get
Set
Code for Set
c Content
o
n
t Backup
e
n
0
0
Get
Code for Get
Set
Code for Set
Restore
Code for restore
Fig. Embebido
6-14
Delegando
• Delegando es la redirección de campo y método invocado desde un
objeto hasta otro, en un camino así, un objeto puede ser visto como
una extensión de otro.
Mira la figura siguiente
aCell
Content
Get
Set
0
Code for Get
Code for Set
aReCell
Content
0
Backup
0
Set
New Code for Set
Restore
Code for restore
Fig. delegando
6-15
Herencia dinámica
• La herencia delegando es llamada herencia estática cuando los enlaces
de los progenitores son fijados permanentemente.
Delegación dinámica es creada cuando los enlaces padres o progenitores
pueden ser actualizados dinámicamente.
aCell
Content
Get
Set
0
Code for Get
Code forSet
2
Content
Get
Other code forGet
Set
Other Code forSet
aReCell
Content
Backup
Set
0
0
New code for Set
Restore
Code for restore
6-16
Fig. Herencia dinámica
Clasificación de herencia
• En la teoría orientada a objetos, algunos conceptos
fundamentales son:
–
–
–
–
Class (clase)
Objeto
Método
Tipo (datos)
• Clasificación de la herencia
– Herencia de tipos (encapsulamiento, datos
abstractos)
– Herencia de clases (class) y objetos
– Herencia de métodos
6-17
• Se define a tipo de datos abstracto como un
nuevo tipo de datos definido por el programador
que incluye:
– un tipo de datos definidos por el programador
– un conjunto de operaciones abstractas sobre
objetos de ese tipo, y
– encapsulamiento de objetos de ese tipo, de tal
manera que el usuario del nuevo tipo no pueda
manipular esos objetos excepto a través del
uso de operaciones definidas.
6-18
• En Ada un paquete proporciona
encapsulamiento para un conjunto de
definiciones de tipo y subprogramas.
Package Tiposeccion is
type IdEstutdiante is integer;
type Seccion (TamañoMax: integer) is private;
procedure AsignarEstudiante(Secc: in out Seccion; prof in integer; salon in
integer);
Private
type seccion(TamañoMax: integer) is
record
salon: integer;
profesor: integer;
tamañodeclase: integer range 0..TamañoMax :=0;
listadeclase: array (1..TamañoMax) of IdEstudiante;
end record;
end;
Package body Tiposeccion is
procedure asignarestudiante is
.....
end;
6-19
End;
• Modelos de implementación para datos abstarctos
package A is
package A is
type Mipila is private;
type MiPila is private:
procedure PilaNueva (S:out miPila);
procedure Pila Nueva(S: out MiPila):
….
…
Private
private
Type MiPila is record
type MiPilaRep;
Top: integer;
----
A: array ( 1..100) of integer;
Detalles ocultos de MiPila
Type MiPila is acces MiPilaRep;
End record;
-----
----
B solo tiene apuntador a pila
End;
encapsulamiento indirecto
B tiene estructura de pila
End;
encapsulamiento directo
6-20
Registro de activación
Paquete A
Registro de activación
Paquete B
Registro de activación
Paquete A
Registro de activación
Paquete B
P
Encapsulamiento indirecto
del objeto P
P
Encapsulamiento directo
del objeto P
6-21
• Tipos de datos abstarctos genéricos
Los tipos primitivos de datos integrados en un lenguaje,
permiten declarar el tipo básico de una clase nueva y
luego especificar atributos de los objetos de datos.
Una definición genérica de tipo abstracto permite
especificar por separado un atributo del tipo de esta
clase.
Una definición genérica de paquete representa una
plantilla que se puede usar para crear tipos de datos
abstractos particulares.
6-22
Generic
type Element is private;
Package
Type Elem is private;
Package TipoCualquierPila is
type Pila (Tamaño:Positive) is private;
procedure Push ( I: in elem; S: in out Pila);
Private
type Pila (Tamaño:Positive) is record
AlmacenamientoPila: array (1 .. Tamaño) of Elem;
Top: Integer range 0 .. Tamaño := 0;
end record;
End TipoCualquierpila;
Package body TipoCualquierPila is
procedure Push (I: in Elem; S: in out Pila) is
begin
-Procedimiento de cuerpo de Push
end;
procedure Pop ( I: out Elem; S: in out Pila) is
begin
-Procedimiento de cuerpo de Pop
end;
End TipocCualquierPila;
6-23
Al proceso de crear la definición particular del tipo a partir
de la definición genérica se llama ejemplarización.
Ejemplo
package TipoPilaEnt is
new TipoCualquierPila(elem => integer);
Package TipoPilaEnte is
type Pila(Tamaño: Positive9 is private;
procedure Push ( I: in integer; S: in out Pila);
procedure Pop (I: out integer; S: in out Pila);
Private
type Pila (Tamaño; Positive) isrecord
AlmacenamientoPila; array (1 .. Tamaño) of integer;
Top: Integer range 0 .. Tamaño :0 0;
end record;
End TipoPilaEnt;
Package body TipoPilaEnt is
procedure Push (I: in integer; S: in out Pila) is
begin
-Procedimiento de cuerpo de Push
end
Procedure Pop (I: out integer; S: in out Pila) is
begin
-Procedimiento de cuerpo de Pop
end;
End TipoPilaEnt;
6-24
• La clasificación de la herencia en los lenguajes OO,
puede ser variable de acuerdo a diferentes autores,
sin embargo la mayoría concide en dos aspectos
importantes:
– Herencia de estructura: Se refiere a los tipos de
datos definidos en la clase y propiedades de los
mismos.
– Herencia de comportamiento: Se refiere a la
herencia de funciones y procedimientos que
forman parte del objeto.
6-25
OBJETOS Y MENSAJES
• Smalltalk representa un enfoque hacia el desarrollo
de objetos y métodos.
• Un programa en Smalltalk se compone de un
conjunto de definiciones de clase integradas por
objetos de datos y métodos. Se compone de tres
caraterísticas primordiales
– Definiciones de la clase
– Ejemplarización de objetos
– Paso de mensajes
6-26
• Definiciones de clase. Son enunciados ejecutables
que definen la estructura interna y los métodos.
• Ejemplarización de objetos. Son objetos específicos
para cada definición de clase invocando métodos
de creación dentro de la definición de clase.
• Paso de mensaje. Los métodos se pasan como
mensajes a un objeto para llevar a cabo una acción.
6-27
• Existen 3 tipos de mensajes en Smalltalk:
– Un mensaje unario es simplemente un método
que no tiene parámetros
– Un mensaje binario se usa principalmente para
operadores aritméticos
– Los mensajes de palabra clave que son
funciones o procedimientos que se aplican
dependiendo del objeto
6-28
• HERENCIA DE CLASES
Los datos en Smalltalk se basan en una jerarquía de
clases.
Si un método que se pasa a un objeto no está
definido dentro de esa clase, se pasa a la clase
progenitora, y así sucesivamente.
La clase OBJETO es la superclase progenitora de
todas las clases.
La herencia de métodos es una característica
primitiva en Smalltalk
6-29
En los métodos de palabra clave, el parámetro para el método se nombra en
forma explícita en la declaración:
If True: Bloquecierto if False: Bloquefalso
Pero qué pasa en x > 2 ?
Para acceder al método > se tiene el objeto self (Se comporta como el
parámetro this de C++)
Ejemplo:
Object subclass: #ClaseA
Instace VariableNames:’’
Class VariableName:’’
PollDictionaries:’’
Category:nil!
ClaseA subclases: #CaseB
Instance VriableNames:’’
Class VariableNames:’’
PollDictionaries:’’
Categiry : nil!
6-30
Conceptos de abstracción
La herencia proporciona un mecanismo para pasar
información entre objetos y clases relacionadas.
Si A => B significa que B es una clase relacionada con A
Cuál es la relación entre objetos de A y objetos de B ?
Respuesta:
Especialización
Descomposición
Ejemplarización
Individualización
6-31
Especialización
Permite que el objeto derivado B obtenga
propiedades más precisas presentes en el objeto A
las
Compuestos
Pila
Registro
............
Pila ent
Pila real
Es la forma más común de la herencia.
6-32
Descomposición
Es el principio que permite separar una abstracción en
sus compenentes
Es el mecanismo típico de encapsulamiento en lenguajes
como Ada sin la herencia de métodos.
pila
tope
Almacenamiento[100]
6-33
Ejemplarización
Es el proceso de crear ocurrencias de una clase.
Un ejemplo es la declaración de ocurrencias de un objeto
de clase en un programa en C++
Pila
Pila A
Pila B
Pila C
6-34
Individualización
Los objetos similares se agrupan unos con otros para
propositpos comunes.
Pila
Registro act
Reg. act C
Tabla símbolos
Reg. act Pascal
6-35
Metaclases
Una clase contiene la descripción de la estructura y el
comportamiento de la instancia.
En la mayoría de los lenguajes OO, las clases son
fábricas que crean e inicializan instancias.
EJEMPLO Smalltalk: una instancia de una clase C es
creada a través del mensaje new.
iC := C new
6-36
En la mayoría de los lenguajes OO las clases son
fábricas que crean e inicializan objetos
En Smalltalk la clase es tratada como un objeto que
puede crear instancias de otros objetos.
Algunos lenguajes OO existen dos tipos de objetos:
Objetos clase: Objetos que pueden actuar como modelo
y crear instancias de ellos mismos
Objetos terminales: Objetos que solamente pueden ser
instanciados pero no pueden crear instancias para otros
objetos.
6-37
Quién o que clase describe el estado y comportamiento
de una clase como objeto, dicho de otra manera, que
es la clase de una clase?
Metaclases: Son clases para dar origen a clases (No
todos los lenguajes soportan el concepto de
metaclase)
6-38
Dos ventaja al tratar las clases como objetos
1. Pueden ser usadas para almacenar un grupo de
información, si la clase es tratada como un objeto, la
información global de todas las variables instanciadas
de la clase puede ser almacenada en una clase “class
instance variable” (llamada class variable en
Smalltalk). Métodos asociados con la clase (llamados
class methods) pueden ser usados para extraer o
actualizar los valores de la class variable.
2.
Uso en la creación e inicialización de nuevas
instancias de la clase.
6-39
Existen lenguajes OO que persiguen en el soporte de
metaclases lo siguiente:
1. Soporte explícito para crear e instanciar metaclases
2. Soporte implícito de metaclases.
6-40
Ejemplo de soporte explícito en OBjVLisp
(send Classs’new
:name
:supers
:i_v
‘()
:methods
‘())
‘metacomplex
‘(Class)
(send Metacomplex’new
:name
‘complex
:supers
‘(object)
:i_v
‘(real imaginary)
:methods
‘(...)
...
=
6-41
Ejemplo de soporte implícito:
En Smalltalk las metaclases no definidas ni creadas
explicitamente.
Las metaclases en Smalltalk están ocultas para el
usuario.
Son usadas y estan definidas en la implementación del
kernel del ambiente de Smalltalk.
6-42
* El modelo de Smalltalk-76
Fue el primer lenguaje en introducir el concepto de
metaclases
Lenguajes con el concepto de metaclases
Smalltalk
Languajes OO sin el concepto de metaclases:
C++
Simula
Eiffel
Oject pascal
6-43
Herencia múltiple
• Si la clase A hereda de más de una clase, p.ej. A
hereda de B1, B2,... Bn, se dice que hablamos de
herencia múltiple.
• La herencia múltiple significa que una subclase
puede tenera más de una superclase.
• Esto permite que la subclase herede propiedades de
más de una superclase y “mezclar” sus
propiedades.
6-44
• La herencia múltiple presenta el siguiente problema:
– Si una clase D hereda en forma múltiple de las
superclases B,C que a su vez son derivadas de
una superclase A y existen atributos o métodos
con el mismo nombre, que atributos o métodos
hereda D
A
B
C
D
6-45
Declaración de Tipos de Elementos en la
definición de las Clases
· Un elemento público (public), puede ser accedido por cualquier
función del programa.
· Un elemento privado (private), puede ser accedido por funciones
miembro
· Un elemento protegido (protected), puede ser accedido por
funciones amigas
Cuando una clase hereda de otra, los elementos privados de la
clase base son inaccesibles a la clase derivada y cuando los
elementos son te tipo protegido estos son accesibles.
6-46
Diferentes facetas de la herencia
La herencia es una poderosa técnica que organiza
bases de código complejo y es muy rica en la
semántica de las relaciones sobre entidades. Pero
esta introduce un poco de complejidad, especialmente
con otros conceptos de la orientación a objetos como
es la encapsulación, tipos, visibilidad y estados de los
objetos
A continuación se describirán cada una de estas
facetas:
6-47
Herencia y Subtipos: En la mayoría de los lenguajes orientados a
objetos los dos objetos son usados sin distinción.
Visibilidad de variables heredadas y métodos: En muchos
lenguajes orientados a objetos como Simula permiten la
manipulación directa de las variables instanciadas. Otros lenguajes
como C++ distinguen entre la manipulación pública y privada. Con la
herencia tenemos una tercera alternativa, que demanda la visibilidad
en la subclase.
Herencia y Encapsulación: La visibilidad de las variables
instanciadas violan el principio de ocultamiento de información ya
que las variables de la superclase son accesadas directamente.
Como se Especializa: La herencia es apropiado para la
especialización de las clases existentes. Las clases pueden ser
especializadas con extender su representación (instanciación de
variables) o comportamiento (operaciones).
6-48
Herencia de Objetos: La mayoría de los lenguajes orientados a
objetos soportan la herencia de clases. Se tienen varios
modelos de de computación que incorpora operaciones con
objetos y uso solamente con herencia de objetos para la
organización de espacios de objetos. Esto es llamado sistema
prototipo.
Herencia Múltiple: En muchas situaciones es necesaria la
herencia de más de una clase. A esto es llamado Herencia
Múltiple. Cuando tenemos una clase heredera de más de un
padre tenemos la posibilidad de conflictos: métodos o variables
instanciadas con un mismo nombre pero con semántica
diferente o no relacionada que son heredadas de diferentes
superclases.
6-49
Tipo de Dato Protegido “Protected”
Protected es el nivel intermedio de protección entre el acceso
público y el acceso privado.
Los miembros y “friend” de la clase base, y los miembros y
“friend” de las clases derivadas son los únicos que pueden
acceder a los miembros “protected” de una clase.
Protected rompe con el encapsulamiento.
6-50
Clase Amigo “Friend”
Las clases amigo pueden acceder a elementos declarados en la
parte privada “private” y protegida “protected” de la clase a la
cual declaro como amigo.
En C++ se declaran a las clases amigo con la palabra reservada
“friend”. También con esta palabra se pueden declarar a
funciones como amigo. Esto se utiliza principalmente para la
sobrecarga de operadores.
6-51
Ejemplo:
Clases amigo.
Class A {
friend class AB;
public:
void mete_a(int aa) {
a = aa; }
private:
int a;
};
Class AB {
public:
void mete_b (int bb) {
b = bb; }
void escribe_ab (A aa);
private:
int b;
};
6-52
# include <iostream.h>
void AB::escribe_ab(A aa)
{
cout << aa.a << “ “ << b;
}
void main ()
{
A obj1;
B obj2;
obj1.escribe_a(1);
obj2.escribe_b(2);
obj2.escribe_ab(obj1);
}
6-53
Sobrecarga de operadores:
#include <iostream.h>
class complejo {
friend ostream &operator(ostream&, const complejo&);
public:
....
private:
int real, imaginario;
};
ostream &operator << (ostream &output, const complejo &numero)
{
output << real << “+” << imaginario << “i”;
return output;
}
void main () {
complejo numero;
....
cout << numero;
...
};
6-54
Tipos de información que se hereda
Herencia public
public
public es la clase derivada
protected protected es la clase derivada
private
private es la clase derivada
Herencia protected
protected es la clase derivada
protected es la clase derivada
private es la clase derivada
Herencia private
private es la clase derivada
private es la clase derivada
private es la clase derivada
Cuando la herencia es de tipo Public, los tipos quedan iguales.
Cuando la herencia es de tipo protected, la parte pública y protegida
de los elementos heredados quedan de tipo protected.
Cuando la herencia es de tipo private, la parte pública y protegida de
los elementos heredados quedan de tipo private.
6-55
• La herencia en C++ entre clases y subclases está
soportada a través de las clases derivadas.
• La declaración general de la forma de las clases
derivadas es:
class < derived-class-name>
: [ public | private] < base-class-name>
{
< derived-class-members>
}
6-56
• Miembros protegidos
class X
{
protected:
int i;
}
class Y : public X
{
Afunc () {i++};
}
X Anx;
Y Ay
...
Anx.i =1; // Error
Ay.i = 2; // Error
6-57
• Herencia múltiple
class < new-derived-class>:
[virtual][public | private] <base-class2>…}
{
…
}
class A
class B
{
{
public:
public:
int a;
}
int b;
}
class C: public A, public B
{
int c:
f () {a = 5; b=6; c=8;
}
6-58
6-59
6-60
Eiffel
class FIXED_LIST[G] inherit
LIST[G];
ARRAY[G] export
feature
...Specific features of fixed-size lists...
end --- class FIXED_LIST
LIST
ARRAY
FIXED_LIST
class C inherit
A rename x as x1, y as y1 end;
B rename x as x2, y as y2 end
feature ...
6-61
class FIXED_TREE[T] inherit
TREE[T]
redefine
attach_to_higher, higher
end;
CELL[T];
FIXED_LIST[like Current]
rename
off as child_off,
after as child_after,
before as child_before
redefine
duplicate, first_child
end;
feature
....(Rest of class omitted) ...
6-62
class Postbag export
…
inherit
Bag
Rename classify as classigyContent;
Inventory
Rename classigy as classigyBag;
Feature
…
end – class Postbag
Si BirminghamMail es una instancia de Postbag, las dos
rutinas heredadas pueden por lo tanto ser usadas sin
conflicto:
Birminghammail . Create ;
BirminghamMail. ClassifyContent;
BirminghamMail. classigyBag
6-63
ObjectPascal
Type aclass = Object ( NSObject )
public size : integer;
private itsdata : integer;
procedure set_its_data( p: integer);
end;
Procedure aclass.set_its_data( p : integer );
begin
itsdata := p;
end;
Var aninstance : aclass;
begin
...
aninstance.amethod(aninstance.size);
...
end;
6-64
6-65
6-66
Java
Java provee una palabra reservada para implementar la herencia,
esta palabra es “extends”. Java no tiene herencia múltiple. Sintaxis de
la herencia sencilla:
public class “Nombre de la clase” extends “acceso nombre de la clase”
Ejemplo:
6-67
Delphi . Delphi, implementa sólamente la herencia sencilla . Cuando se
comienza un nuevo proyecto se utiliza la herencia. Sintaxis:
“Nombre de la clase” = class ( “acceso nombre de la clase”)
Ejemplo 1.
TForm1 = class (TForm)
Ejemplo 2.
type TMotorVehicle = class;
public
function Starten : Boolean; Virtual;
end;
type
TMotorCycle = class (TMotorVehicle);
public
function Starten : Boolean; Override;
end;
6-68
type
TAnimal = class
public
constructor Create;
function GetKind : string;
function Vaice : string; virtual; abstract;
private
Kind : string;
end;
Tdog = class (TAnimal)
public
constructor Create;
function Voice : string; override;
function Eat : string; virtual;
end;
TCat = class (TAnimal)
public
constructor create;
function Voice : string; override;
function Eat : string; virtual;
end;
end;
6-69
type
TTest = class
protected
ProtectedData : Integer;
public
PublicData : Integer;
function GetValue : string;
end;
function TTest.GetValue : string ;
begin
Result := Format (‘Public : %d, Protected : %d’, [PublicData, ProtectedData]);
end;
procedure TForm1.Button1Click(Sender : Tobject);
var
Obj :TTest;
begin
Obj := TTest.Create;
Obj.PublicData := 10;
Obj.ProtectedData := 20; // No se compila
ShowMessage (Obj.GetValue);
Obj.Free;
end;
6-70
Smalltalk
En Smalltalk todo los elementos del programa son objetos, los cuales
son creados heredados de una superclase principal llamada “object”.
Sintaxis: Nombre_de_la_superclase subclass: # Nombre_de_la_clase
Ejemplo.
humano subclass: # estudiante
object
humano
estudiante
6-71
Perl
#-----------------------------package Employee; #Base class
#-----------------------------sub allocate{
my ($pkg, $name, $age, $starting_position) = @_;
my $r_employee = bless {
“name” => $name,
“age”
=> $age,
“position” => $starting_position
}, $pkg;
return $r_employee;
}
sub promote {
my $r_employe
= shift;
my $current_position = $r_employee-> {“position”};
my $next_position
= lookup_next_position($current_position);
$r_employee->{position} = $next_position;
}
6-72
#-----------------------------package HourlyEmployee;
#-----------------------------@ISA = (“Employee”); # Inherits from Employee
sub new{
my ($pkg, $name, $age, $starting_position,
$hourly_rate, $overtime_rate) = @_;
#Let the employee package create and bless the object
my $r_employee = $pkg -> allocate ($name, $age, $starting_position);
#Add HourlyEmployee-specific attributes
$r_employee->{“hourly_rate”} = $hourly_rate;
$r_employee->{“overtime_rate”}
= $overtime_rate;
return $r_employee;
}
….
6-73
use Single ();
use Nested ();
use Multi ();
use strict;
#########################################################
# Simple single inheritance: Creating a "Single" object.
print "\n-------------------\n";
print "SINGLE INHERITANCE.\n";
print "-------------------\n";
my $singleObj = new Single (-base=>'Base data', -single=>'Single data' );
print "\nDISPLAYING OBJECT:\n";
print "----------------\n";
$singleObj->display();
#########################################################
# Nested single inheritance: Creating a "Nested" object.
print "\n\n--------------------------\n";
print "NESTED SINGLE INHERITANCE.\n";
print "--------------------------\n";
my $nestedObj = new Nested (-base=>'Base data', -single=>'Single data', -nested=>'Nested data' );
print "\nDISPLAYING OBJECT:\n";
print "----------------\n";
$nestedObj->display();
print "\nINVOKING A DISTANTLY INHERITED FUNCTION:\n";
print "----------------------------------------\n";
$nestedObj->baseFunction();
6-74
#########################################################
# Multiple inheritance: Creating a "Multi" object.
print "\n\n--------------------------\n";
print "MULTIPLE INHERITANCE.\n";
print "--------------------------\n";
my $multiObj = new Multi (-base=>'Base data', -base2=>'Base2 data', -multi=>'Multi data' );
print "\nDISPLAYING OBJECT:\n";
print "----------------\n";
$multiObj->display();
print "\nINHERITED FUNCTIONS:\n";
print "--------------------\n";
$multiObj->baseFunction();
$multiObj->base2Function();
6-75
Simula
Class Plane;
Begin
RegisterFlightPlan;
FillUpTank;
Checklist;
Inner;
AskForTakOffPermission;
End Plane;
Plane class PostalPlane;
Begin
LoadPostalBags;
End PostalPlane;
Plane class Airliner;
Begin
PassengerBoarding;
End Airliner;
6-76
Bibliografia
Terrence W. Pratt, Marvin V. Zelkowitz
Lenguajes de programacion, Diseño e Implementacion
Prentice Hall
Setra Khoshafian, Ramzmik Abnous
Object Orientation, Cencepts, Lenguages, Databases, User Interfaces
John Wiley
Gerald Masini, Amedeo Napoli
Object Oriented Lenguages
The APIC series 34
Bertrand Mayer, 1992
Eiffel: the lenguage
Prentice Hall
Zhanshan Gao
The University of Calgary
http://sern/ucalgary/ca/courses/SENG/609.03/W98/gao2/paper.html
6-77
Timothy Budd
An intruduction to Object-Oriented Programing
Addison- Wesley
Sriram Srinivasan, 1997
Advanced Perl programing
O´Reilly
Marco Cantu
La bibli de Delphi 5
Anaya multimedia
Zhanshan Gao
The University of Calgary
http://sern/ucalgary/ca/courses/SENG/609.03/W98/gao2/paper.html
6-78