Programacion oo

Presentación

Programación Orientada a Objetos

Ing. Mauricio Paletta, Msc
INGENIERÍA EN INFORMÁTICA
Programación II

UNIVERSIDAD NACIONAL EXPERIMENTAL DE GUAYANA

Programación II


• ¿Cómo llevar a código todos los conceptos, principios y
términos técnicos de la orientación a objetos?
• Lenguajes de programación más populares: C++, Java y
C#.
• Hay lenguajes puros (casados con los conceptos de OO),
e híbridos (permiten hacer cosas no OO).
• Es importante evaluar la plataforma de desarrollo a
utilizar basado en: entorno operativo, amigabilidad,
soporte, tiempo de compilación, biblioteca de clases
predefinida, costo (adquisición, instalación,
mantenimiento, etc.), experiencia, etc.

Programación II


• Algunas sugerencias: Microsoft Visual Studio, Borland
Delphi 2005, Borland BuilderX, Borland Enterprise Studio.
• Usar un lenguaje orientado a objetos no necesariamente
implica hacer programación orientada a objetos. La clave
está en respetar los principios.

Programación II


C++
• Compilado => permite generar programas ejecutables.
• No es puro porque viene del lenguaje C y mantiene todos
los conceptos no orientado a objetos de C.
• Bajo nivel de portabilidad, alta dependencia en la
plataforma operativa.
• Sintaxis simple y semántica compleja.
• Muy rico conceptualmente en lo que a orientación a
objetos se refiere (manejo de herencia múltiple y
sobrecarga de operadores por ejemplo).
• Extensión de los archivos de código fuente: “cpp”.

Programación II


Java
• Pseudo-interpretado (Java bytecode) se requiere un
motor o máquina de ejecución para correr los programas.
• Es puro desde el punto de vista de orientación a objetos.
• Alto nivel de portabilidad, los programas pueden correr
donde haya una máquina de ejecución.
• Sintaxis y semántica simple.
• No se permite ni la herencia múltiple directa ni la
sobrecarga de operadores.
• Extensión de los archivos de código fuente: “java”.
• Extensión de los archivos Pseudo-compilados: “class”.

Programación II


C#
• 70% Java, 10% C++, 5% Visual Basic, 15% cosas
nuevas.
• Pseudo-interpretado (Microsoft Intermediate Language -
MSIL) se requiere un motor o máquina de ejecución
para correr los programas.
• Es puro desde el punto de vista de orientación a objetos.
• Alto nivel de portabilidad, los programas pueden correr
donde haya una máquina de ejecución.
• Sintaxis y semántica medianamente complejas.
• No se permite la herencia múltiple directa.
• Extensión de los archivos de código fuente: “cs”.
Programación II

Definición de Clases

C++ Identificador de
Indica definición la clase
Comienza la
de una clase class Complejo { definición de la
private: clase
double Real, Imag;
Atributos
Declarativas para public:
definir la interfaz de double ObtReal(void) {
los elementos return Real;
}
double ObtImag(void) { Métodos
return Imag;
}
Termina la };
definición de la
Instanciación de objetos opcional
clase
Programación II


C++
• Las declarativas de interfaz pueden aparecer más de
una vez y en cualquier orden. Si no se indica nada es
privada por defecto.
• El cuerpo de los métodos se puede definir tanto dentro
(inline) como fuera (outline) de la definición de la clase.
Hay una diferencia en la llamada del mensaje o
ejecución del método:
inline se hace una copia fiel del código del cuerpo del
método; código más rápido pero más grande
outline se agrega una referencia donde se encuentra el
código del cuerpo del método; código más lento pero
más pequeño

Programación II


C++
Indica relación de dependencia
con una clase

class Complejo { double Complejo::ObtReal(void)
double Real; {
public: return Real;
double ObtReal(void); }
private:
double Imag; double Complejo::ObtImag(void)
public: {
double ObtImag(void); return Imag;
}; }

El cuerpo del método
no está aquí

Programación II


C++
• El cuerpo de los métodos inline debe ser simple, sin
estructuras de control complejas (ciclos, ruptura,
condicionales múltiples).
• Se puede forzar la declaración de los métodos inline
fuera de la definición de la clase. Permite mantener las
ventajas de los métodos inline escondiendo el código a
terceros.

Programación II


C++

inline double Complejo::ObtReal(void) {
return Real;
}
inline double Complejo::ObtImag(void) {
return Imag;
}

Programación II


Java / C# Identificador de
Indica definición la clase
Comienza la
de una clase class Complejo { definición de la
private double Real, Imag; clase

public double ObtReal( ) { Atributos
Declarativas para return Real;
definir la interfaz de }
los elementos public double ObtImag( ) { Métodos
return Imag;
}
}
Termina la
definición de la
clase

Programación II


Java
una vez y en cualquier orden. Si no se indica nada se
asume una interfaz entre privada y protegida. Privada
porque no permite la visibilidad del elemento para las
clases derivadas; protegida porque permite la visibilidad
en todas las clases del mismo paquete.
• El cuerpo de los métodos siempre debe ser definido
dentro de la definición de la clase.
• Todos los elementos de una clase están declarados y
definidos dentro de la clase.

Programación II


C#
una vez y en cualquier orden. Si no se indica nada es
privada por defecto.
• El cuerpo de los métodos siempre debe ser definido
dentro de la definición de la clase.
• Todos los elementos de una clase están declarados y
definidos dentro de la clase.
• Se maneja el concepto de atributos en la cual es posible
esconder el manejo de los métodos de lectura (get) y
asignación (set) de cada uno de los atributos de la
clase.

Programación II


C#
Se puede acceder
class Complejo {
al atributo privado
private double Real, Imag;
Real mediante este
elemento público.
public double ParteReal {
Usado para indicar Para los ojos del
get {
el retorno del valor usuario es como si
return Real;
del atributo fuera un atributo
}
pero realmente es
}
un método.
Se puede usar public double ParteImag {
también la get {
sentencia set para return Imag;
indicar las acciones }
a tomar con la }
modificación del }
valor del atributo
Programación II

Instanciación de Objetos

