Conceptos Avanzados de Programacion Orientada A Objetos

PROGRAMACIÓN DE APLICACIONES
Instructor : Nataniel Marcial Chavez
12.05.11 Programación de aplicaciones

II. CONCEPTOS AVANZADOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS.
12.05.11 Programación de aplicaciones

12.05.11
Conceptos avanzados de la programación orientada a objetos
Conceptos sobre polimorfismo
El polimorfismo, en programación orientada a objetos, se refiere a la posibilidad de

acceder a un variado rango de funciones distintas a través del mismo interfaz. O sea,
un mismo identificador puede tener distintas formas (distintos cuerpos de función,
distintos comportamientos) dependiendo del contexto en el que se halle. El
polimorfismo se puede establecer mediante sobrecarga, sobre-escritura y enlace
dinámico.
Programación de aplicaciones
12.05.11
Sobrecarga
Este término se refiere al uso del mismo identificador u operador en distintos

contextos y con distintos significados.
Si para cada funcionalidad necesitada fuese necesario escribir un método, el código

resultante sería inmanejable. Supongamos que los desarrolladores de C# hubiesen
creado un método para escribir en pantalla una cadena de texto, otro diferente para
escribir un entero, otro para un doble, y así para todas las combinaciones posibles,
seria casi imposible conocer dichos métodos en totalidad. En cambio, con
“Console.WriteLine()” o “Console.Write()” podemos escribir cualquier mensaje en
pantalla.
Este tipo de codificación nos es permitido gracias a la sobrecarga, la cual se aplica a

métodos y constructores.
12.05.11
La sobrecarga de métodos hace que un mismo nombre pueda representar distintos

métodos con distinto tipo y número de parámetros, manejados dentro de la misma
clase.
En el ámbito de la POO, la sobrecarga de métodos se refiere a la posibilidad de tener

dos o más métodos con el mismo nombre pero distinta funcionalidad. Es decir, dos o
más métodos con el mismo nombre realizan acciones diferentes y el compilador
usará una u otra dependiendo de los parámetros usados.
Esto también se aplica a los constructores (de hecho, es la aplicación más habitual
de la sobrecarga).
Podemos diferenciar varios métodos sobrecargados a través de sus parámetros, ya

sea por la cantidad, el tipo o el orden de los mismos. Veamos un ejemplo:
12.05.11
public class Articulo

{
private double precio;
public void setPrecio()

{
precio = 3.50;
}
public void setPrecio(float nuevoPrecio)
{
precio = nuevoPrecio;
}
public void setPrecio(float costo, int porcentajeGanancia)
{
precio = costo + (costo * porcentajeGanancia);
}
}
12.05.11
Sobreescritura
La sobreescritura se aplica a los métodos y está directamente relacionada a la

herencia; se refiere a la redefinición de los métodos de la clase base en las subclases.
Por ejemplo, en la relación de herencia del ejemplo de las figuras aunque la clase
base “Figura” tiene los métodos “calcularArea” y “calcularPerimetro”, las subclases
“Circulo”, “Cuadrado”, “Triangulo” y “Rectangulo” redefinen estos métodos ya que el
calculo del área y el perímetro de cada uno de ellos es diferente.
12.05.11
class Figura {
protected double area;

protected double perimetro;
public Figura() {
this.area=0;
this.perimetro=0;
}
public double getArea() {
return area;
}
public double getPerimetro() {
return perimetro;
}
public void calcularArea(){}
public void calcularPerimetro(){}
}
12.05.11
using System;
public class Circulo : Figura {
public const double PI=3.1415926;

private double radio;
public Circulo() {
}
public double getRadio() {
return radio;
}
public void setRadio(double radio) {
this.radio = radio;
}
public void calcularArea() {
this.area = PI* Math.Pow(this.radio,2.0);

}
public void calcularPerimetro() {
this.perimetro = 2*PI*this.radio;
}
12.05.11
Enlace dinámico
Esto permite invocar operaciones en objetos obviando el tipo actual de éstos hasta el
momento de ejecutar el código. O sea, nos permite definir elementos como un tipo e
instanciarlos como un tipo heredado. Pero ¿qué utilidad tiene obviar el tipo de un
objeto para luego tomar esta decisión?.
Gracias a que en C# la definición de los tipos de objetos se puede producir por

Herencia, no nos debe preocupar a qué tipo de elemento le paso un mensaje, ya que el
compilador tomará la decisión sobre qué objeto ejecutará qué método de acuerdo a la
forma de crear la instancia.
12.05.11
Este concepto es bastante complejo de entender, ya que estamos acostumbrados a

definir los elementos de acuerdo a lo que necesitamos.
Es decir, si requiero un entero lo declaro como entero, para que declarar un elemento
como un tipo y luego usarlo como otro?.
La respuesta está en que no siempre se puede determinar exactamente el tipo de

elemento que va a usarse en la ejecución de nuestro programa.
Se debe tener por lo menos una relación de herencia que permita determinar un tipo
base para la declaración, sea cual sea el subtipo que se instancie.
Veamos un ejemplo que nos aclare un poco las cosas:
12.05.11
using System;
using System.Text;
class Mamifero
{
public void mover() {
Console.WriteLine("Ahora es un mamifero el que se mueve");
}
}
class Perro : Mamifero

{
Console.WriteLine("Ahora es un perro el que se mueve");
}
}
class Gato : Mamifero

