Какая область видимости у protected?

Область видимости protected в Java/Kotlin для Android

В контексте Android-разработки (Java/Kotlin) модификатор доступа protected имеет специфическую область видимости, которая часто вызывает вопросы. Вот подробное объяснение:

Основное определение

protected члены класса (поля, методы, свойства) доступны:

1. Внутри самого класса, где они объявлены
2. Внутри всех классов-наследников (подклассов), даже если они находятся в других пакетах
3. Внутри классов того же пакета (package-private доступ)

Ключевые особенности

// Пример в Java
package com.example.base;

public class BaseClass {
    protected String protectedField = "Доступно в наследниках";
    
    protected void protectedMethod() {
        // Доступно в этом классе
    }
}

// Наследник в ДРУГОМ пакете
package com.example.derived;

import com.example.base.BaseClass;

public class DerivedClass extends BaseClass {
    public void testAccess() {
        // ДОСТУПНО - наследник
        String value = protectedField;
        protectedMethod();
    }
}

// Класс в ТОМ ЖЕ пакете (без наследования)
package com.example.base;

public class SamePackageClass {
    public void testAccess() {
        BaseClass base = new BaseClass();
        // ДОСТУПНО - тот же пакет
        String value = base.protectedField;
        base.protectedMethod();
    }
}

Важные нюансы в Android-разработке

1. Доступ через экземпляр в наследниках

// Пример в Kotlin
open class BaseActivity {
    protected val TAG = "BaseActivity"
}

class MainActivity : BaseActivity() {
    fun test() {
        // ДОСТУПНО напрямую
        println(TAG)
        
        // НЕДОСТУПНО через экземпляр другого наследника
        val other: BaseActivity = MainActivity()
        // println(other.TAG) // Ошибка компиляции!
    }
}

2. Различия между Java и Kotlin

// В Kotlin protected имеет ОГРАНИЧЕННУЮ видимость:
// - Только внутри класса и его наследников
// - НЕ доступен в классах того же пакета!

open class KotlinBase {
    protected val value = 42
}

class KotlinDerived : KotlinBase() {
    fun getValue() = value // OK
}

// class SamePackage {
//     val base = KotlinBase()
//     val x = base.value // ОШИБКА в Kotlin (в Java было бы OK)
// }

3. Практическое применение в Android

open class BaseFragment : Fragment() {
    // Protected методы часто используются для шаблонного метода (Template Method)
    protected open fun setupViews() {
        // Базовая реализация
    }
    
    protected fun showLoading() {
        // Общая логика показа загрузки
    }
}

class ProfileFragment : BaseFragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        setupViews() // Можем переопределить
        showLoading() // Можем использовать
    }
    
    override fun setupViews() {
        // Специфичная для ProfileFragment настройка
    }
}

Когда использовать protected

1. Для методов жизненного цикла в базовых классах (Activity, Fragment)
2. При реализации паттерна "Шаблонный метод"
3. Для вспомогательных методов, используемых наследниками
4. Для доступа к общим ресурсам внутри иерархии классов

Распространённые ошибки

// НЕПРАВИЛЬНО - попытка доступа из несвязанного класса
public class UnrelatedClass {
    public void test() {
        BaseClass base = new BaseClass();
        // base.protectedMethod(); // Ошибка компиляции!
    }
}

// ПРАВИЛЬНЫЙ подход через публичный API
public class BaseClass {
    protected void internalLogic() { /* ... */ }
    
    public void publicMethod() {
        internalLogic(); // Инкапсуляция protected логики
    }
}

Итог

protected в Android-разработке — это модификатор доступа, который балансирует между инкапсуляцией и расширяемостью. Он позволяет:

• Скрыть детали реализации от внешнего мира
• Предоставить контролируемый доступ наследникам для расширения функциональности
• Создавать устойчивые иерархии классов с чёткими контрактами

Важно помнить о различиях между Java и Kotlin в отношении доступа из классов того же пакета, так как это может повлиять на миграцию кода или взаимодействие между Java и Kotlin компонентами в проекте.