C++
Instancias u objetos
(instanciación estática) No es un objeto
Identificador sino un apuntador o
de la Clase dirección de memoria
Complejo C1, C2, *pC;

pC = new Complejo; Instanciación dinámica
haciendo uso del apuntador
…

delete pC;

Liberación del espacio creado
de forma dinámica. Debe ser
hecho por el programador

Programación II


Java

Identificador
de la Clase Instancia u objeto

Complejo C1 = new Complejo( );

NOTAS: - No existe el concepto de apuntador o
dirección de memoria.
- El proceso de instanciación es siempre
dinámico.
- La liberación o recuperación de memoria es
automático y realizado por el motor de
ejecución (no existe un operador delete).

Programación II


C#
Identificador
de la Clase Instancia u objeto

Complejo C1 = new Complejo( );

NOTAS: - Sólo se permiten apuntadores o direcciones de
memoria de tipos primitivos, no estructuras
complejas como el caso de clases.
- El proceso de instanciación es siempre
dinámico.
- La liberación o recuperación de memoria es
automático y realizado por el motor de ejecución
(no existe un operador delete).
Programación II

Acceso a Elementos de la Clase

C++
Complejo C, *pC = new Complejo;
Operador para
double d = C.ObtReal( );
acceder a los
Llamadas de mensajes
elementos del
pCObtImag( ); o ejecución de
objeto
métodos
(*pC).ObtImag( );

Operador para acceder a los elementos El contenido de la
del objeto a partir de un apuntador a la dirección de memoria es un
dirección de memoria del mismo objeto

NOTA: Recordar que los permisos de acceso a los elementos están
regidos por la interfaz asociada en la definición de la clase.

Programación II


Java / C#

Complejo C = new Complejo( );

double d = C.ObtReal( );

Operador para Llamada de mensaje o
acceder a los ejecución del método
elementos del
objeto

NOTA: Recordar que los permisos de acceso a los elementos están
regidos por la interfaz asociada en la definición de la clase.

Programación II


C#


double d = C.ParteReal;

Operador para Acceso al atributo
acceder a los público (llamada
elementos del automática al mensaje
objeto get asociada al
atributo)

Programación II

Constructor

• Basado en el principio de persistencia.
• Es un método particular que es ejecutado automáticamente
durante la instanciación del objeto (tanto estática como
dinámicamente).
• Es útil para definir el estado inicial del objeto y realizar
otras inicializaciones necesarias.
• Como método/operación tiene las siguientes
características:
o Es opcional.
o Debe ser público.
o Se identifica de la misma forma como se identifica la clase.
o No se le especifica tipo de retorno.
o Puede tener cualquier número de parámetros.

Programación II

Constructor

C++
class Complejo {
private: No está permitido la
double Real, Imag; inicialización de variables
en este contexto
public:
Complejo(void) { Un constructor para la
Real = Imag = 0.0; clase
}
double ObtReal(void) { NOTA: Si no se
return Real; especifica un
} constructor la data
double ObtImag(void) { del objeto queda
return Imag; sin inicializar
} (embasurada).
};

Programación II

Constructor

Java / C#
class Complejo {
Se permite la inicialización
private double Real = 0.0;
de elementos en este
private double Imag = 0.0;
contexto
public Complejo( ) { Un constructor
Real = Imag = 0.0; para la clase
}
public double ObtReal( ) { NOTA: Si no se especifica un
return Real; constructor para la clase,
} se asume uno por defecto
public double ObtImag( ) { que no tiene parámetros y
return Imag; que inicializa todos los
} atributos en los literales
} nulos correspondientes (0,
false, „0‟, null, etc.)
Programación II

Polimorfismo

• Basado en el principio que lleva el mismo nombre.
• Definir dos o más métodos con el mismo nombre, tipo de
retorno e interfaz, pero diferente descripción de
parámetros (cantidad y/o tipo de los mismos). Los
parámetros determinan el contexto.
• No hay límite sobre la cantidad de métodos definidos de
forma polimórfica.
• No es una redefinición, cada método se trata de forma
independiente (declaración, definición y llamada).
• Un caso particular es hacer polimorfismo sobre el
constructor. Permite dar al usuario diferentes formas de
inicializar un objeto durante la instanciación del mismo.

Programación II

Polimorfismo

C++
class Complejo {
private:
double Real, Imag;

public:
Complejo(void) {
Real = Imag = 0.0; Polimorfismo
} sobre el
Complejo(double R, double I) { constructor
Real = R, Imag = I;
}
…
} C1, C2(1.0, -1.0);

Dos objetos instanciados cada uno de los cuales llama
a un constructor diferente
Programación II

Polimorfismo

Java / C#
class Complejo {
public Complejo( ) {
Real = Imag = 0.0; Polimorfismo
} sobre el
public Complejo(double R, double I ) { constructor
Real = R; Imag = I;
}
…
} Dos objetos instancia-
… dos cada uno de los
Complejo C1 = new Complejo( ), cuales llama a un
C2 = new Complejo(1.0, -1.0); constructor diferente

Programación II

Inicialización por defecto

• Permite especificar un valor inicial por defecto a los
parámetros de un método para los casos en los cuales el
usuario obvia el parámetro.
• Da al usuario la idea de que los parámetros son
opcionales.
• Cuando hay más de un parámetro, el orden de asignación
entre el valor por defecto y el parámetro es de izquierda a
derecha. No pueden haber saltos en esta relación de
asignación.
• Es útil para reducir el número de métodos de la clase
(simplificar el uso del polimorfismo).
• Es válido para cualquier método, en particular para los
constructores.
Programación II


C++
class Complejo {
private:
double Real, Imag;

public:
Complejo(double R = 0.0, double I = 0.0) {
Real = R, Imag = I;
}
…
} C1, C2(1.0, -1.0), C3(1.0);

Valor por defecto del parámetro

Tres objetos instanciados, todos hacen la
llamada al mismo constructor

Programación II


C++
class Complejo {
…
public:
Complejo(double = 0.0, double = 0.0);
…
};
…
Complejo::Complejo(double R, double I) {
Real = R; Imag = I;
}

