Jordi Linares i Pellicer

Programació amb C# .NET

Tema 4 (a): Introducción a la POO

Índice! Antecedentes históricos

! Razones para usar OO

! Paradigmas de programación

! Noción de Objeto

! Conceptos en la OO

! Lenguajes OO

Antecedentes históricos" La aparición de OO refleja y resume la historia de la

computación como un todo.

" La POO son un conjunto de técnicas que nos permiten mejorar enormemente el proceso de producción de software

" Simula 67, conceptos de clase y herencia.

" El término “Orientado a Objetos” se introdujo con Smalltalk (70, PARC)

" El último gran paso lo da Bjarne Stroustrup en 1986 creando el C++, definido en su libro: The C++ Programming Language

Idea básica

Manejar los datos y los procedimientos en

una única entidad: el objeto.

Un programa es un objeto, que a su vez está formado de objetos.

Razones para usar OO

" Aumento de productividad: reutilización

" Manejo de la complejidad

" Calidad

" Mantenibilidad

Reutilización vs. SW tradicional:

" Se construyen componentes ÚNICOS Y NO INTERCAMBIABLES.! se ensamblan “a mano”! dificultad para entender el código realizado por otros

para extender y refinar el producto.

" Raramente sobreviven y evolucionan (al menos) 10 años.! No son adaptables a los entornos cambiantes:

" incremento del potencial Hardware, SO, expectativas de usuarios, etc.

Reutilización del SW en OO

" La OO enfatiza la reutilización !uso de librerías de componentes, en particular

a través de conceptos como encapsulación y herencia.

! los componentes tienden a tener una alta cohesión semántica por el encapsulamiento de código y datos.

!utiliza la técnica de desarrollo incremental e iterativo.

! técnicamente la reutilización es “más fácil”, aunque no se garantice!.

Paradigmas de programación" Paradigma Imperativo (1)

!Expresa algoritmos que se realizan basados en el funcionamiento de la arquitectura Von Neumann.

!Los datos se almacenan en variables (referencias abstractas de una dirección de memoria) y las operaciones se llaman instrucciones.

!Su realización es llamada ejecución.

! La ejecución de un PROGRAMA IMPERATIVO parte de un estado inicial (Ei) y termina en un estado final (Ef).

! El paso del estado inicial al estado final se realiza mediante una serie de transiciones que se producen al ejecutarse las instrucciones del programa de forma secuencial.

! El paradigma se completa con otras características que dan mayor flexibilidad de cálculo:

" tipos de datos y declaraciones

" instrucciones de control de flujo y condicionales, etc.

" Paradigma Orientado a Objetos! Un OBJETO es un ente autónomo que pertenece

a una cierta CLASE que define su estructura y las operaciones utilizables.

! En el paradigma imperativo se crea una jerarquía de programas, módulos o subrutinas que utilizan los datos.

! En el paradigma OO la jerarquía la forman los objetos.

Noción de Objeto

" Un objeto integra comportamiento y estado en una sola unidad de razonamiento y de programación:

comportamiento + estado = objeto

Objeto1

M2

M3

M1

M4

Los objetos representan una “cosa” del mundo real, por ejemplo, una cuenta bancaria

Object1

M4

M1 M2

M3

M2

M1M4

M3Object2

Object3

M2

M3

M1

M4

mensaje 1mensaje 3

mensaje 2

Interactúan entre sí por el paso de mensajes...

El cliente “ve” sólo la interfaz

Cta_banco:extraerdepositar:

Array:agregarbuscar:

Coche:repostaralquilar:

Los objetos ocultan detalles de implementación...

Noc

ión

de O

bjet

o

nombredirecciónobtenerEdad()

nombredirecciónobtenerEdad()

Heredado

activopasivocalcular%()

Propio

Persona

M4

M1 M2

M3

Cliente

M4

M1 M2

M3

Los objetos heredan (reutilizan) propiedades de objetos más genéricos

En definitiva, los objetos:" Representan una parte del mundo real, algo

tangible, visible.

" Encapsulan la parte estática (datos) y la dinámica (funciones).

" Se comunican a través del paso de mensajes.

" Pueden heredar atributos y comportamiento de otros objetos.

" Estructura y comportamiento de objetos similares se define en su clase común.

