Accessing private members

[John O Sullivan]

This appears kind of quirky to me, just trying to understand what is happening here.
Should I not be able to access the newly created objects private variables?
I understand it is the same class but still they are private fields so how are they accessible?

public class WaterBottle {
    private String brand;

    public static void main(String[] args) {
        new WaterBottle().x();
    }

    public void x() {
        WaterBottle wb = new WaterBottle();
        System.out.println("Brand = " + wb.brand);

        WaterBottle wb2 = new WaterBottle();
        System.out.println("Brand = " + wb2.brand);
    }
}

Thanks,

[Paul Anilprem]

Because private means private to the class and not to the object.
The code accessing a field is written in a class, so how would it work if it were private to an object? How would the compiler accept/reject the code because there is no object at compile time.

[John O Sullivan]

Paul Anilprem wrote:Because private means private to the class and not to the object.
The code accessing a field is written in a class, so how would it work if it were private to an object? How would the compiler accept/reject the code because there is no object at compile time.

So objects just have access to private members of other objects of the same type..?
That seems like it has potential for issues..

public class Main {

    public static void main(String[] args) {
        Customer c1 = new Customer(10000);
        Customer c2 = new Customer(50);
        c1.x(c2);
    }
}
class Customer {
    private long account;
    public Customer(long account) {
        this.account = account;
    }

    public void x(Customer other) {
        System.out.println("Account savings = " + other.account);
    }
}

[Paul Anilprem]

>So objects just have access to private members of other objects of the same type..?
No, they don't just have access to private members. They have access to public, protectec, and default members also.

>That seems like it has potential for issues.
You could say that but I don't think it really is an issue because it is still the developer/owner of the class who decides what members should be accessed and/or modified in any of its methods. It is not like someone else is able to modify fields of object of some one else's class.

In any case, that is just how Java does it.

[John O Sullivan]

Paul Anilprem wrote:>So objects just have access to private members of other objects of the same type..?
No, they don't just have access to private members. They have access to public, protectec, and default members also.

That's not quite what I meant by the 'just' but fair enough, haha.

Paul Anilprem wrote:>
>That seems like it has potential for issues.
You could say that but I don't think it really is an issue because it is still the developer/owner of the class who decides what members should be accessed and/or modified in any of its methods. It is not like someone else is able to modify fields of object of some one else's class.

Sure, I do see you're point, it's just that mistakes can be made over time and things exposed which shouldn't be.
It's just kind of surprising that it is this way, it had me wondering if I was missing something, hence the question.

Paul Anilprem wrote:>
In any case, that is just how Java does it.

So it is

[Campbell Ritchie]

It was intended all along that private members of a class be accessible from the whole of the class; as Paul said, only the people creating that class can access them. It makes it much easier to write the equals() method.

class Foo
{
   private int i;
   private String s; // What good naming of variables!
   // ...
   /* One other method must be overridden too */
   @Override
   public boolean equals(Object ob)
   {
      return ob == this ||
      ob instanceof Foo &&
      ((Foo)ob).i == i &&    // 0r ... this.i &&
      ((Foo)ob).s.equals(s); // 0r ... (this.s);
   }
   // ...
}

Think how much more difficult that would be if private members were accessible only in their own object.
The above is a very basic and old‑fashioned way to write equals(); nowadays you would write this:-

class Foo
{
   private int i;
   private String s;
   // ...
   /* One other method must be overridden too */
   @Override
   public boolean equals(Object ob)
   {
      return ob == this ||
      ob instanceof Foo f &&
      f.i == i &&
      f.s.equals(s);
   }
   // ...
}