Calling methods in Java

Question

I'm a beginner and I'm trying to get a grasp on methods in Java. In general, I understand differences between static and non-static methods, but sometimes, reading others code, I'm confused about how a particular call is written.

As I understand, static method can be called with or without object. Non-static method need an object to be called, however when non-static method is called in another non-static method, in written form, it can be called just by a name(like method()), without a written reference to object (like object.method() or this.method()).

Is there another situation, when a non-static method call can be written this way? Is there another way to call a method beyond those?

I would be grateful for any comments.

Is it reflection that you want? Look here: http://stackoverflow.com/questions/37628/what-is-reflection-and-why-is-it-useful — Wiktor Stribiżew, Mar 05 '15 at 21:58
`foo()` in a nonstatic class method is equivalent to `this.foo()`; the `this` is implied. There's nothing really special about it other than that. — Colonel Thirty Two, Mar 05 '15 at 22:00
@stribizhev He explicitly said written form, I guess he said that to exclude reflection as possible answer. — Evdzhan Mustafa, Mar 05 '15 at 22:00

score 5 · Answer 1 · answered Mar 05 '15 at 22:02

Maybe you're thinking of a call to a method within the same class, e.g.:

public class Foo {
    public void doSomething() {
        doSomethingElse();   // equivalent to "this.doSomethingElse()"
    }

    private void doSomethingElse() {
        System.out.println("Bar");
    }
}

score 3 · Answer 2 · answered Mar 05 '15 at 22:19

Let's not worry about static/non-static for a second, that's another can of worms. Let's think about what kind of programs you've mostly built so far; perhaps you've designed a program like calculating the distance between two (x,y) coordinates.

public static void main(String[] args) {
    double x1 = 4.0;
    double y1 = 3.0;
    double x2 = 4.0;
    double y2 = 4.0;

    double x = Math.pow(x2 - x1, 2);
    double y = Math.pow(y2 - y1, 2);
    double distance = Math.sqrt(x+y);
    System.out.println("The distance is" + distance);
}

Now, what happens if you want to use that code in a more complex program, like a video game to determine if your character is colliding into a wall? Now you have 3 coordinates(A and B are the Wall and C is the Character) and you'll need to find out the distance between all three coordinates (AB, AC, and BC). Why? Because if AB == AC + BC, then our character has ran into a wall! Here's a video explaining why this will work by yours truly: Collision Detection of 2D Points

Do I want to have to repeatedly type the same formula? Or waste time copying and pasting? No, I'm lazy. That's why I program the computer to do things for me.

What I CAN do, however, is design tiny, little programs that can run inside my big, main program. These are called methods.

public static double distance(double x1, double y1, double x2, double y2) {
    double x = Math.pow(x2 - x1, 2);
    double y = Math.pow(y2 - y1, 2);
    double dist = Math.sqrt(x+y);
    return dist;
}

Now, notice that I did two things differently.

One, I named my variable dist instead of distance; it's just good programming practice not to name your variables the same as your method.

Two, I threw in a return statement. Now, think about the first program I showed, what's it doing when it's done? Nothing. It prints to the screen and that's it. It shuts down and clears out memory. But what if I need the distance later? Well, that's where return comes in. It makes sure that after doing the calculations, before clearing out of memory, it wants to give it back to you.

If you've learned about Math.random(), notice that you need to store or use it, otherwise it's gone for good. That's because Math.random() has a return type of a double. Something like System.out.println() has a return type of void because it doesn't 'return' anything, just displays text to our screen.

The basic premise behind a method is:

<access modifier> <return type> <name> (<parameters>) { }

The access modifier, for right now, should just stay public static. You'll learn about classes later. The return type is the important thing because this like like when you make a variable; you had to tell Java what data type it was - same for a method. You have to tell Java what data type this tiny, little program will produce. name is no different than when you named variables but now, you have to add in parameters, which are just placeholders in the method because we don't know what the values/variables that will be used later are going to be!

Now that I have distance as a method, I can use it three times whereever I want:

double distAB = distance(4, 0, 4, 4);
double distAC = distance(4, 0, 4, 2);
double distBC = distance(4, 4, 4, 2);
if (distAB == distAC + distCB)
    System.out.println("Collision Detected");

To add to what I've said, now that I've written a `public static` method, I have access to it from **anywhere** (*relatively speaking*)! If I save my file as `Collision.java` and then make another file `Pacman.java`, then inside of my `main method` in Pacman, I can have: `Collision.distance(x1, y1, x2, y2);` This is where static methods come into play, I refer to the class it was built in, rather than having to do `new Collision()` or something like that. — tsumnia, Mar 05 '15 at 22:24
To add again, the idea of class methods now says what if instead of `doubles`, I wanted to use a custom data type, like a `Point` class that has its own `distance(Point other) {}` method. This version of `distance` now will always directly be associated with its original point; whereas the above is two separate points each time it is called. A `Point p1 = new Point(0,0);` and `Point p2 = new Point(1,1);` now interact with each other with one of the points acting as the *point* of reference (sorry, bad pun), such as `p1.distance(p2);` — tsumnia, Mar 05 '15 at 23:19

score 2 · Answer 3 · answered Mar 05 '15 at 22:07

Basically, you can call non-static methods like this: method(); or this.method();

When you use the second syntax with this, you will be telling the compiler that you will be calling from the instance you are in (explicit).

Both will work the same way.

But, there is another example that can set this clear for you. Thinking on variables. Check this code:

private int a = 1;

public void method(int a) {
    this.a = a;
}

The object's variable is set using a local variable. If you do not use this for that call, the compiler would understand that the variable you are dealing with was just the local one.

Hope it helps.

If a static method is defined within, say TheClass, you can call it from within other methods of this class by simply methodName(_arguments_) or by TheClass.methodName(_arguments_). — Pavlo Maistrenko, Oct 04 '20 at 19:03

score 1 · Answer 4 · answered Mar 05 '15 at 22:07

When you write this in a class in Java (or when it is implied), you are refering to the object instanciating that class so this is a reference to an object not a class. This is hard to get at first but there is a difference between the concept of object and class in object oriented programming and therefore in Java.

Note also that when you call a static method, you use the name of the class containing the static method because the static method is a concept defined for the class not the particular objects instanciating that class.

Calling methods in Java

4 Answers4