{
Console.WriteLine("Ahora es un gato el que se mueve");
}
}
12.05.11
public class Polimorfismo

{
public static void muevete(Mamifero m)
{
m.mover();
}
public static void main(String[] args)
{
Gato bisho = new Gato();
Perro feo = new Perro();
muevete(bisho);
muevete(feo);
}
}
Vemos que el método “muevete” llama al método mover de un mamífero y aunque no sabe
con qué clase de mamífero trata, funciona y se llama al método correspondiente al objeto
específico que lo llama (es decir, primero un gato y luego un perro). Si no existiera el enlace
dinámico, tendríamos que crear un método “muevete” para los mamíferos de tipo “Gato” y
otro para los de tipo “Perro”.
12.05.11
Veamos otro ejemplo donde las instancias se crean de forma aleatoria:
using System;
using System.Text;
public abstract class Instrumento {

public Instrumento() { }
public abstract void tocar();
public abstract void tocar(String nota);
public abstract void afinar();
}
12.05.11
public class Cuerda : Instrumento{

public Cuerda() {}
public void afinar() {
Console.WriteLine("Cuerda.afinar()");
}
public void tocar() {
Console.WriteLine("Cuerda.tocar()");
}
public void tocar(String nota){
Console.WriteLine("Cuerda.tocar()"+nota);
}
}
12.05.11
public class Percusion : Instrumento{

public Percusion() {}
Console.WriteLine("Percusion.afinar()");
}
Console.WriteLine("Percusion.tocar()");
}
Console.WriteLine("Percusion.tocar()"+nota);
}
}
12.05.11
public class Viento : Instrumento{

public Viento() {}
Console.WriteLine("Viento.afinar()");
}
Console.WriteLine("Viento.tocar()");
}
Console.WriteLine("Viento.tocar()"+nota);
}
}
12.05.11
public class LigaduraDinamica {

public static void main(String[] args){
String[] notas = {"Do","Re","Mi","Fa","Sol","La","Si"};
Instrumento [] orquesta = new Instrumento[10];
Random FixRandom = new Random(3);
for(int i=0;i<10;i++){
orquesta[i]=generarInstrumento( FixRandom.Next());
}
afinarInstrumento(orquesta[i]);
}
tocarInstrumento(orquesta[i]);
}
tocarInstrumento(orquesta[i],notas[i%7]);
}
}
12.05.11
public static Instrumento generarInstrumento(int i){

switch(i){
default:
case 0:
return new Viento();
case 1:
return new Percusion();
case 2:
return new Cuerda();
}
}
12.05.11
public static void afinarInstrumento(Instrumento o){

o.afinar();
}
public static void tocarInstrumento(Instrumento o){

o.tocar();
}
public static void tocarInstrumento(Instrumento o,String nota){

o.tocar(nota);
}
}
Vemos que el método “generarInstrumento” crea aleatoriamente las instancias de los

diferentes tipos de instrumentos y que el arreglo de elementos del tipo de instrumentos es
llenado con diferentes elementos de los cuales sólo sabemos que son objetos basados en
“Instrumento”. Sin embargo, los métodos “tocarInstrumento” y “afinarInstrumento” que
reciben como parámetro un Instrumento llaman adecuadamente a los métodos “afinar” o
“tocar” según la instancia que reciben.
13.05.11
Clases Abstractas
Las clases abstractas son aquellas que se utilizan en la herencia y sólo las
utilizaremos para que definan el interfaz (qué hacen) y/o la implementación (cómo
lo hacen) de las clases heredadas
No se podrá crear ocurrencias de ellas. Se utilizan para que las características de esta
clase estén disponibles para sus clases heredadas.
Es una forma de generalizar un comportamiento y, por lo tanto, reutilizar código.
13.05.11
Supongamos que queremos modelar todos los vehículos a motor (coches,

motos, lanchas, ...).
¿Existe en la vida real algún

