В Java это - когда-нибудь плохая идея сделать участников объекта общедоступными?

Если Вы заменяете методы считывания/методы set для производительности/оптимизации памяти, то Вы проявляете неправильный подход. Они почти наверняка не собираются быть причиной Ваше выполнение приложения медленно, или использует слишком много памяти.

Кардинальный грех оптимизации должен сделать это, прежде чем Вы будете знать, что Вы должны. Оптимизируйте только, когда у Вас есть реальная информация, показывающая Вам, где большая часть времени/памяти тратится впустую, и затем проведите свое время, оптимизируя это. Взгляды позади этого состоят в том, что Вы получите больше путем бритья 5% времени в части кода, который поднимает 80% общего времени выполнения, чем бритье даже 20% в части кода, который вносит только 5% в общее время выполнения. (То же относится к памяти).

Кроме того, я был бы осторожен относительно разработки приложения, как Вы предполагаете, так как это будет означать что некоторые свойства (например: простые свойства), будет непосредственно доступно, в то время как у других (более сложные полученные свойства или свойства, где Вы не хотите выставлять базовые типы) будут методы считывания/методы set. Таким образом, Вы закончите с соединением стилей доступа, которые будут менее удобны в сопровождении.

Если бы производительность очень важна, я предложил бы делать поля или частными, если только полученный доступ в том же классе или пакете, локальном, если к ним получают доступ в другом классе. Если Вы дадите внутреннему/вложенному классу частные поля, то компилятор будет добавлять/использовать методы доступа (поскольку VM не позволяет классам получать доступ к полям в другом классе даже при том, что Java делает),

Наличие общедоступных изменяемых полей предлагает вопросы проектирования мне. При наличии производительности, которую не предлагает критическое разделение кода через пакеты, виду трудного кодирования Вас нужен для производительности критический код.

Если у Вас есть неизменные поля, у меня нет проблемы, обнародовав поле, если Вы ожидаете более высокие затраты на разработку, если поля изменят поведение. На самом деле я предлагаю использовать общедоступные неизменные поля, если Вы полагаете, что это делает код более простым/легче понять.

Однако первоочередная задача должна все еще быть удобочитаемостью кода. Самый простой код часто работает лучше всего также.

Аргументом, что этот код только будет для Вашего собственного использования, является очень легкое прерывание для падения в - дело обстоит так с большей частью кода, публично выставленные биты являются обычно очень маленькими. Так принятие большей части кода для личного пользования, почему беспокойство когда-либо с помощью частного, защищенный, финал, константа (C/C++) - риторический вопрос, который я знаю, но я надеюсь, что точка ясна.

Другая вещь, которая пропускается здесь, блокирует. При доступе к участнику непосредственно, Вы будете только когда-либо мочь заблокировать этот код в целом объекте или членском уровне. И та блокировка будет управлять кодом использования, не самим Объектом. Возможно, хорошо, возможно, не, как во всех вещах это - лошади для курсов.

В нашей команде мы используем следующее правило: если состояние, представленное полем класса, изменяемо, затем всегда делают это частным и обеспечивают мутаторы; однако, если бы это неизменно (т.е. не был бы повторно присвоен после инстанцирования класса) затем это может быть объявлено как public final [type] [field-name] - безопасный для доступа.

Обратите внимание на то, что здесь "неизменное состояние" конкретно означает, что поле объявляется как final. Не должен быть перепутан с public [immutable-type] [field-name] где можно было выполнить переназначение, хотя экземпляр неизменного типа самостоятельно неизменен.

Также обратите внимание, что существует много серьезных оснований иметь средство доступа даже для неизменного поля. Например, в случаях, где это требуется, чтобы выполнять некоторое действие (например, проверка защиты) в то время, когда поле читается.

Это всегда - плохая идея обнародовать незаключительные поля.

Что, если Вы позже хотите добавить уведомление о событии?

Что, если Вы позже хотите разделить на подклассы и изменить поведение?

Что, если существуют некоторые ограничения поля перекреста, Вы хотите осуществить?

TofuBeer показывает класс Точки с заключительными полями - это в порядке. Однако класс Точки в AWT не использует финал и вызвал меня много горя вначале в Java.

Я писал некоторый 3D код и требуемый для разделения на подклассы Точки, таким образом, что каждый раз, когда x и y изменились, я мог автоматически скорректировать z по мере необходимости. Поскольку поля Точки были общедоступны, не было никакого способа знать когда x или измененный y!

Я имею, создают два маленьких класса и тестируют их.

• Сначала я имею, создают отдельный объект как прототип.

