Variable Inheritance in Java

You can overwrite the value of Big.tellMe in the constructor of Little.

get rid of:

public String tellMe = "little";

and change the Little constructor to:

public Little(){
    tellMe = "little";
}

at that point, you can get rid of Little.tellMe() also.

What you are doing is hiding the super class field, not overriding it, as the Java documentation states. And it's also stated that it's not a good idea to do it.

So, the dynamic lookup won't work as for a method. If the variable is read from the son class, it will take "its" field value. On the top class, the other one.

What you can override in Java is the behaviour, so what I would suggest is to define a method

public String tellMe() {
  return "Whatever";
}

that you can override in the subclasses to return whatever string you need.

Instead of defining tellMe inside of Big (since you said you do not want to define/use that value in Big) you can create a function in Big:

public abstract String tellMeString();

And define that in each subclass like so (for Little):

public String tellMeString()
{
    return "Little";
}

Then theMethod can execute:

System.out.println ("Big was here: " + tellMe() + ", " + tellMeString());

In this case you wouldn't have to define a variable "tellMe" at all, you just override tellMeString in each subclass to return different Strings.

Fields are not inherited as you are expected. You can access the super class' field (unless it is private) from subclass. But you cannot "override" field. This is why tellMe used by method implemented in super class Big uses variable defined in the same class.

If you want inheritance use methods. For example you can implement method "tellMe()" that returns "BIG" in super class and "little" in subclass:

class Big {
    protected String tellMe() {
        return "BIG";
    }
}
class Little {
    @Override
    protected String tellMe() {
        return "Little";
    }
}

Alternatively you can initialize variable tellMe in constructor:

class Big {
    private String tellMe;
    public Big() {
        this("BIG");
    }
    protected Big(String tellMe) {
        this.tellMe = tellMe;
    }
    protected String tellMe() {
        return "BIG";
    }
}
class Little {
    public Little() {
         super("Little");
    }
}

Now new Little().tellMe() will return "Little": the variable in super class was initialized when constructing the object; the method defined in super class returned this variable.

Methods can be overridden, fields are visible at the scope where they're called.

static class Big {
    String field = "BIG";
    String bark()   { return "(big bark)"; }

    void doIt() {
        System.out.format("field(%s) bark(%s)\n", field,bark());
    }
    void doIt2()    {
        System.out.format("2:field(%s) bark(%s)\n", field,bark());
    }
}

static class Small extends Big {
    String field = "small";
    String bark()   { return "(small bark)"; }
    void doIt2()    {
        System.out.format("2:field(%s) bark(%s)\n", field,bark());
    }
}

public static void main(String... args) {

    Big b = new Big();
    b.doIt();
    b.doIt2();

    Small s = new Small();
    s.doIt();
    s.doIt2();
}

Output is:

field(BIG) bark((big bark))
2:field(BIG) bark((big bark))
field(BIG) bark((small bark))
2:field(small) bark((small bark))

since doIt() is defined in the Big class, it will always see the Big version of field. doIt2() is defined in Big, but overridden in Small. The Big.doIt2() sees the Big version of field, the Small.doIt2() version sees the Small version of field.

As others have pointed out, it's a pretty bad idea to do this - a better approach is to set the new value in the subclass constructor, or to use a method which is overridden.