Cómo llamar a un método que devuelve algún otro método en Java

Un método es una colección de declaraciones que realizan alguna tarea específica y devuelven el resultado a la persona que llama. Un método también puede realizar alguna tarea específica sin devolver nada. En este artículo, entenderemos cómo llamar a un método que devuelve algún otro método en Java.

En Java, hay dos tipos de métodos. Están:

1. Método estático : los métodos estáticos son los métodos en Java que se pueden llamar sin crear un objeto de la clase. Se hace referencia a ellos por el nombre de la clase en sí o por la referencia al objeto de esa clase.
2. Método de instancia : los métodos de instancia son métodos que requieren que se cree un objeto de su clase antes de poder llamarlo. Para invocar un método de instancia, tenemos que crear un objeto de la clase en la que se define.

Llamar a un método estático que devuelve algún otro método estático: dado que los métodos estáticos están asociados a la clase en la que residen (es decir) se pueden llamar incluso sin crear una instancia de la clase, podemos definir directamente un método que llama el método llamando a la definición del método. Entendamos cómo hacer esto con los siguientes ejemplos:

• Ejemplo 1: En este ejemplo, visualicemos un automóvil. Un coche tiene que arrancar antes de ser conducido. Por lo tanto, un automóvil tiene una función de arranque que arranca el automóvil. Para que un automóvil arranque, su motor debe arrancar primero y las demás entidades restantes deben arrancar, por lo que finalmente el automóvil está listo para funcionar. Por lo tanto, esta función carStart() debe tener una firma engineStart() que inicie el motor. Eso es:

  // Java program to visualize the Car    // A class Car public class CarFunc {        // A method engineStart() which     // simply starts the engine     public static void engineStart()     {         System.out.println("Engine Started!");     }        // A method carStart() which starts     // the engine and other entities     // required     public static void carStart()     {         // Calling the function         // engineStart() inside the         // definition of function         // carStart()         engineStart();            // Definitions of starting         // various other entities         // can be defined here            // Finally, the car is         // started         System.out.println("Car Started!");     }        public static void main(String[] args)     {            carStart();            // When the car is started,         // we are ready to drive         System.out.println("Let's Drive!");     } }

  Producción:

  Engine Started!
  Car Started!
  Let's Drive!
  

• Ejemplo 2: en este ejemplo, consideremos un ejemplo similar donde las entidades son aceleradoras y aumentan la velocidad. Para aumentar la velocidad del vehículo, se presiona el acelerador. Una vez que se presiona el acelerador, la velocidad aumenta hasta que no llega al límite de velocidad. Esto se implementa de la siguiente manera:

  // A carSpeed class which manages // the speed of the class public class CarSpeedFunc {        // Speed is a global variable. If     // the speed is changed at any     // part of the car, then the overall     // speed of the car automatically     // changes     static int speed = 0;        // Function to increase the speed     public static void increaseSpeed()     {         speed = speed + 50;         System.out.println(             "Speed increased by 50 km/hr");            // main() called inside this function         main(new String[0]);     }        // Method which performs the increase     // speed function when the accelerator     // is pressed     public static void pressAccelerator()     {         System.out.println(             "Accelerator pressed "             + "to increase speed");         increaseSpeed();     }        // Driver code     public static void main(String[] args)     {         System.out.println(             "Driving with speed = "             + speed             + "km/hr");            if (speed < 200) {             pressAccelerator();         }         else {             System.out.println(                 "Speed Limit Reached! "                 + "Drive Slow. Stay safe.");         }     } }

  Producción:

  Driving with speed = 0km/hr
  Accelerator pressed to increase speed
  Speed increased by 50 km/hr
  Driving with speed = 50km/hr
  Accelerator pressed to increase speed
  Speed increased by 50 km/hr
  Driving with speed = 100km/hr
  Accelerator pressed to increase speed
  Speed increased by 50 km/hr
  Driving with speed = 150km/hr
  Accelerator pressed to increase speed
  Speed increased by 50 km/hr
  Driving with speed = 200km/hr
  Speed Limit Reached! Drive Slow. Stay safe.
  

Llamar a un método estático que devuelve algún otro método estático: los métodos de instancia pertenecen al objeto de la clase, no a la clase (es decir, se pueden llamar después de crear el objeto de la clase). Un método de instancia también se puede llamar desde otro método. Pero, necesitamos saber la dirección del método al que estamos llamando. La dirección del objeto actual se almacena en las palabras clave like this y super . Entendamos esto con un ejemplo. En este ejemplo, la palabra clave super se utiliza para llamar al objeto de la clase principal desde la clase secundaria. Eso es:

class GFG {
  
    // A nested parent class
    // which has the method
    // detail
    public static class BriefDescription {
        void detail()
        {
            System.out.println(
                "Ferrari 812 is "
                + "an awesome car.");
        }
    }
  
    // A child class extending the
    // parent class
    public static class DetailedDescription
        extends BriefDescription {
  
        // Overriding the parent
        // method
        @Override
        void detail()
        {
            // Using super keyword to call
            // 'detail()' method from the
            // parent class
            // 'BriefDescription'
            super.detail();
            System.out.println(
                "It has a seating "
                + "capacity of 2, "
                + "fuel economy of 7 kmpl "
                + "and comes with a horsepower "
                + "of 588 kW.");
        }
    }
  
    // Driver code
    public static void main(String[] args)
    {
        BriefDescription briefDesc
            = new BriefDescription();
  
        BriefDescription detailDesc
            = new DetailedDescription();
  
        System.out.println(
            "Brief detail of Ferrari:");
  
        // Method from the parent class
        // is invoked
        briefDesc.detail();
  
        System.out.println(
            "Complete detail of Ferrari:");
  
        // Method from both parent class
        // and subclass is invoked.
        detailDesc.detail();
    }
}

Brief detail of Ferrari:
Ferrari 812 is an awesome car.
Complete detail of Ferrari:
Ferrari 812 is an awesome car.
It has a seating capacity of 2, fuel economy of 7 kmpl and comes with a horsepower of 588 kW.