Herencia Integrantes: Sun Guo Hua Luis Germán Pérez



Descargar 46,8 Kb.
Fecha de conversión23.06.2017
Tamaño46,8 Kb.

Herencia

  • Integrantes:
  • Sun Guo Hua
  • Luis Germán Pérez
  • Edgar Ricardo López Galván

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.

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.

  • Persona
  • Student
  • Employee
  • Secretary
  • Sales Person
  • Images
  • Raster
  • Vector
  • Hexagon
  • Rectangle
  • Jerarquia de Herencia

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.
  • 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

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
  • 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.
  • 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.

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 ;}
          • }
  • 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.
  • 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
  • C
  • B
  • D
  • Y
  • W
  • X
  • V
  • U
  • Herencia Sencilla
  • Herencia Múltiple

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.

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
  • aReCell
  • Fijate:en aReCell, los métodos
  • “set,reset” son redefinidos
  • 0
  • Fig. Embebido
  • 0
  • Get
  • Content
  • Set
  • Set
  • Code for Get
  • conten
  • Content
  • Backup
  • Get
  • Set
  • Restore
  • 0
  • Code for Get
  • Code for Set
  • Code for restore

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
  • Fig. delegando
  • aCell
  • aReCell
  • Content
  • Get
  • Set
  • 0
  • Code for Get
  • Code for Set
  • Content
  • Backup
  • Set
  • Restore
  • 0
  • 0
  • New Code for Set
  • Code for restore

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.
  • Fig. Herencia dinámica
  • aCell
  • aReCell
  • Content
  • Content
  • Get
  • Set
  • Backup
  • Set
  • Restore
  • 0
  • Code for Get
  • Code forSet
  • 0
  • 0
  • New code for Set
  • Code for restore
  • Content
  • Get
  • Set
  • 2
  • Other code forGet
  • Other Code forSet

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
  • 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.

En Ada un paquete proporciona encapsulamiento para un conjunto de definiciones de tipo y subprogramas.

  • 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;
  • End;

Modelos de implementación para datos abstarctos

  • package A is
  •  
  • type MiPila is private:
  • procedure Pila Nueva(S: out MiPila):
  • private
  • type MiPilaRep;
  • ----      Detalles ocultos de MiPila
  • Type MiPila is acces MiPilaRep;
  • -----         B solo tiene apuntador a pila
  •       End;
  • encapsulamiento indirecto
  • package A is
  • type Mipila is private;
  • procedure PilaNueva (S:out miPila);
  • ….
  • Private
  • Type MiPila is record
  • Top: integer;
  • A: array ( 1..100) of integer;
  • End record;
  • ----         B tiene estructura de pila
  •        End;
  • encapsulamiento directo
  • 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
  • P
  • Encapsulamiento indirecto
  • del objeto P
  • Encapsulamiento directo
  • del objeto P

Tipos de datos abstarctos genéricos

  • 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.

Generic

  • 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;

Al proceso de crear la definición particular del tipo a partir de la definición genérica se llama ejemplarización.

  • 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;
  • 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.
  • 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
  • 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.
  • 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
  • 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

En los métodos de palabra clave, el parámetro para el método se nombra en forma explícita en la declaración:

  • 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!

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

Especialización

  • Especialización
  • Permite que el objeto derivado B obtenga las propiedades más precisas presentes en el objeto A
  • Es la forma más común de la herencia.
  • Compuestos
  • Registro
  • Pila
  • Pila real
  • Pila ent
  • ............
  • 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
  • Almacenamiento[100]
  • tope
  • 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 C
  • Pila A
  • Pila B
  • Individualización
  • Los objetos similares se agrupan unos con otros para propositpos comunes.
  • Pila
  • Tabla símbolos
  • Registro act
  • Reg. act C

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
  •  
  • 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.
  • 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)
  • Dos ventaja al tratar las clases como objetos
  •  
  • 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.
  • Existen lenguajes OO que persiguen en el soporte de metaclases lo siguiente:
  •  
  • Soporte explícito para crear e instanciar metaclases
  • Soporte implícito de metaclases.
  •  
  • Ejemplo de soporte explícito en OBjVLisp
  •  
  • (send Classs’new
  • :name ‘metacomplex
  • :supers ‘(Class)
  • :i_v ‘()
  • :methods ‘())
  •  
  • (send Metacomplex’new
  • :name ‘complex
  • :supers ‘(object)
  • :i_v ‘(real imaginary)
  • :methods ‘(...)
  • ... =
  • 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.
  • * 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

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.
  • 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
  • C
  • B
  • D
  • 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.

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:
  • 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).
  • 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.
  • 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.
  • 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.
  • 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;
  • };
  • # include
  • 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);
  • }
  • Sobrecarga de operadores:
  • #include
  • 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;
  • ... };
  • Tipos de información que se hereda
  • Herencia public
  • Herencia private
  • public
  • public es la clase derivada
  • protected es la clase derivada
  • private es la clase derivada
  • protected
  • protected es la clase derivada
  • protected es la clase derivada
  • private es la clase derivada
  • 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.

La herencia en C++ entre clases y subclases está soportada a través de las clases derivadas.

  • 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>
  • }
  •  
  • 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
  • Herencia múltiple
  •  
  • class < new-derived-class>:
  • [virtual][public | private] …}
  • {
  • }
  •  
  • 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;
  • }

Eiffel

  • Eiffel
  • class FIXED_LIST[G] inherit
  • LIST[G];
  • ARRAY[G] export
  • feature
  • ...Specific features of fixed-size lists...
  • end --- class FIXED_LIST
  • FIXED_LIST
  • LIST
  • ARRAY
  • class C inherit
  • A rename x as x1, y as y1 end;
  • B rename x as x2, y as y2 end
  • feature ...

class FIXED_TREE[T] inherit

  • 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) ...
  • 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
  • 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;
  • ObjectPascal
  • 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:
  • 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;

type

  • 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;
  • 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;
  • 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
  • #------------------------------
  • 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;
  • }
  •  
  • Perl
  •  
  • #------------------------------
  • 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;
  • }
  •  
  • ….
  • 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();
  • #########################################################
  • # 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();
  • 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;
  •  

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

Timothy Budd

  • 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


La base de datos está protegida por derechos de autor ©absta.info 2016
enviar mensaje

    Página principal