Static Classes, Methods and main()

In the second code snippet, Foo is nested inside Main. Nested classes can be either inner classes or static. If they are inner classes (non static), each instance of the inner class must be associated with an instance of the enclosing class.

Therefore, if you remove the static keyword from Foo class in the second snippet, you'll have to instantiate it with :

Foo foo = new Main().new Foo("Foo"); 

When the nested class is static, it doesn't require an instance of the enclosing class, and you can instantiate it with

Foo foo = new Foo("Foo"); 

On the other hand, in your first snippet, Foo is not nested inside Main, so you don't need an instance of Main in order to instantiate it. And it cannot be static, since top level classes can't be static.

I thought i'd got the concept of static down. but apparently i lack a lot of concepts.

When applied to nested classes, the static keyword has a different meaning than it has when applied to methods and variables. You should read about nested classes.

In the top example, you have two independent classes in the same file. main can reference Foo because it's just another class.

In the bottom example, you have a static nested class. It's also able to be instantiated independently. If you got rid of the static keyword on Foo you'd have an inner class, tied to a particular instance of Main, but when you are running the static main method there is no particular instance of Main to reference.

This reference might help: https://docs.oracle.com/javase/tutorial/java/javaOO/nested.html

In java, we can’t make Top level class static. Only nested classes can be static. So,For 1st scenario you will not be able to make the Foo class as static. for the 2nd Scenario Non-static nested classes (inner classes) have access to other members of the enclosing class, even if they are declared private. Static nested classes do not have access to other members of the enclosing class.

Java is an Object Oriented programming language.

If you need a non-static declaration, field, method etc. from a class you need to create an instance from this class.

But to access static fields, methods you do not need to create an instance.

Now have a look at your example;

1.Main and Foo is different classes so you can create an instance from Foo everywhere.

public class Main { public static void main(String[] args) { Foo foo = new Foo("Foo"); } } class Foo { public Foo(String A) { System.out.println(A); } } 

2.Foo is an inner class and Foo class is never accessible if an instance of Main not created. So If you create a Main instance you can create Foo too. But without creating a Main instance, only accessing Foo is defining Foo class as static

public class Main { public static void main(String[] args) { Foo foo = new Foo("Foo"); } static class Foo { public Foo(String A) { System.out.println(A); } } }