• Затем я имею, создают 2 000 000 массивов для хранения их всех.

• Затем я выполнил цикл, создаю новый экземпляр там и принимаю значения от прототипа.

Средние результаты в секундах, сравнивая каждого:

WithGS  Without
1.1323  1.1116

Diff  = 0.0207 secs.

Так, для этого случая я думаю, что было бы намного лучше иметь неоптимизированное решение сначала, и после того как никакие дальнейшие требования не необходимы, возобновляют профилирование.

Вот код:

PersonGetSet.java


public class PersonGetSet {
    private String name;
    private boolean deceased;

    public void setName( String name ) {
        this.name = name;
    }
    public String getName() {
        return name;
    }

    public void setDeceased( boolean deceased ) {
        this.deceased = deceased;
    }
    public boolean isDeceased() {
        return this.deceased;
    }

    public static void main( String [] args )  {
        PersonGetSet pb = new PersonGetSet();
        pb.setName( "name" );
        pb.setDeceased( true ) ;

        long start = System.currentTimeMillis();
        PersonGetSet [] array = new PersonGetSet[2000000];
        for( int i = 0 ; i < array.length; i++ ) {
            PersonGetSet personGs = new PersonGetSet();
            personGs.setName( pb.getName() );
            personGs.setDeceased( pb.isDeceased() );
            array[i] =  personGs;
        }
        System.out.println( "PersonGetSet took " + ( System.currentTimeMillis() - start ) + " ms. " );
    }
}


Person.java


public class Person {
    String name;
    boolean deceased;
    public static void main( String [] args )  {
        Person pb = new Person();
        pb.name=  "name" ;
        pb.deceased = true;

        long start = System.currentTimeMillis();
        Person [] array = new Person[2000000];
        for( int i = 0 ; i < array.length; i++ ) {
            Person simplePerson = new Person();
            simplePerson.name=  pb.name;
            simplePerson.deceased = pb.deceased;
            array[i] =  simplePerson;
        }
        System.out.println( "Person took " + ( System.currentTimeMillis() - start ) + " ms. " );
    }
}

Разработка функционально Вас никогда не испытывает необходимость (методы считывания/методы set), так же плохо как преждевременная оптимизация. Если это действительно только для Вашего использования, не обнародуйте его и затем структурируйте его, которому Вы верите, является самым простым.

Оптимизация и/или методы считывания должны только быть добавлены при фактической необходимости в них.

Вам нужен метод считывания вообще? То есть Ваш объект должен делать работу для Вас, а не Ваш клиент, получающий значения данных и работающий, работает сами?

Один ключевой аспект ООП говорит объекту сделать что-то, вместо того, чтобы вытащить биты и сделать его самостоятельно. например,

double ret = myObj.calculateReturn()

по сравнению с.

int v = myObj.getValue();
int ov = myObj.getOldValue();
double ret = (v-ov)/ov * 100; // do I work about dividing by zero etc.? 

который я вижу много. Часто Вам действительно нужны методы считывания (и методы set, возможно), но когда я пишу метод считывания, я всегда спрашиваю меня, должны ли те данные быть выставлены, или должен ли объект скрыть их полностью для меня.

Если скорость является настолько критической, могло бы стоить записать это в C или C++.

С точки зрения того, кто написал код и кто собирается использовать его, затем не имеет значения возможно, ли Вы или кто-либо еще, Вам, все еще понадобились методы считывания и методы set - если любой при всем использовании это позже это - defacto общедоступный API.

Однако, если это действительно - просто данные, и Вы не нуждаетесь ни в каком поведении, связанном с классом, затем любой ценой имеете членскую общественность.

Мне, имеет ли класс поведение или если Вы могли бы хотеть изменить имена или типы его элементов данных, поскольку реализация детализирует, это действительно имеет значение.

Относительно питания процессора и памяти - Вы имели размеры?

Если Ваш приоритет является производительностью, необходимо изучить выбор виртуальной машины Java и как это выполняет программы. Настольный Java от Sun проводит МНОГО времени, представляя и компилируя байт-код Java в машинный код, который приводит к программам, которые могут работать очень быстро, но используют большую память.

Если Вы находите, что хотите использовать основанную на HotSpot JVM, необходимо изучить все приемы для помощи ей. Методы считывания и методы set обычно встраиваются (т.е. заменяются непосредственно в машинном коде вместо вызова к подпрограмме), и константы свернуты. Операторы переключения для маленьких диапазонов обычно преобразовываются в таблицу переходов.

