Métodos, Atributos y Comportamiento en POO con C#

¿Qué son los métodos en la programación orientada a objetos?

Si las clases son los sustantivos de la programación, los MÉTODOS son los verbos, son las acciones que dan vida a nuestros objetos.

Métodos de Instancia - Las Acciones del Objeto

Y un método de instancia es, un bloque de código dentro de una clase que realiza una tarea específica y está ligado a un objeto ¿Y Por qué está ligado a un objeto? Porque necesita una instancia, un objeto real, para poder funcionar e invocarlo.

Vamos a mejorar nuestra clase Carro. Le añadiremos un atributo para el kilometraje y un nuevo método llamado Viajar, este método no solo realizará una acción, sino que también cambiará el estado interno de nuestro objeto. ¡Observa!

• Primero, agregamos un nuevo atributo de tipo Double para guardar el kilometraje que recorre nuestro vehículo.
• Y como la clase pasada, ya vimos que son los constructores, vamos a agregarle nuevos constructor a nuestra clase
  • Un constructor por defecto que inicializa nuestros atributos con valores predeterminados, es un método público con el mismo nombre de nuestra clase e inicializamos nuestros atributos con valores por defecto.
  • Agregamos un segundo constructor, el cual, también es un método público con el mismo nombre que nuestra clase Carro y recibe un string con el modelo otro string para el color y un entero para el año.
• Si te fijas, dentro de este constructor utilizamos "this.Modelo" igual a modelo, "this.Color" igual a color, etc.

¿Qué es this y para qué sirve en la programación orientada a objetos?

Imagina que tenemos 100 objetos Carro diferentes ¿Cómo sabe un método a cuál de los 100 coches pertenece cuando es llamado?

• La respuesta es this.

Dentro de un método de instancia, this es un atajo que significa "este objeto en particular" o "yo mismo".

• Si llamas a miElectrico.ArrancarMotor(), dentro de ese método, this se refiere al objeto miElectrico.
• Si llamas a miToyota.ArrancarMotor(), this se refiere a miToyota.

Principalmente usamos this, para dos cosas:

1. Evitar ambigüedad: Es su uso más común. Sirve para diferenciar un atributo de clase a un parámetro de un método cuando se llaman igual.
   1. Por ejemplo, para distinguir entre un atributo de clase como this.Modelo y el parámetro de un método como modelo.  
2. Otro uso es pasar el objeto actual: A veces, un método necesita enviar el objeto completo a otra parte del programa.
   1. Podrías hacer algo como ServicioDeRegistro.RegistrarVehiculo(this);"

Ahora que sabemos qué es this, continuemos mejorando nuestra clase.

• Primero creamos un método que simula un viaje, y muy importante, este método modifica el estado del carro, es un método público no regresa nada y le ponemos de nombre viajar, recibe un parámetro double para la distancia y dentro de este método.
  • Si la distancia es mayor a cero simplemente se la sumamos al kilometraje, con esto estamos modificando el estado del carro.
  • Y mandamos a Consola el mensaje: el carro con modelo tal ha viajado cierta distancia en kilómetros y el kilometraje total es kilometraje en km.
• Pero también podemos tener métodos que no precisamente modifican el estado de un objeto sino que proporcionan información de los atributos del objeto. Por ejemplo:
  • Podemos tener un método para mostrar los detalles del carro.
  • Este método no modifica el estado del carro, sólo muestra información de nuestro objeto.
  • Lo declaramos como un método público no regresa nada y le ponemos como nombre mostrar detalles, dentro de este método, simplemente vamos a agregar un mensaje a Consola que diga detalles del vehículo y concatenamos, modelo concatenamos color y el kilometraje actual.

// Carro.cs
// Creamos nuestro namespace para organizar nuestro código.
namespace console_poo_ewebik;

// Esta es nuestra PLANTILLA o nuestro PLANO.
public class Carro
{
    // --- Primero Definimos las CARACTERÍSTICAS (Campos y Propiedades) ---
    // Las cuales son las variables que definen el estado de un carro.

    public string Modelo = "";
    public string Color = "";
    public int Anio;
    // ¡Nuevo atributo!
    public double Kilometraje = 0;
    private int velocidadActual = 0;

    public SistemaNavegacionGPS GPS { get; set; } = new SistemaNavegacionGPS();

    //<summary>
    /// Constructor por defecto para el Carro.
    /// Este constructor inicializa un carro con valores predeterminados.
    /// </summary>
    public Carro()
    {
        this.Modelo = "Desconocido";
        this.Color = "Desconocido";
        this.Anio = 0;
        this.Kilometraje = 0;
        this.velocidadActual = 0;
    }

    // Constructor para inicializar el carro
    public Carro(string modelo, string color, int anio)
    {
        // 'this' se refiere a la instancia ACTUAL del objeto.
        // Esencial para evitar ambigüedad
        // entre el parámetro 'modelo' y el atributo 'this.Modelo'
        this.Modelo = modelo;
        this.Color = color;
        this.Anio = anio;
        // Todo carro nuevo empieza con 0 km.
        this.Kilometraje = 0;
    }

    // --- Métodos de Instancia ---

    // Este método SIMULA un viaje y MODIFICA el estado del carro.
    public void Viajar(double distancia)
    {
        if (distancia > 0)
        {
            // Modificamos el estado interno
            this.Kilometraje += distancia;
            Console.WriteLine(
              $"El carro con {this.Modelo} ha viajado {distancia} km."
            + $"Kilometraje total: {this.Kilometraje} km.");
        }
    }

    // Método para mostrar los detalles del carro.
    // Este método NO modifica el estado del carro, solo lo muestra.
    public void MostrarDetalles()
    {
        Console.WriteLine(
            $"Detalles del Vehículo:"
            + $"Modelo {this.Modelo},"
            + $" Color {this.Color},"
            + $" Kilometraje {this.Kilometraje} km.");
    }

    // Método para arrancar el motor del carro.
    public void ArrancarMotor()
    {
        if (velocidadActual == 0)
        {
            Console.WriteLine($"El carro con modelo {Modelo} ha arrancado el motor.");
        }

        else
        {
            Console.WriteLine($"El Carro con modelo {Modelo} ya está en movimiento.");
        }
    }

    // Método para acelerar el carro.
    public void Acelerar(int incremento)
    {
        velocidadActual += incremento;
        Console.WriteLine($"Acelerando. Velocidad actual: {velocidadActual} km/h.");
    }

    // Método para frenar el carro.
    public void Frenar()
    {
        velocidadActual = 0;
        Console.WriteLine($"El carro con modelo {Modelo} se ha detenido por completo.");
    }
}

Ahora veamos cómo se usa todo lo que acabamos de hacer, en la práctica:

• Primero. Regresamos a Program.cs que recuerda que en la clase pasada es la entrada principal de nuestro programa, y es como si fuera la fábrica que construye nuestros carros.
• Aquí definimos dos objetos uno que era mi deportivo, y otro que era mi eléctrico, y cada uno, tiene sus propiedades, pero, si ves aquí no pasamos parámetros en el constructor, lo hacemos a través de asignar directamente los atributos, vamos a cambiar todo esto, tomando en cuenta los cambios que hemos hecho en nuestra clase carro.
• Primero vamos a crear otra vez el objeto miDeportivo, pero, el modelo, el color y el año; se lo vamos a pasar en el constructor, le pasamos Ferrari F8 que es de color rojo y es del año 2025, y listo, tenemos nuestro objeto creado mediante nuestro nuevo constructor, por lo tanto, tienes la opción de crear tu carro con este constructor y también, modificar los atributos de forma independiente.
• Ahora hagamos uso de nuestros métodos y los vamos a invocar en cierto orden, para crear una secuencia que más o menos tenga lógica de cómo utilizamos un carro.
  • Primero llamamos a nuestro método mostrar detalles que imprime detalles del vehículo modelo Ferrari F8 color rojo kilometraje 0 km
  • Después llamamos a calcular ruta y le pasamos la ruta la cima del éxito en programación que imprime calculando la mejor ruta hacia la cima del éxito en programación mediante la cartografía de Google Maps, porque recuerda que si no establecemos una cartografía, tomará por defecto Google Maps
  • Siguiente, invocamos arrancar motor que imprime el carro con modelo Ferrari F8 a arrancado el motor
  • Ahora procedemos a acelerar, le pasamos  un incremento de 100 que imprime acelerando velocidad actual 100 km/h
  • Invocamos nuestro nuevo método, viajar que imprime el carro con modelo Ferrari F8, ha viajado 10 km kilometraje total 10 km, porque recuerda que nuestro carro empieza en 0 km.
  • Volvemos a invocar nuestro método viajar porque estamos en ruta y ahora le volvemos a pasar otros 10 km de distancia que imprime el carro con modelo Ferrari F8 ha viajado 10 km kilometraje total 20 km.
  • Ahora, supongamos que llegamos a nuestro destino, invocamos el método frenar que imprime el carro con modelo Ferrari F8, se ha detenido por completo.
  • Y finalmente mostramos los detalles para saber el estado actual de nuestro vehículo que imprime detalles del vehículo modelo Ferrari F8 color rojo y ahora el kilometraje es 20 km.
• Y recuerda que podemos crear los objetos que necesitemos, así que podemos repetir lo mismo para un segundo objeto que se llame miElectrico, tal como lo teníamos en la clase pasada.
• Y ambos objetos son independientes y pueden hacer viajes diferentes.
• Si ejecutamos nuestro proyecto, podemos ver todos los mensajes que te describí, lo que indica que nuestro programa está funcionando correctamente.

//Program.cs
using console_poo_ewebik;

// OBJETO 1: Creamos un deportivo rojo.
Carro miDeportivo = new Carro("Ferrari F8", "Rojo", 2025);

miDeportivo.MostrarDetalles();
// Que imprime:
// Detalles del Vehículo:
// Modelo Ferrari F8,
// Color Rojo,
// Kilometraje 0 km.
miDeportivo.GPS.CalcularRuta("La cima del éxito en programación");
// Que imprime: Calculando la mejor ruta hacia
// La cima del éxito en programación
// mediante la cartografía Google Maps.
miDeportivo.ArrancarMotor();
//Que imprime:
//El carro con modelo Ferrari F8 ha arrancado el motor.
miDeportivo.Acelerar(100);
//Que imprime:
//Acelerando. Velocidad actual: 100 km/h.
miDeportivo.Viajar(10);
//Que imprime:
//El carro con modelo Ferrari F8 ha viajado 10 km.
//Kilometraje total: 10 km.
miDeportivo.Viajar(10);
//Que imprime:
//El carro con modelo Ferrari F8 ha viajado 10 km.
//Kilometraje total: 20 km.
miDeportivo.Frenar();
//Que imprime:
//El carro con modelo Ferrari F8 se ha detenido por completo.
miDeportivo.MostrarDetalles();
// Que imprime:
// Detalles del Vehículo:
// Modelo Ferrari F8,
// Color Rojo,
// Kilometraje 20 km.

// OBJETO 2: Creamos un sedán eléctrico azul.
Carro miElectrico = new Carro("Tesla Model 3", "Azul", 2024);
miElectrico.GPS = new SistemaNavegacionGPS("Waze");

miElectrico.MostrarDetalles();
// Que imprime:
// Detalles del Vehículo:
// Modelo Tesla Model 3,
// Color Azul,
// Kilometraje 0 km.
miElectrico.GPS.CalcularRuta("La cima del éxito en programación");
// Que imprime: Calculando la mejor ruta hacia
// La cima del éxito en programación
// mediante la cartografía Waze.
miElectrico.ArrancarMotor();
//Que imprime:
//El carro con modelo Tesla Model 3 ha arrancado el motor.
miElectrico.Acelerar(150);
//Que imprime:
//Acelerando. Velocidad actual: 150 km/h.
miElectrico.Viajar(20);
//Que imprime:
//El carro con modelo Tesla Model 3 ha viajado 20 km.
//Kilometraje total: 20 km.
miElectrico.Viajar(15);
//Que imprime:
//El carro con modelo Tesla Model 3 ha viajado 15 km.
//Kilometraje total: 35 km.
miElectrico.Frenar();
//Que imprime:
//El carro con modelo Tesla Model 3 se ha detenido por completo.
miElectrico.MostrarDetalles();
// Que imprime:
// Detalles del Vehículo:
// Modelo Tesla Model 3,
// Color Azul,
// Kilometraje 35 km.

Métodos Estáticos - Las Herramientas de la Fábrica

Pero, ¿y si tenemos una función que está relacionada con los coches, que no depende de un coche en específico?

Por ejemplo, una fórmula para convertir millas a kilómetros. No necesitas un Ferrari para saber esa fórmula, ¿cierto?

• Para eso existen los MÉTODOS ESTÁTICOS.

¿Qué es y para qué sirve un Método Estático en POO?

Un método estático, marcado con la palabra reservada static, es una función que pertenece a la clase en sí, no a un objeto individual.

Piénsalo como una herramienta universal en la caja de herramientas de la fábrica de Carro, disponible para cualquiera sin necesidad de tener un coche construido.

Sus características clave son:

• Se llaman desde la clase: No necesitas un objeto.
  • Escribes: NombreDeLaClase.NombreDelMetodo() y listo.
• No usan this: Como no están atados a ningún objeto, no tienen acceso a this. Por lo tanto, no pueden modificar los atributos de una instancia (como Kilometraje o Color).
• Son perfectos para utilidades: Su uso principal es para funciones auxiliares, cálculos o crear objetos de una manera específica.

Veamos cómo añadir uno a nuestra clase:

• Primero en nuestra clase carro, agregamos un atributo estático para convertir millas a kilómetros declaramos Public Const double MillasAKilometros igual a 1.60934.
• Y agregamos una nueva sección a nuestra clase para los métodos estáticos.
• Y a aquí creamos un método estático, que convierte millas a kilómetros y lo declaramos como public la palabra reservada static para indicar qué es un método estático, el cual, regresa un tipo double y lo nombramos ConvertirMillasAKilometros y recibe un parámetro tipo double con las millas que deseamos convertir. Dentro de este método utilizamos el  atributo estático MillasAKilometros para realizar la conversión.

// Carro.cs
// Creamos nuestro namespace para organizar nuestro código.
namespace console_poo_ewebik;

// Esta es nuestra PLANTILLA o nuestro PLANO.
public class Carro
{
    // ... (Atributos, Constructor y Métodos de Instancia anteriores) ...
    public SistemaNavegacionGPS GPS { get; set; } = new SistemaNavegacionGPS();
    
    
// Un atributo estático (constante)
    public const double MillasAKilometros = 1.60934; 

    // --- Método Estático ---
    // Es una utilidad que pertenece a la CLASE Carro.
    // Nota que NO usa la palabra 'this', porque no hay instancia.
    
    public static double ConvertirMillasAKm(double millas)
    {
        return millas * MillasAKilometros;
    }

}

La diferencia clave es cómo lo llamamos. No necesitamos un objeto new Carro().

• Vayamos otra vez a Program.cs
• Y lo voy a hacer aquí, al principio, declaro una variable tipo double distanciaEnKm es igual a carro punto Convertir millas a kilómetros y le paso 100 millas.
• Si mando a consola esta variable: nos regresará el mensaje: 100 millas son equivalentes a 160.934 km.
• Algo importante, es que si tú tratas de invocar este método estático en un objeto, pues simplemente te va a marcar error porque no está definido en un objeto, este método estático está definido en la clase y solamente puedes acceder a él, así como lo acabamos de hacer a través de la clase y no a través de un objeto.

//Program.cs
using console_poo_ewebik;

// No se necesita una instancia.
//Se llama directamente desde la Clase.
double distanciaEnKm = Carro.ConvertirMillasAKilometros(100);
Console.WriteLine($"100 millas son equivalentes a {distanciaEnKm} km.");
// Imprime: 100 millas son equivalentes a 160.934 km.
// Esto daría un ERROR, porque el método no pertenece a un objeto:
// miDeportivo.ConvertirMillasAKm(100); // ¡ERROR!

Los métodos estáticos son perfectos para funciones de utilidad, cálculos o para manejar información que es común a todos los objetos de la clase, pero que no es específica de ninguno.

En resumen: Métodos y atributos en la programación orientada a objetos.

La gran diferencia de hoy:

• Métodos de Instancia: Son las acciones de un objeto específico, necesitan una instancia para existir y usan this para referirse a su propio estado y se llama a través de un objeto.
• Métodos Estáticos: Son utilidades que pertenecen a la clase en general, no necesitan una instancia y no pueden usar this y se llama a través de un clase.

Comprender cuándo usar cada uno es clave para escribir código limpio y lógico.

Ahora, un pequeño reto para ti:

• ¿Qué otro método estático podrías añadir a la clase Carro? ¿Quizás uno para validar un número de serie de un vehículo? Etc. ¡Deja tu idea en los comentarios!

No olvides suscribirte y activar la campanita, porque en siguientes vídeos nos adentraremos aun más en la programación orientada a objetos ¡No te lo querrás perder!

Y recuerda sigue viajando por la web.