Does the order of declaration matter in Java/C# like it does in C++?

Question

In C++ I can't use a method if I declare it after the calling method.

Does this order matter in other languages like Java or C#?

Answer 1

I'm not sure about c#, but in java you can.

Answer 2

No

Answer 3

It doesn't in C#.

Answer 4

neither C# nor Java does.

Answer 5

In Java as well as in c# there is no separate method declaration.

The declaration of the method is done with its implementation. You also do not need to keep track of file includes so that the classes know about eachother as long as they are in the same namespace.

Answer 6

The variable should be accessible in the method where it is being used. It does not matter if it is declared before or after the usage.

Answer 7

Declaration order of methods never matters in C# or Java. Likewise it doesn't matter whether you declare a method before or after a variable that it uses.

Declaration order of variables can matter, however, when they're initialized one depends on another. For example (C#):

using System;

class Test
{
    static int x = 5;
    static int y = x;

    static void Main()
    {
        // Prints x=5 y=5
        Console.WriteLine("x={0} y={1}", x, y);
    }
}

but:

using System;

class Test
{
    static int y = x;
    static int x = 5;

    static void Main()
    {
        // Prints x=5 y=0
        Console.WriteLine("x={0} y={1}", x, y);
    }
}

Java prevents this exact situation, but it's easy to mimic:

public class Test
{
    static int y = getInitialValue();
    static int x = 5;

    public static void main(String args[])
    {
        System.out.println("x=" + x + " y=" + y);
    }

    static int getInitialValue()
    {
        return x;
    }
}

In C# things become even more confusing when you involve partial classes. Initialization occurs in textual order in C#, but that order isn't fully defined when you have multiple files contributing to the same class.

Needless to say, avoid this wherever you possibly can!

Answer 8

For Java, the authoritative answer is hidden in Chapter 1 (Introduction) of the Java Language Specification ("JLS," 3rd edition, viewable online for free):

Declaration order is significant only for local variables, local classes, and the order of initializers of fields in a class or interface.

Answer 9

No, the compiler does two passes.

Answer 10

There is one tricky case where lexically the function to be called can be declared after the point of call, but not semantically. This is because the class is deemed to be completely defined in the body of the class member functions.

$9.2.2 - "A class is considered a completely-defined object type (3.9) (or complete type) at the closing } of the class-specifier. Within the class member-specification, the class is regarded as complete within function bodies, default arguments and constructor ctor-initializers (including such things in nested classes). Otherwise it is regarded as incomplete within its own class member-specification."

struct A{
    void f(){g();}    // OK to call 'g' even if the compiler has not seen 'g' as yet
    void g(){};
};

int main(){
    A a;
    a.f();
}