2 Metodología de la programación

orientada a objetos.
Ingeniería Mecatrónica
M. en C. Omar Pérez Romero
 Objetivo:
Objetivo: El alumno descubrirá los fundamentos del paradigma de programación orientado a
objetos.
Contenido:
2.1 Clases y objetos. Constructores, atributos y métodos.
2.2 Encapsulación, herencia y polimorfismo.
2.3 Sobrecarga de funciones.
2.4 Sobrecarga de operadores.
2.5 Manejo de errores y de excepciones.
2.6 Arreglos y colecciones.
2.7 Implementación de interfaces.
2.8 Manejadores de eventos.
2.9 Construcción de bibliotecas y reutilización de código.
2.10 Almacenamiento, actualización y eliminación de información en base a estructuras.
2.11 Manejo de archivos (escritura, lectura, acceso secuencial, acceso aleatorio).
 2.1 Clases y objetos. Constructores, atributos y métodos.
Clase es un conjunto de elementos que tienen unas características comunes, es decir, que son del mismo tipo. El concepto de clase es un
concepto abstracto.
Describe el comportamiento de un objeto mediante las propiedades y los métodos
Un Objeto en cambio será la concreción de uno de los elementos de una Clase, que permitirá almacenar tanto los atributos como las
posibles acciones que realizará.
Es una estructura de datos que tiene asignadas propiedades y que puede generar eventos y métodos. Un objeto es una instancia de una
clase, es decir, un caso concreto de una clase.
Un evento es una acción desencadenada por un objeto.
Los métodos: Son las acciones que los objetos de la clase pueden realizar.

Una propiedad es un atributo o una característica de un objeto.

Almacenan información sobre el estado del objeto.
Los conjuntos de valores de cada una de las propiedades de un objeto definen el estado de dicho objeto.
 Practica 1

Un banco tiene 3 clientes que pueden hacer depósitos y extracciones. También el banco requiere que al final del día
calcule la cantidad de dinero que hay depositada.

Paso 1 Abstracción: Modelar cuantas clases, cuantos objetos de clase, atributos y métodos de estos.

Clase atributos métodos

Cliente nombre constructor
monto Depositar
Extraer
RetornarMonto

Banco 3 Cliente (3 objetos de la constructor

clase Cliente) Operar
DepositosTotales
Paso 2 : Inicie Visual Studio 2022.
Paso 3 : ¿Qué quiere hacer?>Tareas iniciales>Crear un proyecto.
Paso 4 : Crear un proyecto>Aplicación de consola>C#>>Windows>>Consola
Paso 5 : Configure su nuevo proyecto>Aplicación de consola>Nombre del proyecto:Practica1,Ubicación
Paso 6 : Información adicional>Framework>Crear
Paso 7 : En Program.cs codificar esto:
Solución en C# class Banco
{
using System; private Cliente cliente1, cliente2, cliente3;
using System.Collections.Generic;
using System.Linq;
public Banco()
using System.Text;
{
cliente1 = new Cliente("Yhonas");
namespace EjerciciosconClases cliente2 = new Cliente("Ana");
{ cliente3 = new Cliente("Pedro");
class Cliente }
{
private string nombre;
public void Operar()
private int monto;
{
cliente1.Depositar(100);
public Cliente(string nom) cliente2.Depositar(150);
{ cliente3.Depositar(200);
nombre = nom; cliente3.Extraer(150);
monto = 0; }
}
public void DepositosTotales()
public void Depositar(int m) {
{ int t = cliente1.RetornarMonto() +
monto = monto + m; cliente2.RetornarMonto() +
} cliente3.RetornarMonto();
Console.WriteLine("El total de dinero en el banco es:" +
public void Extraer(int m) t);
{ cliente1.Imprimir();
monto = monto - m; cliente2.Imprimir();
} cliente3.Imprimir();
}
public int RetornarMonto()
{ static void Main(string[] args)
return monto; {
} Banco banco1 = new Banco();
banco1.Operar();
public void Imprimir() banco1.DepositosTotales();
{ Console.ReadKey();
Console.WriteLine(nombre + " tiene depositado la suma de " + monto); }
} }
} }
Al ejecutar el código muestra el siguiente resultado
 Practica 2

Plantear un programa que permita jugar a los dados. Las reglas de juego son: se tiran tres dados si los tres salen con el
mismo valor mostrar un mensaje que "gano", sino "perdió".

