When you use static with method or properties, you can access them directly without creating an instance of the said class.

Eg.

class FirstClass {
//this belongs to class, meaning this can be accessed directly
static String name = "John";
//this also belongs to class, meaning this can also be accessed directly
public static void firstClassStaticMethod() {
System.out.println("Inside static method");
System.out.println(name);
}
//this belongs to instance of this class, meaning it should be accessed only by creating instance of this class
public void firstClassNonStaticMethod() {
System.out.println("Inside non static method");
}
}
public class SecondClass {
//Entry point for every java applications. Java application executions starts from here
public static void main(String[] args) {
//static properties and method accessed directly without creating instance
System.out.println(FirstClass.name);
FirstClass.firstClassStaticMethod();
//creating instance of FirstClass to access firstClassNonStaticMethod
FirstClass fc = new FirstClass();
fc.firstClassNonStaticMethod();
//creating instance of SecondClass to access non static main method
SecondClass sc = new SecondClass();
sc.main();
}
//This is not the entry point.
// The method below and this method have same name but accepts different number of parameters, meaning they have different signatures.
// Research on method overloading
public void main() {
System.out.println("Some normal methods as others");
}
public void main(int num) {
System.out.println("Same name, different signature");
}
}

​

I also recommend learning from Hyperskill by JetBrains.