Practica 14

_________________________________________________________

Class Punto

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Practica_14

{

class Punto

{

protected int x;

protected int y;

protected int z=0;

public Punto()

{

x = 0;

y = 0;

}

public Punto(int x1, int y1)

{

x = x1;

y = y1;

}

public virtual double Area()

{

return z;

}

public double distancia(Punto A, Punto B)

{

double x = Math.Pow((A.x - B.x), 2);

double y = Math.Pow((A.y - B.y), 2);

double d = Math.Sqrt(x + y);

return d;

}

}

}

___________________________________________________________

Class Circulo

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Practica_14

{

class Circulo:Punto

{

public double radio;

public Circulo(int x1, int y1,double rad):base (x1,y1)

{

radio = rad;

}

public Circulo()

{

x = 0;

y = 0;

radio = 0;

}

public override double Area()

{

return Math.PI*(radio*radio);

}

}

}

__________________________________________________________

Class Program

using System;

using System.Collections.Generic;

using System.Linq;

using System.Text;

namespace Practica_14

{

class Program

{

static void Main(string[] args)

{

int x1, x2, y1, y2;

double rad1, rad2;

Circulo C1;

Circulo C2;

Console.Write("Ingresa la coordenada X del Punto 1: ");

x1 = int.Parse(Console.ReadLine());

Console.Write("Ingresa la coordenada Y del Punto 1: ");

y1 = int.Parse(Console.ReadLine());

Console.Write("\nIngresa la coordenada X del Punto 2: ");

x2 = int.Parse(Console.ReadLine());

Console.Write("Ingresa la coordenada Y del Punto 2: ");

y2 = int.Parse(Console.ReadLine());

Console.Write("\nIngresa el radio para el Circulo 1: ");

rad1=double.Parse(Console.ReadLine());

Console.Write("Ingresa el radio para el Circulo 2: ");

rad2=double.Parse(Console.ReadLine());

C1 = new Circulo(x1,y1,rad1);

C2 = new Circulo (x2,y2,rad2);

Console.WriteLine("El Area del circulo 1 es: {0}", C1.Area());

Console.WriteLine("El Area del circulo 2 es: {0}", C2.Area());

Console.WriteLine("\nLa distacia entre los 2 puntos es: {0}", C1.distancia(C1, C2));

Console.ReadKey();

}

}

}

PracticaTeorica Clases Abstractas

1.- ¿Que es una clase abstracta?

Son clases de las que no es posible crear instancias; frecuentemente,
están implementadas sólo parcialmente o no están implementadas.

2.- Formato General de una clase abstracta

interface I
{
void M();
}
abstract class C: I
{
public abstract void M();
}

3.-Diferencia entre interface y clase abstracta.

Pareciera que son lo mismo, las clases abstractas no se implementa y las interfances tampoco. Pero las interfances son mas un conjunto de comportamientos definidos, que esperan ser implementados por el programador. Las clases abstractas, en primer lugar deben ser heredadas para ser implementadas en su totalidad o parcialmente, las clases abstractas se usan mas para una relacion de " es un ".

4.-Ejemplo de clase abstracta

using System;

