როგორ შეიძლება შეერთდეს package-private წვდომა Java-ში ინკაპსულაციასთან?

პაკეტ-პრივატული წვდომა, რომელიც Java-ში წარმოადგენს დეფოლტულ წვდომის დონეს (public, protected ან private გარეშე), შეზღუდავს კლასის წევრების (ფილდერების, მეთოდების, კონსტრუქტორების) ხილვადობას მხოლოდ იმ პაკეტში, სადაც ისინი განთავსებულია. ინკაპსულაცია — ეს ობიექტ-ორგანიზებული პროგრამირების პრინციპია, რომელიც გულისხმობს მონაცემებისა და მეთოდების დამალვას ობიექტის შიგნით, მათზე კონტროლირებადი წვდომის მიცემით (პუბლიკურ ინტერფეისების მეშვეობით).

პაკეტ-პრივატული წვდომა და ინკაპსულაცია ერთობლივად მუშაობს შემდეგი გზით:

1. მონაცემების დამალვა: კლასის წევრები გამოაცხადება private მორფიკატორით. ეს უზრუნველყოფს, რომ ისინი არ იქნება პირდაპირ ხელმისაწვდომი გარედან.
2. კონტროლირებადი წვდომა იმ პაკეტში: იმისათვის, რომ მიეცეს წვდომა პირად ფილდერებზე ან ოპერაციებზე მათზე იმავე პაკეტში, გამოიყენება package-private წვდომის მეთოდები.

მაგალითი:

დავუშვათ, გვაქვს com.example.internal პაკეტი და InternalData კლასი:

package com.example.internal;

public class InternalData {

    private int value; // პირადი ფილდი

    // კონსტრუქტორი `package-private` წვდომით
    InternalData(int value) {
        this.value = value;
    }

    // `package-private` მეთოდი მნიშვნელობის შეცვლისთვის
    void setValue(int value) {
        this.value = value;
    }

    // `package-private` მეთოდი მნიშვნელობის მისაღებად
    int getValue() {
        return this.value;
    }
}

ამ კლასში:

• value ფილი აქვს private მორფიკატორი, რაც უზრუნველყოფს მონაცემების დამალვას.
• InternalData(int value) კონსტრუქტორი, setValue() და getValue() მეთოდები აქვთ package-private წვდომა (მოდიფიკატორი არ არის მითითებული).`

შემდეგ, InternalService კლასი იმავე პაკეტში, com.example.internal, გამოიყენებს InternalData ობიექტებს:

package com.example.internal;

public class InternalService {

    public void processData() {
        // ქმნის `InternalData` ობიექტს `package-private` კონსტრუქტორით
        InternalData data = new InternalData(100);

        // იყენებს `package-private` მეთოდებს
        System.out.println("დაწყებითი მნიშვნელობა: " + data.getValue());
        data.setValue(200);
        System.out.println("განახლებული მნიშვნელობა: " + data.getValue());
    }
}

აქ InternalService შეუძლია პირდაპირ გამოიძახოს setValue() და getValue() მეთოდები, რადგან ორივე იმავე პაკეტშია.

თუ შევეცდებით სხვა პაკეტიდან — მაგალითად, com.example.api — მიეღოთ წვდომა InternalData ან მისი package-private წევრებზე:

package com.example.api;

// import com.example.internal.InternalData; // შეცდომა იქნება თუ კლასი `public` არ არის

public class ExternalProcessor {

    public void someMethod() {
        // ცდილობს შექმნას `InternalData` ობიექტი — თუ კლასი `package-private` არის
        // InternalData data = new InternalData(10); // შეცდომა იქნება თუ კონსტრუქტორი `package-private` არის

        // ცდილობს წვდომა `package-private` ფილდერებზე ან მეთოდებზე
        // data.setValue(50); // შეცდომა
    }
}

აქ ჩვენ ვაწყდებით კომპილაციის შეცდომებს, რადგან ExternalProcessor კლასია სხვა პაკეტში — com.example.internal.

სummary:

პაკეტ-პრივატული წვდომა საშუალებას აძლევს განახორციელოს ინკაპსულაცია, შეზღუდოს კლასის შიდა დეტალების ხილვადობა მხოლოდ ერთ პაკეტში. ეს სასარგებლოა შიდა დამხმარე კლასების ან მეთოდების შექმნისთვის, რომლებიც გარედან გამოყენებისთვის განკუთვნილი არ არის, მაგრამ უნდა ჰქონდეთ შესაძლებლობა ურთიერთქმედონ იმავე პაკეტში სხვა კლასებთან, რათა შეინარჩუნოს კონსისტენცია და ლოგიკა. ფილდერები უნდა დარჩნენ private იმისათვის, რომ მაქსიმალურად მკაცრად შეინარჩუნოს ინკაპსულაცია.