What is "encapsulation"

Encapsulation is a property of the system that allows you to combine data and methods that work with it in a class and hide implementation details from the user, revealing only what is needed for subsequent use.

The goal of encapsulation is to get away from the implementation dependency of the external interface of a class (something that other classes can use). So that the slightest change in the class does not entail a change in the external behavior of the class.

Let's imagine for a moment that we found ourselves at the end of the century before last, when Henry Ford had not yet invented the conveyor belt, and the first attempts to create a car faced criticism from the authorities that these smoking monsters pollute the air and scare horses. Imagine that in order to drive the first steam car, it was necessary to know how the steam boiler works, constantly toss up coal, monitor the temperature and water level. In this case, to turn the wheels, use two levers, each of which turns one wheel separately. I think we can agree that driving a car at that time was very uncomfortable and difficult.

Now let's return to today to the modern wonders of the auto industry with an automatic transmission. In fact, in essence, nothing has changed. The gas pump still supplies gasoline to the engine, differentials provide wheel rotation at different angles, the crankshaft converts the forward motion of the piston into rotational motion of the wheels. Progress is different. Now all these actions are hidden from the user and allow him to turn the steering wheel and press the gas pedal without thinking about what happens to the injector, the throttle valve and the camshaft. It is the concealment of the internal processes occurring in the car that allows it to be effectively used even by those who are not a professional auto mechanic with twenty years of experience. This hiding in OOP is called encapsulation.

Example:

public class MyPhone {

    private int year;
    private String company;

    public MyPhone (int year, String company) {
        this.year = year;
        this.company = company;
    }

    private void openConnection() {
        // findComutator
        // openNewConnection ...
    }

    public void call() {
        openConnection ();
        System.out.println("Calling the number");
    }

    public void ring() {
        System.out.println("Tink-Tink");
    }
}

The private modifier makes the fields and methods of the class available only within this class. This means that it is impossible to access private fields from outside, just as there is no way to call private methods.

Hiding access to the openConnection method also leaves us free to change the internal implementation of this method, since this method is guaranteed not to be used by other objects and will not break their work.

To work with our object, we leave open the call and ring methods using the public modifier. Providing public methods for working with an object is also part of the encapsulation mechanism, since if you completely close access to the object, it will become useless.

Read also:


Comments

Post a Comment

Popular posts from this blog

Methods for reading XML in Java

Image
DOM (Document Object Model) - object - reads XML, recreating it in memory in the form of an object structure, while the XML document is represented as a set of tags - nodes. Each node can have an unlimited number of child nodes. Each child can also contain several levels of descendants or none at all. Thus, the result is a kind of tree. Pluses: Easy to program. If there are many objects in XML with cross-references to each other, it is enough to go through the document twice: first time create objects without references and fill in the name-object dictionary, the second time - restore links. If an error occurs in XML, a half-created XML structure remains in memory, which will be automatically destroyed. Suitable for both reading and writing. Minuses: Low speed. Wastes a lot of memory. SAX (Simple API for XML) - event-driven - reads an XML document, responding to emerging events (opening or closing tag, string, attribute) by calling the event handlers provided by the appl...
Read more

XML, well-formed XML and valid XML

Image
XML, the eXtensible Markup Language, is a language with a simple formal syntax, well suited for creating and manipulating documents with programs, and at the same time easy to read and create documents by humans. XML is extensible, it does not fix the markup used in documents, and the developer is free to create markup in accordance with the needs of a particular area, being limited only by the syntax rules of the language. DTD A DTD, Document Type Definition, is a predefined set of rules that defines the relationships between elements and attributes. For example, the DTD for HTML says that the DIV tag must be inside the BODY tag and can appear multiple times, TITLE - in HEAD and only once, and SCRIPT - both there and there as many times as you want. A DTD is usually described directly in the document as a formulation line starting with <!DOCTYPE ... > or in a separate file. Difference between well-formed XML and valid XML Depending on the level of compliance, the document...
Read more

ArrayList and LinkedList in Java, memory usage and speed

Image
How much extra memory is needed when calling ArrayList.add()? If there is enough space in the array to accommodate a new element, then no additional memory is required. Otherwise, a new array is created, 1.5 times larger than the existing one (this is true for JDK above 1.7, in earlier versions the size of the increase is different). How much extra memory is allocated when you call LinkedList.add()? One new instance of the nested Node class is created. How much memory to store one byte primitive in LinkedList? Each LinkedList element stores a link to the previous element, the next element, and a data link. private static class Node<E> { E item; Node<E> next; Node<E> prev; //... } For 32-bit systems, each link is 32 bits (4 bytes). The object (header) of the nested Node class itself takes 8 bytes. 4 + 4 + 4 + 8 = 20 bytes, and since the size of each object in Java is a multiple of 8, so we get 24 bytes. A byte primitive occupies 1 by...
Read more