please can someone help me to understand what exactly each line does and the sequence of the lines, i want to understand when we run the code which line works first and what does it do. If possible comment before each line like i did

Line13: the 'name' variable does not go to line 22 and does not read "Charlie". The program section between lines 7 and 15: it is the Cat class. It does nothing on its own. This is just a template for Cat objects to be created later. Until you create at least one Cat object, lthe program section between lines 7 and 15 do not exist for the Java Machine. On line 21, you create the first Cat object. This 'cat' object has a setName method. On line 22, you send the string "Charlie" to the setName method of that 'cat' object, which will set the 'name' variable of the 'cat' object to "Charlie".

when you "new" an object, you actually create an instance of this object. You can think object as a template of something. e.g.

Cat c = new Cat();

c is an instance of Cat object. then you can use c to do something. for example, c.setName("a name"); when you call an method(non static) of this object, like c.setName(parameter), you are actually call something like c.setName(this, parameter). self means c itself in this example. so you can see in some languages like python they use "self". because in reality you probably will create multiple instances of this object. So by using "this". the program knows which instance you are referring to. for static methods, we do not pass "this" to the method, so often you will see we use the object to call the static method. like Cat.staticMethod(parameter); For the second question: You can't access an instance variable from static methods. for static methods, we do not pass "this" to the method, so if you want to access non-static instance variable, we do not know which one you want to access.

System.out.println(cat.name);

this line is right. but if you do this

System.out.println(name);
//or
System.out.println(this.name);

this is not right.

public class MyClass {

    private String text;

    /**
     * This method has a parameter (text). If you use the variable text inside this method it refers to this parameter.
     * If you want to refer to the field text (the instance variable), then this is not possible anymore using just text.
     * But you can if you use this.text (where this just means 'the current object' - it's referencing the current object)
     */
    public void setText(String text) {
        System.out.println(text); // refers to the passed argument
        System.out.println(this.text + " text from field"); // the field, before assigning a value null
        this.text = text; // assign the parameter texts value to the field text
        System.out.println(this.text + " text from field");

        // here we can invoke other instance methods, this works from inside an instance method
        instanceMethodCall();
    }

    private void instanceMethodCall() {
        System.out.println("inside 2nd instance method");
    }

    public static void staticPrint(String text) {
        System.out.println(text);
    }

    public static void main(String[] args) {
        // inside a static method, now we can not invoke instance methods like static ones, we always need a reference
        // to an object
        staticPrint("Hi"); // no problem
        // setText("test"); // does not compile, reference needed
        MyClass mcObject = new MyClass();
        mcObject.setText("inside instance method");
    }
}

The this keyword refers to the current object. This becomes clearer later on when you work more with objects.