Conceptos en la OO" Clases y Objetos

" Abstracción

" Encapsulación

" Herencia

" Comunicación interobjetual

" Polimorfismo

" Clases y Objetos

!Una clase se puede considerar como una descripción genérica (en cuanto a estructura y comportamiento) para un conjunto de objetos.

!En la clase se declaran todas las propiedades (estáticas y dinámicas) de los miembros que pertenecen a esa clase.

!Un objeto es un ejemplar de una clase determinada.

!Los objetos se caracterizan por:" Identidad: Los objetos se distinguen unos de

otros" Comportamiento: Los objetos pueden realizar

tareas" Estado: Los objetos contienen información

! Instanciación Es la operación que permite la creación de

representantes físicos de las clases:

Objetos, instancias, ejemplares, ...

CLASE: PERSONA-------------------------Nombre,Direccion, Edad-------------------------ObtenerEdad

Ejemplo de instanciación:

PersonaJosé Perez

c/ Reus 35, 27

ObtenerEdad()

...PersonaJuan Díaz

c/ Colón 7, 35

ObtenerEdad()...

" Abstracción! Visión simplificada de cierta parte de la realidad,

que realza ciertos detalles o propiedades y suprime otros.

! Permite la elección de los detalles esenciales y centrarse en ellos.

! Básica para diseñar software de calidad.

" Encapsulación! Un objeto puede tener una interface pública y una

representación privada claramente diferenciadas.! Los datos privados del objeto sólo se permiten

modificar a través operaciones propiamente definidas.

! La encapsulación de datos y sucesos es básica en el paradigma objetual: permite el control y el cambio.

Ejemplo de encapsulación:

" Herencia

!“Un conjunto de abstracciones a menudo se relacionan en sus características y comportamientos, de tal forma que pueden agruparse en niveles, simplificando grandemente el entendimiento del problema”.

! Es el principio por el cual se dice que el conocimiento de una categoría más general es aplicable también a la categoría más específica.

! Una subclase es una clase que hereda comportamiento y estructura de otra clase (superclase).

! La subclase puede añadir sus propias propiedades.

! Herencia múltiple: una subclase hereda de más de una superclase.

CLASE A

CLASE B

CLASE C

CLASE D

CLASE E

superclase

subclaseD “es un” C

E “es un” D ytambién un B

Ejemplo 1:

Escrito

Libro Artículo

AutorTítulo

EditorialPrecio

RevistaFecha

Ejemplo 2

Comunicación interobjetual " Un objeto accede a otro enviándole un mensaje

" Cuando eso ocurre, el receptor ejecuta el método correspondiente al mensaje

" Un mensaje consiste en un nombre de método más cualquier argumento adicional que es enviado por un objeto (cliente) a otro (servidor)

" El conjunto de mensajes a los que un objeto responde caracteriza su comportamiento

" El método asociado a un mensaje es el algoritmo detallado que lo implementa (privado).

Polimorfismo" Cualidad que poseen los objetos para responder

de distinto modo ante el mismo mensaje.

" Implica que el objeto que envía un mensaje no necesita conocer la instancia de la clase receptora.

" Permite detectar y aprovechar similitudes entre distintas clases de objetos: objetos distintos que respondan a un mismo mensaje pueden ser tratados de la misma forma por el remitente.

Ejemplo:

Polígono

RectánguloTriángulo

mover()area()

area() area()

Lenguajes OO" En 1986, E. Stroustrup extendió el lenguaje de

programación C a C++, es decir C con conceptos de clases y objetos, también por esas fechas se creo desde sus bases el lenguaje EIFFEL.

" En 1995 apareció el más reciente lenguaje OO, Java desarrollado por SUN, que hereda conceptos de C++.

" El lenguaje de desarrollo más extendido para aplicaciones Web, el PHP 5, trae todas las características necesarias para desarrollar software orientado a objetos.

" Además de otros lenguajes que fueron evolucionando, como el Pascal a Delphi.

" Finalmente también otros lenguajes script como el ActionScript que si bien no es totalmente orientado a objetos pero sí posee algunas características.

Jordi Linares i Pellicer

Programació amb C# .NET

Tema 4 (b): Programación Orientada a Objetos con C#

Índice! Introducción

! Espacios con nombre (Namespaces)

! Definición de Clases

