Руководство по модификатору static в Java

public class Car {

    static int numberOfCars;

    private String name;
    private String engine;  	 
  	 
    public Car(String name, String engine) {
        this.name = name;
        this.engine = engine;
        numberOfCars++;
    }
    
    // getters and setters
}

public class CarMain {

    public static void main(String[] args) {
        Car car1 = new Car("Jaguar", "V8");
        Car car2 = new Car("Bugatti", "W16");

        System.out.println("Результат: " + Car.numberOfCars);
    }
}

Результат: 2

import java.io.Serializable;

public class Student implements Serializable {

    private static final long serialVersionUID = 1234567890l;
    static int age;
    static transient String faculty;

    String firstName;
    transient boolean examPassed;
}

import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;

public class SerializationStudent {
    public static void main(String[] args) {
        Student student = new Student();
        student.firstName = "Игорь";
        student.examPassed = true;
        student.age = 22;
        student.faculty = "Факультет авиационных и космических систем";

        try (FileOutputStream fos = new FileOutputStream("./out.txt")) {
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(student);
            System.out.println("Данные сериализованы в out.txt");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.FileInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;

public class DeSerializationStudent {
    public static void main(String[] args) {
        Student student = null;

        try (FileInputStream fis = new FileInputStream("./out.txt")) {
            ObjectInputStream ois = new ObjectInputStream(fis);
            student = (Student) ois.readObject();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException c) {
            System.out.println("Класс Student не найден");
            c.printStackTrace();
            return;
        }

        System.out.println("Десериализация объекта Student...");
        System.out.println("Имя студента: " + student.firstName);
        System.out.println("Возраст студента: " + student.age);
        System.out.println("Экзамен сдан? " + student.examPassed);
        System.out.println("Факультет студента: " + student.faculty);
    }
}

import java.io.Serializable;

public class Student implements Serializable {
    private static final long serialVersionUID = 1234567890l;
    static int age = 17;
    static transient String faculty = "Факультет радиофизики";

    public String firstName = "Катя";
    transient boolean examPassed = true;    
}

public class Main {
    public static void main(String[] args) {
        static String wrongVar = "Modifier 'static' not allowed here";     
        System.out.println(wrongVar);
    }
}

В примере с классом Car присвоим 100 статической переменной numberOfCars:
public static int numberOfCars = 100;

А затем обратимся к этому полю через класс Car:
System.out.println("Результат: " + Car.numberOfCars);

Результат: 100

// Рекомендуется
System.out.println("Результат: " + Car.numberOfCars);

// Не рекомендуется, но работает
System.out.println("Результат: " + car1.numberOfCars);

public class Test {
    int x;

    public static void main(String[] args) {
        x = 0;
    }
}

public class MathUtils {
    public static int sumOfInts(int i, int...nums) {
        int sum = i;

        for(int num : nums) {
     	      sum += num;
        }
        return sum;
    }
}


class Main {
    public static void main(String[] args) {
        System.out.println("Результат: " + MathUtils.sumOfInts(1, 2, 3));
    }
}

Результат: 6

public interface Arithmetic {
    public static int multiply(int a, int b) {
        return a * b;
    }
}

class Main {
    public static void main(String[] args) {
        int result = Arithmetic.multiply(2, 3);
        System.out.println(result);
    }
}

Результат: 6

public class SuperClass {
    public static void staticMethod() {
        System.out.println("SuperClass: внутри статического метода");
    }

    public void notStaticMethod() {
        System.out.println("SuperClass: внутри не статического метода");
    }
}

class SubClass extends SuperClass {
    //Попытка "переопределения" статического метода
    public static void staticMethod(){
        System.out.println("SubClass: внутри статического метода");
    }

    // переопределение не статического метода
    public void notStaticMethod() {
        System.out.println("SubClass: внутри не статического метода");
    }
}

class Main {
    public static void main(String[] args) {
        SuperClass superClassWithSuperCons = new SuperClass();
        SuperClass superClassWithSubCons = new SubClass();
        SubClass subClassWithSubCons = new SubClass();

        superClassWithSuperCons.staticMethod();
        superClassWithSubCons.staticMethod();
        subClassWithSubCons.staticMethod();

        System.out.println();

        superClassWithSuperCons.notStaticMethod();
        superClassWithSubCons.notStaticMethod();
        subClassWithSubCons.notStaticMethod();
    }
}

import static java.util.Arrays.asList;

// Без статического импорта
Assertions.assertThat(1).isEqualTo(2);

// С использованием статического импорта
import static org.assertj.core.api.Assertions.*;

assertThat(1).isEqualTo(2);

List<Integer> numbers = Arrays.asList(1, 2, 3);

// Имя метода "asList" информативно само по себе
List<Integer> numbers = asList(1, 2, 3);

// получение даты следующей пятницы относительно сегодня
LocalDate.now().with(TemporalAdjusters.next(DayOfWeek.FRIDAY));

// Более элегантное и легкое для чтения выражение
LocalDate.now().with(next(FRIDAY));

public class Main {
    public static void main(String[] args) {
        System.out.println(Math.sqrt(Math.abs(Integer.MIN_VALUE) - 
                Math.max(Integer.MAX_VALUE, Integer.MIN_VALUE)));
    }
}

import static java.lang.Integer.*;
import static java.lang.Math.*;
import static java.lang.Math.max;

public class Main {
    public static void main(String[] args) {
        System.out.println(sqrt(abs(MIN_VALUE) - max(MAX_VALUE, MIN_VALUE)));
    }
}

public class StaticBlockDemo {
    public static List<String> ranks = new LinkedList<>();
    
    static {
        ranks.add("Lieutenant");
    	ranks.add("Captain");
    	ranks.add("Major");
    }
  	 
    static {
        ranks.add("Colonel");
        ranks.add("General");
    }
}

public class Test {
    
    static {
        System.out.println("Вызов статического блока");
    }

    Test() {
        System.out.println("Вызов конструктора");
    }
}

class Main {
    public static void main(String[] args) {
        Test t1 = new Test();
        Test t2 = new Test();
    }
}

public class Singleton  {    
    private Singleton() {}
   
    private static class SingletonHolder {    
        private static final Singleton INSTANCE = new Singleton();
    }    
    
    public static Singleton getInstance() {    
        return SingletonHolder.instance;    
    }    
}