Learning java, why are my privates private?

Question

Im learning java, coming from python there are quite a few things I don't fully understand that exist in java and the first of these has to be public and private declarations. I mean from a language that has no real visible public private declarations to a language where everything MUST be private, I understand the ground principle about what they do. Im asking 'why' they do it. Why should anyone care who touches there private parts? It shouldn't really be a problem if your a good programmer you know which bits you 'should' and 'should not' poke in code. So why the secrecy? Why hide and obscure and make things private from the world? Why care to start with.

Answer 1

(Opinionated answer follows.)

This is because Java is a bondage and discipline language, designed to cater for mediocre programmers. Python, otoh, is a language aimed at consenting adults who agree to expose their objects' private parts to each other, trusting other programmers not to abuse the undocumented/unguaranteed functionality offered to them. If they do and anything breaks, the person who broke stuff gets to keep the pieces.

Python does have some access control, such as __all__ to hide/show parts of a module, it's just that all of it is optional and can be by-passed at the risk of the person doing so.

(To repeat what I said in the comment: I'm not saying that all Java programmers are mediocre. I'm just saying that the language is designed so that it can safely be used by such programmers.)

Answer 2

Because others people don't care nearly as much about your privates as you do. You decide what is and isn't private.

On a serious note, public things define the API - the contract with the outside world - it's an important decision to make. On the other hand, as much stuff as possible should be private - that's encapsulation. Welcome to OO.

Answer 3

You don't want other programmers accessing and possibly modifying your private variables. e.g.

private int ryan; //its your responsibility to save private ryan

All jokes aside, privates are useful for encapsulation. Plus, private constructors disallow subclassing and feature in the factory method pattern. Classes with private constructors only allow objects to be instantiated within this class (which can be done via a static public method for example).

So as you can see, privates can be quite useful....

Answer 4

This principle of hiding data members is known as Data Encapsulation.

From the article above:

The advantage of using data encapsulation comes when the implementation of the class changes but the interface remains the same. For example, to create a stack class which can contain integers, the designer may choose to implement it with an array, which is hidden from the user of the class. The designer then writes the push() and pop() methods which puts integers into the array and removes them from the array respectively. These methods are made accessible to the user. Should an attempt be made by the user to access the array directly, a compile time error will result. Now, should the designer decide to change the stack's implementation to a linked list, the array can simply be replaced with a linked list and the push() and pop() methods rewritten so that they manipulate the linked list instead of the array. The code which the user has written to manipulate the stack is still valid because it was not given direct access to the array to begin with.

Answer 5

You are free to declare every field in your class as public. Why this is not considered "good practice" is because in a multi-developer situation, where a codebase has to be maintainable over time (and after you leave), it is important for other people to be able to understand your classes (and how they should and should not be used). Making a field "private" is an excellent way to forcible indicate that this field is internal to the workings of the class and should not be modified from the outside. It's not about "obscuring", it's about "securing" and "maintaining" (see above posts about API and contract).

Sure, a "good programmer" would be able to eventually figure out the exact workings of your code, given enough time - but why would you not spare him or her that time by instead making the effort of only exposing the "public" functionality (the API) and hiding the stuff that should not be touched?

On a side-note, and purely for your benefit, not practicing proper data encapsulation and API/public interface discipline will make your peers detest you and will most likely get you fired, in short order. The code you produce will be regarded (rightly) as very brittle and unmaintainable.

Answer 6

Take this example of why you might want to prevent other programmers, or even yourself, from using a variable directly.

class Car() {
    public int speed;
}

You, or another programmer, might just do "speed = -20" (perhaps because a calculation was wrong or another function isn't acting as expecting). Then when you try to use your speed, you get weird results and spend time and energy tracking down the problem. This is a better solution:

class Car() {
    private int speed;

    public void setSpeed(int newSpeed) {
        if (newSpeed < 0)
            throw new Exception("Car speeds can't be negative!");
        speed = newSpeed;
    }

    public int getSpeed() {
        return speed;
    }
}

You will know right away if your interface is used as you don't intend.

Your question indicates that you might be a little confused about why public and private methods are even useful, so let's take a step back.

You don't declare "everything" private. You declare things private when you do not want other classes using them -- they are totally for internal use. You declare things public when use of your class requires calling that method or using that variable. Indeed, a class with no public methods wouldn't be that useful! (this statement is a pure lie but it works for what we're talking about.)

By making the things you intend to be used from outside the class public and everything else private, you are creating an interface for people using your classes -- either you or others. The heavy lifting is hidden from every other class.

In one sentence: "Program to an interface, not an implementation." When you write a class, the first thought should be "How do I intend other classes to use my class?", not "How should I get the functionality I want?" In my opinion, that distinction is the difference between the mindsets you should have when doing imperative programming and object oriented programming.

Answer 7

well it is really easy to understand the need for private modifiers in java which is purely an object oriented language

consider you have a very nice sports car A!

would you like to have a field called gasPumped and maybe some other fields that may increase the speed?

or

would you like to have a function called increaseSpeed() which access all these fields?

Probably when you get the new version of this car, it will have the same increaseSpeed() with much more fields that are manipulated!

The car manufacturer wants you to know that you can

increaseSpeed()

but he doesnt really want you to know the inside parts!

Answer 8

I would say that privates are private in Java because:

• the mechanism is inherited from C++ (in C++, having all fields/methods be accessible by clients would mean putting them in the header file, which would put a significant and undue burden on the clients)
• it allows for some static optimizations that are otherwise impossible (e.g. you can inline a private method call - effectively removing the method from the compiled class, while still keeping your source code structured).

Answer 9

• It simplifies the API to keep implementation dependent stuff private.
• Good object oriented design demands that each class has its own scope of functionality. Hence its a good thing to keep others from violating this by accessing such fields or implementation dependent methods directly.
• Classes are easier to maintain this way. For example changing the internal data structure doesn't affect others which would be the case when they accessed the fields directly.
• Other people can't mess up the object's state.