NOTA: Cuando el cuerpo del constructor está fuera de la definición de
la clase, las inicializaciones por defecto se especifican dentro
de la clase en la declaración del método y no en su definición.

Programación II


Java / C#
• Concepto no soportado en estos lenguajes.
• Se permite inicialización de elementos en definición de la
clase.
class Complejo {
private double Real = 0.0; Inicialización de
private double Imag = 0.0; elementos
public Complejo(double R, double I ) {
Real = R; Imag = I;
}
… Es un error porque no
} se puede resolver con
… el constructor existente
Programación II

Destructor

• Basado en el principio de persistencia.
• Es un método particular que es ejecutado
automáticamente durante la destrucción o pérdida de
alcance del objeto (tanto estática como dinámicamente).
• Es útil para realizar código necesario cuando el objeto ya
no va a ser mas utilizado, como por ejemplo la liberación o
recuperación de espacios de memoria.
• No aplica en lenguajes con recuperación automática de
memoria.

Programación II

Destructor

• Como método/operación tiene las siguientes
características:
o Es opcional.
o Debe ser público.
o No se le especifica tipo de retorno.
o No tiene parámetros.

Programación II

Destructor

C++
class Complejo {
private:
El destructor se llama double Real, Imag;
igual que la clase pero
con el prefijo ~ public:
Complejo(double R = 0.0, double I = 0.0) {
Real = R, Imag = I;
Expresa que el método }
tiene un cuerpo vacío ~Complejo(void) { }
o no tiene código
…
asociado
};

NOTA: La destrucción ocurre cuando el objeto pierde su alcance de
vida. En el caso de la instanciación dinámica, esto ocurre
cuando se hace la operación delete

Programación II

Destructor

Java

protected void finalize( ) {
… Se puede redefinir el método
} finalize para que sea llamado
de forma automática por el
algoritmo de recuperación de
memoria

NOTA: No soporta el concepto de destructores por el algoritmo
de recuperación automática de memoria. Se
recomienda no usar finalize y dejar todo el trabajo al
motor de ejecución.

Programación II

Destructor

C#
class Complejo { Al igual que Java, se puede
… redefinir el método Finalize
void Finalize( ) { para que sea llamado de forma
… automática por el algoritmo de
} recuperación de memoria
}

class Complejo { También soporta la misma sintaxis
… de C++ y tener un método que se
~Complejo( ) { llama igual que la clase con el
… prefijo ~. Este método y la
} redefinición de Finalize no pueden
} convivir en la misma clase

Programación II

Elementos estáticos

• Basado en el principio de concurrencia.
• Permite que todos los objetos instanciados de una misma
clase y que están activos en un mismo instante,
compartan la misma información asociada a uno o varios
de sus atributos y/o compartan el mismo código asociado
a uno o varios de sus métodos.
• La idea es forzar a todos los objetos a ver / usar el mismo
elemento.

Programación II


• Un ejemplo típico de Java / C#, es el caso particular del
método que representa el programa principal (main /
Main); este debe ser estático porque no tiene sentido dos
instancias de objetos cada uno de los cuales con un
programa principal de ejecución; todas las instancias
comparten el mismo método.

Programación II


C++
Indica que
class String;
String es una
class File { clase cuya
private: definición se
Atributo
static int NumAbiertos; encontrará
estático
public: mas adelante
File(const String &, const String &);
File(const File &);
Destructor ~File(void); Indica pasaje
static int Abiertos(void) { de parámetro
return NumAbiertos; por referencia
}
… Método
}; estático

Programación II


C++
Asignación del valor
inicial al atributo
int File::NumAbiertos = 0; estático, nótese que
está fuera de la
File::File(const String &N, const String &M) {
definición de la clase
…
NumAbiertos++;
}
File::~File(void) {
… Constructor y
NumAbiertos--; destructor definidos
} fuera de la definición
… de la clase

Programación II


Java
La clase que contiene
public class Ejemplo { el programa principal
debe ser pública
static int NumInstancias = 0;
public static int Instancias( ) { Atributo estático con su
return NumInstancias; inicialización
}
Método estático
public Ejemplo( ) {
NumInstancias++; Para tomar los posibles
} argumentos del
public static void main(String args[ ]) { programa principal
…
} Para definir el código
} del programa principal

Programación II


C#
La clase que contiene
public class Ejemplo { el programa principal
debe ser pública
static int NumInstancias = 0;
public static int Instancias( ) { Atributo estático con su
return NumInstancias; inicialización
}
Método estático
public Ejemplo( ) {
NumInstancias++; Para tomar los posibles
} argumentos del
public static void Main(string args[ ]) { programa principal
…
} Para definir el código
} del programa principal

Programación II

Operador de Asignación o Copia

• Los lenguajes orientados a objetos manejan internamente
el uso del operador natural de asignación cuando es
aplicado sobre una instancia u objeto.
• El efecto es copiar el contenido de la memoria que
corresponde a los atributos de la expresión que resulta del
lado derecho de la asignación, en el espacio de memoria
equivalente del objeto que recibe el valor en el lado
izquierdo de la operación.
• Hay que tener cuidado con direcciones de memoria o uso
de apuntadores como atributos (si aplica en el lenguaje).

Programación II


• Los lenguajes que soportan la sobrecarga de operadores
pueden dar su propia definición del operador de
asignación y así evitar problemas como el caso anterior.
• En algunos lenguajes se realiza una llamada indirecta al
constructor cuando el contexto es claro.

Programación II


C++
Construcción indirecta
Complejo C1(2.5, -1.0), C2 = C1, C3 = 1.0; de una instancia para
resolver la operación

Java / C#
Complejo C1 = new Complejo(2.5, -1.0), C2 = C1; Uso del operador de
asignación entre objetos

Complejo C1 = new Complejo(2.5, -1.0),
C2 = new Complejo( );
…
C2 = C1;

Programación II

Sobrecarga de Operadores

• Basado en el principio de polimorfismo.
• Permite escribir una implementación propia sobre el uso
de un símbolo predeterminado, usado por el lenguaje para
representar operaciones sobre elementos primitivos.
• Ejemplo: Para representar la suma de dos objetos C1 y
C2 de tipo Complejo y guardar el resultado en el Complejo
C3, es más elegante hacer
C3 = C1 + C2
que hacer
C3 = C1.Suma(C2) ó
C3 = Suma(C1, C2)

