What is a Instance Variable?

These are variables declared with in a class, outside any method, with the static keyword.

In Java, a class variable (also known as a static variable) is a variable that is declared with the "static" keyword and is associated with a class, rather than an instance of the class. This means that there is only one instance of the class variable shared among all objects of that class. The value of a class variable can be accessed using the class name and the dot operator (.) without creating an instance of the class. Class variables are used to store information that is common to all instances of a class, such as a constant value that is shared among all objects of a class.

Here's an example to illustrate the use of a class variable in Java:

class Circle {
   static final double PI = 3.14;
   double radius;
   double area;

   void setRadius(double r) {
      radius = r;
      area = PI * r * r;
   }
}

public class Main {
   public static void main(String[] args) {
      Circle circle1 = new Circle();
      Circle circle2 = new Circle();

      circle1.setRadius(5);
      circle2.setRadius(10);

      System.out.println("Circle1: " + circle1.area);
      System.out.println("Circle2: " + circle2.area);

      // Accessing the class variable using the class name and the dot operator
      System.out.println("PI: " + Circle.PI);
   }
}

In this example, the PI class variable is a constant value that is shared among all instances of the Circle class. The value of PI is accessed using the class name and the dot operator (.) in the setRadius method to calculate the area of the circle. The result of this program will be:

Circle1: 78.5
Circle2: 314.0
PI: 3.14

Constructor gets invoked when a new object is created. Every class has a constructor. If we do not explicitly write a constructor for a class the java compiler builds a default constructor for that class.

A constructor in Java is a special type of method that is used to initialize objects of a class. It has the same name as the class and is called when an object of the class is created. A constructor can take arguments and can perform any initialization that is required for the object. The constructor is called automatically and is not invoked explicitly. The purpose of a constructor is to provide a convenient way to initialize objects with a specific set of values or properties.

Here is an example of a Java class with a constructor:

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

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

   // Getters and Setters
   public String getName() {
      return name;
   }

   public void setName(String name) {
      this.name = name;
   }

   public int getAge() {
      return age;
   }

   public void setAge(int age) {
      this.age = age;
   }
}

In this example, the Person class has a constructor that takes two arguments, name and age. The constructor initializes the instance variables name and age with the values passed as arguments. To create an object of the Person class, you can use the following code:

Person person = new Person("John Doe", 30);

In this code, the new keyword calls the constructor, and the arguments "John Doe" and 30 are passed to it. The constructor then initializes the name and age instance variables with these values.