Большие Внутренние классы и частные переменные
Если вы работаете в Windows , вы можете использовать:
import os
user_input = input("Insert word")
os.system('cls')
В качестве альтернативы, если вы находитесь в Linux / OS X :
import os
user_input = input("Insert word")
os.system('clear')
5 ответов
На уровне байт-кода внутренние классы являются просто классами Java. Так как верификатор байт-кода Java не предоставляет доступ членам парламента, не занимающим официального поста, он генерирует синтетические методы доступа для каждого частного поля, которое Вы используете. Кроме того, для соединения внутреннего класса с его экземпляром включения компилятор добавляет синтетический указатель на внешнее 'это'.
Рассматривая это, внутренние классы являются просто слоем сахара синтаксиса. Они удобны, и Вы перечислили некоторые положительные стороны, таким образом, я перечислил бы некоторые отрицательные аспекты, которые Вы могли бы хотеть рассмотреть:
- Ваш внутренний класс имеет скрытую зависимость к целому родительскому классу, который запутывает его входящий интерфейс. При извлечении его как частного на пакет класса, у Вас есть шанс улучшить Ваш дизайн и сделать его более удобным в сопровождении. Первоначально это является более подробным, но часто Вы находили бы что:
- Вместо того, чтобы выставить 10 средств доступа Вы на самом деле хотите совместно использовать единственный объект значения. Часто Вы находили бы, что Вам действительно не нужна ссылка на целый внешний класс. Это также работает хорошо с МОК.
- Вместо того, чтобы предоставить методы для явной блокировки, это более удобно в сопровождении, чтобы инкапсулировать операцию с ее контекстом в отдельном классе (или переместить его в один из этих двух классов - внешний или раньше внутренний).
- Удобные методы принадлежат пакета частные служебные классы. Можно использовать статический импорт Java5, чтобы заставить их появиться как локальные.
- Ваш внешний класс может обойти любые уровни защиты и членов парламента, не занимающих официального поста доступа Вашего внутреннего класса непосредственно. Это не плохая вещь по сути, но она убирает одно из средств языка выражения Вашего дизайна.
- Так как Ваш внутренний класс встраивается точно в один внешний класс, единственный способ снова использовать его состоит в том, чтобы разделить внешний класс на подклассы. Альтернатива должна была бы передать прямую ссылку на закрытый интерфейс пакета, который реализует внешний класс. Это позволило бы Вам дразнить внешний и лучший тест внутренний класс.
- Хотя недавние отладчики довольно хороши, я испытал проблемы с отладкой внутренних классов прежде (беспорядок объема условной точки останова, не остановка в точках останова, и т.д.)
- Частные классы чрезмерно увеличивают размер Вашего байт-кода. См. мой первый абзац - часто существует API, что Вы могли использовать и сократить количество синтетического хлама.
P.S. Я говорю о нетривиальных внутренних классах (особенно, которые не реализуют интерфейсов). Три реализации слушателя строки хороши.
Не забывайте рассматривать, почему Вы пытаетесь разбить свой большой класс. Это в целях разработки программного обеспечения? Например, это - горячая точка программирования, и у Вас есть такой большой файл, это вызывает сложные слияния в Вашей команде разработчика?
Это - просто общее требование избежать больших классов? В этом случае может случиться так, что Ваше время было бы лучше проведено, улучшая код, который Вы действительно имеете.
Код, становящийся трудным справиться, например, отлаживающий и гарантирующий, что предотвращение непреднамеренных побочных эффектов становится более трудным.
Комментарий Rick's об использовании модульных тестов для обеспечения продолженного последовательного поведения очень ценен и хорошая идея. Может случиться так, что текущий дизайн просто устраняет осуществлять рефакторинг, и Вы - более обеспеченная перереализация того же поведения, начинающего с интерфейса оригинала. Будьте готовы к большому количеству тестирования регрессии!
Yeap. Вероятно, необходимо повторно осуществить рефакторинг тех помощников и не переместить их всех как они. Некоторые вещи принадлежат сервису некоторый другой помощнику. Вероятные новые классы должны использоваться для инкапсуляции данных.
Одна возможность, которую можно использовать, к AOP, чтобы обеспечить мелкомодульный доступ и включать в сокращение точки, что метод должен быть только вызван от "друга" класс. Тем не менее Ваш метод был бы выставлен :(
Я предполагаю, что нет никакого легкого решения для этого.
Строку между инкапсуляцией и разделением может быть трудно обойти. Однако я думаю, что основной вопрос здесь - то, что Вам нужна некоторая основательная модель взаимодействия для использования в качестве основания разделения классов.
Я думаю, что разумно иметь внешние классы утилиты помощника, которые используются во многих местах, пока они не примыкают эффект, я не вижу проблему. Также разумно иметь статические классы помощника, пока они хорошо организованы, которые часто содержат используемые методы, такие как checkAssetIsValid (). Это предполагает, что checkAssetIsValid не должен получать доступ ни к какому внешнему состоянию кроме объекта, Вы передаете его.
Самая важная вещь для разделения не состоит в том, чтобы иметь объектов, которые совместно используют постоянные ссылки во многих из этих классов. Мне нравится обращаться к функциональному программированию для руководства. Каждый класс не должен достигать кишок других классов и изменять состояние. Вместо этого каждый класс, который действительно работает, должен произвести и использовать контейнерные объекты.
Визуализация может быть очень полезной также. Я заметил поток по теме инструментов Java Visualization здесь. Идеально, Ваша схема взаимодействия класса должна больше походить на дерево, чем график.
Кроме того, я просто хочу отметить, что рефакторинг большого класса в меньшие классы может быть чрезвычайно трудным. Лучше создавать комплект модульных тестов на открытый интерфейс по крайней мере так, чтобы сразу стало очевидно при повреждении чего-то. Я знаю, что тесты сохранили меня бесчисленные часы в прошлом.
Надо надеяться, часть этого будет полезна. Я - вид просто пустой болтовни здесь.
Я не поклонник чрезмерного использования внутренних классов. Я думаю, что они действительно не предлагают преимущества (при использовании в экстремальном значении), что помещение кода в нормальном классе не будет, и они просто служат для создания файла класса излишне большим и твердым следовать.
Каков вред, если необходимо увеличить видимость нескольких методов? Это собирается полностью повредить Вашу абстракцию или интерфейс? Я думаю слишком часто, что программисты склонны делать все частным по умолчанию, где нет действительно большой части вреда в разрешении некоторым другим классам назвать Ваши методы - если Ваш дизайн действительно основан на OO, который является.
Если все Ваши "внутренние классы помощника" нуждаются в доступе к некоторым из тех же методов, рассматривают помещение их в базовом классе, таким образом, они могут быть совместно использованы через наследование.