Programación II

C++
• Se pueden sobrecargar los siguientes operadores:
o Aritméticos: +, -, *, /, %, ++, --, +=, -=, *=, /=, %=.
o Asignación: =.
o Relacionales: >, <, >=, <=, ==, !=.
o Manejo de bits: &, |, ^, >>, <<, ~, &=, |=, ^=, >>=, <<=.
o Lógicos: &&, ||, !.
o Conversión de tipos (casting): ( )
o Direccionamiento de arreglos: [ ]
o Manejo dinámico de memoria: new, delete.

Programación II


C++
• No es posible modificar la asociatividad del operador y
tampoco la semántica de interpretación (por ejemplo,
los operadores de relación deben retornar un valor
lógico válido).

Programación II


C++
class Complejo {
private:
double Real, Imag;
public:
…
// Sobrecarga de un operador binario asociativo
Complejo &operator +(Complejo &C) {
return *new Complejo(Real + C.Real, Imag + C.Imag);
}
…
} C1, C2(5.0, -1.0), C3(2.5);
…
C1 = C2 + C3; // Llamada del mensaje

Programación II


C++
class Complejo {
private:
double Real, Imag;
public:
…
operator double( ) { // Sobrecarga de un operador
return Real; // unario de conversión de tipo
}
…
} C(5.0, -1.0);
…
double d = (double)C; // Llamada del mensaje

Programación II


Java
class Complejo {
…
public Complejo Suma(Complejo C) {
return new Complejo(Real + C.Real, Imag + C.Imag);
}
…
}
…
C2 = new Complejo(5.0, 2.5),
C3 = C1.Suma(C2);

NOTA: No soporta la sobrecarga de operadores.
Programación II

C#
• Se pueden sobrecargar los siguientes operadores:
o Aritméticos: +, -, *, /, %, ++, --.
o Relacionales: >, <, >=, <=, ==, !=.
o Manejo de bits: &, |, ^, >>, <<, ~.
o Lógicos: !, true, false.
o Conversión de tipos (casting): ( )

Programación II


C#
• Al sobrecargar un operador binario op, también se
sobrecarga el operador de asignación correspondiente
op=, si lo posee.
• El direccionamiento de arreglos [ ] no se considera
como una sobrecarga. Se maneja haciendo uso del
concepto de “indexadores” (indexer).

Programación II


C#
class Complejo {
…
public static Complejo operator +(Complejo C1, Complejo C2) {
return new Complejo(C1.Real + C2.Real, C1.Imag + C2.Imag);
}
…
}
…
C2 = new Complejo(5.0, 2.5),
C3 = C1 + C2;

NOTA: Deben ser obligatoriamente métodos públicos y estáticos.
Programación II


C#
class Complejo {
…
public static explicit operator double(Complejo C) {
return C.Real;
}
public static implicit operator Complejo(double d) {
Complejo C = new Complejo(d, 0.0);
return C;
}
…
}
…
Complejo C = 1.0; // Conversión implícita
double d = (double)C; // Conversión explícita

Programación II

Referencia al objeto actual

• Variable predefinida que permite al programador hacer
referencia al objeto actualmente instanciado. Para los tres
lenguajes en estudio la variable se identifica como this.
• Es útil cuando en el cuerpo de un método se hace
referencia a un elemento de la clase con más de una
instancia, incluyendo la actual y se quiere representar la
diferencia.
• Para los lenguajes que permiten la sobrecarga de
operadores, es útil para retornar la instancia actual cuando
el operador es unario y asociativo.
• En C++, this es un apuntador por lo que se debe usar con
el operador .

Programación II


• En Java, this se puede usar como una función dentro de
un constructor para hacer una llamada de otro constructor
de la misma clase.

Programación II


C++
class Complejo {
…
public:
…
Complejo &operator ++(void) { // Operador unario
*this = *this + Complejo(1.0, 1.0); // asociativo con
return *this; // modificación del
} // estado del objeto
… // que hace la llamada
} C(5.0, -1.0);
…
(++C)++; // Ejecución del operador dos veces, la primera vez
// como prefijo y la segunda como postfijo

Programación II


Java

class Complejo {
public Complejo(double R, double I ) {
Real = R; Imag = I;
}
public Complejo( ) {
this(0.0, 0.0); // Llamada al primer constructor
}
public Complejo Suma(Complejo C) {
return new Complejo(this.Real + C.Real, this.Imag + C.Imag);
}
…
}
Programación II


C#

class Complejo {
public Complejo(double R, double I) {
Real = R; Imag = I;
}
public Complejo(Complejo C) {
this.Real = C.Real; this.Imag = C.Imag;
}
…
}
…
Complejo C1 = new Complejo(1.0, 1.0), C2 = new Complejo(C1);

Programación II

Herencia

C++ class Carro {
private:
int Mod, Cap;
Constructor clase Base public:
Carro(int M = 0, int C = 0) { … }
…
Interfaz de la herencia };
(¿Cómo serán vistos en clase Operador de
Derivada los elementos class Carga : public Carro { relación entre
públicos de la clase Base?) private: clase Base y
int CapCarga; clase Derivada
public:
Constructor clase
Carga(int M = 0, int C = 0, int P = 0) :
Derivada
Carro(M, C) { … }
…
Llamada al constructor
};
de la clase Base
Programación II

Herencia

C++

class A { En
private: int A1; Dentro Deriva- Fuera de
protected: int A2; de B das de B B
public: int A3; A1
};
A2
class B : private A { A3
private: int B1;
protected: int B2; B1
public: int B3; B2
};
B3

Programación II

Herencia

C++

class A { En
protected: int A2; de C das de C C
public: int A3; A1
};
A2
class C : protected A { A3
private: int C1;
protected: int C2; C1
public: int C3; C2
};
C3

Programación II

Herencia

C++

class A { En
protected: int A2; de D das de D D
public: int A3; A1
};
A2
class D : public A { A3
private: int D1;
protected: int D2; D1
public: int D3; D2
};
D3