namespace ClaseAbstracta {

//clase abstracta
abstract class Persona {

//atributo abstracto
protected string nombre;

public abstract string Nombre {
get;
set;
}

//metodo abstracto
public abstract string Info();
}

//clase Alumno
class Alumno: Persona {
private int grado;
private int nivel;

public override string Nombre {
get {
return nombre;
}
set {
nombre = value;
}
}

//otra propiedad
public int Grado {
get {
return grado;
}
set {
grado = value;
}
}

//otra propiedad
public int Nivel {
get {
return nivel;
}
set {
nivel = value;
}
}

//constructor
public Alumno (string nom, int niv, int grado){
this.nombre = nom;
this.nivel = niv;
this.grado = grado;
}

public override string Info() {
return "Nombre: " + this.nombre + " - Nivel: " +
this.nivel + " - Grado: " + this.grado;
}
}


5.- Ventajas de una clase abstracta y una interface.

Clase abstrácta
* Describen partes de objetos.
* Utilizadas en polimorfismo para definir operaciones comunes.
* Se pueden utilizar junto con la herencia.

Interfaz
* Una de las principales ventajas de utilizar interfaces es el polimorfismo ya que separamos la definicion de los metodos de su implementación.

Practica 13

Class Program:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Herencia
{

class Program
{
static void Main(string[] args)
{
classBase CB = new classBase();
classDerivada CD = new classDerivada();

Console.Write("Ingresa el valor de a: ");
CD.a = int.Parse(Console.ReadLine());
Console.Write("Ingresa el valor de b: ");
CD.b = int.Parse(Console.ReadLine());
Console.Write("Ingresa el valor de c: ");
CD.c = int.Parse(Console.ReadLine());

CD.ImprimirSuma();
CD.Imprimir_Producto();

Console.WriteLine("El dato mayor es: {0}",CD.Mayor());
Console.WriteLine("El dato menor es: {0}", CD.Menor());
CD.Imprimir_Intervalo();
Console.ReadKey();
}
}
}


ClassBase:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Herencia
{
public class classBase
{

public int a;
public int b;

public void Imprimir_ab()
{
Console.WriteLine("a={0}, b={1}", a, b);

}

}
}

ClassDerivada:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Herencia
{
public class classDerivada:classBase
{
public int c;

public void Imprimir_c()
{
Console.WriteLine("c= {0}", c);
}

public void ImprimirSuma()
{
Console.WriteLine("\nLa Suma de {0}+{1}+{2} es: {3}",a,b,c, (a + b + c));
}

public void Imprimir_Producto()
{
Console.WriteLine("El Producto de {0}*{1}*{2} es: {3}",a,b,c, (a * b * c));
}

public int Mayor()
{
if (a > b && a > c)
{


return a;

}
else if (b > a && b > c)
{


return b;

}
else if (c > a && c > b)
{


return c;

}
else
{

return a;
}


}

public int Menor()
{
if (a < b && a < c)
{

return a;
}
else if (b < a && b < c)
{

return b;
}
else if (c < a && c < b)
{

return c;
}
else
return a;
}

public void Imprimir_Intervalo()
{
Console.WriteLine("La diferencia entre {0} y {1} es: {2}",Mayor(),Menor(),(Mayor()-Menor()));
}
}
}

Practica 12

Capturas:

Codigo:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Practica12
{
class Racional
{
int numerador;
int denominador;
public static int i;

public Racional()
{
numerador = 1;
denominador = 1;
i = 0;
}

public Racional(int num, int den)
{
numerador = num;
denominador = den;
}

public void asignarNumerador(int Num)
{
numerador = Num;
}
public int obtenerNumerador ()
{
return numerador;
}

public void asignarDenominador (int Den)
{
denominador=Den;
}

public int obtenrDenominador()
{
return denominador;
}

public int Numerador
{
get { return numerador; }
set { numerador = value; }
}
public int Denominador
{
get { return denominador; }
set {denominador=value;}
}

public static Racional operator + (Racional R1, Racional R2)
{
int D1=R1.Denominador*R2.Denominador;
int N1=R2.Denominador*R1.Numerador +R1.Denominador*R2.Numerador;

for (i = 2; i < 20; i++)
{


while (N1 % i == 0 && D1 % i == 0)
{
D1 = D1 / i;
N1 = N1 / i;
}
}
Racional RT=new Racional (N1,D1);
return RT;
}

public static Racional operator -(Racional R1, Racional R2)
{
int D1 = R1.Denominador * R2.Denominador;
int N1 = R2.Denominador * R1.Numerador - R1.Denominador * R2.Numerador;

for (i = 2; i < 20; i++)
{
while (N1 % i == 0 && D1 % i == 0)
{
D1 = D1 / i;
N1 = N1 / i;
}
}
Racional RT = new Racional(N1, D1);
return RT;
}

public static Racional operator *(Racional R1, Racional R2)
{
int D1 = R1.Denominador * R2.Denominador;
int N1 = R1.Numerador * R2.Numerador;

for (i = 2; i < 20; i++)
{
while (N1 % i == 0 && D1 % i == 0)
{
D1 = D1 /i;
N1 = N1 / i;
}
}
Racional RT = new Racional(N1, D1);
return RT;
}

public static Racional operator /(Racional R1, Racional R2)
{
int D1 = R1.Denominador * R2.Numerador;
int N1 = R1.Numerador * R2.Denominador;

for (i = 2; i < 20; i++)
{
while (N1 % i == 0 && D1 % i == 0)
{
D1 = D1 / i;
N1 = N1 / i ;
}
}
Racional RT = new Racional(N1, D1);
return RT;
}

}
class Program
{
static void Main(string[] args)
{

int num1,num2,den1,den2;

Console.Write("Introduce el numerador de la Fraccion 1:\t");
num1 = int.Parse(Console.ReadLine());
Console.Write("Introduce el denominador de la Fraccion 1:\t");
den1 = int.Parse(Console.ReadLine());

Console.Write("\nIntroduce el numerador de la Fraccion 2:\t");
num2 = int.Parse(Console.ReadLine());
Console.Write("Introduce el denominador de la Fraccion 2:\t");
den2 = int.Parse(Console.ReadLine());

Racional Numero1 = new Racional(num1, den1);
Racional Numero2 = new Racional(num2, den2);
Racional Suma,Resta,Multiplicacion,Division;

Console.WriteLine("\nLa Fraccion 1 es: {0}/{1}", Numero1.Numerador, Numero1.Denominador);
Console.WriteLine("La Fraccion 2 es: {0}/{1}", Numero2.Numerador, Numero2.Denominador);

Suma= Numero1+Numero2;
Resta = Numero1 - Numero2;
Multiplicacion = Numero1 * Numero2;
Division = Numero1 / Numero2;

if (Suma.Denominador == 1 )
{
Console.WriteLine("\n\nLa Suma de las Fracciones es: {0}", Suma.Numerador / Suma.Denominador);

}
else
{
Console.WriteLine("\n\nLa Suma de las Fracciones es: {0}/{1}", Suma.Numerador, Suma.Denominador);
}


if (Resta.Denominador == 1)
{
Console.WriteLine("\nLa Resta de las Fracciones es: {0}", Resta.Numerador / Resta.Denominador);
}
else
{
Console.WriteLine("\nLa Resta de las Fracciones es: {0}/{1}", Resta.Numerador, Resta.Denominador);
}


if (Multiplicacion.Denominador == 1)
{
Console.WriteLine("\nLa Multiplicacion de las Fracciones es: {0}", Multiplicacion.Numerador / Multiplicacion.Denominador);
}
else
{
Console.WriteLine("\nLa Multiplicacion de las Fracciones es: {0}/{1}", Multiplicacion.Numerador, Multiplicacion.Denominador);
}


if (Division.Denominador == 1)
{
Console.WriteLine("\nLa Division de las Fracciones es: {0}", Division.Numerador / Division.Denominador);
}
else
{
Console.WriteLine("\nLa Division de las Fracciones es: {0}/{1}", Division.Numerador, Division.Denominador);
}

Console.ReadKey();
}
}
}

Practica Teorica

1.- ¿Que es la Herencia?

Es una propiedad que permite que los objetos sean creados a partir de otros ya existentes, obteniendo características (métodos y atributos) similares a los ya existentes. Es un mecanismo que nos permite crear clases derivadas a partir de clase base, Nos permite compartir automáticamente métodos y datos entre clases subclases y objetos.
La herencia es uno de los mecanismos de la programación orientada a objetos, por medio del cual una clase se deriva de otra, llamada entonces superclase, de manera que extiende su funcionalidad. Una de sus funciones más importantes es la de proveer Polimorfismo y late binding.

2.- De un ejemplo de Herencia.

Las clases pueden heredar de otra clase. Para conseguir esto, se coloca un signo de dos puntos después del nombre de la clase al declarar la clase y se denomina la clase de la cual se hereda (la clase base) después del signo de dos puntos, del modo siguiente:

public class A
{
public A() { }
}

public class B : A
{
public B() { }
}

3.- ¿Como se clasifica la herencia? Y mencione un ejemplo.

• Herencia simple: Un objeto puede extender las características de otro objeto y de ningún otro, es decir, que solo puede heredar o tomar atributos de un solo padre o de una sola clase.

• Herencia múltiple: Un objeto puede extender las características de uno o más objetos, es decir, puede tener varios padres. En este aspecto hay discrepancias entre los diseñadores de lenguajes. Algunos de ellos han preferido no admitir la herencia múltiple por las posibles coincidencias en nombres de métodos o datos miembros. Por ejemplo C++, Python permiten herencia múltiple, mientras que Java, Ada y C# sólo permiten herencia simple.

4.- Tipos de Acceso a clases derivadas y clase base

Hay determinadas circunstancias en las que cuando redefinamos un determinado método nos interese poder acceder al código de la versión original. Por ejemplo, porque el código redefinido que vayamos a escribir haga lo mismo que el original y además algunas cosas extras. En estos casos se podría pensar que una forma de conseguir esto sería convirtiendo el objeto actual al tipo del método a redefinir y entonces llamar así a ese método, como por ejemplo en el siguiente código:

using System;

class A

{

public virtual void F()

{

Console.WriteLine(“A”);

}

}

class B:A

{

public override void F()

{

Console.WriteLine(“Antes”);

((A) this).F(); // (2)

Console.WriteLine(“Después”);

}

public static void Main()

{

B b = new B();

b.F();

}

}

Pues bien, si ejecutamos el código anterior veremos que la aplicación nunca termina de ejecutarse y está constantemente mostrando el mensaje Antes por pantalla. Esto se debe a que debido al polimorfismo se ha entrado en un bucle infinito: aunque usemos el operador de conversión para tratar el objeto como si fuese de tipo A, su verdadero tipo sigue siendo B, por lo que la versión de F() a la que se llamará en (2) es a la de B de nuevo, que volverá a llamarse así misma una y otra vez de manera indefinida.

Para solucionar esto, los diseñadores de C# han incluido una palabra reservada llamada base que devuelve una referencia al objeto actual semejante a this pero con la peculiaridad de que los accesos a ella son tratados como si el verdadero tipo fuese el de su clase base. Usando base, podríamos reemplazar el código de la redefinición de F() de ejemplo anterior por:

public override void F()

{

Console.WriteLine(“Antes”);

base.F();

Console.WriteLine(“Después”);

}

Si ahora ejecutamos el programa veremos que ahora sí que la versión de F() en B llama a la versión de F() en A, resultando la siguiente salida por pantalla:

Antes

A

Después

A la hora de redefinir métodos abstractos hay que tener cuidado con una cosa: desde el método redefinidor no es posible usar base para hacer referencia a métodos abstractos de la clase padre, aunque sí para hacer referencia a los no abstractos. Por ejemplo:

abstract class A

{
public abstract void F();

public void G()

{}
}

class B: A

{
public override void F()

{

base.G(); // Correcto

base.F(); // Error, base.F() es abstracto

}
}

Practica 11

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Practica11
{
class Program
{
static void Main(string[] args)
{
Empleado[] Compania = new Empleado[20];
Empleado E1;
int No, HorasT,Opcion,Num2,i,menu;
int[] Numeros = new int[20];
float PagoH;
No = Num2 =i= menu=0;


do
{
Console.Clear();
Console.WriteLine("\t\tM e n u");
Console.WriteLine("\nSelecciona una opcion");
Console.WriteLine("\n1) Introducir un nuevo empleado");
Console.WriteLine("2) Modificar los datos de un empleado");
Console.WriteLine("3) Eliminar un empleado");
Console.WriteLine("4) Desplegar los datos de un empleado");
Console.WriteLine("5) Desplegar toda la informacion de los empleados");
Console.Write("Opcion: ");
Opcion = int.Parse(Console.ReadLine());

switch (Opcion)
{
case 1:
{

Console.Clear();
NumeroEmp:
Console.Write("Introduce el numero de empleado: ");
Numeros[i] = No;
No = int.Parse(Console.ReadLine());
if (No <> 20)
{
Console.WriteLine("Numero incorrecto, debe estar entre 1 a 20");
goto NumeroEmp;
}
for (int j = 0; j < 20; j++)
{
Num2 = Numeros[j];
if (No == Num2)
{
Console.WriteLine("El Numero de Empleado Ya Existe!!, captura otro\n");
goto NumeroEmp;
}
}
Console.Write("Introduce su Pago por hora: ");
PagoH = float.Parse(Console.ReadLine());
Console.Write("Introduce las horas trabajadas: ");
HorasT = int.Parse(Console.ReadLine());
E1 = new Empleado(No, PagoH, HorasT);
Compania[No - 1] = E1;
i++;

Console.WriteLine("\nLos datos de empleado han sido agregados");
Console.WriteLine("\nPresione una tecla para regresar al menu...");
Console.ReadKey();


break;

}
case 2:
{
Console.Clear();
NumeroEmp:
Console.Write("\nIntroduce el No. de empleado a modificar: ");
No = int.Parse(Console.ReadLine());
if (No <> 20)
{
Console.WriteLine("Numero incorrecto, debe estar entre 1 a 20");
goto NumeroEmp;
}


if (Compania[No - 1] != null)
{

Console.Write("\nIntroduce su Pago por hora: ");
PagoH = float.Parse(Console.ReadLine());
Compania[No - 1].AsignarPagoHora(PagoH);
Console.Write("Introduce las horas trabajadas: ");
HorasT = int.Parse(Console.ReadLine());
Compania[No - 1].AsignarHorasTrabajadas(HorasT);
Console.WriteLine("Los Datos de empleado se han modificado correctamente");
Console.WriteLine("\nPresione una tecla para regresar al menu...");
Console.ReadKey();



}
else
{
Console.WriteLine("EL numero de empleado no existe, intente otra ves");
goto NumeroEmp;
}

break;
}

case 3:
{
Console.Clear();
NumeroEmp:
Console.Write("Introduce el No. de Empleado a eliminar: ");
No = int.Parse(Console.ReadLine());
if (No <> 20)
{
Console.WriteLine("Numero incorrecto, debe estar entre 1 a 20");
goto NumeroEmp;
}


if (Compania[No - 1] != null)
{

Compania[No - 1] = null;
Console.Write("El empleado {0} ha sido borrado",No);
Console.WriteLine("\nPresione una tecla para regresar al menu...");
Console.ReadKey();


}
else
{
Console.WriteLine("EL numero de empleado no existe, intente otra ves");
goto NumeroEmp;
}
break;
}

case 4:
{
Console.Clear();
NumeroEmp:
Console.Write("\nIntroduce el No. de Empleado: ");
No = int.Parse(Console.ReadLine());
if (No <> 20)
{
Console.WriteLine("Numero incorrecto, debe estar entre 1 a 20");
goto NumeroEmp;
}


if (Compania[No - 1] != null)
{

Console.WriteLine("\nLos datos del empleado {0} son:", No);
Console.WriteLine("\nPago por Hora "+"Horas Trabajadas\n");
Console.WriteLine(" {0} {1} ",Compania[No-1].ObtenerPagoHora(),Compania[No - 1].ObtenerHorasTrabajadas());

Console.WriteLine("\n\nPresione una tecla para regresar al menu...");
Console.ReadKey();


}
else
{
Console.WriteLine("EL numero de empleado no existe, intente otra ves");
goto NumeroEmp;
}
break;
}

case 5:
{
Console.Clear();
Console.WriteLine("\t*****INFORMACION DE TODOS LOS EMPLEADOS*****");
Console.WriteLine("\n\nNo. Empleado "+" Pago por Hora " + "Horas Trabajadas\n");
for (i = 0; i < 20; i++)
{
if (Compania[i] != null)
{
Console.WriteLine(" {0} {1} {2} ",Compania[i].ObtenerNoEmp(), Compania[i].ObtenerPagoHora(), Compania[i].ObtenerHorasTrabajadas());

}

}
Console.WriteLine("\nPresione una tecla para regresar al menu...");
Console.ReadKey();

break;
}

default:
{
Console.Clear();
Console.WriteLine("Opcion Invalida!!, presiona una tecla para regresar al menu...");
Console.ReadKey();

break;
}

}
}
while (menu==0);


}
}
}

Class Empleado:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Practica11
{
class Empleado
{
int NoEmp;
float PagoHora;
int HorasTrabajadas;

public Empleado(int Num, float Pago, int Horas)
{
NoEmp = Num;
PagoHora = Pago;
HorasTrabajadas = Horas;
}
public Empleado()
{
NoEmp = 0;
PagoHora = 0.0f;
HorasTrabajadas = 0;
}

public void AsignarNoEmp(int Numero)
{
NoEmp = Numero;
}
public void AsignarPagoHora(float P)
{
PagoHora = P;
}
public void AsignarHorasTrabajadas(int Hr)
{
HorasTrabajadas = Hr;
}


public int ObtenerNoEmp()
{
return NoEmp;
}
public float ObtenerPagoHora()
{
return PagoHora;
}
public int ObtenerHorasTrabajadas()
{
return HorasTrabajadas;
}
~Empleado()
{
}
}
}

Practica 10

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Practica10_CuentaAhorros
{
class Program
{
static void Main(string[] args)
{
int N, i;
double saldo,interes,tasa;
CuentaAhorros[] Clientes;

Console.Write("Introduce la cantidad de Clientes: ");
N = int.Parse(Console.ReadLine());
Clientes = new CuentaAhorros[N];
CuentaAhorros C1 = new CuentaAhorros();

for (i = 0; i < N; i++)
{
Console.Write("Introduce el saldo del ahorrador {0}: ", i + 1);
saldo = double.Parse(Console.ReadLine());
C1.ultimoInteresMensual();
interes = C1.Interes_Mensual;
C1 = new CuentaAhorros(saldo,interes);
Clientes[i] = C1;
}
for (i = 0; i < N; i++)
{
Clientes[i].ultimoInteresMensual();
Console.WriteLine("El nuevo saldo {0} es: {1}",i+1,Clientes[i].Saldo_ahorro );
}

Console.WriteLine("\nLa tasa interes subio a 4%");
//tasa = double.Parse(Console.ReadLine());
CuentaAhorros.ModificatasaInteres(0.04);

for (i = 0; i < N; i++)
{
Clientes[i].ultimoInteresMensual();
Console.WriteLine("El nuevo saldo {0} es: {1}", i + 1, Clientes[i].Saldo_ahorro);
}
Console.ReadLine();
}
}
}

Class CuentaAhorros:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Practica10_CuentaAhorros
{
class CuentaAhorros
{
double saldoAhorro,interesMensual;
public static double tasaInteresAnual=0.03;

public CuentaAhorros()
{
saldoAhorro = 0;
interesMensual = 0;
}
public CuentaAhorros(double saldo,double interes)
{
saldoAhorro = saldo;
interesMensual = interes;

}

public static void ModificatasaInteres(double NuevoValor)
{
tasaInteresAnual = NuevoValor;
}

public void ultimoInteresMensual()
{
interesMensual = (saldoAhorro * tasaInteresAnual) / 12;
saldoAhorro = saldoAhorro + interesMensual;
}

public double Saldo_ahorro
{
get { return saldoAhorro; }
set { saldoAhorro = value; }
}
public double Interes_Mensual
{
get { return interesMensual; }


}
}
}