Обычно я нахожу, что "head-under-the-arm" метод работает хорошо на написание большей части кода, и затем Вы представляете под управлением код и находите узкие места. Я нашел, например, что StringBuffers быстры для многих вещей, но deleteCharAt (0) не является одним из них. При перезаписи для использования простого повторения по строке вместо того, чтобы удалить в строковом буфере, сделал чудеса. Вы также, скорее всего, найдет, что самые большие преимущества находятся в алгоритмах - не маленькие ярлыки.

В мире C человек может едва больше перехитрять компилятор. В мире Java человек может помочь HotSpot путем записи прямого Java.

Это не глупо, но я думаю, что это - вероятно, не хорошая идея также.

Я понимаю искушение..., если никто больше никогда не использует код, затем Вы не должны волноваться об этом. Но снова и снова, оказывается, что это просто не соответствует тому, что на самом деле происходит..., Вы узнаете использование его в большем количестве мест, чем Вы думали, или проект становится больше, чем ожидалось, или кто-то просто хватает его и думает, что это полезно... вещи, которые никогда не предназначались, чтобы быть permenant, или общественность имеют способ стать тем путем.

Есть ли действительно что труден предел на питание процессора и память? Я не знаю о Вашей ситуации (встроенное приложение, возможно?), но как (сверхобобщенное) правило, Вы - более обеспеченный взгляд в другом месте для ресурсов... в Ваших структурах данных, алгоритмы, или архитектура для наблюдения лучших улучшений памяти или ЦП.

Потенциальные недостатки для использования

public final введите var;

вместо

private final введите var;

public ввести getvar() {return var ;}

(который я лично испытал), включайте:

• Перспектива - однако вряд ли это кажется теперь - который представление должно будет изменить в базовом классе или в некотором будущем подклассе.

• Потенциальная неловкость смешивания, выставленного неизменно - и изменяемо введенные поля.

• Беспокойство запоминания, которое используют классы public final и которые используют getvar.

• Беспокойство объяснения этого несоответствия кому-то еще, кто может позже видеть исходный код.

Я только что никогда не мог убедить меня, что это стоит того, даже при том, что я попробовал.

По моему скромному мнению, для свойств, которые по самой своей природе просто предназначены для пассивного содержания данных и не могли сделать, что-либо более сложное, полностью не изменяя их значение с точки зрения пользователя API, методов считывания и методов set является просто ненужным шаблоном. Если свойство, и по его характеру ясно всегда будет, просто держатель данных, такой как класс, это привыкло так же к структуре C, просто обнародуйте глупую вещь. Как более общее утверждение, лучшие практики могут легко стать пустой тратой времени или даже худшими методами при фанатичном применении, не думая о том, почему они - лучшие практики. Heck, даже goto возможно выравнивается по ширине время от времени.

Любое использование стека будет очень переходным и не уверенность так или иначе. Можно найти, что компилятор оптимизирует любые ненужные издержки так или иначе, таким образом, можно найти, что Вы ничего не получаете в реальном выражении.

Я соглашаюсь, что это не обязательно плохо для частного класса не-API для использования общедоступных участников, но что Вы получаете, является настолько маленьким (если бы существует кто-либо вообще), я просто не обеспокоился бы.

Это - плохая идея сделать участников общедоступными как оптимизация. Как другие сказали, это не окажет фактически никакого влияния. Однако, если объект является простой структурой данных с небольшим поведением, хорошо писать этому тот путь. Пока Вы делаете его для простоты и удобочитаемости, не производительности.

Как с любой оптимизацией, мера прежде и после видеть, существует ли какое-либо преимущество, которое выравнивает по ширине оборотные стороны.

Я думаю, что Вы найдете, что это не будет иметь никакого заметного значения к производительности Вашего кода (но пробовать его за себя). JVM встроит часто используемые методы считывания и методы set.

Используйте профилировщика и найдите реальные горячие точки в Вашем приложении. Оптимизация без доказательства является просто догадками.

Мне никогда не жаль, что у меня не было общедоступного поля вместо свойства, но я не могу считать количество раз, я хотел свойство и имел общедоступное поле. В конечном счете Вы заканчиваете тем, что желали логику в нем.

Возможности хороши, что тривиальные методы считывания и методы set будут встроены так или иначе - но с общедоступными полями Вы потеряете различие между контрактом (API) и реализацией. Даже если это - только API, который Вы будете использовать, хорошо сохранить слабо связанный IMO вещей.

Методы считывания и методы set не только для защиты/конфиденциальности. Основное использование должно изменить способ, которым Вы выставляете базовые данные.

