//La asignación de la propiedad Horas hace que el 'set' de acceso a ser llamado. t.hours = 24;

Transcripción

1 Continuación del tema 3 Métodos especiales (Propiedades) Herencia Polimorfismo Sobrecargas Espacios de Nombre(namespace) Propiedades Las propiedades son miembros que ofrecen un mecanismo flexible para leer, escribir o calcular los valores de campos privados. Las propiedades pueden utilizarse como si fuesen miembros de datos públicos, aunque en realidad son métodos especiales denominados descriptores de acceso. De este modo, se puede obtener acceso a los datos con facilidad, a la vez que se promueve la seguridad y flexibilidad de los métodos. Ejemplo de propiedades: en este ejemplo existe una propiedad llamada Hours la cual se encarga de obtener y mostrar lo que almacena la variable de tipo doble Hours. En este ejemplo,la clase TimePeriod almacena un periodo de tiempo. Internamente,la clase almacena el tiempo en segundos,pero una propiedad denominada Hours permite a un cliente especificar el tiempo en horas. Los descriptores de acceso de la propiedad Hours realizan la conversión entre horas y segundos class TimePeriod private double seconds; public double Hours get return seconds / 3600; set seconds = value * 3600; class Program static void Main() TimePeriod t = new TimePeriod(); //La asignación de la propiedad Horas hace que el 'set' de acceso a ser llamado. t.hours = 24; / / La evaluación de la propiedad Horas hace que el 'Get' de acceso a ser llamado. System.Console.WriteLine("Time in hours: " + t.hours); // salida: Time in hours: 24 //Esta información la pueden encontrar mas detallada

2 Las propiedades se declaran en el bloque de clase especificando el nivel de acceso del campo, seguido por el tipo de la propiedad, por el nombre de la propiedad y por un bloque de código que declara un descriptor de acceso get y/o un descriptor de acceso set. Por ejemplo: class Person private string name; // El campo nombre public string Name // La propiedad nombre get return name; set name = value; Cuando se asigne un valor a la propiedad, se llamará al descriptor de acceso set utilizando un argumento que proporcione el nuevo valor. Por ejemplo: Person person = new Person(); person.name = "Joe"; // the set accessor is invoked here System.Console.Write(person.Name); // the get accessor is invoked here

3 Ejemplo de herencia y polimorfismo: Una empresa utiliza el siguiente programa para calcular los salarios de sus trabajadores, el programa utiliza una clase base llamada empleado y una clase derivada que se llama contratista, la diferencia del empleado con el contratista es la forma de calcular su salario,el polimorfismo se aplica cuando el metodo CalcularSalario() tiene diferentes comportamiento uno para el empleado y otro para el contratista using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace Ejemplodepolimorfismo//espacio de nombres public class empleado string nombres; string apellidos; double salariobasico; double seguridadsocial; //propiedad que obtiene y establese el nombre del empleado public string Nombres get return nombres; set nombres = value; //propiedad que obtiene y establese el apellido public string Apellidos get return apellidos; set apellidos = value; //propiedad que obtiene y establese el Salario base public double SalarioBasico get return salariobasico; set salariobasico = value; public double SeguridadSocial set seguridadsocial = value; // metodo para calcular el salario devengado public virtual void CalcularSalario() double salario; double social; string mensaje; // Calcular la seguridad social social = salariobasico * seguridadsocial / 100; // Determinar el salario devengado salario = salariobasico - social; // Construir el mensaje que se va a mostrar mensaje = "Seguridad social: " + social; mensaje += "\nsalario devengado: " + salario; MessageBox.Show(mensaje, "Empleado");

4 public class Contratista : Empleado double numerohoras; public double NumeroHoras set numerohoras = value; // Reescritura del metodo CalcularSalario() public override void CalcularSalario() double salario; double valorhora; string mensaje; // Calcular el valor de la hora con base en el salario b テ sico valorhora = base.salariobasico / 160; // Determinar el salario devengado salario = valorhora * numerohoras; // Construir el mensaje que se va a mostrar mensaje = "Valor por hora: " + valorhora; mensaje += "\nsalario devengado: " + salario; MessageBox.Show(mensaje, "Contratista"); //Función Main using System; using Ejemplodepolimorfismo; public class SalarioDevengado static void Main() Empleado trabajador = new Empleado(); trabajador.nombres = "Juan"; trabajador.apellidos = "P テゥ rez"; trabajador.salariobasico = ; trabajador.seguridadsocial = 16; trabajador.calcularsalario(); Contratista obrero = new Contratista(); obrero.nombres = "Jos テゥ "; obrero.apellidos = "Rodr テュ guez"; obrero.salariobasico = ; obrero.seguridadsocial = 0; obrero.numerohoras = 80; obrero.calcularsalario(); //Este ejemplo se encuentra en el libro C# como programar deitel deitel para cualquier duda Capitulo 10.4

