soluciones clases c

SOLUCIONES CLASES C#
50 Define, en Visual C#, una clase Bombilla que sirva permita modelar el estado y comportamiento de
una bombilla, la cual podrá estar encendida o apagada. La clase constará de:



Los atributos privados: encendida (lógico), intensidad (float), iMáxima (intensidad máxima que puede
alcanzar la bombilla), iMinima (el mínimo de intensidad que tendrá al encenderse).
Los métodos saberEstado, ponerEstado, modificarIntensidad, serán los métodos a través de los cuales
se accederá a los campos anteriores:
o ponerEstado.- Permitirá encender o apagar la bombilla, según el parámetro que le llegue.
Cuando se enciende una bombilla, el valor de la intensidad es iMinima
o modificarIntensidad.- Se encargará de aumentar, o disminuir, la intensidad de la bombilla en
una cantidad que recibe como parámetro. Nunca se podrá superar la iMaxima y cuando la
intensidad sea cero, o menor que cero, la bombilla se apagará
o saberEstado.- Permitirá conocer el estado y la intensidad de la bombilla en un instante
determinado.
La clase dispondrá de constructores, que además de fijar los valores de intensidad máxima y mínima
de encendido de la bombilla, realizarán:
o El primero que se encargará de crear el objeto bombilla por defecto, esto es, la bombilla está
apagada.
o El segundo crea el objeto bombilla encendida con su intensidad mínima.
Codifica la clase Programa que pruebe la clase anterior, para lo cual creará diferentes objetos bombilla e
irá probando los métodos y el resultado de su aplicación.
namespace Ejercicio50
{
// -----------------------------------------------------------------------// Clase Bombilla. Modela el funcionamiento de una bombilla
//
// Autor: J. Alvarez
// Fecha: 01/02/2014
// -----------------------------------------------------------------------class Bombilla
{
bool encendida;
float intensidad;
float iMaxima;
float iMinima;
// Constructor que fija las intensidades mínimas y máximas
public Bombilla(float iMinima, float iMaxima)
{
encendida = false;
intensidad = 0;
this.iMinima = iMinima;
this.iMaxima= iMaxima;
}
// Constructor que fija la intensidad con la que se enciende la bombilla
public Bombilla(float intensidad, float iMinima, float iMaxima)
{
encendida = true;
this.intensidad = intensidad;
this.iMinima = iMinima;
this.iMaxima = iMaxima;
}
// Método para saber el estado y la intensidad de una bombilla
public void saberEstado(out float intensidad, out bool estado)
{
intensidad = this.intensidad;
estado = encendida;
}
// Método pra encener/apagar la bombilla
public void ponerEstado(bool encernder)
{
if (encernder)
{
if (!encendida)
{
encendida = true;
intensidad = iMinima;
}
}
else
{
encendida = false;
intensidad = 0;
}
}
// Aumenta/Disminuye la intensidad de una bombilla
public void modificarIntensidad(float cantidad)
{
if (encendida)
{
intensidad += cantidad;
if (intensidad > iMaxima) intensidad = iMaxima;
if (intensidad < iMinima)
{
intensidad = 0;
encendida = false;
}
}
}
}
// Clase Programa50. Prueba la clase Bombilla
class Program50
{
static void Main(string[] args)
{
bool estadoBombilla;
float intensidad;
Bombilla bombilla1 = new Bombilla(10, 100);
Bombilla bombilla2 = new Bombilla(50, 10, 100);
// Mostramos el estado y la intensidad de la bombilla1
bombilla1.saberEstado(out intensidad, out estadoBombilla);
Console.WriteLine("Bombilla1: Estado: {0} - Intensidad: {1}", estadoBombilla, intensidad);
// Mostramos el estado y la intensidad de la bombilla2
bombilla2.saberEstado(out intensidad, out estadoBombilla);
Console.WriteLine("Bombilla2: Estado: {0} - Intensidad: {1}", estadoBombilla, intensidad);
// Intentamos aumentar la intensidad de la bombilla apagada
bombilla1.modificarIntensidad(500);
// Mostramos el estado y la intensidad de la bombilla2
bombilla1.saberEstado(out intensidad, out estadoBombilla);
Console.WriteLine("Bombilla1: Estado: {0} - Intensidad: {1}", estadoBombilla, intensidad);
// Aumentamos por encima del valor máximo la bombilla 2
bombilla2.modificarIntensidad(500);
// Mostramos el estado y la intensidad de la bombilla2
bombilla2.saberEstado(out intensidad, out estadoBombilla);
Console.WriteLine("Bombilla2: Estado: {0} - Intensidad: {1}", estadoBombilla, intensidad);
// Encendemos la bombilla 1
bombilla1.ponerEstado(true);
// Mostramos el estado y la intensidad de la bombilla2
bombilla1.saberEstado(out intensidad, out estadoBombilla);
Console.WriteLine("Bombilla1: Estado: {0} - Intensidad: {1}", estadoBombilla, intensidad);
//Apgamos la bombilla 2 bajanndo su intensidad
bombilla2.modificarIntensidad(-500);
// Mostramos el estado y la intensidad de la bombilla2
bombilla2.saberEstado(out intensidad, out estadoBombilla);
Console.WriteLine("Bombilla2: Estado: {0} - Intensidad: {1}", estadoBombilla, intensidad);
}
}
}
51 Nos han pedido modelar, en Visual C#, la clase Monedero, la cual debe permitir gestionar la cantidad
de dinero que una persona tiene en un momento determinado.
 Se supone que cuando le entregan a una persona un monedero, se lo entregan vacío, pero también