objeto que sea un vehículo a
motor? NO
Existen coches , motos, etc...
La clase VehiculosAMotor nos

servirá para reutilizar sus
métodos y datos, pero no
para crear ocurrencias de ella.
13.05.11
using System;
using System.Collections.Generic;
using System.Text;
public abstract class VehiculosAMotor

{
public abstract void Arrancar();
}
using System;
using System.Text;
public class Carro:VehiculosAMotor

{
public override void Arrancar()
{
Console.WriteLine("Prender motor del carro");
}
} Programación de aplicaciones
13.05.11
using System;
using System.Text;
class Moto: VehiculosAMotor

{
public override void Arrancar()
{
Console.WriteLine("Prender motor la moto");
}
}
13.05.11
Clases y miembros de clase abstractos y Sellados
13.05.11
La palabra clave abstract permite crear clases y miembros de clase únicamente con
propósitos de herencia: para definir características de clases derivadas, no
abstractas. La palabra clave sealed permite impedir la herencia de una clase o de
ciertos miembros de clase marcados previamente como virtuales.
Clases y miembros de clase abstractos
Las clases se pueden declarar como abstractas. Esto se logra colocando la palabra
clave abstract antes de la palabra clave class en la definición de clase. Por ejemplo:
public abstract class A {
// Class members here.
}
No se pueden crear instancias de una clase abstracta. El propósito de una clase
abstracta es proporcionar una definición común de una clase base que múltiples
clases derivadas pueden compartir. Por ejemplo, una biblioteca de clase puede
definir una clase abstracta que se utiliza como parámetro para muchas de sus
funciones y solicitar a los programadores que utilizan esa biblioteca que
proporcionen su propia implementación de la clase mediante la creación de una
clase derivada.
13.05.11
Las clases abstractas también pueden definir métodos abstractos. Esto se consigue
agregando la palabra clave abstract antes del tipo de valor que devuelve el método.
Por ejemplo:
public abstract class A {

public abstract void DoWork(int i);
}
Los métodos abstractos no tienen ninguna implementación, de modo que la definición

de método va seguida por un punto y coma en lugar de un bloque de método normal.
Las clases derivadas de la clase abstracta deben implementar todos los métodos
abstractos. Cuando una clase abstracta hereda un método virtual de una clase base, la
clase abstracta puede reemplazar el método virtual con un método abstracto. Por
ejemplo:
13.05.11
public class D
{
public virtual void DoWork(int i)
{
// Original implementation.
}
}
public abstract class E : D

{
public abstract override void DoWork(int i);
}
public class F : E
{
public override void DoWork(int i)
{
// New implementation.
}
}
13.05.11
Si un método virtual se declara abstracto, sigue siendo virtual para cualquier

clase que se herede de la clase abstracta. Una clase que hereda un método
abstracto no puede tener acceso a la implementación original del método; en el
ejemplo anterior,
DoWork de la clase F no puede llamar a DoWork de la clase D. De esta forma,

una clase abstracta puede obligar a las clases derivadas a proporcionar nuevas
implementaciones de método para los métodos virtuales.
13.05.11
clases y miembros de clase sellados
Las clases pueden declararse como selladas. Esto se logra colocando la palabra clave
sealed antes de la palabra clave class en la definición de clase. Por ejemplo:
public sealed class D

{
// Class members here.
}
Una clase sellada no se puede utilizar como clase base. Por esta razón, tampoco
puede ser una clase abstracta. Las clases selladas se utilizan principalmente para
impedir la derivación. Puesto que nunca se pueden utilizar como una clase base,
algunas optimizaciones en tiempo de ejecución pueden hacer que sea un poco más
rápido llamar a miembros de clase sellada.
13.05.11
Un miembro de clase, método, campo, propiedad o evento de una clase derivada