! Miembros de una clase

! Interfaces

! Sobrecarga de operadores

! Clases Parciales

! Clases Estáticas

Introducción

! Tradicionalmente el código se reutilizaba por el sistema de cortar aquí y pegar allá:" Manual" Difícil mantenimiento posterior" Nunca se acaba de cerrar nada

! Los objetos permiten encapsular datos y métodos, herencia, polimorfismo, interfaces, …

! C# es un lenguaje orientado a objetos.

! Se estudiará cómo crear clases propias para utilizarlas creando objetos, así como otros conceptos relacionados con la programación orientada a objetos (POO).

! En la plataforma .NET todos los objetos se organizan en espacios con nombre.

! Un espacio con nombre define un grupo de miembros distintos, o ámbito, que comparten un nombre y un propósito común.

! Un espacio con nombre puede contener a otros espacios con nombre dando lugar a una jerarquía:

System

Windows

Forms

Web

Services

UI

Espacios con nombre (Namespaces)

! Definición:namespace Espai1 { class Classe1 { ... } }

! Namespaces anidados:namespace Espai1 { namespace SubEspai1 { class Classe2{…} } }

! Acceso cualificado a las definiciones de los namespaces: ! Espai1.Classe1…! System.Console.ReadLine();

! Using permite hacer referencia a namespaces:! Using System! Using System.Windows.Forms! Using System.Console # ERROR, porque Console es una clase

! Dos clases pueden tener el mismo nombre pero en espacios de nombre diferentes, en ese caso, se han de usar referencias completas o usar un alias.

Ejemplo: namespace MaClasses{ namespace Espai1 { public class Mostra { public void MostraMissatge() { Console.WriteLine(“Hola des de Espai1.Mostra"); } } } namespace Espai2 { public class Mostra { public void MostraMissatge() { Console.WriteLine(“Hola des de Espai2.Mostra "); } } }}

using System;using MaClasses.Espai1; // con alias: using Esp1 = MaClasses.Espai1using MaClasses.Espai2; // con alias: using Esp2 = MaClasses.Espai2

namespace App1{ class ClasseExemple { [STAThread] static void Main(string[] args) { // Mostra m = new Mostra(); # Error por referencia ambigua // Tenemos que usar una referencia completa la clase: MaClasses.Espai1.Mostra m = new MaClasses.Espai1.Mostra(); m.MostraMissatge(); // … o podemos usar tambien un alias si lo hemos definido Esp2.Mostra k = new Esp2.Mostra(); k.MostraMissatge();

} }}

Definición de Clases

! Las clases permiten crear nuevos tipos de datos.

! Las clases se definen dentro de un namespace mediante la palabra clave class seguida del identificador de la clase.

! A diferencia de los demás tipos de datos las clases pueden derivarse unas de otras.

! Contienen datos, métodos y propiedades! Una clase puede incluir otras clases.! Las clases pueden implementar interfaces.! También pueden incluir delegados y eventos.

! Modificadores de acceso:

! Todas las clases derivan implícitamente de la clase base System.Object y heredan todos sus métodos públic y protected: Finalize(), Equals(), GetType(), ToString(),…, etc.

public La clase o miembro es accesible en cualquier ámbito.

protectedSe aplica sólo a miembros de la clase. Indica que sólo es accesible desde la propia clase y desde las clases derivadas.

privateSe aplica a miembros de la clase. Un miembro privado sólo puede utilizarse en el interior de la clase donde se define, por lo que no es visible tampoco en clases derivadas.

internalLa clase o miembro sólo es visible en el proyecto (ensamblado) actual.

internal protected

Visible en el proyecto (ensamblado) actual y también visible en las clases derivadas.

! Constructores y Destructores" En C# existen unos métodos específicos para controlar la

creación (constructores) y la eliminación de objetos (destructores).

" En C# si no se definen se heredan por defecto de System.Object.

" Los constructores tienen el mismo nombre de la clase y no devuelven ningún valor.

" Pueden tomar o no argumentos (constructor por defecto).class MaClasse { public MaClasse() { // Codi del constructor per defecte } public MaClasse(int maEnt) { // Constructor con parámetro maEnt }}

" Puede haber múltiples constructores en una clase (si cuenta con diferentes argumentos), pero cada clase sólo puede contar como máximo con un destructor.