podrían dárselo con una cantidad inicial.
 Sobre el monedero se pueden realizar varias operaciones: meter dinero en el monedero, sacar
dinero y visualizar cuánto dinero hay disponible.
 Sólo podrá operarse con el monedero a partir de estos métodos.
 No se podrá sacar más dinero que el que haya en el monedero, ni se admitirán cantidades
negativas de dinero.
Codifica la clase Programa que pruebe la clase anterior
namespace Ejercicio51
{
// --------------------------------------------------------------------------------// Modelar, en Visual C#, la clase Monedero, para gestionar la cantidad de dinero
// que una persona tiene en un momento determinado. Inicialmente se supone vacío
// pero también podrían dárselo con una cantidad inicial.
// Operaciones: guardar dinero , sacar dinero y visualizar dinero disponible
//
// Autor: J. Alvarez
// Fecha: 01/02/2014
// --------------------------------------------------------------------------------class Monedero
{
float dinero;
// Inicializa el monedero a cero
public Monedero()
{
dinero = 0;
}
// Inicializa el monedero con una cantidad inicial
public Monedero(float cantidad)
{
dinero = cantidad;
}
// Visualiza el saldo del monedero
public float VisualizarDinero
{
get { return dinero; }
}
public string ingresarDinero(float cantidad)
{
string mensaje;
// No se admite que la cantidad sea negativa
if (cantidad > 0)
{
dinero += cantidad;
mensaje = "Operación realizada correctamente";
}
else mensaje = "No se puede ingresar una cantidad negativa";
return mensaje;
}
public string sacarDinero(float cantidad)
{
string mensaje;
// No se admite que la cantidad sea negativa
if (cantidad > 0)
{
if (dinero >= cantidad)
{
dinero -= cantidad;
mensaje = "Operación realizada correctamente";
}
else mensaje = "No se dispone de esa cantidad de dinero";
}
else mensaje = "No se puede retirar una cantidad negativa";
return mensaje;
}
}
// Clase Programa51. Permite modelar la clase Monedero
class Program51
{
static void Main(string[] args)
{
Monedero miMonedero = new Monedero();
Monedero tuMonedero = new Monedero(4000);
// Visualizamos los saldos de los monederos
Console.WriteLine("Saldo Monedero miMonedero = {0} ", miMonedero.VisualizarDinero);
Console.WriteLine("Saldo Monedero tuMonedero = {0} ", tuMonedero.VisualizarDinero);
// Ingresamos en el primer monedero 1000 euros y los retiramos del segundo
Console.WriteLine("miMonedero {0} ", miMonedero.ingresarDinero(1000));
Console.WriteLine("tuMonedero {0} ", tuMonedero.sacarDinero(1000));
// Visualizamos los saldos de los monederos
Console.WriteLine("Saldo Monedero miMonedero = {0} ", miMonedero.VisualizarDinero);
Console.WriteLine("Saldo Monedero tuMonedero = {0} ", tuMonedero.VisualizarDinero);
// Intentamos ingresar en miMonedero una cantidad negativa
Console.WriteLine("miMonedero {0} ", miMonedero.ingresarDinero(-1000));
// Intentamos sacer de tuMonedero más de lo que tiene.
Console.WriteLine("tuMonedero {0} ", tuMonedero.sacarDinero(8000));
// Visualizamos los saldos de los monederos
Console.WriteLine("Saldo Monedero miMonedero = {0} ", miMonedero.VisualizarDinero);
Console.WriteLine("Saldo Monedero tuMonedero = {0} ", tuMonedero.VisualizarDinero);
}
}
}
52 - La empresa informática “IES Número1” necesita llevar un registro de todos sus empleados que se
encuentran en la oficina central, para eso ha creado el diagrama de clases que se muestra
La clase Empleado está formada por:



Campo Estático
o float SALBASE; se corresponde con el salario base que es de 600,00 euros
Campos Privados
o string nombre;
o string dni;
o int edad;
o bool casado;
o float sueldo;
Constructores
o Empleado()
o Empleado (string nombre, string dni, int edad, bool casado, float sueldo)
Nota.- Si el campo dni que se recibe no tiene ocho caracteres no se
guardará. Si la edad no está comprendida entre los 18 y los 45 años, se
pondrá a cero. Por último, si el sueldo no fuese positivo se pondrá a cero.


Propiedades
o Una de lectura y escritura por cada campo, excepto para el sueldo que sólo será de lectura.
Métodos
o string Categoria().- Establecerá la categoría del trabajador en función de su edad. Cuando
sea menor de 21 años, su categoría será Principiante, si está entre los 18 y 35 será “Junior”
y con más de 35 años será “Senior”
o void EstablecerSueldo().- Establecerá el sueldo del empleado
o
o
void AumentarSalario(float porcentaje). Permite aumentar el sueldo en el porcentaje
recibido. Si el porcentaje fuese negativo, se reduciría su sueldo, nunca por debajo de los
600 euros.
int edad;
La clase Programador está formada por:



Campos Privados
o string lenguaje; es el lenguaje en el que programa
Constructor
o Programador (string nombre, string dni, int edad, bool casado, float sueldo, string lenguaje)
Propiedades
o Una de lectura y escritura para acceder al campo privado.
Codifica la clase Programa que pruebe las clases anteriores, para lo cual esta clase dispondrá de un
método principal que fije diferentes valores y comprueba que todo funciona correctamente. Por ejemplo:
Programador
Programador
Programador
Programador
objProgramador1
objProgramador2
objProgramador3
objProgramador4
=
=
=
=
new
new
new
new
Programador("Visual C++");
Programador("Gemma Cienfuegos", "57098765",21, false, 860, "Java");
Programador("Susana Llaneza", "10056234", 32, true , 1200, "Visual C#");
Programador("María Álvarez", "", 18, true, 0, "Phyton");
objProgramador1.Nombre = "Mercedes García";
objProgramador1.Edad = 43; objProgramador1.Dni = "10867111"; objProgramador1.Casado = true;
objProgramador1.EstablecerSueldo(2700); objProgramador1.MostrarDatosEmpleado();
objProgramador2.AumentarSalario(5);
objProgramador2.MostrarDatosEmpleado();
namespace Ejercicio52
{
class Empleado
{
static double SALBASE = 600.00;
string nombre;
string dni;
int edad;
// Debe estar entre 18 y 45 años */
bool casado;
double sueldo;
public Empleado()
{
}
public Empleado (string nombre, string dni, int edad, bool casado, double sueldo)
{
this.nombre = nombre;
this.casado = casado;
if (dni.Length != 8) this.dni = string.Empty;
this.dni = dni;
if ((edad < 18) || (edad > 45)) this.edad = -1;
else this.edad = edad;
if (sueldo < 0) this.sueldo = 0;
else this.sueldo = sueldo;
}
public string Nombre
{
set {nombre= value;}
get {return nombre;}
}
public string Dni
{
set {dni = value;}
get {return dni;}
}
public int Edad
{
set {edad = value;}
get {return edad;}
}
public bool Casado
{
set {casado = value;}
get {return casado;}
}
public double Sueldo
{
get {return sueldo;}
}
public string Categoria()
{
string tipoTrabajador;
if (edad <= 21) tipoTrabajador = "Principiante";
else
if (edad > 35) tipoTrabajador = "Senior";
else tipoTrabajador = "Junior";
return tipoTrabajador;
}
public void EstablecerSueldo(float salario)
{
if (sueldo < 0) sueldo = SALBASE;
this.sueldo = salario;
}
public void AumentarSalario(float porcentaje)
{
sueldo = sueldo*(1+porcentaje/100);
if (sueldo < 600) sueldo = SALBASE;
}
public void MostrarDatosEmpleado()
{
string eCivil;
if (casado) eCivil = "Casado";
else eCivil = "Soltero";
Console.WriteLine("Empleado ........: {0}", nombre);
Console.WriteLine("Dni..............: {0}", dni);
Console.WriteLine("Edad ............: {0}", edad);
Console.WriteLine("Categoria .......: {0}", Categoria());
Console.WriteLine("Estado Civil.....: {0}", eCivil);
Console.WriteLine("Salario .........: {0}", Sueldo);
Console.WriteLine("======================================================= ");
}
}
class Programador:Empleado
{
string lenguaje;
public Programador(string lenguaje)
{
this.lenguaje = lenguaje;
}
public Programador(string nombre, string dni, int edad, bool casado, double sueldo, string
lenguaje):base(nombre, dni, edad, casado, sueldo)
{
this.lenguaje=lenguaje;
}
public string Lenguaje
{
set {lenguaje = value;}
get {return lenguaje;}
}
}
class Program
{
static void Main(string[] args)
{
Programador objProgramador1 = new Programador("Visual C++");
Programador objProgramador2 = new Programador("Gemma Cienfuegos", "57098765",21, false, 860, "Java");
Programador objProgramador3 = new Programador("Susana Llaneza", "10056234", 32, true , 1200, "Visual C#");
Programador objProgramador4 = new Programador("María Álvarez", "", 18, true, 0, "Phyton");
// Trabajamos con el programador1
objProgramador1.Nombre = "Mercedes García";
objProgramador1.Edad = 43;
objProgramador1.Dni = "10867111";
objProgramador1.Casado = true;
objProgramador1.EstablecerSueldo(2700);
objProgramador1.MostrarDatosEmpleado();
objProgramador2.AumentarSalario(5);
objProgramador2.MostrarDatosEmpleado();
}
}
}
53 En sentido amplio se llama número racional o fracción común a todo número que puede
representarse como el cociente de dos enteros con denominador distinto de cero. Por ejemplo, 0,25 se
puede representar como ¼.
Cuando en un equipo informático realizamos múltiples operaciones encadenadas, con números reales se
producen aproximaciones que pueden llegar a distorsionar el resultado final, por ello, sería interesante
disponer de una clase Racionales que disponga de los campos y métodos necesarios para poder
implementar las tareas siguientes:

