In Java, there are four types of variables: instance variables, class variables, local variables, and parameters.

1. Instance variables are variables that are declared in a class, but outside of any method, constructor, or block. They are also known as fields or member variables. Instance variables have default values and are unique to each object of the class. They are accessed using the this keyword or by using the name of the variable.

Here is an example of an instance variable:

public class Person {
  private String name;
  private int age;

  public Person(String name, int age) {
    this.name = name;
    this.age = age;
  }

  // Getters and setters for the name and age attributes
}

In this example, the name and age variables are instance variables of the Person class. They can be accessed using the this keyword (e.g., this.name) or by using their names (e.g., name).

2. Class variables, also known as static variables, are variables that are declared using the static keyword. They are shared by all objects of the class and are accessed using the class name.

Here is an example of a class variable:

public class Person {
  private static int count;

  public Person() {
    count++;
  }

  public static int getCount() {
    return count;
  }
}

In this example, the count variable is a class variable of the Person class. It is shared by all objects of the class and can be accessed using the class name (e.g., Person.count).

3. Local variables are variables that are declared within a method, constructor, or block. They are only visible within the scope of the method, constructor, or block and are not accessible from outside.

Here is an example of a local variable:

public void doSomething() {
  int x = 10;
  // The x variable is only visible within the doSomething() method
}

In this example, the x variable is a local variable of the doSomething() method. It is only visible within the scope of the method and cannot be accessed from outside.

4. Parameters are variables that are passed to a method, constructor, or lambda expression as arguments. They are treated like local variables within the method, constructor, or lambda expression and are only visible within the scope of the method, constructor, or lambda expression.

Here is an example of a parameter:

public void doSomething(int x) {
  // The x variable is a parameter of the doSomething() method
  // It is treated like a local variable and is only visible within the method
}

In this example, the x variable is a parameter of the doSomething() method. It is treated like a local variable and is only visible within the method.