Paso 1 Abstracción: Modelar cuantas clases, cuantos objetos de clase, atributos y métodos de estos.

Clase atributos métodos

Dado valor constructor
Tirar
Imprimir
RetornarValo

JuegoDeDados 3 Dado (3 objetos de la constructor

clase Dado) Jugar
Paso 2 : Inicie Visual Studio 2022.
Paso 3 : ¿Qué quiere hacer?>Tareas iniciales>Crear un proyecto.
Paso 4 : Crear un proyecto>Aplicación de consola>C#>>Windows>>Consola
Paso 5 : Configure su nuevo proyecto>Aplicación de consola>Nombre del proyecto:Practica1,Ubicación
Paso 6 : Información adicional>Framework>Crear
Paso 7 : En Program.cs codificar esto:
 class JuegoDeDados
using System; {
using System.Collections.Generic; private Dado dado1, dado2, dado3;
using System.Linq;
using System.Text; public JuegoDeDados()
{
namespace EjerciciosconClases dado1 = new Dado();
{ dado2 = new Dado();
class Dado dado3 = new Dado();
{ }
private int valor;
private static Random aleatorio; public void Jugar()
{
public Dado() dado1.Tirar();
{ dado1.Imprimir();
aleatorio = new Random(); dado2.Tirar();
} dado2.Imprimir();
dado3.Tirar();
public void Tirar() dado3.Imprimir();
{ if (dado1.RetornarValor() == dado2.RetornarValor() &&
valor = aleatorio.Next(1, 7); dado1.RetornarValor() == dado3.RetornarValor())
} {
Console.WriteLine("Ganó");
}
public void Imprimir() else
{ {
Console.WriteLine("El valor del dado es:" + valor); Console.WriteLine("Perdió");
} }
Console.ReadKey();
public int RetornarValor() }
{
return valor; static void Main(string[] args)
} {
} JuegoDeDados j = new JuegoDeDados();
j.Jugar();
}
}
}
Al ejecutar el código muestra el siguiente resultado
Ejercicios: //Método ImprimirPerimetro()
public void ImprimirPerimetro()
1.-Desarrollar un programa que tenga una clase que {
represente un Cuadrado y tenga los siguientes métodos: int perimetro;
ingresar valor a su lado, imprimir su perímetro y su perimetro = lado * 4;
superficie. Console.WriteLine("El perímetro es:" + perimetro);
}
//Método ImprimirSuperficie()
using System; public void ImprimirSuperficie()
using System.Collections.Generic; {
using System.Linq; int superficie;
using System.Text; superficie = lado * lado;
Console.WriteLine("La superficie es:" + superficie);
namespace PruebaClase }
{ //Main() principal del programa
class Cuadrado static void Main(string[] args)
{ {
Cuadrado cuadrado1 = new Cuadrado();
private int lado;
cuadrado1.Inicializar(); //Llamando al método Inicializar();
//método Inicializar() cuadrado1.ImprimirPerimetro(); //Llamando al método ImprimirPerimetro();
public void Inicializar() cuadrado1.ImprimirSuperficie(); //Llamando al método ImprimirSuperficie();
{ Console.ReadKey();
Console.Write("Ingrese valor del lado:"); }
}
string linea; }
linea = Console.ReadLine();
Al ejecutar el código muestra el siguiente resultado
lado = int.Parse(linea);
}
Ejercicios: //Método Restar()
public void Restar()
2.-Implementar la clase operaciones. Se deben ingresar {
los dos valores enteros, calcular su suma, resta, int resta;
resta = valor1 - valor2;
multiplicación y división, cada una en un método, e Console.WriteLine("La resta es:" + resta);
imprimir dichos resultados.. }
using System; // Método Multiplicar()
using System.Collections.Generic; public void Multiplicar()
using System.Linq; {
using System.Text; int multiplicacion;
namespace PruebaClase multiplicacion = valor1 * valor2;
{ Console.WriteLine("La multiplicación es:" + multiplicacion);
class Operaciones }
{ //Método Dividir()
private int valor1, valor2; public void Dividir()
// Método Inicializar() {
public void Inicializar() int division;
{ division = valor1 / valor2;
string linea; Console.WriteLine("La división es:" + division);
Console.Write("Ingrese primer numero:"); }
linea = Console.ReadLine(); // Main() principal del programa
valor1 = int.Parse(linea); static void Main(string[] args)
Console.Write("Ingrese segundo numero:"); {
linea = Console.ReadLine(); Operaciones operacion1 = new Operaciones();
valor2 = int.Parse(linea); operacion1.Inicializar(); // Llamando al método Inicializar();
} operacion1.Sumar(); // Llamando al método Sumar();
// Método Sumar() operacion1.Restar(); // Llamando al método Restar();
public void Sumar() operacion1.Multiplicar(); // Llamando al método Multiplicar();
{ operacion1.Dividir(); // Llamando al método Dividir();
int suma; Console.ReadKey();
suma = valor1 + valor2; }
Console.WriteLine("La suma es:" + suma); }
} } Al ejecutar el código muestra el siguiente resultado
2.2 Encapsulación, herencia y polimorfismo.

Al ejecutar el código muestra el siguiente resultado

Encapsulación
Encapsulación
 Encapsulación
Acceso privado.
Un miembro de una clase declarado privado con el modificador de acceso 'private' puede ser accedido por
un objeto de esa clase sólo desde los métodos y propiedades de dicha clase. Esto significa que no puede
ser accedido desde los métodos y propiedades de cualquier otra clase, incluidas las subclases.

public class Program

{
public static void Main()
{
CircleClass circleClass = new CircleClass();
double r = circleClass.radio; // Error: miembro privado de
la clase 'CircleClass'.
}
public class CircleClass
{
private double radio;
}
}
 Encapsulación
Acceso privado.
Un miembro de una clase declarado privado con el modificador de acceso 'private' puede ser accedido por
un objeto de esa clase sólo desde los métodos y propiedades de dicha clase. Esto significa que no puede
ser accedido desde los métodos y propiedades de cualquier otra clase, incluidas las subclases.

public class Program El compilador nos daría un error puesto que el

{ atributo 'radio' perteneciente a la clase 'CircleClass'
public static void Main() está declarado con el modificador de acceso 'private'
{ y, por lo tanto, sólo es visible desde la propia clase
CircleClass circleClass = new CircleClass(); 'CircleClass' y nunca desde fuera de ella.
double r = circleClass.radio; // Error: miembro Hay que tener en cuenta que de forma
privado de la clase 'CircleClass'. predeterminada, si no se especifica un modificador de
} acceso, el miembro declarado para a ser de manera
public class CircleClass automática declarado como 'private'. Sin embargo, y
{ es mi opinión, considero que esta práctica no es
private double radio; aconsejable, y que siempre debes declarar el
} modificador de acceso, sea 'private' o sea cualquier
} otro.
 Encapsulación
Acceso protegido.
Un miembro de una clase declarado protegido con el modificador de acceso 'protected' se comporta de igual
manera que uno declarado como privado para los métodos y propiedades de cualquier otra clase, excepto para
los métodos y propiedades de sus subclases, para las cuales se comporta como si fuera un miembro público. Es
poco ususal declarar miembros protegidos, pero realizando una programación avanzada en la cual haya
implementaciones de clases derivadas, es posible que sea un recurso que debas utilizar con cierta frecuencia.
Acceso interno.
Un miembro de una clase declarado interno con el modificador de acceso 'internal' puede ser accedido por un objeto de
esa misma clase en cualquier parte de la aplicación actual, o del ensamblado actual, donde el objeto en cuestión sea
accesible. Esto se implementa con mucha frecuencia en aquellas aplicaciones que estén construidas a base de
ensamblados, o archivos '.dll', que no son más que conjuntos de clases agrupadas en un mismo ensamblado con extensión
'.dll'. La construcción de aplicaciones a base de ensamblados es una de las organizaciones más productivas en programación
en la plataforma .NET, y constituyen la mejor estrategia de diseño en vista a un mantenimiento fácil dividido por módulos.
 Encapsulación
public class Program
{
public static void Main()
{
CircleClass circleClass = new CircleClass();
double r = circleClass.Radio; // Correcto: miembro interno de la clase 'CircleClass'.
}
internal class CircleClass
{
private double radio;
internal double Radio
{
get
{
return radio;
}
set
{
radio = value;
}
}
}
}
 Encapsulación
Acceso público.
Un miembro de una clase declarado público con el modificador de acceso 'public' puede ser accedido desde
un objeto de esa misma clase o en cualquier parte donde el objeto en cuestión sea accesible. En este caso no
hay restricciones de acceso, pues los miembros públicos de una clase constituyen la interfaz pública de los
objetos de esa clase. Además, también serán accesibles desde cualquier otro ensamblado de la misma
aplicación.

public class Program

{
public static void Main()
{
CircleClass circleClass = new CircleClass();
double r = circleClass.Radio; // Correcto: miembro público de la clase 'CircleClass'.
}
public class CircleClass
{
private double radio;
public double Radio
{
get
{
return radio;
}
set
{
radio = value;
}
}
}
}
 Encapsulación
Acceso parcial.
Como norma general, una clase se define en un archivo, pero una clase, estructura, método o interfaz declarado
público con el modificador de acceso 'partial' los autoriza a definirse en varios archivos. En algunos casos, como
sucede con los formularios, Visual Studio gestiona una parte del código fuente que se genera automáticamente
en un archivo por el diseñador de vista y deja al desarrollador la posibilidad de añadir la lógica en otro archivo.
De esta manera, los dos archivos juntos componen la clase entera.

Por ejemplo, y en el caso de la creación a través de Visual Studio de un formulario de Windows Forms, el
entorno de desarrollo integrado creará dos archivos separados que, juntos, completarán la clase que controla
dicho formulario. Así, en primer lugar tendremos el archivo del formulario propiamente dicho ('archivo
Form1.cs'), y en segundo lugar el archivo del código subyacente (archivo 'From1.Designer.cs'):

public partial class Form1 : Form partial class Form1

{
{ private System.ComponentModel.IContainer components = null;
public Form1() protected override void Dispose(bool disposing)
{ {
InitializeComponent(); // ...
}
} private void InitializeComponent()
} {
// ...
}
}
 Polimorfismo
En programación orientada a objetos, el polimorfismo se refiere a la propiedad por la que es posible enviar
mensajes sintácticamente iguales a objetos de tipos distintos. El único requisito que deben cumplir los objetos
que se utilizan de manera polimórfica es saber responder al mensaje que se les envía.
Polimorfismo
herencia
herencia

Es la capacidad de compartir atributos y métodos entre clases.

Es la propiedad que permite definir nuevas clases usando como
base clases ya existentes.
La nueva clase (clase derivada) hereda los atributos y
comportamiento que son específicos de
la clase existente.
La herencia es una herramienta poderosa que proporciona un
marco adecuado para producir
software fiable, comprensible, de bajo costo, adaptable y
reutilizable
 herencia
La herencia o relación es-un es la relación que existe entre dos clases, en la que una clase
denominada derivada o subclase se crea a partir de otra ya existente, denominada clase
base o superclase.
Evidentemente, la clase base y la clase derivada tienen código y datos comunes, de modo que
si se crea la clase derivada de modo independiente, se duplicaría mucho de lo que ya se ha
escrito para la clase base.
C# soporta el mecanismo de derivación que permite crear clases derivadas, de modo que la
nueva clase hereda todos los datos miembro que pertenecen a la clase ya existente
La declaración de derivación de clases debe incluir el nombre de la clase base de la que se
deriva y el especificador de acceso que indica el tipo de herencia (pública, privada ó protegida).
La primera línea de cada declaración debe incluir la sintaxis siguiente:
 herencia
Tipos de Herencia.
Dependiendo del número de clases y de cómo se relacionen, la herencia puede ser:
a) Simple.
b) Múltiple.
c) De niveles múltiples.
Con independencia del tipo de herencia, una clase derivada no puede acceder a variables y
funciones privadas de su clase base. Para ocultar los detalles de la clase base y de clases y
funciones externas a la jerarquía de clases, una clase base utiliza normalmente elementos
protegidos en lugar de elementos privados.

Herencia Simple.
Cuando sólo se tiene una clase base de la cual hereda la clase derivada, se dice que hay
herencia simple (ver Figura 1.a).
Sin embargo, la herencia simple no excluye la posibilidad de que de una misma clase base se
pueda derivar más de una subclase o clase derivada (Figura 1.b)
 herencia

En la figura 2a, la clase Persona es la clase base y Empleado es la clase derivada. Un objeto
de esta clase también es un objeto de la clase “Persona”, por lo tanto, tendrá los atributos y
métodos de ambas clases.
En la figura 2b, la clase Mamífero es la clase base y Vacuno y Equino son las clases
derivadas. En este caso, se dice que todo “Vacuno” y todo “Equino” también son objetos de la
clase “Mamífero” y en consecuencia tendrán todos los atributos y métodos que heredan de la
clase base.
Los miembros protegidos de la clase base podrán ser usados por los métodos de las clases
derivadas, pero no por sus clientes.
Los miembros públicos estarán disponibles para los métodos de las clases derivadas y para
todos sus clientes.
 herencia

Para declarar una clase derivada de una clase previamente

class Base
definida se utiliza la siguiente
{ private: sintaxis:
// Miembros declarados en la sección privada: accesibles
sólo para miembros de esta clase class Base
protected:
/* Miembros declarados en la sección protegida:
{ // Declaración de atributos y métodos de la clase Base
accesibles sólo para miembros de esta };
clase y de sus derivadas */ // Relación de herencia pública entre las clases Base y Derivada
public: class Derivada :Base
// Miembros declarados en la sección pública: accesibles
para todos { // Declaración de atributos y métodos de la clase Derivada
}; };
 herencia
Herencia de Niveles Múltiples.
Se presenta cuando una clase derivada se usa como base para definir otra clase derivada. Es
decir, existen diferentes niveles de herencia: en el primero, la clase derivada hereda los
miembros de una clase base, mientras que en el segundo, la clase derivada funciona a su vez
como una clase base y de esta forma comparte con una tercera clase sus propios miembros y
los que heredó (ver Figura 4). Esta relación puede extenderse a tantos niveles como lo
requiera el problema que se esté resolviendo.
 herencia
Ejemplo 1:
Se muestra un ejemplo más a nivel didáctico de Herencia simple. El objetivo es verificar
que se pueden compartir elementos entre clases y para ello se realiza la implementación
de la jerarquía de clases mostrada en la siguiente figura:

Los valores son propiedad de la clase principal y cada clase derivada implementa un método llamado operar.
herencia
herencia
herencia
 EXAMEN PRACTICO
TÉCNICAS DE PROGRAMACIÓN
NOMBRE: _______________________________________ Expediente: ____________________

Ejercicio 1.- Descripción Defina la clase Empleado. Esta clase debe almacenar la siguiente información:
numero de empleado, nombre, apellidos, domicilio, fecha de contratación y salario. Todos estos datos son de tipo String, excepto el salario
que es double. Todos los atributos son de acceso privado.
Defina el método constructor de la clase, los metodos ‘get’(), `set()`y el metodo getAtributos(); este método debe de devolver una cadena con
todos los atributos concatenados, como se muestra en el siguiente ejemplo:
NumEmpleado:123ABC Pérez López, Juan 25/03/2014 15,000.00
Defina la clase MiExamen con el metodo main(). Defina un objeto que instancie a la clase Empleado y muestre sus atributos por consola.

Ejercicio 2. Crea una clase Coche con las siguientes propiedades:

– ID
– Marca
– Modelo
– KM
– Precio

Debemos crear un constructor donde le pasemos los valores.

Crea sus get y set de cada propiedad.
Crea el metodo toString.
— Coche
 EXAMEN PRACTICO
TÉCNICAS DE PROGRAMACIÓN

NOMBRE: _______________________________________ Expediente: ____________________

Ejercicio 3.-Codificar un programa que contenga una clase llamada Puerta que contenga los atributos: ancho, alto, color, abierta y los métodos
Abrir, Cerrar, MostrarEstado y completa el programa que use un objeto de la clase Puerta, muestre su estado , la abra y vuelva a mostrar su
estado.

Ejercicio 4. Para guardar información sobre libros, vamos a comenzar por crear una clase "Libro", que contendrá atributos "autor", "titulo",
"ubicacion" (todos ellos strings) y métodos Get y Set adecuados para leer su valor y cambiarlo. Prepara también un Main (en la misma
clase), que cree un objeto de la clase Libro, dé valores a sus tres atributos y luego los muestre.

Ejercicio 5. Crea una clase llamada Persona, en el fichero "persona.cs". Esta clase deberá tener un atributo "nombre", de tipo string. También
deberá tener un método "SetNombre", de tipo void y con un parámetro string, que permita cambiar el valor del nombre. Finalmente,
también tendrá un método "Saludar", que escribirá en pantalla "Hola, soy " seguido de su nombre. Crea también una clase llamada
PruebaPersona. Esta clase deberá contener sólo la función Main, que creará dos objetos de tipo Persona, les asignará un nombre a cada uno y
les pedirá que saluden.

¡¡¡Saludos y mucha suerte!!

GRACIAS