1. Nombre del Alumno: Jesús Guadalupe Trujillo Ramírez
Francisco Javier Nuriulu Suchiapa
Hugo Andrés López López
Gustavo Hernández Naturi
Rey David Cueto Vázquez
Nombre del Profesor: Mtro. Alejandro Vázquez Rodríguez
Materia: Programación de Aplicaciones
Cuatrimestre: 7°
Grupo: “D”
Carrera: TICSI
Tema: Tipos de métodos

2. Contenido
Polimorfismo:..................................................................................................................................... 1
Un Método Abstracto:...................................................................................................................... 1
Interfaces:.......................................................................................................................................... 1
PRACTICAS...................................................................................................................................... 2
Practica1: IdAnimal_Felino. ........................................................................................................ 2
Practica: IdVehiculo_Carreras.................................................................................................... 4
Practica3: IdHbitad_Desierto_Selva.......................................................................................... 7
PRACTICA ABSTRACTA ALUMNO_PROFESOR................................................................. 8
CONCLUSION................................................................................................................................ 16

3. 1
Polimorfismo:
Esta propiedad, como su mismo nombre nos dice, son múltiples formas, que se
refiere a la posibilidad de acceder a varios tipos de rango de funciones distintas a
través de la misma interfaz. Es también conocido como „Sobrecarga de
parámetros‟ ya que las características de los objetos permiten aceptar distintos
parámetros para un mismo método (diferentes implementaciones) generalmente
con comportamientos distintos e independientes para cada una de ellas. En la
práctica veremos a un mismo identificador que puede tener: (distintas formas,
distintos cuerpos de función, distintos comportamientos) dependiendo, en general,
del contexto en el que se encuentre.
Un Método Abstracto:
Es un método que nunca va a ser ejecutado porque no tiene cuerpo (sin
corchetes, y seguido por un punto y coma). Simplemente, un método abstracto
referencia a otros métodos de las subclases, es decir que solo escribimos su
nombre, parámetros y tipos devuelto pero no su código. Podemos ver un método
abstracto como una palanca que fuerza dos cosas: la primera, que no se puedan
crear objetos de una clase. La segunda, que todas las subclases sobreescriban el
método declarado como abstracto.
Interfaces:
Una interfaz define una serie de métodos que deben implementarse en una clase.
Es decir, que es una colección de métodos sin cuerpo, que contiene únicamente lo
que se denomina signatura del método. Es más, una interfaz puede verse como
una forma especial de definir clases abstractas que tan sólo contengan miembros
abstractos. Las interfaces se utilizan para indicar el comportamiento que tendrá
una clase, o al menos qué miembros debe definir esa clase.