Programación II

Herencia

C++
class B1 { class B2 {
private: int IB1; private: int IB2;
public: public:
B1(int I = 0) { IB1 = I; } B2(int I = 0) { IB2 = I; }
… …
}; };
Herencia múltiple
class D : public B1, public B2 {
public:
D(int I1 = 0, int I2 = 0) : B1(I1), B2(I2) { };
…
};

Constructores de clases Base
Programación II

Herencia

C++
class B1 { class B2 {
public: int B; public: int B;
… …
}; };

class D : public B1, public B2 { Operador que
public: int B; indica búsqueda
… sobre un
contexto superior
} UnD;
(en la jerarquía)
… al actual
UnD.B = 0; // Acceso al elemento B de D
UnD.B1::B = 0; // Acceso al elemento B de B1
UnD.B2::B = 0; // Acceso al elemento B de B2

Programación II

Herencia

C++
class Cb { public: int I; };
class Cd1 : public Cb { };
class Cd2 : public Cb { };
class Chm : public Cd1, public Cd2 { };
…
Chm hm; hm.Cd1::I = 1; hm.Cd2::I = 2; // Cada I es independiente
cout << hm.Cd1::I << 'n' << hm.Cd2::I; // La salida es: 1 2

class Cb { public: int I; };
class Cd1 : public virtual Cb { };
class Cd2 : public virtual Cb { };
class Chm : public Cd1, public Cd2 { };
…
Chm hm; hm.Cd1::I = 1; hm.Cd2::I = 2; // I es compartido (el mismo)
cout << hm.Cd1::I << 'n' << hm.Cd2::I; // La salida es: 2 2

Programación II

Herencia

Java
class Carro {
Constructor clase Base
private int Mod = 0, Cap = 0;
public Carro(int M, int C) { … }
Indica herencia …
}

Constructor clase class Carga extends Carro {
Derivada private int CapCarga = 0;
public Carga(int M, int C, int P) {
super(M, C);
…
Llamada al constructor }
de la clase Base …
}

Programación II

Herencia

Java
class A { B UnB = new B(1, -1);
public int I; // Acceso al elemento I
… // de B.
} //
class B extends A { UnB.I++;
public int I; // No es posible acceder
public B(int I1, int I2) { // al elemento I de A con
I = I1; // Acceso al elemento I de B // la instancia UnB, no
// (equivalente a usar this.I) // hay forma de resolver
A.I = I2; // Acceso al elemento I de A // la ambigüedad con el
} // elemento I entre la
… // clase base A y la clase
} // derivada B

Programación II

Herencia

Java
public interface VideoClip { Representa una interfaz
void Play( );
void Stop( ); Métodos de la interfaz a
} definir en otro lugar

class MiClase implements VideoClip { Clase que implementa o
void Play( ) { … } usa una interfaz
void Stop( ) { … }
Definición de los
…
métodos de la interfaz
}

NOTA: Una interface en Java representa un conjunto de métodos
cuya definición (implementación) está en otro lugar
(concepto parecido a los métodos virtuales pero sin usar la
herencia).
Programación II

Herencia

Java
interface Interfaz1 {
NOTA: Aunque Java no
public void Print1( );
soporta la herencia
}
múltiple, el uso de
interface Interfaz2 {
interfaces represen-
public void Print2( );
ta un truco para
}
hacer algo parecido
class Superclase {
protected String S = “Ejemplo”;
}
class Subclase extends Superclase implements Interfaz1, Interfaz2 {
public void Print1( ) { System.out.println(S); }
public void Print2( ) { System.out.println(“Por Interfaz 2”); }
}

Programación II

Herencia

C#
class Carro {
Constructor clase Base
private int Mod = 0, Cap = 0;
public Carro(int M, int C) { … }
Indica herencia …
};

Constructor clase class Carga : Carro {
Derivada private int CapCarga = 0;
public Carga(int M, int C, int P) :
base(M, C) {
…
Llamada al constructor }
de la clase Base …
}

Programación II

Herencia

C#
class A { Permite indicar que B UnB = new B(1, -1);
public int I; es un elemento
// Acceso al elemento I
… nuevo y no se trata
// de B.
de una redefinición
} //
relativa a la clase
base UnB.I++;
class B : A {
new public int I; // No es posible acceder
public B(int I1, int I2) { // al elemento I de A con
this.I = I1; // Elemento I de B // la instancia UnB, no
base.I = I2; // Elemento I de A // hay forma de resolver
} // la ambigüedad con el
… // elemento I entre la
} // clase base A y la clase
// derivada B

Programación II

Herencia

C#
Representa una interfaz
public interface VideoClip {
int Frames { get; } Atributo de la interfaz a
void Play( ); definir en otro lugar
void Stop( );
Métodos de la interfaz a
}
definir en otro lugar
class MiClase : VideoClip { Clase que implementa o
public int Frames { get { … } } usa una interfaz
public void Play( ) { … }
public void Stop( ) { … } Definición de los
… atributos y métodos de
} la interfaz

NOTA: Una interface en C# representa un conjunto de atributos (de C#)
y métodos cuya definición (implementación) está en otro lugar.
Programación II

Herencia

C#
interface Interfaz1 { NOTA: Aunque C# no
void Print1( ); soporta la herencia
} múltiple, el uso de
interface Interfaz2 { interfaces representa
void Print2( ); un truco para hacer
} algo parecido
class Superclase {
protected String S = “Ejemplo”;
}
class Subclase : Superclase, Interfaz1, Interfaz2 {
public void Print1( ) { Console.WriteLine(S); }
public void Print2( ) { Console.WriteLine(“Por Interfaz 2”); }
}

Programación II

Clases abstractas y métodos virtuales

C++
class Graphics {
Método public:
virtual virtual void DrawL(int x1, int y1, int x2, int y2) { … }
virtual double Area(void) = 0;
Método …
virtual };
puro
class MyClass : public Graphics { Indica que la
función no tiene un
Redefini- public: cuerpo definido y
ción del double Area(void) { … } que debe ser hecho
método … en las clases
}; derivadas
virtual

