Embed Size (px)
DESCRIPTION
Tecnología Orientada a Objetos - UNEG - Profesor Mauricio Paletta
Citation preview
Programación II
Ing. Mauricio Paletta, Msc
Presentación
Programación Orientada a Objetos
UNIVERSIDAD NACIONAL EXPERIMENTAL DE GUAYANA
INGENIERÍA EN INFORMÁTICA
Programación II
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 Orientada a Objetos
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 Orientada a Objetos
Programación II
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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
Programación Orientada a Objetos
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
C++
class Complejo {
private:
double Real, Imag;
public:
double ObtReal(void) {
return Real;
}
double ObtImag(void) {
return Imag;
}
};
Definición de Clases
Indica definición
de una clase
Identificador de
la clase
Declarativas para
definir la interfaz de
los elementos
Comienza la
definición de la
clase
Termina la
definición de la
clase
Atributos
Métodos
Instanciación de objetos opcional
Programación II
C++
Definición de Clases
• 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++
Definición de Clases
class Complejo {
double Real;
public:
double ObtReal(void);
private:
double Imag;
public:
double ObtImag(void);
};
double Complejo::ObtReal(void)
{
return Real;
}
double Complejo::ObtImag(void)
{
return Imag;
}
El cuerpo del método
no está aquí
Indica relación de dependencia
con una clase
Programación II
C++
Definición de Clases
• 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++
Definición de Clases
inline double Complejo::ObtReal(void) {
return Real;
}
inline double Complejo::ObtImag(void) {
return Imag;
}
Programación II
class Complejo {
private double Real, Imag;
public double ObtReal( ) {
return Real;
}
public double ObtImag( ) {
return Imag;
}
}
Java / C#
Definición de Clases
Indica definición
de una clase
Identificador de
la clase
Declarativas para
definir la interfaz de
los elementos
Comienza la
definición de la
clase
Termina la
definición de la
clase
Atributos
Métodos
Programación II
Java
Definición de Clases
• Las declarativas de interfaz pueden aparecer más de
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#
Definición de Clases
• 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 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
class Complejo {
private double Real, Imag;
public double ParteReal {
get {
return Real;
}
}
public double ParteImag {
get {
return Imag;
}
}
}
C#
Definición de Clases
Se puede acceder
al atributo privado
Real mediante este
elemento público.
Para los ojos del
usuario es como si
fuera un atributo
pero realmente es
un método.
Usado para indicar
el retorno del valor
del atributo
Se puede usar
también la
sentencia set para
indicar las acciones
a tomar con la
modificación del
valor del atributo
Programación II
C++
Instanciación de Objetos
Complejo C1, C2, *pC;
pC = new Complejo;
…
delete pC;
Liberación del espacio creado
de forma dinámica. Debe ser
hecho por el programador
Instancias u objetos
(instanciación estática)No es un objeto
sino un apuntador o
dirección de memoria
Instanciación dinámica
haciendo uso del apuntador
Identificador
de la Clase
Programación II
Java
Instanciación de Objetos
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).
Instancia u objetoIdentificador
de la Clase
Programación II
C#
Instanciación de Objetos
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).
Instancia u objetoIdentificador
de la Clase
Programación II
C++
Acceso a Elementos de la Clase
Complejo C, *pC = new Complejo;
double d = C.ObtReal( );
pCObtImag( );
(*pC).ObtImag( );
Operador para acceder a los elementos
del objeto a partir de un apuntador a la
dirección de memoria del mismo
Llamadas de mensajes
o ejecución de
métodos
El contenido de la
dirección de memoria es un
objeto
Operador para
acceder a los
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
Java / C#
Complejo C = new Complejo( );
double d = C.ObtReal( );
Operador para
acceder a los
elementos del
objeto
Acceso a Elementos de la Clase
Llamada de mensaje o
ejecución del método
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#
Complejo C = new Complejo( );
double d = C.ParteReal;
Operador para
acceder a los
elementos del
objeto
Acceso a Elementos de la Clase
Acceso al atributo
público (llamada
automática al mensaje
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
C++class Complejo {
private:
double Real, Imag;
public:
Complejo(void) {
Real = Imag = 0.0;
}
double ObtReal(void) {
return Real;
}
double ObtImag(void) {
return Imag;
}
};
No está permitido la
inicialización de variables
en este contexto
Un constructor para la
clase
Constructor
NOTA: Si no se
especifica un
constructor la data
del objeto queda
sin inicializar
(embasurada).
Programación II
class Complejo {
private double Real = 0.0;
private double Imag = 0.0;
public Complejo( ) {
Real = Imag = 0.0;
}
public double ObtReal( ) {
return Real;
}
public double ObtImag( ) {
return Imag;
}
}
Java / C#
Se permite la inicialización
de elementos en este
contexto
Un constructor
para la clase
Constructor
NOTA: Si no se especifica un
constructor para la clase,
se asume uno por defecto
que no tiene parámetros y
que inicializa todos los
atributos en los literales
nulos correspondientes (0,
false, „\0‟, null, etc.)
Programación II
• 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.
Polimorfismo
Programación II
C++class Complejo {
private:
double Real, Imag;
public:
Complejo(void) {
Real = Imag = 0.0;
}
Complejo(double R, double I) {
Real = R, Imag = I;
}
…
} C1, C2(1.0, -1.0);
Dos objetos instanciados cada uno de los cuales llama
a un constructor diferente
Polimorfismo
sobre el
constructor
Polimorfismo
Programación II
class Complejo {
private double Real = 0.0;
private double Imag = 0.0;
public Complejo( ) {
Real = Imag = 0.0;
}
public Complejo(double R, double I ) {
Real = R; Imag = I;
}
…
}
…
Complejo C1 = new Complejo( ),
C2 = new Complejo(1.0, -1.0);
Java / C#
Polimorfismo
sobre el
constructor
Dos objetos instancia-
dos cada uno de los
cuales llama a un
constructor diferente
Polimorfismo
Programación II
• 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.
Inicialización por defecto
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
Inicialización por defecto
Tres objetos instanciados, todos hacen la
llamada al mismo constructor
Programación II
C++
Inicialización por defecto
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
Inicialización por defecto
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;
private double Imag = 0.0;
public Complejo(double R, double I ) {
Real = R; Imag = I;
}
…
}
…
Complejo C = new Complejo( );
Es un error porque no
se puede resolver con
el constructor existente
Inicialización de
elementos
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
C++class Complejo {
private:
double Real, Imag;
public:
Complejo(double R = 0.0, double I = 0.0) {
Real = R, Imag = I;
}
~Complejo(void) { }
…
};
El destructor se llama
igual que la clase pero
con el prefijo ~
Expresa que el método
tiene un cuerpo vacío
o no tiene código
asociado
Destructor
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
Java
protected void finalize( ) {
…
}
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.
Destructor
Se puede redefinir el método
finalize para que sea llamado
de forma automática por el
algoritmo de recuperación de
memoria
Programación II
C#
class Complejo {
…
void Finalize( ) {
…
}
}
Destructor
Al igual que Java, se puede
redefinir el método Finalize
para que sea llamado de forma
automática por el algoritmo de
recuperación de memoria
También soporta la misma sintaxis
de C++ y tener un método que se
llama igual que la clase con el
prefijo ~. Este método y la
redefinición de Finalize no pueden
convivir en la misma clase
class Complejo {
…
~Complejo( ) {
…
}
}
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
Elementos estáticos
• 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++
class String;
class File {
private:
static int NumAbiertos;
public:
File(const String &, const String &);
File(const File &);
~File(void);
static int Abiertos(void) {
return NumAbiertos;
}
…
};
Destructor
Atributo
estático
Elementos estáticos
Método
estático
Indica pasaje
de parámetro
por referencia
Indica que
String es una
clase cuya
definición se
encontrará
mas adelante
Programación II
C++
int File::NumAbiertos = 0;
File::File(const String &N, const String &M) {
…
NumAbiertos++;
}
File::~File(void) {
…
NumAbiertos--;
}
…
Elementos estáticos
Asignación del valor
inicial al atributo
estático, nótese que
está fuera de la
definición de la clase
Constructor y
destructor definidos
fuera de la definición
de la clase
Programación II
Java
public class Ejemplo {
static int NumInstancias = 0;
public static int Instancias( ) {
return NumInstancias;
}
public Ejemplo( ) {
NumInstancias++;
}
public static void main(String args[ ]) {
…
}
}
Elementos estáticos
Atributo estático con su
inicialización
Para definir el código
del programa principal
Para tomar los posibles
argumentos del
programa principal
La clase que contiene
el programa principal
debe ser pública
Método estático
Programación II
C#
public class Ejemplo {
static int NumInstancias = 0;
public static int Instancias( ) {
return NumInstancias;
}
public Ejemplo( ) {
NumInstancias++;
}
public static void Main(string args[ ]) {
…
}
}
Elementos estáticos
Atributo estático con su
inicialización
Para definir el código
del programa principal
Para tomar los posibles
argumentos del
programa principal
La clase que contiene
el programa principal
debe ser pública
Método estático
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
Operador de Asignación o Copia
• 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
Java / C#
C++
Complejo C1(2.5, -1.0), C2 = C1, C3 = 1.0;
Uso del operador de
asignación entre objetos
Operador de Asignación o Copia
Complejo C1 = new Complejo(2.5, -1.0), C2 = C1;
Complejo C1 = new Complejo(2.5, -1.0),
C2 = new Complejo( );
…
C2 = C1;
Construcción indirecta
de una instancia para
resolver la operación
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++
Sobrecarga de Operadores
• 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++
Sobrecarga de Operadores
• 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
Sobrecarga de Operadores
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
Sobrecarga de Operadores
Programación II
Java
Sobrecarga de Operadores
class Complejo {
private double Real = 0.0;
private double Imag = 0.0;
…
public Complejo Suma(Complejo C) {
return new Complejo(Real + C.Real, Imag + C.Imag);
}
…
}
…
Complejo C1 = new Complejo(1.0, -1.0),
C2 = new Complejo(5.0, 2.5),
C3 = C1.Suma(C2);
NOTA: No soporta la sobrecarga de operadores.
Programación II
C#
Sobrecarga de Operadores
• 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#
Sobrecarga de Operadores
• 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#
Sobrecarga de Operadores
class Complejo {
private double Real = 0.0;
private double Imag = 0.0;
…
public static Complejo operator +(Complejo C1, Complejo C2) {
return new Complejo(C1.Real + C2.Real, C1.Imag + C2.Imag);
}
…
}
…
Complejo C1 = new Complejo(1.0, -1.0),
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#
Sobrecarga de Operadores
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
Referencia al objeto actual
• 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
Referencia al objeto actual
Programación II
Java
Referencia al objeto actual
class Complejo {
private double Real = 0.0;
private double Imag = 0.0;
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#
Referencia al objeto actual
class Complejo {
private double Real = 0.0;
private double Imag = 0.0;
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
C++
Herencia
class Carro {
private:
int Mod, Cap;
public:
Carro(int M = 0, int C = 0) { … }
…
};
class Carga : public Carro {
private:
int CapCarga;
public:
Carga(int M = 0, int C = 0, int P = 0) :
Carro(M, C) { … }
…
};
Constructor clase
Derivada
Llamada al constructor
de la clase Base
Interfaz de la herencia
(¿Cómo serán vistos en clase
Derivada los elementos
públicos de la clase Base?)
Constructor clase Base
Operador de
relación entre
clase Base y
clase Derivada
Programación II
C++
Herencia
class A {
private: int A1;
protected: int A2;
public: int A3;
};
class B : private A {
private: int B1;
protected: int B2;
public: int B3;
};
Dentro
de B
En
Deriva-
das de BFuera de
B
A1
A2
A3
B1
B2
B3
Programación II
C++
Herencia
class A {
private: int A1;
protected: int A2;
public: int A3;
};
class C : protected A {
private: int C1;
protected: int C2;
public: int C3;
};
Dentro
de C
En
Deriva-
das de CFuera de
C
A1
A2
A3
C1
C2
C3
Programación II
C++
Herencia
class A {
private: int A1;
protected: int A2;
public: int A3;
};
class D : public A {
private: int D1;
protected: int D2;
public: int D3;
};
Dentro
de D
En
Deriva-
das de DFuera de
D
A1
A2
A3
D1
D2
D3
Programación II
C++
Herencia
class B1 {
private: int IB1;
public:
B1(int I = 0) { IB1 = I; }
…
};
class D : public B1, public B2 {
public:
D(int I1 = 0, int I2 = 0) : B1(I1), B2(I2) { };
…
};
class B2 {
private: int IB2;
public:
B2(int I = 0) { IB2 = I; }
…
};
Herencia múltiple
Constructores de clases Base
Programación II
C++
Herencia
class B1 {
public: int B;
…
};
class D : public B1, public B2 {
public: int B;
…
} UnD;
…
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
class B2 {
public: int B;
…
};
Operador que
indica búsqueda
sobre un
contexto superior
(en la jerarquía)
al actual
Programación II
C++
Herencia
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
Java
Herencia
class Carro {
private int Mod = 0, Cap = 0;
public Carro(int M, int C) { … }
…
}
class Carga extends Carro {
private int CapCarga = 0;
public Carga(int M, int C, int P) {
super(M, C);
…
}
…
}
Constructor clase Base
Indica herencia
Constructor clase
Derivada
Llamada al constructor
de la clase Base
Programación II
Java
Herencia
class A {
public int I;
…
}
class B extends A {
public int I;
public B(int I1, int I2) {
I = I1; // Acceso al elemento I de B
// (equivalente a usar this.I)
A.I = I2; // Acceso al elemento I de A
}
…
}
B UnB = new B(1, -1);
// Acceso al elemento I
// de B.
//
UnB.I++;
// No es posible acceder
// al elemento I de A con
// la instancia UnB, no
// hay forma de resolver
// la ambigüedad con el
// elemento I entre la
// clase base A y la clase
// derivada B
Programación II
Java
Herencia
public interface VideoClip {
void Play( );
void Stop( );
}
class MiClase implements VideoClip {
void Play( ) { … }
void Stop( ) { … }
…
}
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).
Representa una interfaz
Clase que implementa o
usa una interfaz
Definición de los
métodos de la interfaz
Métodos de la interfaz a
definir en otro lugar
Programación II
Java
Herencia
interface Interfaz1 {
public void Print1( );
}
interface Interfaz2 {
public void Print2( );
}
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”); }
}
NOTA: Aunque Java no
soporta la herencia
múltiple, el uso de
interfaces represen-
ta un truco para
hacer algo parecido
Programación II
C#
Herencia
class Carro {
private int Mod = 0, Cap = 0;
public Carro(int M, int C) { … }
…
};
class Carga : Carro {
private int CapCarga = 0;
public Carga(int M, int C, int P) :
base(M, C) {
…
}
…
}
Constructor clase Base
Indica herencia
Constructor clase
Derivada
Llamada al constructor
de la clase Base
Programación II
C#
Herencia
class A {
public int I;
…
}
class B : A {
new public int I;
public B(int I1, int I2) {
this.I = I1; // Elemento I de B
base.I = I2; // Elemento I de A
}
…
}
B UnB = new B(1, -1);
// Acceso al elemento I
// de B.
//
UnB.I++;
// No es posible acceder
// al elemento I de A con
// la instancia UnB, no
// hay forma de resolver
// la ambigüedad con el
// elemento I entre la
// clase base A y la clase
// derivada B
Permite indicar que
es un elemento
nuevo y no se trata
de una redefinición
relativa a la clase
base
Programación II
C#
Herencia
public interface VideoClip {
int Frames { get; }
void Play( );
void Stop( );
}
class MiClase : VideoClip {
public int Frames { get { … } }
public void Play( ) { … }
public void Stop( ) { … }
…
}
NOTA: Una interface en C# representa un conjunto de atributos (de C#)
y métodos cuya definición (implementación) está en otro lugar.
Representa una interfaz
Clase que implementa o
usa una interfaz
Definición de los
atributos y métodos de
la interfaz
Métodos de la interfaz a
definir en otro lugar
Atributo de la interfaz a
definir en otro lugar
Programación II
C#
Herencia
interface Interfaz1 {
void Print1( );
}
interface Interfaz2 {
void Print2( );
}
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”); }
}
NOTA: Aunque C# no
soporta la herencia
múltiple, el uso de
interfaces representa
un truco para hacer
algo parecido
Programación II
C++
Clases abstractas y métodos virtuales
class Graphics {
public:
virtual void DrawL(int x1, int y1, int x2, int y2) { … }
virtual double Area(void) = 0;
…
};
class MyClass : public Graphics {
public:
double Area(void) { … }
…
};
Método
virtual
NOTA: Una clase que tenga al menos un método virtual puro es una
clase abstracta (no es posible crear instancias con ella).
Redefini-
ción del
método
virtual
Método
virtual
puroIndica que la
función no tiene un
cuerpo definido y
que debe ser hecho
en las clases
derivadas
Programación II
Java
Clases abstractas y métodos virtuales
abstract class Graphics {
public void DrawL(int x1, int y1, int x2, int y2) { … }
public abstract double Area(void);
…
}
class MyClass extends Graphics {
public double Area(void) { … }
…
}
Método
virtual
NOTA: Una clase que tenga al menos un método virtual debe ser
declarada abstracta obligatoriamente.
Redefini-
ción del
método
virtual
No todos los
métodos de una
clase abstracta son
virtuales
Clase
abstracta
Programación II
C#
Clases abstractas y métodos virtuales
abstract class Graphics {
public void DrawL(int x1, int y1, int x2, int y2) { … }
public abstract double Area(void);
…
}
class MyClass : Graphics {
public override double Area(void) {
…
}
…
}
Método
virtual
puro
NOTA: Una clase que tenga al menos un método virtual puro (método
abstracto) debe ser declarada abstracta obligatoriamente.
Redefini-
ción del
método
virtual
No todos los
métodos de una
clase abstracta son
virtuales
Clase
abstracta
Programación II
C#
Clases abstractas y métodos virtuales
class A {
public virtual void F1(void) { … }
public virtual void F2(void) { … }
public virtual void F3(void) { … }
…
}
class B : A {
public override void F1(void) { … }
public new void F2(void) { … }
public new virtual F3(void) { … }
…
}
NOTA: Los métodos virtuales pueden ser redefinidos en clases
derivadas; deben tener una definición válida (cuerpo) en la
clase base.
Métodos virtuales
Redefinición del método F1
Nueva versión del método F2
Nueva versión del método F3
y virtual para las clases
derivadas de B
Programación II
C++
Paquetes
namespace MiPaquete {
class Clase1 {
…
};
…
}
…
int main(void) {
MiPaquete::Clase1 Obj1;
…
}
NOTA: Se hace uso del concepto conocido como “espacio de
nombres”.
Declaración e inicio del espacio de
nombres o paquete
Forma de acceder a los elementos
definidos dentro del paquete
Cualquier cosa definida dentro del
bloque del espacio de nombres
pertenece al paquete
Programación II
C++
Paquetes
namespace Nuevo = MiPaquete;
…
int main(void) {
using namespace Nuevo;
Clase1 Obj1;
…
}
Permite definir nombres
alternativos a paquetes ya
existentes
Indica que los elementos
usados en el bloque ocurrente,
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
Java
Paquetes
package MiPaquete;
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.
Indica que las clases definidas en este
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.MiClasePara hacer referencia a alguna de las clases
del Paquete (permite resolver ambigüedades)
Programación II
C#
Paquetes
using Paquete1;
…
namespace MiPaquete {
class Clase1 {
…
}
…
}
NOTA: Se hace uso del concepto de espacio de nombres. Se
pueden anidar entre sí.
Declaración e inicio del espacio de
nombres o paquete
Cualquier clase definida dentro del
bloque del espacio de nombres
pertenece al paquete
Indica que este archivo fuente hace uso
del paquete indicado
Paquete1.Clase1
Para hacer referencia a alguna de las
clases del Paquete (permite resolver
ambigüedades)
Programación II
C++ - Funciones y Clases amigas
Otros Conceptos
• 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
C++ - Funciones y Clases amigas
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
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 *);
…
};
C++ - Funciones y Clases amigas
NOTA: Una función o clase puede ser amiga de dos clases
diferentes. Dos clases pueden ser amigas entre sí.
Otros Conceptos
Programación II
// 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;
}
C++ - Funciones y Clases amigas
Otros Conceptos
Programación II
C++ - Plantillas de funciones y clases
Otros Conceptos
• 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
C++ - Plantillas de funciones y clases
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
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;
}
Otros Conceptos
C++ - Plantillas de funciones y clases
Programación II
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
Otros Conceptos
C++ - Plantillas de funciones y clases
Programación II
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
Otros Conceptos
C++ - Plantillas de funciones y clases
Programación II
// 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
Otros Conceptos
C++ - Plantillas de funciones y clases
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
C++ - Conversión avanzada de clases
Otros Conceptos
• 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 <B *> (a);
Programación II
• 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).
C++ - Conversión avanzada de clases
Otros Conceptos
class A { } *a = new A;
class B : public A { } *b = static_cast <B *> (a);
Programación II
C++ - Conversión avanzada de clases
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 <B *>(a1); // Ok
B *b2 = dynamic_cast <B *>(a2); // Falla nulo
B b3 = dynamic_cast <B &*>(a1); // Ok
B b4 = dynamic_cast <B &*>(a2); // Excepción
Programación II
C++ - Conversión avanzada de clases
• 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)) …
Otros Conceptos
Programación II
• 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.
Java – Clases y métodos finales
Otros Conceptos
Programación II
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
}
Java – Clases y métodos finales
Otros Conceptos
Programación II
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.
Otros Conceptos
Programación II
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
}
…
}
C# – Clases y métodos finales
Otros Conceptos
Programación II
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.
Otros Conceptos
Programación II
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) {
…
}
}
C# – Constructor estático
Otros Conceptos
Programación II
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.
Otros Conceptos
Programación II
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];
…
} }
}
…
}
C# – Indexadores
Otros Conceptos
Programación II
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).
Otros Conceptos
Programación II
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
}
C# – Clases anidadas
Otros Conceptos
Programación II
class A { … }
class B : A { … }
class C : B { … }
A a;
a = new A( );
a = new B( ); // Ok
a = new C( ); // Ok
B b = a; // ERROR
if (a is C) … // true
if (a is B) … // true
if (a is A) … // true
a = null; // Ok
if (a is C) … // false
C# – Operaciones de conversión entre clases
A a = new C( ); // Ok
B b = (B)a; // Si (a is B) Ok
C c = (C)a; // sino Excepción
a = null; // Ok
c = (C)a; // Ok
A a = new C( ); // Ok
B b = a as B; // Si (a is B) b = (B)a
C c = a as C; // sino b = null
a = null;
c = a as C // c == null
Otros Conceptos
Programación II
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.
Otros Conceptos
Programación II
C# – Delegados y eventos
• 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.
Otros Conceptos
Programación II
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;
C# – Delegados y eventos
Otros Conceptos
Programación II
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.
Otros Conceptos
Programación II
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 { … }
Otros Conceptos
Programación II
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)]
Otros Conceptos
Programación II
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
Otros Conceptos
Programación II
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;
…
}
}
Otros Conceptos