Например, в asp.net c# свойство видимости управления может иметь что-то, такое как:

private bool visible = true;

public bool Visible
{
    get
    {
        return visible && Parent.Visible;
    }
    set
    {
        visible = value;
    }
}

Внешнее свойство (средство доступа/мутатор) имеет другое значение к основной переменной. Кроме того, если у Вас нет вышеупомянутой функциональности, когда Вы начинаете, когда Вы имеете простой, добирается / наборы, это становится чем-то, что можно добавить позднее, легко.

Что касается точки производительности и сохранения каждой унции процессора и памяти Вы можете. Если это собирается оказать значимое влияние затем, Вы - вероятно, более обеспеченное рассмотрение другого языка.

Люди Python не используют методы считывания, и они не горят в аду.

Метод считывания/метод set является способом выставить часть класса к простому самоанализу Java. Бобовая спецификация Java полагается на наличие общедоступных методов считывания и методов set как способ определить, какие атрибуты важны.

В то время как важный для вещей, которые требуют/производят/используют бобов, это не существенная особенность программирования OO или программирования Java. Это - просто часть Бобовой спецификации и требуется для любого класса, который хочет участвовать в подобных бобу вещах.

Общедоступные атрибуты прекрасны. Они являются простыми, прямыми и очевидными.

Я думаю, что инверсия этого вопроса является лучшей для выяснения:

Это - когда-нибудь хорошая идея сделать участников объектов общедоступными?

С разработкой это обычно - хорошая идея приблизиться к вещам от принципа использования самого низкого требуемого уровня доступности; другими словами, только выставьте столько данных, сколько Вам нужно. Если Вы обычно применяете этот принцип, то это становится большим количеством практики только совместного использования так, как требуется.

Так после этих слов - почему делают это?

Я вполне уверен, используемый объем памяти незначителен. JVM могла бы даже оптимизировать вызовы, чтобы заставить их встроить в зависимости от реализации во времени выполнения, если Вы создаете для производства. При разработке его сами это могло бы все еще помочь, потому что, если у Вас есть трудное для отслеживания ошибки, можно установить точку останова в методе считывания/методе set и видеть точно при изменении значений. Это не должен быть никакой код для записи также, потому что самый современный IDE имеет функции, чтобы сгенерировать код автоматически.

Это немного еретически, но я соглашаюсь с Вами, что, если Вы знаете, никто больше не собирается быть использованием Вашего класса, можно пропустить тот материал. Я не сделал бы этого в коде, который мог бы быть снова использован, даже скрыт позади API, но в Вашем случае это кажется довольно безопасным.

Вы никогда не знаете, всегда кодируете, как будто люди, которые прочитали Ваш код, знают, где Вы живете и являетесь серийными убийцами. Даже при разработке кода только для себя попробуйте (imo), чтобы сделать это, как будто Вы разрабатывали в команде. Таким образом, Вы привыкаете для создания читаемого кода лучшей практики. С для производительности наверху, возможно, лучше сделать это в чем-то как C затем действительно действительно при реальной необходимости в каждом бите памяти и каждом цикле ЦП.

Полагайте, после того как помещение чего-то в общедоступный API, что он установлен в камне. Вы не можете изменить имя его, Вы не можете изменить тип его, Вы не можете измениться, как это хранится.

Помещение его позади метода не приводит ни к какому штрафу производительности на современном VM (в значительной степени ничто за прошлые 10 лет).

Гибкость, которую Вы получаете от наличия методов для получения значения, более важна, по-моему.

Если Вы действительно решаете обнародовать их, удостоверяются, что Вы отмечаете их как финал и что они неизменны.

public class Point
{
    public final int x;
    public final int y;

    public Point(final int xVal, final int yVal) 
    {
        x = xVal;
        y = yVal;
    }
}

Править:

Общедоступным API я имею в виду любую переменную, которая общедоступна, не, что сам класс был бы частью выставленного API для других разработчиков. Путем создания этого общедоступным можно вызвать себя проблемы позже (если это был "реальный" общедоступный API, что у других разработчиков был доступ к нему, буквально установлен в камне, если Вам не нравится взламывать другой код народов при выпуске обновления).

Все преждевременные вопросы оптимизации были обсуждены в предыдущих ответах.

Я просто думал, что стоит упомянуть, что в Java можно подражать структурам C путем определения класса только с общедоступными участниками как так:

public class DataClass {
    public int a;
    public String b;
    public char c;
}

и к которому получат доступ (получение и установка) только путем обращения к тем общедоступным участникам.

Эта идиома полностью приемлема в некоторых определенных сценариях.