5 Sobrecarga de métodos: Pueden declararse métodos con el mismo nombre en la misma clase, siempre y cuando tengan distintos conjuntos de parámetros (determinados en base al número, tipos y orden de los parámetros). A esto se le conoce comosobrecarga de métodos. Cuando se hace una llamada a un método sobrecargado, el compilador de C# selecciona el método apropiado mediante un análisis del número, tipos y orden de los argumentos en la llamada. Por lo general, la sobrecarga de métodos se utiliza para crear varios métodos con el mismo nombre que realicen la misma tarea o tareas similares, pero con distintos tipos o distintos números de argumentos. // Declaraciones de metodos sobrecargados. using System; public class SobrecargaMetodos // prueba los metodos Cuadrado sobrecargados public void ProbarMetodosSobrecargados() Console.WriteLine( "El cuadrado del integer 7 es 0", Cuadrado( 7 ) ); Console.WriteLine( "El cuadrado del double 7.5 es 0", Cuadrado( 7.5 ) ); // fin del metodo ProbarMetodosSobrecargados // Metodo Cuadrado con argumento int public int Cuadrado( int valorint ) Console.WriteLine( "Se llam テウ a Cuadrado con argumento int: 0", valorint ); return valorint * valorint; // fin del metodo Cuadrado con argumento int // Metodo Cuadrado con argumento double public double Cuadrado( double valordouble ) Console.WriteLine( "Se llam テウ a Cuadrado con argumento double: 0", valordouble ); return valordouble * valordouble; // fin del metodo Cuadrado con argumento double // fin de la clase SobrecargaMetodos // //funcion main para probar los metodos sobrecargados public class PruebaSobrecargaMetodos public static void Main( string[] args ) SobrecargaMetodos sobrecargametodos = new SobrecargaMetodos(); sobrecargametodos.probarmetodossobrecargados(); // fin de Main // fin de la clase PruebaSobrecargaMetodos Sobrecarga del operador + para sumar matrices En este ejemplo podemos ver la sobrecarga del operador + en una clase la cual se llama Matriz la suma retorna como resultado un objeto de tipo Matriz. public static Matriz operator +(Matriz mat1, Matriz mat2) Matriz nuevamatriz = new Matriz(); for (int x=0; x < tamanyo; x++)

6 for (int y=0; y < tamanyo; y++) nuevamatriz[x, y] = mat1[x, y] + mat2[x, y]; return nuevamatriz; La llamada desde el main a la sobrecarga de operadores nos quedaría de la forma siguiente Matriz matriz3 = matriz1 + matriz2; //Cree la clase Matriz la cual almacene una matriz bidimensional,en la función main cree 2 objetos de tipo Matriz y súmelos guarde el resultado en el 3er objeto de tipo Matris Espacios de nombres (namespace) En C# se podemos utilizar espacios de nombres para agrupar de forma lógica ciertas porciones de código de forma que se les asocia un nombre para su uso. Si no utilizamos explícitamente ningún espacio de nombres estaremos utilizando el espacio de nombres global, como se hace en el primer ejemplo holamundo.cs. Veamos ahora como utilizar explícitamente el espacio de nombres System en holamundo2.cs de forma que no tengamos que escribir System. cada vez que nos queramos referir a alguna variable, clase,... que esté definida en su interior. Para ello deberemos emplear using. System.Console.WriteLine("Hello World!"); System es un espacio de nombres y Console es una clase de ese espacio de nombres. Se puede utilizar la palabra clave using para que no se requiera el nombre completo, como en el ejemplo siguiente: Console.WriteLine("Hello"); Console.WriteLine("World!"); Nosotros también podemos declarar nuestros espacios de nombre propios,los cuales no ayudan a controlar los nombres de los métodos y las clases en nuestros proyectos,cuando utilizamos programas grandes. Utilizando la palabra clave namespace,vease el ejemplo siguiente: namespace Ejemplodepolimorfismo//espacio de nombres //la clase empleado se encuentra dentro del espacios de nombres Ejemplodepolimorfismo public class empleado string nombres; string apellidos; double salariobasico; double seguridadsocial; Las propiedades de los espacios de nombres: Organizar proyectos de codigo de gran tamaño. El operador. Delimita los espacios de nombres. Using directive hace que no sea necesario espesificar el nombre del espacio de nombre para cada clase. El espacio de nombre global es el espacio de nombre raiz :global::system siempre hara referencia al espacio de nombres System de.net Framework