que reemplaza a un miembro virtual de la clase base puede declarar ese miembro
como sellado. Esto niega el aspecto virtual del miembro para cualquier clase
derivada adicional. Esto se logra colocando la palabra clave sealed antes de la
palabra clave override en la declaración del miembro de clase. Por ejemplo:
public class D : C
{
public sealed override void DoWork() { }
}
13.05.11
Interfaces
Las interfaces se definen utilizando la palabra clave interface. Por ejemplo:
interface IComparable
{
int CompareTo(object obj);
}
Las interfaces describen un grupo de comportamientos relacionados que pueden

pertenecer a cualquier clase o estructura. Las interfaces pueden estar compuestas de
métodos, propiedades, eventos, indizadores o cualquier combinación de estos cuatro
tipos de miembros. Una interfaz no puede contener campos. Los miembros de
interfaz son automáticamente públicos.
13.05.11
Al igual que las clases se pueden heredar de una clase base o estructura, las
clases y estructuras se pueden heredar de interfaces, con dos excepciones:
• Una clase o estructura puede heredar más de una interfaz.
• Cuando una clase o la estructura hereda una interfaz, hereda sólo los
nombres de método y las firmas, ya que la propia interfaz no contiene
ninguna implementación. Por ejemplo:
public class Minivan : Car, IComparable

{
public int CompareTo(object obj)
{
//implementation of CompareTo
return 0; //if the Minivans are equal
}
}
13.05.11
Para implementar un miembro de interfaz, el miembro correspondiente de la clase

debe ser público, no estático y tener el mismo nombre y la misma firma que el
miembro de interfaz. Las propiedades e indizadores de una clase pueden definir
descriptores de acceso adicionales para una propiedad o indizador definidos en una
interfaz. Por ejemplo, una interfaz puede declarar una propiedad con un descriptor
de acceso get, pero la clase que implementa la interfaz puede declarar la misma
propiedad con descriptores de acceso get y set. Sin embargo, si la propiedad o el
indizador utiliza una implementación explícita, los descriptores de acceso deben
coincidir.
Las interfaces y los miembros de interfaz son abstractos; las interfaces no
proporcionan una implementación predeterminada.
La interfaz IComparable informa al usuario del objeto de que éste se puede

comparar con otros objetos del mismo tipo y el usuario de la interfaz no necesita
saber cómo se implementa.
13.05.11
Las interfaces pueden heredar otras interfaces. Es posible que una clase herede una
interfaz varias veces, a través de las clases base o interfaces que hereda. En ese caso,
la clase sólo puede implementar la interfaz una vez, siempre que ésta se declare
como parte de la nueva clase. Si la interfaz heredada no está declarada como parte
de la nueva clase, la clase base que la declaró proporcionará su implementación. Es
posible que una clase base implemente miembros de interfaz a través de miembros
virtuales. En ese caso, la clase que hereda la interfaz puede cambiar el
comportamiento de la interfaz reemplazando los miembros virtuales.
13.05.11
Una interfaz tiene las siguientes propiedades:

• Una interfaz es similar a una clase base abstracta. Cualquier tipo no abstracto
que hereda la interfaz debe implementar todos sus miembros.
• No se pueden crear instancias directamente de una interfaz.
• Las interfaces pueden contener eventos, métodos, indizadores y propiedades.
• Las interfaces no contienen implementaciones de métodos.
• Las clases y estructuras se pueden heredar de más de una interfaz.
• Una interfaz se puede heredar de varias interfaces.
13.05.11
Implementación explícita de interfaz
13.05.11
Si una clase implementa dos interfaces que contienen un miembro con la misma
firma, la implementación de ese miembro en la clase hará que ambas interfaces usen
ese miembro como implementación. Por ejemplo:
interface IControl
{
void Paint();
}
interface ISurface
{
void Paint();
}
class SampleClass : IControl, ISurface
{
public void Paint()
{
}
}
13.05.11
Sin embargo, sI los miembros de dos interfaces no realizan la misma función, esto puede llevar a
una implementación incorrecta de una o ambas interfaces. Es posible implementar un miembro
de interfaz explícitamente, creando un miembro de clase que sólo se llama a través de la interfaz
y es específico de ésta. Esto se puede llevar a cabo asignando al miembro de clase el nombre de
la interfaz y un punto. Por ejemplo:
public class SampleClass : IControl, ISurface

{
void IControl.Paint()
{
System.Console.WriteLine("IControl.Paint");
}
void ISurface.Paint()
{
System.Console.WriteLine("ISurface.Paint");
}
}
14.05.11
El miembro de clase IControl.Paint sólo está disponible a través de la interfaz

