What is class variable and an instance variable?

When you declare static variables in a class you can access them from anywhere without creating an object from it. For example:

public class Persona{
  static public String nombreEstatico = "Nombre Estatico";
  public String nombreMiembroClase = "Nombre Miembro de la clase";
}
public class Main{
  static public main(String[] args){
  System.out.println(Persona.nombreEstatico);
  Persona persona = new Persona();
  System.out.println(persona.nombreMiembroClase);}}

You call static variables with the name of the class and a period, and the name of the variable or function. To access variables of the object (the non-static ones), we must instantiate an object of it and access its variable or function.

First it is necessary to point out that the Java language specification is quite exact in the terms it uses, and in particular the word member is not used. We always talk about variables that belong to a class, an object or a method.

Referring to the specification we find the following:

There are eight types of variables:

1. A class variable is a field declared using the reserved word staticwithin a class declaration or with or without the reserved word staticwithin an interface declaration. A class variable is created when your class or interface is prepared and is initialized to a default value. The class variable ceases to exist when its class or interface is unloaded.
2. An instance variable is a field declared within a class declaration without using the reserved word static. If a class Thas a field athat is an instance variable, then a new instance variable ais created and initialized to a default value as part of each new object created from the class Tor from any class that is a subclass of Tthe instance variable. ceases to exist when the object of which it is a field is no longer referenced, after any necessary completion of the object has been completed

Class variables belong to the class definition. To define one, the keyword is used staticas a modifier.

public class Car {

    public static int total = 0;

    public Car() {
        total++;
    }

    public static int getTotal() {
        return this.total;
    }
}

The variable totalis shared by all objects of type Carthat are created:

Car carro1 = new Car(); //total=1
Car carro2 = new Car(); //total=2, la variable se comparte en todas las referencias
System.out.println(carro1.total); //Imprime 2
System.out.println(carro2.total); //Imprime 2

Every time I create an object of type I Carincrease the variable total(number of objects created) by one, since the variable is shared by all objects (because it belongs to the class definition), when in principle one could think of a variable class as a 'global variable. Since the definition of the variable belongs to the class, it is possible to access it without using an object reference, so this is absolutely valid:

System.out.println(Car.total); 

we access the variable through the class name and not through some reference to an object.

Instance variables are those that are declared in a class but without the reserved wordstatic

public class Book {

    private int total = 0;

    public Book() {
        total++;
    }

    public int getTotal() {
        return this.total;
    }

    public void setTotal(int total) {
        this.total = total;
    }

}

Unlike class variables, ownership and responsibility for these belongs to each object that is created. For example:

Book libro1 = new Book(); //la variable total de esta referencia es 1
Book libro2 = new Book(); //la variable total de esta referencia es 1 y NO es la misma que la variable total de la referencia libro1

In other words, instance variables are the responsibility of each instance of a class, so each has its own copy of the variable, and changing the value of an instance variable in the object will libro1not change the value of the same variable. instance with the same name in the objectlibro2

libro1.setTotal(10); //Al modificar la variable de instancia total en la referencia libro1 sólo modifico la copia de esta
System.out.println(libro1.getTotal() == libro2.getTotal()) //Imprime false, ya que son variables diferentes.
libro2.setTotal(8); //De igual modo, al modificar la variable de instancia total en la referencia libro2 tampoco modifico la variable del mismo nombre en la referencia libro1 porque son variables diferentes.
System.out.println(libro1.getTotal() == libro2.getTotal()) //Imprime false, ya que son variables diferentes.

This video explains class variables and instance variables: https://www.youtube.com/watch?v=SLyl1OO7CzQ