NOTA: Una clase que tenga al menos un método virtual puro es una
clase abstracta (no es posible crear instancias con ella).

Programación II


Java
Clase abstract class Graphics {
abstracta public void DrawL(int x1, int y1, int x2, int y2) { … }
Método public abstract double Area(void);
virtual …
}
No todos los
class MyClass extends Graphics { métodos de una
Redefini-
public double Area(void) { … } clase abstracta son
ción del
… virtuales
método
}
virtual

NOTA: Una clase que tenga al menos un método virtual debe ser
declarada abstracta obligatoriamente.

Programación II


C#
Clase abstract class Graphics {
abstracta public void DrawL(int x1, int y1, int x2, int y2) { … }
Método public abstract double Area(void);
virtual … No todos los
puro } métodos de una
clase abstracta son
class MyClass : Graphics { virtuales
Redefini-
public override double Area(void) {
ción del
…
método
}
virtual
…
}

NOTA: Una clase que tenga al menos un método virtual puro (método
abstracto) debe ser declarada abstracta obligatoriamente.

Programación II


C#
class A {
public virtual void F1(void) { … }
public virtual void F2(void) { … } Métodos virtuales
public virtual void F3(void) { … }
…
}
class B : A {
public override void F1(void) { … } Redefinición del método F1
public new void F2(void) { … } Nueva versión del método F2
public new virtual F3(void) { … } Nueva versión del método F3
… y virtual para las clases
} derivadas de B

NOTA: Los métodos virtuales pueden ser redefinidos en clases
derivadas; deben tener una definición válida (cuerpo) en la
clase base.
Programación II

Paquetes

C++
Declaración e inicio del espacio de
namespace MiPaquete {
nombres o paquete
class Clase1 {
…
}; Cualquier cosa definida dentro del
… bloque del espacio de nombres
} pertenece al paquete
…
int main(void) {
MiPaquete::Clase1 Obj1;
… Forma de acceder a los elementos
} definidos dentro del paquete

NOTA: Se hace uso del concepto conocido como “espacio de
nombres”.
Programación II

Paquetes

C++
Permite definir nombres
namespace Nuevo = MiPaquete; alternativos a paquetes ya
… existentes
int main(void) { Indica que los elementos
using namespace Nuevo; usados en el bloque ocurrente,
Clase1 Obj1; pueden pertenecer al paquete
… indicado
}

NOTA: Cualquier cosa (variable, función, clase, estructura, macro,
etc.) que se puede definir en el lenguaje en el contexto del
programa principal, se puede colocar dentro de un espacio
de nombres. Los espacios de nombre solo se definen en el
mismo contexto del programa principal.

Programación II

Paquetes

Java
Indica que las clases definidas en este
package MiPaquete;
archivo fuente pertenecen a este paquete

import MiPaquete.Miclase; Indica que el archivo fuente actual va a
usar la clase MiClase del paquete indicado
import MiPaquete.*; Indica que el archivo fuente actual va a usar
las clases definidas en el paquete indicado

MiPaquete.MiClase Para hacer referencia a alguna de las clases
del Paquete (permite resolver ambigüedades)
NOTA: Un archivo fuente contiene la definición de una clase y el
nombre de la clase y del archivo coinciden. Los nombres de
los paquetes deben coincidir con directorios donde se
encuentren los archivos fuente correspondientes. Solo
aquellas clases que sean de interfaz pública pueden ser
importadas de un paquete.
Programación II

Paquetes

C#
Indica que este archivo fuente hace uso
using Paquete1;
del paquete indicado
…
namespace MiPaquete { Declaración e inicio del espacio de
class Clase1 { nombres o paquete
… Cualquier clase definida dentro del
} bloque del espacio de nombres
… pertenece al paquete
}
Para hacer referencia a alguna de las
Paquete1.Clase1 clases del Paquete (permite resolver
ambigüedades)
NOTA: Se hace uso del concepto de espacio de nombres. Se
pueden anidar entre sí.
Programación II

Otros Conceptos

C++ - Funciones y Clases amigas
• Las funciones amigas son funciones que están definidas
fuera del contexto de una clase y tienen permiso de
acceder a los elementos privados de esa clase.
• Una clase A es amiga de otra clase B cuando dentro de
los métodos de A se puede acceder a los elementos
privados de B.
• Se utiliza la declarativa friend para indicar que una
función o clase es amiga de una clase. La relación de
amistad se declara dentro de la clase que permite la
amistad.

Programación II

Otros Conceptos

• Su utilidad es discutible. Concepto poco elegante desde
el punto de vista de la orientación a objetos. Se puede
evitar su uso con poco esfuerzo (basta por ejemplo,
definir métodos públicos para acceder a elementos
privados).

Programación II

Otros Conceptos

class Date; // Indica que existe una clase Date ya definida o a definir
class Time {
private:
long secs;
friend char *gtime(Time); // gtime es una función amiga de Time
friend class Date; // Date es una clase amiga de Time
public:
Time(char *);
…
};

NOTA: Una función o clase puede ser amiga de dos clases
diferentes. Dos clases pueden ser amigas entre sí.

Programación II

Otros Conceptos

// Definición del constructor de forma “outline”
Time::Time(char *Tm) {
char *Hr = strtok(Tm, “:”), *Mn = strtok(0, “:”);
secs = atol(Hr) * 3600 + atol(Mn) * 60; // Acceso al elemento
} // privado “secs”
// Definición de la función gtime. Nótese que no pertenece a la clase
char *gtime(Time x) {
char *buffer = new char[10];
int h = x.secs / 3600, // Acceso al elemento privado
m = (x.secs % 3600) / 60; // secs usando la instancia x
sprintf(buffer, “%02d:%02d”, h, m);
return buffer;
}

Programación II

Otros Conceptos

C++ - Plantillas de funciones y clases
• Las plantillas de funciones permiten definir funciones
genéricas que admiten cualquier tipo de dato como
parámetros sin necesidad de usar polimorfismo.
Parecido a una macro.
• Las plantillas de clases permiten definir clases cuyos
elementos están basados en tipos genéricos que no
deben ser definidos en el momento de su creación.
• Se usa la declarativa template y la palabra reservada
class ó typename (no hay diferencia entre una u otra).
• UML soporta este concepto en su sintaxis.

