Какие области видимости у модификатора package

Области видимости модификатора Package (Package-Private)

В Java существует четыре уровня доступа для членов класса (поля, методы, вложенные классы). Модификатор package-private (когда модификатор доступа не указан вообще) имеет особенные правила видимости.

1. Определение Package-Private

Package-private — это доступ по умолчанию, когда вы не используете никаких модификаторов (public, private, protected):

// ❌ Явно указан (это не package-private)
public class PublicClass { }
private class PrivateClass { }  // нельзя для top-level класса
protected class ProtectedClass { }  // нельзя для top-level класса

// ✅ Package-private: без модификатора
class PackagePrivateClass { }

public class MyPublicClass {
    int packageField;          // Package-private
    String packageMethod() { } // Package-private
    
    public int publicField;    // Public
    private int privateField;  // Private
    protected int protectedField; // Protected
}

2. Области видимости Package-Private

Package-private видна в следующих местах:

2.1 Внутри одного класса

package com.example;

public class Service {
    int count = 0;  // Package-private
    
    void processData() {  // Package-private
        count++;  // Доступно
    }
}

2.2 Внутри того же пакета (любой класс)

package com.example;  // ОДИНАКОВЫЙ пакет

public class AnotherClass {
    public void test() {
        Service service = new Service();
        service.count++;  // ✅ Доступно - в одном пакете
        service.processData();  // ✅ Доступно
    }
}

2.3 Вложенные классы

package com.example;

public class OuterClass {
    int outerField;  // Package-private
    
    // Вложенный класс (даже static)
    static class InnerClass {
        void access() {
            // ❌ Не может прямо обращаться к outerField
            // Нужна ссылка на OuterClass
        }
    }
    
    // Но внутренний класс (non-static) может
    class NonStaticInner {
        void access() {
            int x = outerField;  // ✅ Доступно
        }
    }
}

3. Сравнение всех модификаторов видимости

package com.example;

public class VisibilityDemo {
    public int publicField;      // Видна везде
    protected int protectedField;  // Видна в пакете + наследники
    int packageField;            // Видна только в пакете
    private int privateField;    // Видна только в этом классе
}

Таблица видимости:

╔════════════════════╦════════╦═══════════╦═══════════╦═════════╗
║ Модификатор        ║ Класс  ║ Пакет     ║ Наследник ║ Весь мир║
╠════════════════════╬════════╬═══════════╬═══════════╬═════════╣
║ private            ║   ✓    ║     ✗     ║     ✗     ║    ✗    ║
║ package-private    ║   ✓    ║     ✓     ║     ✗     ║    ✗    ║
║ protected          ║   ✓    ║     ✓     ║     ✓     ║    ✗    ║
║ public             ║   ✓    ║     ✓     ║     ✓     ║    ✓    ║
╚════════════════════╩════════╩═══════════╩═══════════╩═════════╝

4. Примеры visibility в разных файлах

Файл 1: Service.java

package com.example.service;  // Пакет 1

public class UserService {
    int databaseId;  // Package-private - видна в пакете com.example.service
    
    void connectDatabase() {  // Package-private
        // Логика
    }
}

Файл 2: Helper.java (ТОТ ЖЕ пакет)

package com.example.service;  // ОДИНАКОВЫЙ пакет

public class DatabaseHelper {
    public void setupService(UserService service) {
        service.databaseId = 123;  // ✅ ДОСТУПНО - одинаковый пакет
        service.connectDatabase();  // ✅ ДОСТУПНО
    }
}

Файл 3: Client.java (ДРУГОЙ пакет)

package com.example.client;  // ДРУГОЙ пакет

public class ApiClient {
    public void test() {
        UserService service = new UserService();
        service.databaseId = 456;  // ❌ ОШИБКА КОМПИЛЯЦИИ - в другом пакете
        service.connectDatabase();  // ❌ ОШИБКА КОМПИЛЯЦИИ
    }
}

5. Package-private vs Protected

Ключевое отличие: protected видна наследникам в других пакетах, package-private нет.

// Пакет 1
package com.example.parent;

public class Parent {
    int packageField;       // Package-private
    protected int protectedField;  // Protected
}

// Пакет 2 - ДРУГОЙ пакет
package com.example.child;

import com.example.parent.Parent;

public class Child extends Parent {
    void test() {
        packageField = 10;      // ❌ ОШИБКА - package-private, другой пакет
        protectedField = 20;    // ✅ OK - protected, это наследник
    }
}

6. Package-private на уровне класса

Top-level класс может быть только public или package-private:

// ✅ Package-private top-level класс
class UtilityClass {
    static void helper() {
        // Видна только в этом пакете
    }
}

// ✅ Public top-level класс
public class PublicClass {
}

// ❌ ОШИБКА - protected/private не работает для top-level
protected class ProtectedClass { }  // Compilation error
private class PrivateClass { }      // Compilation error

7. Лучшие практики

Когда использовать package-private:

package com.example.utils;

// Public API
public class StringUtils {
    // Публичная утилита
    public static String capitalize(String str) {
        return internalCapitalize(str);
    }
    
    // Внутренняя реализация - package-private
    static String internalCapitalize(String str) {
        if (str == null || str.isEmpty()) return str;
        return str.substring(0, 1).toUpperCase() + str.substring(1);
    }
}

// Вспомогательный класс - package-private
class StringValidation {
    static boolean isValidString(String str) {
        return str != null && !str.isEmpty();
    }
}

Пример: правильное разделение visibility

package com.example.payment;

public class PaymentService {
    // PUBLIC API - используют снаружи
    public boolean processPayment(Payment payment) {
        if (!validatePayment(payment)) {
            return false;
        }
        return executePayment(payment);
    }
    
    // Package-private - вспомогательные методы
    boolean validatePayment(Payment payment) {
        return payment != null && payment.getAmount() > 0;
    }
    
    void executePayment(Payment payment) {
        // Внутренняя логика
    }
    
    // Private - самые внутренние детали
    private void logTransaction(Payment payment) {
        System.out.println("Transaction: " + payment.getId());
    }
}

8. Частые ошибки

Ошибка 1: Забыли про пакет

// Service.java
package com.api;
class Service {  // Package-private
    void process() { }
}

// Main.java
package com.main;  // ДРУГОЙ пакет
Service service = new Service();  // ❌ ОШИБКА - не видна

Ошибка 2: Думал что protected = package-private

// Parent.java
package com.parent;
public class Parent {
    int packageField;       // Видна только в com.parent
    protected int protField;  // Видна везде в наследниках
}

// Child.java (другой пакет)
package com.child;
public class Child extends Parent {
    void test() {
        packageField = 1;    // ❌ Не видна - другой пакет
        protField = 2;       // ✅ Видна - это protected
    }
}

Итоговое резюме

Package-private (без модификатора) видна:

1. ✓ В своём классе
2. ✓ В других классах одного пакета
3. ✗ В наследниках других пакетов
4. ✗ За пределами пакета

Это полезно для скрытия деталей реализации и создания чётких границ API.