IControl, mientras que ISurface.Paint sólo está disponible a través de ISurface.
Ambas implementaciones de método son independientes y ninguna está
directamente disponible en la clase. Por ejemplo:
SampleClass obj = new SampleClass();
IControl c = (IControl)obj;
c.Paint();
ISurface s = (ISurface)obj;
s.Paint();
14.05.11
La implementación explícita también se usa para resolver casos donde cada una de
las dos interfaces declara miembros diferentes del mismo nombre como propiedad
y método: interface ILeft
{
int P { get; }
}
interface IRight
{
int P();
}
14.05.11
Para implementar ambas interfaces, una clase tiene que utilizar implementación
explícita, ya sea para la propiedad P, el método P o ambos, con el fin de evitar un error
del compilador. Por ejemplo:
class Middle : ILeft, IRight

{
public int P() { return 0; }
int ILeft.P { get { return 0; } }
}

Conceptos Avanzados de Programacion Orientada A Objetos

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Conceptos Avanzados de Programacion Orientada A Objetos

Uploaded by

Copyright:

Available Formats

PROGRAMACIÓN DE APLICACIONES

Instructor : Nataniel Marcial Chavez

12.05.11 Programación de aplicaciones

II. CONCEPTOS AVANZADOS DE LA PROGRAMACIÓN ORIENTADA A OBJETOS.

12.05.11 Programación de aplicaciones

Conceptos sobre polimorfismo

El polimorfismo, en programación orientada a objetos, se refiere a la posibilidad de

Este término se refiere al uso del mismo identificador u operador en distintos

Si para cada funcionalidad necesitada fuese necesario escribir un método, el código

Este tipo de codificación nos es permitido gracias a la sobrecarga, la cual se aplica a

La sobrecarga de métodos hace que un mismo nombre pueda representar distintos

En el ámbito de la POO, la sobrecarga de métodos se refiere a la posibilidad de tener

Podemos diferenciar varios métodos sobrecargados a través de sus parámetros, ya

public class Articulo

private double precio;

public void setPrecio()

La sobreescritura se aplica a los métodos y está directamente relacionada a la

protected double area;

public class Circulo : Figura {

public const double PI=3.1415926;

this.area = PI* Math.Pow(this.radio,2.0);

Gracias a que en C# la definición de los tipos de objetos se puede producir por

Este concepto es bastante complejo de entender, ya que estamos acostumbrados a

La respuesta está en que no siempre se puede determinar exactamente el tipo de

Veamos un ejemplo que nos aclare un poco las cosas:

class Perro : Mamifero

class Gato : Mamifero

public class Polimorfismo

Veamos otro ejemplo donde las instancias se crean de forma aleatoria:

public abstract class Instrumento {

public class Cuerda : Instrumento{

public class Percusion : Instrumento{

public class Viento : Instrumento{

public class LigaduraDinamica {

public static Instrumento generarInstrumento(int i){

public static void afinarInstrumento(Instrumento o){

public static void tocarInstrumento(Instrumento o){

public static void tocarInstrumento(Instrumento o,String nota){

Vemos que el método “generarInstrumento” crea aleatoriamente las instancias de los

Es una forma de generalizar un comportamiento y, por lo tanto, reutilizar código.

Supongamos que queremos modelar todos los vehículos a motor (coches,

¿Existe en la vida real algún

Existen coches , motos, etc...

La clase VehiculosAMotor nos

public abstract class VehiculosAMotor

public class Carro:VehiculosAMotor

class Moto: VehiculosAMotor

Clases y miembros de clase abstractos y Sellados

Clases y miembros de clase abstractos

public abstract class A {

Los métodos abstractos no tienen ninguna implementación, de modo que la definición

public abstract class E : D

Si un método virtual se declara abstracto, sigue siendo virtual para cualquier

DoWork de la clase F no puede llamar a DoWork de la clase D. De esta forma,

clases y miembros de clase sellados

public sealed class D

Un miembro de clase, método, campo, propiedad o evento de una clase derivada

Las interfaces se definen utilizando la palabra clave interface. Por ejemplo:

Las interfaces describen un grupo de comportamientos relacionados que pueden

public class Minivan : Car, IComparable

Para implementar un miembro de interfaz, el miembro correspondiente de la clase

La interfaz IComparable informa al usuario del objeto de que éste se puede

Una interfaz tiene las siguientes propiedades: