domingo, 8 de septiembre de 2024

■ Trabajando con más de una clase

Cuando se trabaja con más de una clase sólo una puede llevar el método main y se dice que esta clase que lo contiene es la clase principal, las demás clases son secundarias.

Estructura empleando dos clases

class <identificador> {
    // Código de la clase secundaria
}

public class <identificador> {
    public static void main(String[] args) {
        // Código clase principal
    }
}

Como puede verse, el método main solo va en una clase y esa es nuestra clase principal, las otras clases, ya que pueden declararse varias, no llevan método main, solo llevan métodos normales.


¿Por qué se usan clases secundarias?

El uso de clases secundarias es principalmente para tener un código más organizado y fácil de entender, por ejemplo si quisiera hacer un programa con varios métodos, empleando una sola clase quedaría así:

public class Metodos {
    public static double calcularAreaCuadrado(double lado) {
        double area;
        area = lado * lado;

        return area;
    }

    public static double calcularAreaCirculo(double radio) {
        double area, pi;
        pi = 3.14;
        area = pi * (radio * radio);

        return area;
    }

    public static double convertirAFahrenheit(double gradosC) {
        double gradosF;
        gradosF = (gradosC * 1.8) + 32;

        return gradosF;
    }

    public static double convertirACentigrados(double gradosF) {
        double gradosC;
        gradosC = (gradosF - 32) * 0.555;

        return gradosC;
    }

    public static void main(String[] args) {
        double ladoCuadrado, radioCirculo, areaCuadrado, areaCirculo;
        double centigrados, fahrenheit, gradosC, gradosF;

        ladoCuadrado = 5.5;
        radioCirculo = 7.5;
        centigrados = 30.2;
        fahrenheit = 77;

        areaCuadrado = calcularAreaCuadrado(ladoCuadrado);
        areaCirculo = calcularAreaCirculo(radioCirculo);
        gradosF = convertirAFahrenheit(centigrados);
        gradosC = convertirACentigrados(fahrenheit);

        System.out.println("El área del cuadrado es " + areaCuadrado);
        System.out.println("El área del círculo es " + areaCirculo);
        System.out.println(centigrados + "°C equivalen a " + gradosF + "°F");
        System.out.println(fahrenheit + "°F equivalen a " + gradosC + "°C");
    }
}

En la misma clase quedan mezclados todos los métodos y si fueran más estarían todos revueltos y sería tedioso si tuvieran que modificarse o buscar un error.

Una posible solución sería clasificar los métodos y separarlos en clases diferentes.


Usando varias clases en el mismo archivo

Si quisiéramos organizar el código anterior en diferentes clases, para decidir ¿en cuántas?, podríamos clasificar los métodos que contiene, por ejemplo los primeros dos calculan el área de figuras, mientras que los otros dos calculan temperaturas.

Entonces podríamos crear 2 clases, una para los métodos que calculan áreas y otra para los que calculan temperaturas, esas dos serían las clases secundarias, es decir, las que no llevarían método main, la otra sería nuestra clase principal, en esta si va el main, el código quedaría de la siguiente forma:

class Area {
    public static double Cuadrado(double lado) {
        double area;
        area = lado * lado;

        return area;
    }

    public static double Circulo(double radio) {
        double area, pi;
        pi = 3.14;
        area = pi * (radio * radio);

        return area;
    }
}

class Temperatura {
    public static double Fahrenheit(double gradosC) {
        double gradosF;
        gradosF = (gradosC * 1.8) + 32;

        return gradosF;
    }

    public static double Centigrados(double gradosF) {
        double gradosC;
        gradosC = (gradosF - 32) * 0.555;
return gradosC;
    }
}

public class Main {
    public static void main(String[] args) {
        double ladoCuadrado, radioCirculo, areaCuadrado, areaCirculo;
        double centigrados, fahrenheit, gradosC, gradosF;

        ladoCuadrado = 5.5;
        radioCirculo = 7.5;
        centigrados = 30.2;
        fahrenheit = 77;
// Declaración de objetos de cada clase
Area area = new Area();
Temperatura temperatura = new Temperatura();

// Invocación de los métodos
        areaCuadrado = area.Cuadrado(ladoCuadrado);
        areaCirculo = area.Circulo(radioCirculo);
        gradosF = temperatura.Fahrenheit(centigrados);
        gradosC = temperatura.Centigrados(fahrenheit);

        System.out.println("El área del cuadrado es " + areaCuadrado);
        System.out.println("El área del círculo es " + areaCirculo);
        System.out.println(centigrados + "°C equivalen a " + gradosF + "°F");
        System.out.println(fahrenheit + "°F equivalen a " + gradosC + "°C");
    }
}

Invocar métodos de clases secundarias

Mientras que cuando solo se tiene una clase los métodos pertenecen a ella misma y basta con poner el nombre del método, con sus paréntesis y parámetros si es que lleva, para llamarlo.

Pero cuando se requiere llamar a un método que pertenece a otra clase, debemos crear un objeto de dicha clase y mediante ese objeto invocar a sus métodos. La estructura es la siguiente:

<nombre_de_la_clase> <nombre_objeto> = new <nombre_de_la_clase>();

En el ejemplo anterior esto lo hacemos en las líneas:
Area area = new Area();
Temperatura temperatura = new Temperatura();

Donde "Area" y "Temperatura" con mayúscula, son los nombres de las clases secundarias de las que crearemos el objeto.
Y "area" y "temperatura" con minúscula son los nombres que nosotros decidamos darle a los objetos.

Teniendo el objeto declarado, la invocación de sus métodos se hace de la siguiente forma:
<objeto>.<método>(parámetros);

Si el método devuelve un valor se deberá asignar a una variable del mismo tipo del valor que regresa, así:
<variable> = <objeto>.<método>(parámetros);

En el ejemplo anterior los métodos son invocados en las líneas:
areaCuadrado = area.Cuadrado(ladoCuadrado);
areaCirculo = area.Circulo(radioCirculo);
gradosF = temperatura.Fahrenheit(centigrados);
gradosC = temperatura.Centigrados(fahrenheit);

Donde: areaCuadrado, areaCirculo, gradosF y gradosC son variables de tipo double ya que el resultado que los métodos devuelven es de dicho tipo; y ladoCuadrado, radioCirculo, centigrados y fahrenheit son variables también de tipo double ya que son los datos que los métodos reciben en sus parámetros y son de dicho tipo.

De esta forma si nuestro programa tuviera muchos métodos quedaría mejor organizado ya que estarían clasificados por clases y al momento de llamarlos sabríamos a qué clase pertenecen y con ello evitamos saturar la clase principal, además esto también permite que varios métodos compartan el mismo nombre siempre y cuando pertenezcan a clases distintas.

No hay comentarios:

Publicar un comentario