I print correct, I think - but still don't pass :S

The base class Person does not know about methods the descendants may have. That's why you check with instanceof if an object is of a certain type. If so, you can cast it (eg. to a User type) and call that types methods. A static method has no reference attached to it while instance methods do. Static methods you usually just use inside utility classes while for the rest you go oop. Here you have inheritence and polymorphism (fully use of abstract classes and interfaces). You'll see later what you can do with that.

As Thomas says, the keyword 'static' means that the method (or class or field) is independent of any object. It's hard to explain but think of static as being shared between all objects. As an abstract example think of memory like boxes that contain information. Now imagine that a class field or a method (static or not) needed 1 block of memory. To access any field or method a computer needs to go get the box that contains it. If I had class code that contained: 1 static field 1 field 1 static method 1 method and I create the very first object of this class then the computer would have 4 boxes in memory reserved, 1 for each field/method, and to access any of the fields or methods the computer would go to the specific box and get it. Now if I created a second object only 2 more boxes would be created for the new object for the non static items. If i were to call the non static field on the first object the computer would go to the box that contained the first objects non-static field. If I were to call the same field on the second object the computer would go to the second object's box that had that field. Now for the static methods/fields, no matter what object I tried to access them from the computer would go to the same box to retrieve it. This is very abstract so don't memorize it as rules. Java has very specific rules for static methods, fields, and classes that you will learn as you go.

Here is a coded example:

public class Solution {
    /* here we use both a static field and a regular field*/
    static int staticField;
    int nonStaticField;

    /*In the constructor we set both the static and regular field
    to the same EXACT value
     */
    Solution(int x) {
        staticField = x;
        nonStaticField = x;
    }

    @Override
    public String toString() {
        return "{" +
                "nonStaticField=" + nonStaticField +
                "; staticField= " + staticField+
                "}\n";
    }

    void addOne() {
        nonStaticField++;
        staticField++;
    }

    public static void main(String[] args) {
        Solution s1 = new Solution(1);
        Solution s2 = new Solution(2);
        Solution s3 = new Solution(3);

        System.out.print("Printing s1 -- " + s1);
        System.out.print("Printing s2 -- " + s2);
        System.out.print("Printing s3 -- " + s3);
        System.out.println();

        /*adds one to both fields of each object and then prints result
        in order*/

        s1.addOne();
        System.out.print("Printing s1 -- " + s1);
        s2.addOne();
        System.out.print("Printing s2 -- " + s2);
        s3.addOne();
        System.out.print("Printing s3 -- " + s3);
    }
}

The output from this code is: Printing s1 -- {nonStaticField=1; staticField= 3} Printing s2 -- {nonStaticField=2; staticField= 3} Printing s3 -- {nonStaticField=3; staticField= 3} Printing s1 -- {nonStaticField=2; staticField= 4} Printing s2 -- {nonStaticField=3; staticField= 5} Printing s3 -- {nonStaticField=4; staticField= 6}

In it you have two class fields, one that is static and one that is not. With the field that is not static, the value is going to be unique to each and every object created. The static field is independent and no matter how many objects are created it will remain the very last value that it was set to. In the main method 3 objects are created that simply use the numbers 1, 2, and 3 to set both the static and non-static fields. Then each object is output. This is the first three lines of output and hen looking at them you can see that the non-static field has the unique number passed to the object constructor, however the static field for all three objects is 3. This is because 3 was the last value set to it (on line 9) before outputting the information. In main, after each object is output the first time, next I call a method that increases both the static field and the non-static field, followed immediately by outputting the object. If you look at the next lines of output you can see that each object has had their unique non-static field increased by one, but the static field has increased 3 times to now equal 6.

thank you! I think, I understand it more now!

It's a bit confusing at first, but it will slowly start making sense more and more as you are exposed to it.