Programación II

Otros Conceptos

• Es útil para escribir programas genéricos con menos
código. Desde el punto de vista de la orientación a
objetos es más elegante el uso del principio de
Polimorfismo.

Programación II

Otros Conceptos

template <class T> // Definición de la plantilla
T GetMax(T a, T b) { // de la función GetMax
T res = (a > b) ? a : b;
return res;
}
int main(void) {
int i = 5, j = 6, k;
long l = 10L, m = 5L, n;
k = GetMax(i, j); // Uso de la plantilla con el tipo int
n = GetMax(l, m); // Uso de la plantilla con el tipo long
cout << k << n;
return 0;
}

Programación II

Otros Conceptos

template <class T> // Definición de la plantilla
class Par { // de la clase Par
private:
T v1, v2;
public:
Par(T pri, T seg) { v1 = pri; v2 = seg; }
T GetMax(void);
};
template <class T> // Definición del método GetMax de Par
T Par<T>::GetMax(void) {
return v1 > v2 ? V1 : v2;
}
…
Par <int> MiObjeto(100, 75); // Instanciación del objeto usando int

Programación II

Otros Conceptos

template <class T>
class Par {
T v1, v2;
public:
Par(T pri, T seg) { v1 = pri; v2 = seg; }
T Modulo(void) { return 0 }
};
template <> // Especialización de la plantilla Par
class Par <int> { // usando el tipo int
int v1, v2;
public:
Par(int pri, int seg) { v1 = pri; v2 = seg; }
int Modulo(void) { return v1 % v2; } // Especialización de
}; // la función Modulo

Programación II

Otros Conceptos


// Algunos ejemplos del uso de plantillas
//
template <class T> // La más usual: una clase como parámetro
template <class T, class U> // Dos clases
template <class T, int N> // Una clase y un tipo primitivo
template <class T = char> // Con un valor por defecto
template <int Tfunc(int)> // Una función como parámetro

NOTA: Las plantillas son compiladas por demanda, es decir, el
código de las plantillas de funciones no se compila hasta
que no se tenga una instancia y el compilador conozca el
tipo de dato que corresponde a esa instancia.

Programación II

Otros Conceptos

C++ - Conversión avanzada de clases
• reinterpret_cast: convierte un apuntador a otro tipo de
apuntador. No se hace ningún tipo de chequeo ni
transforma-ción al contenido de lo apuntado.

class A { } *a = new A;
class B { } *b = reinterpret_cast (a);

Programación II

Otros Conceptos

• static_cast: ejecuta cualquier conversión que puede ser
realizada implícitamente de la misma forma que la
conversión inversa (aún si no está permitida de forma
implícita).

class A { } *a = new A;
class B : public A { } *b = static_cast (a);

Programación II

Otros Conceptos

• dynamic_cast: similar a static_cast con la diferencia
que se hace un chequeo de la validez de la operación (si
la conversión retorna un objeto válido del tipo requerido).
El chequeo es en tiempo de ejecución y si no es válido
se retorna un valor nulo.
class A { virtual dummy( ); };
class B : public A { };
A *a1 = new B;
A *a2 = new A;
B *b1 = dynamic_cast (a1); // Ok
B *b2 = dynamic_cast (a2); // Falla  nulo
B b3 = dynamic_cast (a1); // Ok
B b4 = dynamic_cast (a2); // Excepción
Programación II

Otros Conceptos

• const_cast: manipula los atributos de tipo constante del
objeto a convertir, ya sea para ser agregados o
removidos en el proceso de conversión.

class C { };
const C *a = new C;
C *b = const_cast <C *>(a);

• typeid: operador que permite revisar el tipo resultante
de una expresión.

class A { } *a, b;
if (typeid(a) == typeid(b)) …

Programación II

Otros Conceptos

Java – Clases y métodos finales
• Una clase final es aquella que no puede ser derivada.
No puede ser usada como clase base en una herencia.
Permiten terminar una cadena de herencia.
• Un método final es aquél que no puede ser redefinido en
clases derivadas. Incluye la definición de elementos
polimórficos.
• Se usa la declarativa final.
• Los errores se identifican en tiempo de compilación.

Programación II

Otros Conceptos

Java – Clases y métodos finales
public final class C1 { // Define una clase final
…
}
public class C2 extends C1 { // ERROR
…
}
public class C3 {
public final Metodo1( ) { … } // Define un método final
…
}
public class C4 extends C3 {
public Metodo1( ) { … } // ERROR
}

Programación II

Otros Conceptos

C# – Clases y métodos finales
• Una clase final es aquella que no puede ser derivada.
No puede ser usada como clase base en una herencia.
Permiten terminar una cadena de herencia.
• Un método final es un método de una clase derivada
que redefine uno equivalente de una clase base
correspondiente y que no se desea sea más redefinido
en otros niveles de herencia, si es el caso.
• Se usa la declarativa sealed.
• Los errores se identifican en tiempo de compilación.

Programación II

Otros Conceptos

C# – Clases y métodos finales
public sealed class C1 { // Define una clase final
…
}
public class C2 {
public virtual void f( ) { … } // Método virtual
…
}
public class C3 : C2 {
public sealed override void f( ) { // Redefinición del método
… // virtual y definido como final
}
…
}

Programación II

Otros Conceptos

C# – Constructor estático
• Permite definir un constructor para la clase, que se
invoca una sola vez y sólo la primera vez que la clase es
usada (la primera instanciación de la misma).
• No puede tener parámetros.
• No se le indica declarativa de interfaz.
• Solo puede haber un constructor estático por clase.
• No limita la existencia o definición de otros constructores
no estáticos.
• Al igual que otros métodos estáticos, solo puede
acceder a miembros estáticos de la clase.
• Se usa la declarativa static.
Programación II

Otros Conceptos

C# – Constructor estático
class Rectangulo {
static bool Edo = false; // Atributo estático
…
static Rectangulo( ) { // Constructor estático
Console.WriteLine(“Clase Rectángulo Inicializada”);
Edo = true;
}
public Rectangulo( ) { // Constructores no estáticos
…
}
public Rectangulo(int w, int h) {
…
}
}