7 //Usando la directiva using // espacios.cs using System; // usaremos el espacio de nombres System namespace Espacio1 // declaraci テウ n del espacio de nombres Espacio1 public class Prueba public Prueba() Console.WriteLine("Espacio1.Prueba"); namespace Espacio2 // declaraci テウ n del espacio de nombres Espacio2 public class Prueba public Prueba() Console.WriteLine("Espacio2.Prueba"); using Espacio2; // usaremos el espacio de nombres Espacio2 public class Namespace public static void Main() Prueba p = new Prueba(); Espacios de nombres anidados Los espacios de nombres pueden anidarse, es decir, definirse dentro de otros espacios de nombres. Para ello no tendremos más que encerrara la declaración de un espacio de nombres dentro de la de otro espacio de nombres. Para referirnos a las declaraciones del espacio interior habremos de utilizar la clausula using seguida de todos los espacios de nombres unidos mediante un punto o referirnos a un tipo empleando su nombre completo. // anidado.cs using System; namespace Exterior namespace Interior class Hola

8 public Hola() Console.WriteLine(" ツ Hola!"); using Exterior.Interior; class EspacioNombresAnidado public static void Main() Hola hola = new Hola(); // alternativamente se podr テュ a haber utilizado: // Exterior.Interior.Hola hola = new Exterior.Interior.Hola(); Alias En c# podemos crear alias de tipos y espacios de nombres,con lo que podremos referinos a ciertos tipos y espacios de nombres // alias.cs using sys = System; // alias de espacio de nombres using cadena = System.String; // alias de tipo class Alias public static void Main() cadena c = " ツ Hola, mundo!"; sys.console.writeline(c); // ツ hola, mundo! sys.console.writeline(c.gettype()); // System.String

9 Uso de espacio de nombres para controlar el ambito : La palabra clave namespace se utiliza para declarar un ámbito. La capacidad de crear ámbitos dentro del proyecto permite organizar el código y le permite crear tipos únicos globales. En el ejemplo siguiente, una clase titulada SampleClass se define en dos espacios de nombres, uno anidado dentro de otro. Operador. (Referencia de C#) se utiliza para diferenciar a qué método se llama. namespace SampleNamespace class SampleClass public void SampleMethod() System.Console.WriteLine("SampleMethod inside SampleNamespace"); / / Crear un espacio de nombres anidado, y definir otra clase. namespace NestedNamespace class SampleClass public void SampleMethod() System.Console.WriteLine("SampleMethod inside NestedNamespace"); class Program static void Main(string[] args) / / Muestra "SampleMethod dentro SampleNamespace." SampleClass outer = new SampleClass(); outer.samplemethod(); / / Muestra "SampleMethod dentro SampleNamespace." SampleNamespace.SampleClass outer2 = new SampleNamespace.SampleClass(); outer2.samplemethod(); / / Muestra "SampleMethod dentro NestedNamespace." NestedNamespace.SampleClass inner = new NestedNamespace.SampleClass(); inner.samplemethod();

10 //nombres completos Los espacios de nombres y tipos tienen nombres únicos que se describen mediante nombres completos que indican una jerarquía lógica. Por ejemplo, la instrucción A.B implica que A es el nombre del espacio de nombres o tipo y que B está anidado dentro de él. En el siguiente ejemplo, se muestran clases y espacios de nombres anidados. El nombre completo se indica como un comentario que sigue a cada entidad. namespace N1 // N1 class C1 // N1.C1 class C2 // N1.C1.C2 namespace N2 // N1.N2 class C2 // N1.N2.C2 El espacio de nombres N1 es un miembro del espacio de nombres global. Su nombre completo es N1. El espacio de nombre N2 es un miembro del espacio de nombre N1. Su nombre completo es N1.N2. La clase C1 es un miembro del espacio de nombres N1. Su nombre completo es N1.N2. La clase C1 es un miembro de N1. Su nombre completo es N1.C1. El nombre de clase C2 se utiliza dos veces en el código. Sin embargo, los espacios completo son únicos. La primera instancia de C2 se declara dentro de C1; por lo tanto, su nombre completo es N1.C1.C2. La segunda instancia de C2 se declara dentro de un espacio de nombres N2; por lo tanto, su nombre completo es N1.N2.C2. Mediante el segmento de código anterior, se puede agregar un nuevo miembro de clase, C3, al espacio de nombres N1.N2 de la siguiente forma: namespace N1.N2 class C3 // N1.N2.C3 Bibliografia Libros C# como programar Deitel Deitel Lenguaje de programacion c# Francisco Ceballos Siteo Web