Sumar valores Racionales.

Restar valores Racionales.

Multiplicar valores Racionales.

Dividir valores Racionales.

Comprobar la igualdad de valores Racionales. Crea el método esIgual, que recibiendo los dos
valores Racionales, devolverá true si son iguales y false en otro caso
Los números racionales serán iguales cuando se cumpla que a x d = b x c

Comparar dos valores racionales.- Crea el método comparaRacional, que recibiendo los dos valores
Racionales, devolverá -1 si el primer valor es menor que el segundo, 0 si son iguales y 1 si el
primer valor es mayor
Codifica la clase Programa que pruebe la clase anterior, para lo cual esta clase dispondrá de un método
principal que le pregunte a un alumno de secundaria por dos fracciones y nos muestre por los resultados
de aplicar las operaciones anteriores.
Ejemplo: Si le mandan sumar dos fracciones, donde la primera fracción es de la forma
numerador 3, denominador 5 y la segunda fuese numerador 4, denominador 5 la salida
por pantalla sería:
Resultado =3/5 + 4/5 = 7/5
Donde resultado, fraccion1, fraccion2 son objetos de la clase Racional
namespace Ejercicio53
{
// ----------------------------------------------------------------------------// Clase Racional, permite operar valores racionales sin pérdida de información
//
// Autor: Joaquin Alvarez
// Fecha: 01/02/2014
// ----------------------------------------------------------------------------class Racional
{
public int numerador, denominador;
public Racional(int n, int d)
{
numerador = n;
denominador = d;
}
// Sobrecarga del operador suma para adaptarlo a la suma de feacciones
public static Racional operator + (Racional x, Racional y)
{
return new Racional(x.numerador * y.denominador + y.numerador * x.denominador,
x.denominador * y.denominador);
}
// Sobrecarga del operador resta para adaptarlo a la diferencia de feacciones
public static Racional operator - (Racional x, Racional y)
{
return new Racional(x.numerador * y.denominador - y.numerador * x.denominador,
x.denominador * y.denominador);
}
// Sobrecarga del operador producto para adaptarlo al producto de feacciones
public static Racional operator * (Racional x, Racional y)
{
return new Racional(x.numerador * y.numerador , x.denominador * y.denominador);
}
// Sobrecarga del operador cociente para adaptarlo al cociente de feacciones
public static Racional operator / (Racional x, Racional y)
{
return new Racional(x.numerador * y.denominador , x.denominador * y.numerador);
}
// Comprobamos la igualdad de dos números racionales
public static bool operator == (Racional x, Racional y)
{
if ((double)x == (double)y) return true;
else return false;
}
// Comprobamos la igualdad de dos números racionales
public static bool operator != (Racional x, Racional y)
{
if ((double)x != (double)y) return true;
else return false;
}
// Comprobamos si el primer numero racional es menor que el segundo
public static bool operator < (Racional x, Racional y)
{
if ((double)x < (double)y) return true;
else return false;
}
// Comprobamos si el primer numero racional es mayor que el segundo
public static bool operator > (Racional x, Racional y)
{
if ((double)x > (double)y) return true;
else return false;
}
// Conversión de la fracción al tipo de dato double
public static explicit operator double(Racional f) //Convierte a double.
{
return (double)f.numerador / f.denominador;
}
// Reemplazar el método ToString para mostrar un número fraccionario por pantalla
// en el formato adecuado:
public override string ToString()
{
return (String.Format("{0} / {1}", numerador, denominador));
}
// Creamos una función esIgual para comparar números racionales
public bool esIgual(Racional x, Racional y)
{
if (x == y) return true;
else return false;
}
// Creamos una función para comparar valores racionales
public int comparaRacional(Racional x, Racional y)
{
if (x == y) return 0;
else
if (x < y) return -1;
else return 1;
}
}
// Clase Programa53: Prueba la clase Racional
class Program53
{
static void Main(string[] args)
{
Racional numero1, numero2, resultado;
int numerador, denominador;
// Preguntamos por el numerador del primer número racional
Console.Write("Introduce el numerador del primer número racional: ");
numerador = Convert.ToInt32(Console.ReadLine());
// Preguntamos por el denominador del primer número racional
Console.Write("Introduce el denominador del primer número racional: ");
denominador = Convert.ToInt32(Console.ReadLine());
// Creamos el número racional
numero1 = new Racional(numerador, denominador);
// Preguntamos por el numerador del segundo número racional
Console.Write("Introduce el numerador del segundo número racional: ");
numerador = Convert.ToInt32(Console.ReadLine());
// Preguntamos por el denominador del segundo número racional
Console.Write("Introduce el denominador del segundo número racional: ");
denominador = Convert.ToInt32(Console.ReadLine());
// Creamos el número racional
numero2 = new Racional(numerador, denominador);
// Realizamos la suma y mostrsamos el resultado
resultado = numero1 + numero2;
Console.WriteLine(resultado);
// Realizamos la resta y mostramos el resultado
resultado = numero1 - numero2;
Console.WriteLine(resultado);
// Realizamos el producto y mostramos el resultado
resultado = numero1 * numero2;
Console.WriteLine(resultado);
// Realizamos el cociente y mostramos el resultado
resultado = numero1 / numero2;
Console.WriteLine(resultado);
// Comprobamos si los números son iguales
if (resultado.esIgual(numero1, numero2)) Console.WriteLine("{0} y {1} son iguales",
numero1, numero2);
else Console.WriteLine("{0} y {1} son distintos", numero1, numero2);
// Comprobamos si el primer número es menor que el segundo
if (resultado.comparaRacional(numero1, numero2) < 0) Console.WriteLine("{0} es menor que
{1}", numero1, numero2);
else Console.WriteLine("{0} es mayor que {1}", numero1, numero2);
}
}
}
54 Crear
una clase llamada “hora” que contenga en su parte privada tres variables enteras
llamadas hh, mm y ss, que representan las horas, los minutos y los segundos.
Dicha clase tendrá además:







Un constructor sin parámetros para la clase de forma que se inicialicen las tres variables privadas
a cero.
Otro constructor con parámetros para poder inicializar una hora con los valores que se quieran al
declarar un objeto. Si cualquiera de estos valores no fueran correctos (0-23 y 0-59), se les
asignará el valor 0 a ese único valor.
Propiedades para una de las variables privadas, comprobando su rango de valores. Si no lo
cumple, asignar un cero
Redefinir el método ToString() de tal forma que para que nos muestre la hora de cualquier objeto
de la clase con el formato hh:mm:ss
Redefinir el operador “+”, de tal forma que se puedan sumar dos objetos hora. El resultado será
otro objeto de tipo hora con los valores correctos (0-23 y 0-59) de las variables privadas. Las
horas que excedan de 24 vuelven a comenzar en cero.
Redefinir el operador “>”, de tal forma que podamos comparar si dos objetos de la clase hora,
devolviéndonos true en el caso que el primero sea mayor que el segundo y false en caso
contrario.
Redefinir el operador “<”, de tal forma que podamos comparar si dos objetos de la clase hora,
devolviéndonos true en el caso que el primero sea menor que el segundo y false en caso
contrario.
Codifica la clase Programa que pruebe la clase anterior.
namespace Programa54
{
// ------------------------------------------------------------------------// Clase Hora. Permite operar los objetos hora a través del polimorfismo
// de los operadores
//
// Autor: Joaquín Álvarez
// Fecha: 01/02/2013
// ------------------------------------------------------------------------class Hora
{
int horas;
int minutos;
int segundos;
// Constructor sin paráemtros. Inicializa la hora
public Hora()
{
horas = minutos = segundos = 0;
}
// Constructor con parámetros. Fija la hora
public Hora(int hora, int minuto, int segundo)
{
// Comprobamos que la hora sea válida
if ((hora > 0) && (hora < 24)) this.horas = hora;
else this.horas = 0;
// Comprobamos que el minuto sea válido
if ((minuto > 0) && (minuto < 60)) this.minutos = minuto;
else this.minutos = 0;
// Comprobamos que el segundo sea válido
if ((segundo > 0) && (segundo < 60)) this.segundos = segundo;
else this.segundos = 0;
}
// Propiedad para asignar y recuperar la hora
public int Horas
{
set { horas = value; }
get { return horas; }
}
// Propiedad para asignar y recuperar el minuto
public int Minutos
{
set { minutos = value; }
get { return minutos; }
}
// Propiedad para asignar y recuperar el segundo
public int Segundos
{
set { segundos = value; }
get { return segundos; }
}
// Modificamos el método ToString para escribir según las necesidades
public override string ToString()
{
return string.Format("{0} : {1} : {2} ",horas, minutos, segundos);
}
// Redefinimos el operador > para poder comparar horas
public static bool operator >(Hora hora1, Hora hora2)
{
int segundos1, segundos2;
segundos1 = hora1.segundos + hora1.minutos * 60 + hora1.horas * 3600;
segundos2 = hora2.segundos + hora2.minutos * 60 + hora2.horas * 3600;
return segundos1>segundos2;
}
// Redefinimos el operador < para poder comparar horas
public static bool operator <(Hora hora1, Hora hora2)
{
int segundos1, segundos2;
segundos1 = hora1.segundos + hora1.minutos * 60 + hora1.horas * 3600;
segundos2 = hora2.segundos + hora2.minutos * 60 + hora2.horas * 3600;
return segundos1 < segundos2;
}
public static Hora operator + (Hora hora1, Hora hora2)
{
Hora resultado = new Hora();
resultado.segundos = hora1.segundos + hora2.segundos;
if (resultado.segundos > 59)
{
resultado.segundos = resultado.segundos - 60;
resultado.minutos = 1;
}
resultado.minutos += hora1.minutos + hora2.minutos;
if (resultado.minutos > 59)
{
resultado.minutos = resultado.minutos - 60;
resultado.horas = 1;
}
resultado.horas += hora1.horas + hora2.horas;
if (resultado.horas > 23) resultado.horas = 0;
return resultado;
}
}
// Clase Programa54: Prueba la clase Hora
class Program54
{
static void Main(string[] args)
{
Hora hora1, hora2;
// Creamos la primera hora meduante el contructor con parámetros
hora1 = new Hora(08, 01, 59);
// Creamos la segunda hora con el constructor por defecto
hora2 = new Hora();
// Asignamos la hora2 utilizando las propiedades
hora2.Horas = 03;
hora2.Minutos = 58;
hora2.Segundos = 59;
// Acumulamos las dos horas
Console.WriteLine(hora1 + hora2);
// Comprobamos qué hora va antes
if (hora1 < hora2) Console.WriteLine("la hora {0} es anterior a la hora {1}", hora1, hora2);
if (hora1 > hora2) Console.WriteLine("la hora {0} es posterior a la hora {1}", hora1, hora2);
}
}
}