" El destructor no retorna ningún valor y no tiene argumentos.

~MaClasse() {

// Códi del destructor.

}

" El constructor de la clase se ejecuta en el momento que se utiliza new para crear un nuevo objeto de esa clase.

" El destructor de la clase se ejecuta para cierto objeto cuando ya no hay ninguna referencia a ese objeto. De ello se ocupa el recolector de basura (garbage collector) de la plataforma .NET. (ya no existe el delete en C#)

" Para hacer referencia explícita dentro de la clase al objeto que llama al método usaremos this.

" Ejemplo:

namespace POO{ class Persona { string Nom, Cognoms; ushort Edat; // constructor per defecte public Persona () { Console.WriteLine("Constructor per defecte de

Persona.Sense arguments "); }

// constructor amb arguments

public Persona(string Nom, string Cognoms, ushort Edat)

{

this.Nom = Nom;

this.Cognoms = Cognoms;

this.Edat = Edat;

Console.WriteLine("Constructor de {0} {1}", Nom, Cognoms);

}

//Destructor ~~Persona() { Console.WriteLine("Destruït: {0} {1} ",

Nom, Cognoms); Console.ReadLine(); } public void MostraDades() { Console.WriteLine("\nNom:

{0}\nCognoms: {1}\nEdat: {2}", Nom, Cognoms, Edat);

} }}