Programación II

Otros Conceptos

C# – Indexadores
• Representa un operador para indexar un conjunto de
atributos de la clase.
• Es una mezcla del manejo de atributos y arreglos.
• Además de la declarativa de interfaz y el tipo de dato, se
usa la palabra reservada this con una indicación del tipo
de dato del índice encerrado entre corchetes (similar a la
forma como de declaran los arreglos.
• Como atributo se le pueden definir las operaciones get y
set correspondientes.

Programación II

Otros Conceptos

C# – Indexadores
class VentasMes {
int[ ] producto1 = new int[12]; // Definición de arreglos
int[ ] producto2 = new int[12];
public int this[int i] { // Indexador cuyo índice es un entero
get { return producto1[i-1] + producto2[i-1]; }
}
public int this[string mes] { // Indexador cuyo índice es una cadena
get { switch (mes) {
case “Ene”: return producto1[0] + producto2[0];
…
} }
}
…
}

Programación II

Otros Conceptos

C# – Clases anidadas
• Permite definir clases auxiliares que se desean
mantener escondidas.
• La clase interna puede acceder a todos los miembros de
la clase externa, incluyendo los elementos privados.
• La clase externa puede acceder solo a los miembros
públicos de la clase interna.
• Otras clases pueden acceder a la clase interna solo si
ésta se define como pública.
• El concepto de anidamiento también aplica a estructuras
(struct), enumerados (enum), interfaces (interface) y
delegados (delegate).

Programación II

Otros Conceptos

C# – Clases anidadas
class A {
int x;
B b = new B(this); // Objeto de la clase anidada B
public void f( ) { b.f( ); } // Acceso a miembro público de B
public class B { // Clase anidada de A
A a;
public B(A a) { this.a = a; }
public void f( ) {a.x = 1; a.f( ); } // Acceso a miembros de A
} // tanto públicos como privados
}
class C {
A a = new A;
A.B b = new A.B(a); // Acceso a clase B fuera de A
}

Programación II

Otros Conceptos

C# – Operaciones de conversión entre clases
class A { … } A a = new C( ); // Ok
class B : A { … } B b = (B)a; // Si (a is B) Ok
class C : B { … } C c = (C)a; // sino Excepción
A a; a = null; // Ok
a = new A( ); c = (C)a; // Ok
a = new B( ); // Ok A a = new C( ); // Ok
a = new C( ); // Ok B b = a as B; // Si (a is B) b = (B)a
B b = a; // ERROR C c = a as C; // sino b = null
if (a is C) … // true a = null;
if (a is B) … // true c = a as C // c == null
if (a is A) … // true
a = null; // Ok
if (a is C) … // false

Programación II

Otros Conceptos

C# – Delegados y eventos
• Delegado: método para recibir y procesar eventos;
patrón que describe el aspecto que tiene un controlador
específico de eventos; define lo que debe devolver el
controlador de eventos del usuario y lo que debe ser la
lista de parámetros.
• Evento: medio con el cual se puede avisar de una
condición.
• Los métodos que necesitan procesar un evento deben
obedecer las convenciones de llamada del delegado: no
deben devolver ningún dato y deben tener una sola
cadena como lista de parámetros.

Programación II

Otros Conceptos

• Las implementaciones de control de eventos pueden
tener cualquier nombre de método mientras su tipo
devuelto y su lista de parámetros concuerdan con el
patrón de delegados.

Programación II

Otros Conceptos

delegate void Notificador(string Enviador); // Declaración de un tipo
// delegado
Notificador Saludos; // Una variable delegada
void DiHola(string Enviador) {
Console.WriteLine(“Hola desde ” + Enviador);
}
Saludos = new Notificador(DiHola); // Asignar un método
// a la variable delegada
Saludos(“Mauricio”); // Llamada del delegado
// Declaración de un evento (variable delegada especial). Solo las clases
// que declaran el evento lo pueden disparar (mejor abstracción)
public event Notificador DiAlgo;

Programación II

Otros Conceptos

C# – Atributos
• Permiten incluir directivas en las clases y en sus
miembros para mejorar su declaración mediante
información que es interpretada por otras clases en
tiempo real.
• Se pueden usar los atributos predefinidos en el lenguaje
y los personalizados por el programador.

Programación II

Otros Conceptos

C# – Atributos
• Los atributos se escriben entre corchetes y debe
aparecer antes de la declaración en la que se debe
aplicar: clases, miembros de la clase, estructuras,
interfaces, miembros de la interfaz, enumeraciones,
miembros de la enumeración y delegados.

[MiAtributo]
class MiClase { … }

Programación II

Otros Conceptos

C# – Atributos
• Al atributo se puede anteponer un modificador que
defina el elemento al que se aplica el atributo. Va
seguido de dos puntos. Recibe el nombre de enlazar un
atributo.

[MiEnlace:MiAtributo]

• Algunos atributos están construidos para aceptar
parámetros.

[MiAtributo(Parámetros)]

Programación II

Otros Conceptos

C# – Atributos
• Para escribir clases de atributos propias para definir
atributos personalizados, hay que derivar de la clase
predefinida “Attribute” del espacio de nombre “System”.

public class CodeAuthorAttribute : Attribute { … }

[CodeAuthorAttribute]
[CodeAuthor]

// Todos los atributos cuyos nombres terminan con el sufijo Attribute,
// se puede también usar como alias el nombre sin ese sufijo

Programación II

Otros Conceptos

C# – Atributos
• Los atributos también pueden ser clases derivadas de la
clase “Attribute”.
// Ejemplo: Llamada a métodos extornos en DLL
namespace System.Runtime.InteropServices {
[AttributeUsage(AttributeTargets.Method)]
public class DllImportAttribute : System.Attribute {
public DllImportAttribute(string dllName) { … }
public CallingConvention CallingConvention;
public string EntryPoint;
public bool SetLastError;
…
}
}

Programación II

Programacion oo

Más contenido relacionado

La actualidad más candente (20)

Destacado (10)

Similar a Programacion oo (20)

Más de karlalopezbello (20)

Programacion oo