Calling Class Methods

So far in your Java journey, you've mostly seen methods that belong to objects. For example, if you have a Dog object named fido, you might call fido.bark(). That action is tied directly to that specific fido object.

But what about actions or calculations that aren't tied to any one object? That's where class methods come in.

What Makes a Method a Class Method?

A class method is a method that belongs to the class itself—the blueprint—rather than any individual object created from that blueprint.

The key to identifying a class method is the static keyword.

static: A Java keyword that indicates a method or variable belongs to the class, not to any one instance (object). There is only one copy of a static member, shared by all objects of that class.

Let's look at a method header: public **static** void doSomething()

That static keyword is our big signal. It tells us doSomething() is a class method. If static is missing, it's a regular instance method that needs an object to be called.

The Ultimate Analogy: A Public Library

Imagine a public library system for a city like Seattle.

• Instance Method
  myLibraryCard.checkoutBook(). This action is specific to your library card object. It affects your personal account, your due dates.
• Class Method
  SeattlePublicLibrary.getTodaysHours(). This information is the same for everyone. It belongs to the library system as a whole, not your individual card. You don't need a library card in your hand to look up the hours online.

Class methods are the getTodaysHours() of the programming world. They are shared utilities.

How to Call a Class Method

Because class methods belong to the class, you call them using the class name, followed by a dot, followed by the method name.

The syntax is: ClassName.methodName(arguments);

The most famous example in all of Java is the Math class. The Math class is a collection of common mathematical functions. It wouldn't make sense to create a Math object. Math is universal!

// We don't create a Math object. We use the class directly.

// Find the absolute value of -15
double absValue = Math.abs(-15.0); // absValue is now 15.0

// Calculate 2 to the power of 5
double powerResult = Math.pow(2, 5); // powerResult is now 32.0

// Get a random number between 0.0 (inclusive) and 1.0 (exclusive)
double randomNumber = Math.random();

Notice the pattern: Math.abs(), Math.pow(), Math.random(). We're always using the class name, Math, to call these static methods.

Creating Your Own Class Methods

Let's create a simple utility class to see this in action. Imagine we're building an app and frequently need to convert temperatures.

public class TempConverter {

    // This is a class method. Notice the 'static' keyword.
    // It takes a temperature in Fahrenheit and returns it in Celsius.
    public static double fahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5.0 / 9.0;
    }

    // Another class method.
    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32;
    }
}

Now, in another part of our program (like our main method), we can use these tools without ever creating a TempConverter object.

public class WeatherApp {
    public static void main(String[] args) {
        double tempInBostonF = 75.5;

        // Call the static method using the class name
        double tempInBostonC = TempConverter.fahrenheitToCelsius(tempInBostonF);

        System.out.println("The temperature in Boston is " + tempInBostonC + "°C.");
        // Output: The temperature in Boston is 24.166...°C.
    }
}

This is incredibly useful! We've created a reusable tool that any part of our code can access just by knowing the TempConverter class name.

The One Exception: Calling from Inside

There's one situation where you don't have to use the class name.

If you are calling a static method from within the same class where it is defined, the class name is optional.

Let's add another method to our TempConverter class:

public class TempConverter {

    public static double fahrenheitToCelsius(double fahrenheit) {
        return (fahrenheit - 32) * 5.0 / 9.0;
    }

    public static double celsiusToFahrenheit(double celsius) {
        return (celsius * 9.0 / 5.0) + 32;
    }

    // A new static method to display a conversion table
    public static void displayFahrenheitConversion(double f_temp) {
        // Calling another static method from WITHIN the same class.
        // Notice we don't need "TempConverter." here.
        double c_temp = fahrenheitToCelsius(f_temp); 
        System.out.println(f_temp + "°F is " + c_temp + "°C.");
    }
}

Inside displayFahrenheitConversion, we can just write fahrenheitToCelsius(f_temp) instead of TempConverter.fahrenheitToCelsius(f_temp). Java knows you mean the static method in the current class.

Let's walk through a couple of scenarios to make this crystal clear.

Ready to try it yourself? Here are a couple of challenges.

1. 1
   Vowel Counter

   Create a new class named StringUtil. Inside this class, define a public static method called countVowels that accepts a String and returns an int representing the number of vowels (a, e, i, o, u, case-insensitive) in that string. In your main method, test it with a few different words.
2. 2
   Game Night

   You're making a game that involves rolling two dice. Use the Math.random() method to simulate rolling a single six-sided die (a random integer from 1 to 6). Then, create a public static method in your main class called rollTwoDice that calls your single-die-roll logic twice and prints the result of each roll and their sum.