class Class1 { [STAThread] static void Main(string[] args)

{ Persona p, q; p = new Persona(); q = new Persona("Pepe", "Pérez",

23); p.MostraDades(); q.MostraDades(); Console.WriteLine("\n\n---Final de

l'aplicació---"); Console.ReadLine(); } }

! Herencia" Es el mecanismo para definir una nueva clase (clase

derivada) partiendo de una clase existente (clase base)

" La herencia permite la reutilización de código.

" La clase derivada hereda todos los miembros de su clase base, excepto los que son privados.

" Todas las clases derivan implícitamente de Object.

" C# sólo permite heredar de una sola clase.

" Si una clase deriva de otra clase base se indica tras el nombre de la clase con dos puntos y el nombre de la clase de la cual deriva:

<NomDer>:<NomBase>

" Para llamar al constructor de la clase base:

public Quadrat(string nom) : base(nom){ … }

" Ejemplo de herencia (derivación) class animal { // hereda de Object

protected int peso=100; protected int talla=50; } class perro : animal {// perro hereda de la clase animal public void mostrarTodosDatos() { Console.WriteLine(peso.ToString() + " " + talla.ToString()); } }

desde Main():

perro p = new perro(); p.mostrarTodosDatos();

" Cuando no interesa que se derive de una clase (porque se trata de una clase final) se usa el modificador sealed (sellada) delante de class:

public sealed class perro : animal{...}

" Muchas clases de .NET Framework son selladas: String, StringBuilder, etc.

" En cambio, si la clase sólo debe actuar como clase base de otras clases se denomina clase abstracta y se usa el modificador abstract en la declaración:

public abstract class animal {...}

# No es posible instanciar objetos directamente de una clase abstracta, es necesario derivar.

Miembros de una clase! En una clase se definen campos, propiedades

y métodos.

! Cada miembro tiene su propio nivel de accesibilidad: private, public, protected, internal, protected internal.

! Además, los miembros definidos estáticos (static) son compartidos por todos los objetos de la clase y se acceden directamente:

<nombreClase>.<nombreMiembroEstatico>

! Campos" Se definen como las variables añadiendo su nivel de

accesibilidad, además de static y const opcionalmente." Las variables estáticas se acceden por la clase y nunca por

instancias de la clase.class MaClasse { public int MaEnt; //primera lletra en majúscula public static int MaEntEstat; // public const int MaConst=120; // constant pública }

! Métodos" Se definen como las funciones indicando su nivel de

accesibilidad y static de forma opcional." Métodos sobrecargados: permiten tener en una misma

clase varios métodos con el mismo nombre pero con diferentes argumentos. Se aplica también a los contructores.

" A la definición del método pueden añadirse las palabras reservadas: virtual, abstract, override o extern.

" Ejemplo de sobrecarga:

class ObjGeometrico { public static void Dibuixa(int x, int y) { // dibuixa en un punt } public static void Dibuixa(int color){ // pinta la pantalla de color } public static void Dibuixa(int x, int y, int color) { // dibuixa en un punt i ompli de color }}class Quadrat : ObjGeometrico { public static void Dibuixa(int x1, int y1, int x2, int y2) { // dibuixa un quadrat } public static void Dibuixa(int x1, int y1, int x2, int y2, int color) { // dibuixa un quadrat i l'ompli de color }}

" Métodos virtuales.! Permiten que las clases sean polimórficas.! Se usa la palabra clave virtual.! Un método virtual especifica una implementación de un método

que puede ser sustituida por polimorfismo en una clase derivada. ! Un método no virtual especifica la única implementación de un

método. No es posible sustituir por polimorfismo un método no virtual en una clase derivada.

! Los métodos virtuales no son ni estáticos ni privados.class ObjGeometrico { protected string nom; ... public virtual void Dibuixa(int

x, int y) { // dibuixa l’objecte en la pos x,y } public string MostraNom() { return nom; }}

" Sustitución de métodos (override):! Un método override especifica otra implementación de un

método virtual definido en una clase base.! El método override debe coincidir exactamente con su método

virtual heredado asociado.! Un método override se puede sustituir también en las clases

derivadas.

class Quadrat : ObjGeometrico{ public override void Dibuixa(int x, int y) { // nova implementació del mètode // per a dibuixar el quadrat }

public override string MostraNom() { return “Quadrat” + nom; } $ERROR MostraNom no es virtual!!}

" Ocultación de métodos! En ocasiones, un método heredado no implementa en la clase

derivada exactamente lo que se desea. ! Al redefinirlo, el método de la clase base queda oculto.

! Se utiliza el modificador new en el método de la clase derivada para indicar que se redefine el método.

class ObjGeometricoImp: ObjGeometrico{ new public static void Dibuixa(int x, int y) { // nova implementació del mètode // oculta el mètode de la classe base Console.WriteLine(“Punt a impressora”); }}

! Propiedades" Aparecen en la clase como campos de datos." Las propiedades tienen un tipo, pero la asignación y lectura de

las mismas se realiza a través de métodos de lectura y escritura." Con las propiedades se puede limitar el acceso a un campo

permitiendo sólo la lectura y también se puede realizar cualquier comprobación cuando se asignan valores a la propiedad.

" Con Intellisense de Visual Studio 2005 se inserta directamente una nueva propiedad: Insertar fragmento de código#prop

" Ejemplo: private string nombre; // camp privat public string Nombre // propietat pública { get { return nombre; } set { nombre = value; } }

Propiedad de lectura / escritura

" Para indicar que una propiedad es de sólo lectura o sólo escritura hay que omitir el apartado set o get repectivamente.

" Ejemplo:class Ficha {

private string nombre; private int anyo; public string Nombre //propiedad de sólo lectura { get {

return “El teu nom és: “ + nombre; } } public int Anyo //propiedad de lectura/escritura {

get { return anyo; } set { if (value>1900) // comprovem si és correcte

anyo = value; else Console.WriteLine(“Només anys >1900”); } }

Interfaces! Muchas veces al heredar de un objeto lo único que queremos es que herede un

comportamiento.! Es decir, asegurarnos que implemente unos métodos concretos para aplicar el

polimorfismo.! También hay situaciones en las que nos gustaría heredar de varias clases: pero C#

no permite herencia múltiple.

! Una interfaz es la definición de un conjunto de métodos, propiedades, etc. para los que no se da implementación pero que las clases hijas sí que deben implementar.

! Una interfaz no contiene tipos, ni campos, ni modificadores de acceso (sólo public)! Al no tener implementación los interfaces no se pueden instanciar.! Una clase puede implementar varias interfaces separándolos por comas.! Una clase ha de implementar todos los métodos de interfaz heredados

! Declaración:

interface IPalClave{ int NumLinea( ); string Palabra( );}

IPalClave« interface »

NumLinea( )Palabra( )

Métodos sin cuerpo

Los nombres de interfacesempiezan con “I”mayúscula

Sin especificación de acceso

! Ejemplo: Editor de formas geométricasIn

terf

aces

public interface IFigura

{

void Dibujar();

float Area();

float Perimetro();

}

public class Cuadrado : IFigura

{

protected float lado;

public Cuadrado(float l) {

this.lado=l;

}

public float Area() {

return lado*lado;

}

public float Perimetro() {

return 4*lado;

}

public void Dibujar() {

System.Console.WriteLine("[]");

}

}

Inte

rfac

es

" Definición:

public class Circulo : IFigura

{ protected float radio; protected const float PI=3.14159F; public Circulo(float radio) { this.radio=radio; } public float Area() { return PI*(float)Math.Pow(radio,2); } public float Perimetro() { return 2*PI*radio; } public void Dibujar() {

Console.WriteLine("O");

public interface IFigura

{void Dibujar();

float Area();

float Perimetro();

}

Obligación de implementar

todos los métodos de la

interfaz

Inte

rfac

es

Circulo fig1=new Circulo(1);

Cuadrado fig2=new Cuadrado(2);IFigura[] Figuras = new IFigura[2]; //array de interfaces

IFigura f; //referencia a la interfazf=fig1; f.Dibujar();Console.WriteLine("PERIMETRO=“ + f.Perimetro() ); Console.WriteLine(“AREA="+ f.Area() );f=fig2;

f.Dibujar(); Console.WriteLine("PERIMETRO=“ + f.Perimetro() );Console.WriteLine(“AREA=“ + f.Area() );Figuras[0] = new Circulo(4);Figuras[1] = new Cuadrado(2);

Inte

rfac

es

" Uso de las interfaces.

Una interfaz puede hacer referencia a cualquier clase que la implemente:

Sobrecarga de Operadores! C# permite la sobrecarga de operadores para hacer

algunas operaciones más intuitivas: +, -, * , /, <,>…etc.

! Hay que usarlo sólo cuando su aplicación resulta más clara que con la llamada a un método.

! Ejemplos:" Sumar, restar, etc. dos arrays." Operaciones con números complejos." Comparar cadenas usando >,<, etc.

! Todos los operadores sobrecargados se definen public y static seguido del tipo devuelto, la palabra clave operator i el operador que se quiere sobrecargar.

! Ejemplo: sumar y restar dos vectores de enterosclass Vector { int[] v; public Vector(params int[] v) { this.v = new int[v.Length]; for (int i = 0; i < v.Length; i++) this.v[i] = v[i]; }

public static Vector operator +(Vector v1, Vector v2) { int[] minV, maxV;

if (v1.v.Length > v2.v.Length) { minV = v2.v; maxV = v1.v; } else{ minV = v1.v; maxV = v2.v; }

int[] suma = new int[maxV.Length]; int i,j; for (i = 0; i < minV.Length; i++) suma[i] = minV[i] + maxV[i]; for (j=i; j<maxV.Length;j++) suma[j] = maxV[j];

return new Vector(suma); } public override string ToString() { string s=""; foreach (int i in this.v) s += i + " "; return s; }

}

static void Main(string[] args)

{

Vector v1 = new Vector(1,2,3,4);

Vector v2 = new Vector(1,2,3,4,5,6);

Vector v3 = v1 + v2;

Console.WriteLine(v3.ToString());

Console.ReadLine();

}

Clases Parciales! Permiten dividir la definición de una clase, estructura o interfaz

en ficheros separados.! Esto es lo que ocurre con el código generado por Visual Studio.! Es útil cuando:

" Varios programadores quieren trabajar a la vez con la misma clase," El fichero se hace muy grande," Los métodos se quieren tener por separado.

! Definición: //fichero ClasePart1.cs partial class ClaseParcial { public void Metode1() { } } //fichero ClassPart2.cs partial class ClaseParcial { public void Metode2() { } }

#Al compilar habrá una clase ClaseParcial con dos métodos.

! Las Interfaces aplicadas a una clase parcial se aplica a todas las partes de la clase:

public partial class MaClasse : IMaInterface1 { ....} public partial class MaClasse : IMaInterface2{ ....}

equivale a:public class MaClasse : IMaInterface1, IMaInterface2 { ...

}

Clases Estáticas

! Una clase estática sólo contiene miembros estáticos.! Una clase estática nunca se instancia.

! Definición: static class ClasseEstatica {

public static void MetodeEstatic(){..}

}

! Uso directo del método:ClasseEstatica.MetodeEstatic();