4. 2
PRACTICAS
Practica1: IdAnimal_Felino.
En esta práctica podemos observar el concepto de Herencia que es el
Comportamiento de la Clase Padre que en este caso es IdAnimal como de la
Clase Hija que es Felino.
Observamos que se crearon las dos Clases La Clase padre que hereda a la Clase
Hija.
En la siguiente figura mostramos el programa en ejecución los datos que se piden
y los datos ingresados y el resultado y presionar ENTER para poder salir del
programa.
CODIGO DE LA CLASE ANIMAL
namespace Pract1Animal_Felino
{
class IdAnimal
{
private String Nombre;
private String Raza;

5. 3
protected Double Peso;
public void PedirDatosAnimales()
{
Console.WriteLine("nnIngrese el nombre del animal: ");
Nombre = Console.ReadLine();
Console.WriteLine("nnIngrese la raza del animal: ");
Raza = Console.ReadLine();
Console.WriteLine("nnIngrese el peso del animal: ");
Peso = Double.Parse(Console.ReadLine());
}
public void VisualizarDatosAnimales()
{
Console.WriteLine("nnLos datos que ingreso son los
siguientes:");
Console.WriteLine();
Console.WriteLine("nNoombre: " + Nombre);
Console.WriteLine("nRaza: " + Raza);
Console.WriteLine("nPeso: " + Peso);
}
}
}
CODIGO DE LA CLASE FALINO
namespace Pract1Animal_Felino
{
class Felino : IdAnimal
{
private Double KiloCaloriasDiarias;
private Double KiloCaloriasComida;
private String TipoComida;
public void PedirDatosComida()
{
Console.WriteLine("nnIngrese el tipo de comida que consume:
");
TipoComida = Console.ReadLine();
Console.WriteLine("nncuantas calorias consume en cada
comida");
KiloCaloriasComida = Double.Parse(Console.ReadLine());
}
public void VisualizarComida()
{
Console.WriteLine();
Console.WriteLine("nTipo de comida: " + TipoComida);
Console.WriteLine("nKilo Calorias por comida: " +
KiloCaloriasComida);
}
public void CalcularCaloriasDiariaComida()
{
KiloCaloriasDiarias = KiloCaloriasComida * base.Peso;

6. 4
Console.WriteLine("nKilo Calorias Diarias: " +
KiloCaloriasDiarias);
Console.WriteLine("nPRESIONE ENTER PARA SALIR DEL
PROGRAMA!!!!");
Console.ReadKey();
}
}
}
CODIGO DE LA CLASE PRINCIPAL
namespace Pract1Animal_Felino
{
class Program
{
static void Main(string[] args)
{
Felino objFelino = new Felino();
objFelino.PedirDatosAnimales();
objFelino.PedirDatosComida();
objFelino.VisualizarDatosAnimales();
objFelino.VisualizarComida();
objFelino.CalcularCaloriasDiariaComida();
}
}
}
Practica: IdVehiculo_Carreras.
En esta practica tambien observamos el concepto de herencia donde la clase
padre es idVehiculo que hereada a la clase hija que es Carreras.
En esta imgen les mostramo los resultados del programa una ves insertado los
datos pedidos y dando clic en ENTER salimos del programa.

7. 5
CODIGO DE LA CLASE VEHICULO
namespace Pract2IdVehiculo_Carreras
{
class IdVehiculo
{
private String Marca;
private String Modelo;
protected Double Precio;
private String Fabricante;
public void PedirDatosVehiculo()
{
Console.WriteLine("nnIngrese la marca del vehiculo:");
Marca = Console.ReadLine();
Console.WriteLine("nnIngrese la Modelo del vehiculo:");
Modelo = Console.ReadLine();
Console.WriteLine("nnIngrese el precio del vehiculo:");
Precio = Double.Parse(Console.ReadLine());
Console.WriteLine("nnIngrese el fabricante del vehiculo:");
Fabricante = Console.ReadLine();
}
public void VisualizarDatosVehiculo()
{
Console.WriteLine("nnnnLos datos que ingreso son los
siguientes:");
Console.WriteLine();
Console.WriteLine("nMarca: " + Marca);
Console.WriteLine("nModelo: " + Modelo);
Console.WriteLine("nFabricante: " + Fabricante);
Console.WriteLine("nPrecio: " + Precio);
}
}
}

8. 6
CODIGO DE LA CLASE CARRERAS
namespace Pract2IdVehiculo_Carreras
{
class Carreras : IdVehiculo
{
private Double CostoDevaluacion;
private int AnhoCompra;
public void CalcularDevaluacion()
{
CostoDevaluacion = Precio * AnhoCompra * 2.15;
}
public void VisualizarDatosDevaluacion()
{
Console.WriteLine("nnAño de Compra: " + AnhoCompra);
Console.WriteLine("nnCosto de Devaluacion: " +
CostoDevaluacion);
Console.WriteLine("nnnnPRESIONE UNA TECLA PARA SALIR DEL
PROGRAMA!!!!");
Console.ReadKey();
}
public void PedirAnhoCompra()
{
Console.WriteLine("nnIngrese el año de Compra del
vehiculo");
AnhoCompra = int.Parse(Console.ReadLine());
}
}
}
CODIGO DE LA CLASE PRINCIPAL
namespace Pract2IdVehiculo_Carreras
{
class Program
{
static void Main(string[] args)
{
Carreras objCarreras = new Carreras();
objCarreras.PedirDatosVehiculo();
objCarreras.PedirAnhoCompra();
objCarreras.CalcularDevaluacion();
objCarreras.VisualizarDatosVehiculo();
objCarreras.VisualizarDatosDevaluacion();
}
}
}

9. 7
Practica3: IdHbitad_Desierto_Selva
En esta pantalla les mostramos los datos que por ley ya estaba dados antes de la
ejecución, un ejemplo más donde asemos referencia a la herencia de la clase
padre que hereda sus atributos a la clase hija.
Código de la clase IdHavitad
namespace Pract4IdHavitad_Selva_Desierto
{
class IdHabitad
{
int NumHab;
String Tipo;
public void NumHabitantes(int num)
{
NumHab = num;
}
public void Caracteristicas(String tipo)
{
Tipo = tipo;
}
public void Imprimir()
{
Console.WriteLine("nnNumero de habitantes: " + NumHab);
Console.WriteLine("nnEste habitad es de tipo: " + Tipo);
}
}
}

10. 8
Código de la clase Desierto
namespace Pract4IdHavitad_Selva_Desierto
{
class Desierto : IdHabitad
{
public void Visualizar()
{
Console.WriteLine("nnClase Desierto");
base.NumHabitantes(500);
base.Caracteristicas("Desierto");
base.Imprimir();
}
}
}
Código de la clase Selva
namespace Pract4IdHavitad_Selva_Desierto
{
class Selva: IdHabitad
{
}
}
PRACTICA ABSTRACTA ALUMNO_PROFESOR
En esta práctica creamos tres Clases Persona, Alumno y Profesor donde persona
hereda a las otras dos clases, estas las realizamos en un formulario donde
mostraremos las actividades que se realizaran, El formulario queda de la siguiente
manera.

11. 9
CODICO DE LA CLASE PERSONA
namespace Practica_Abstracta
{
abstract class Persona
{
protected string nombre;
public abstract String Nombre
{
get;
set;
}
public abstract string Info();
}
}
CODICO DE LA CLASE PROFESOR
namespace Practica_Abstracta
{
class Profesor : Persona
{
protected string especialidad;

12. 10
public override String Nombre
{
get
{
return nombre;
}
set
{
nombre = value;
}
}
//
public string Especialidad
{
get
{
return especialidad;
}
set
{
especialidad = value;
}
}
public Profesor(string nom, string especialidad)
{
this.nombre = nom;
this.especialidad = especialidad;
}
public override string Info()
{
return "Nombre: " + this.nombre + " - Especialidad: " +
this.especialidad;
}
}
}
CODIGO DE LA CLASE ALUMNO
namespace Practica_Abstracta
{
class Alumno : Persona
{
private int grado;
private int nivel;
public override string Nombre
{
get
{
return nombre;
}
set
{
nombre = value;
}

13. 11
}
public int Grado
{
get
{
return grado;
}
set
{
grado = value;
}
}
public int Nivel
{
get
{
return nivel;
}
set
{
nivel = value;
}
}
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;
}
}
}
ESTE ES EL CODIGO DEL FORMULARIO
namespace Practica_Abstracta
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
Persona miObjPersona;
private void btnRegistrar_Click(object sender, EventArgs e)
{
if (this.rdoAlumno.Checked == true)
{

14. 12
string nom = txtANombre.Text;
int niv = cboANivel.SelectedIndex + 1;
int gra = cboAGrado.SelectedIndex + 1;
miObjPersona = new Alumno(nom, niv, gra);
txtInformacion.AppendText(miObjPersona.Info() +
System.Environment.NewLine);
}
else
{
string nom = txtPNombre.Text;
string esp = txtPEsp.Text;
miObjPersona = new Profesor(nom, esp);
txtInformacion.AppendText(miObjPersona.Info() +
System.Environment.NewLine);
cboANivel.Text = "";
cboAGrado.Text = "";
}
}
private void rdoProfesor_CheckedChanged(object sender, EventArgs e)
{
if (this.rdoProfesor.Checked == true)
{
pneAlumno.Visible = !(pneProfesor.Visible == true);
}
else
{
pneAlumno.Visible = !(pneProfesor.Visible == false);
}
}
private void rdoAlumno_CheckedChanged_1(object sender, EventArgs e)
{
if (this.rdoAlumno.Checked == true)
{
pneProfesor.Visible = !(pneAlumno.Visible == true);
}
else
{
pneProfesor.Visible = !(pneAlumno.Visible == false);
}
}
}
}
En esta imagen mostramos el serulatado al ejecutar el programa cuando se
encuentra activado la obcion Alumno para poder registrarlo, insertar los datos de
dicho del Alumno y damos click en registrar y se muestra de la siguiente manera.

15. 13
Si el usuario desea registrar a un Profesor devemos activar la obcion Profesor y
llenar los datos como se muestra acontinuacion en la imagen al ejecutarse el
programa.

16. 14
ESTA ES LA PRACTICA DE EMPLEADO
En esta imagen mostramos los datos del empleado que an sido guardados al
mismo tiempo manda un mesaje diciendo “Listo has Guardado tus Datos”
automaticamente cuando el programa se esta ejeutando.
En esta otra imagen les mostramos que al dar click en el boton Cancelar quedan
cancelados todos los datos, los campos que estavan llenos quedan en Limpio.
Codigo de la Clase IdEmpleado
namespace Practica_Empleado
{
class IdEmpleado
{
public string nombre;
public int edad;
public string Rfc;
}
}

17. 15
Codigo de la Clase Empleado_Asalariado
namespace Practica_Empleado
{
class Empleado_Asalariado : IdEmpleado
{
public int DatoEmpleado(string nom, int ed, string rfc)
{
nombre = nom;
edad = ed;
Rfc = rfc;
return 1;
}
}
}
Codigo de la Clase Principal
namespace Practica_Empleado
{
public partial class Form1 : Form
{
public Form1()
{
InitializeComponent();
}
public void Limpiar()
{
txtNombre.Text = "";
txtEdad.Text = "";
txtRFC.Text = "";
}
private void buttonGuardar_Click(object sender, EventArgs e)
{
Empleado_Asalariado miEA = new Empleado_Asalariado();
int r = miEA.DatoEmpleado(txtNombre.Text,
Convert.ToInt32(txtEdad.Text), txtRFC.Text);
if (r == 1)
{
MessageBox.Show("Listo has Guardado tus datos");
}
else
{
MessageBox.Show("Lo siento NO se pudo Guardar tus
datos");
}
}
private void buttonCancelar_Click(object sender, EventArgs e)
{
Limpiar();
}
}
}

18. 16
CONCLUSION
Francisco Javier Nuriulu Suchiapa
Con las creaciones de estas prácticas nos pudimos dar cuenta como una Clase
Padre puede Heredar todas sus características a la Clase Hija. Con esto nos
quedaron más claro los conceptos o significados de Polimorfismo y un Método
Abstracto. Con la realización de estos ejercicios nos dimos cuenta cómo funciona
cada uno de ellos ya que los pusimos en práctica.
Durante el trabajo desarrollado se dio a conocer los conceptos de polimorfismo,
métodos abstractos e interfaces con estas definiciones se dieron a conocer la
funcionalidad de cada uno de ellos y así se aplicaron en las prácticas que se
desarrollarlo, durante la investigación nos dimos cuenta de que es muy importante
tomar en cuenta la funcionalidad de cada código a utilizar este permite tener un
código más ordenado y comprensible.
Jesús Guadalupe Trujillo Ramírez
Después de esta investigación, nos queda claro que la herencia, el polimorfismo y
la reflexión son tipos de relaciones que surgieron con gran fuerza con la aparición
de los lenguajes de programación por objetos. También concluimos que los tres
están relacionados de cierta forma, y se pueden utilizar a la vez en una misma
clase.
Creemos que es muy importante en la programación estos tipos de relaciones, y
que realmente contribuyen a la práctica y eficiente programación, y que con su
nivel de abstracción contribuyen sobre todo al buen entendimiento del código, ya
que son relaciones que las personas vemos de forma natural. El único secreto que
existe en cuanto a estas ellas es la cantidad de usos que pueden dársele si se
comprenden bien los conceptos, y se saben utilizar bien estas herramientas.
Finalmente, creemos que es importante conocer lo que se puede lograr con las
características de cada lenguaje, como en el caso de los RTTI en C++, que hacen

19. 17
posible una implementación de algunas características de la reflexión, sin tener las
herramientas que se dan en java para obtener ésta misma.