Метод считывания/метод set Java разрабатывает вопрос

Даже в вашем пакете с закрытым исходным кодом инкапсуляция - хорошая идея.

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

Я бы придерживался единого стиля (и в этом случае предоставил бы сеттеры / геттеры). Почему?

1. это хорошая практика, когда вы работаете с другими людьми или предоставляете библиотеки для сторонних разработчиков
2. , многие фреймворки Java предполагают соглашения о получении / установке и приспособлены для их поиска / раскрытия / опроса. Если вы этого не сделаете, ваши Java-объекты будут закрыты для этих фреймворков и библиотек.
3. Если вы используете сеттеры / геттеры, вы можете легко реорганизовать то, что за ними стоит. Простое использование полей напрямую ограничивает ваши возможности.

Действительно заманчиво принять подход «только для меня», но существует множество условностей, поскольку материал их использует и / или по какой-то причине является хорошей практикой. Я постараюсь следовать им как можно больше.

Я не думаю, что это хороший язык должен иметь ЛЮБОЙ уровень доступа, кроме закрытого - я не уверен, что вижу в этом выгоду.

С другой стороны, также будьте осторожны с геттерами и сеттерами вообще - у них много подводных камней:

• Они склонны поощрять плохой объектно-ориентированный дизайн (обычно вы хотите попросить свой объект что-то сделать для вас, не воздействовать на его атрибуты)
• Этот плохой объектно-ориентированный дизайн приводит к тому, что код, связанный с вашим объектом, распространяется по разным объектам и часто приводит к дублированию.
• сеттеры делают ваш объект изменяемым (чего всегда приятно избегать, если можно).
• сеттеры и геттеры раскрывают ваши внутренние структуры (если у вас есть геттер для int, позже трудно изменить его на двойное значение). -вы должны коснуться каждого места, к которому был осуществлен доступ, и убедиться, что он может обрабатывать double без переполнения / возникновения ошибки, если вы только что попросили свой объект манипулировать значением в первую очередь, единственные изменения будут внутренними для вашего объекта .

Меня бы не волновал стиль как таковой (или какая-либо догма в этом отношении), а удобство в ремонтопригодности , который поставляется с набором методов получения / установки. Если вам (или кому-то другому) позже понадобится изменить поведение, связанное с изменением одного из этих атрибутов (зарегистрировать изменения, сделать его поточно-ориентированным, очистить ввод и т. Д.), Но уже напрямую изменили их во многих других места в вашем коде, вы бы предпочли вместо этого использовать методы получения и установки.

Inline:: ASM - Запись подпрограмм Perl в ассемблере.

SYNOPSIS

   print "9 + 16 = ", add(9, 16), "\n";
   print "9 - 16 = ", subtract(9, 16), "\n";

   use Inline ASM => 'DATA', 
              AS => 'as',
              PROTO => {add => 'int(int,int)'};

   use Inline ASM => 'DATA',
              AS => 'nasm',
              ASFLAGS => '-f elf',
              PROTO => {subtract => 'int(int,int)'};

   __END__
   __ASM__

   .text
   .globl    add

   add:      movl 4(%esp),%eax
             addl 8(%esp),%eax
             ret
   __ASM__
             GLOBAL subtract
             SECTION .text

   subtract: mov eax,[esp+4]
             sub eax,[esp+8]
             ret

префикс _ с («TEXT») добавляет произвольный текст между INSERT и остальной частью SQL. execute () принимает список словарей с записями, которые требуется вставить, или один словарь, если требуется вставить только одну запись.

Синтаксис SQLite для поведения, которое вы ищете:

inserter = table_object.insert().prefix_with("OR REPLACE")
inserter.execute([{'column1':'value1'}, {'column1':'value2'}])

Поскольку вы единственный пишете код в вашем пакете/библиотеке с закрытым исходным кодом, я не думаю, что вам стоит слишком беспокоиться о стиле - просто делайте то, что работает лучше для вас.

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

Стиль - это вопрос соглашение. Нет правильного ответа, пока он непротиворечив.

Я не поклонник верблюда, но в мире Java правила camelStyle высшие, и все переменные-члены должны быть закрытыми.

getData();
setData(int i);

Следуйте официальному соглашению по коду Java от Sun ( cough Oracle), и все будет в порядке.

http://java.sun.com/docs/codeconv/

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

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

Код должен быть написан так, чтобы он следовал за Говори, не спрашивай . Вы можете практиковать это, например, выполняя упражнение Художественная гимнастика с объектами .

Стиль - это вопрос условности. Нет правильного ответа до тех пор, пока он является последовательным.

Я не поклонник верблюда, но в мире Java правила camelStyle являются высшими, и все переменные-члены должны быть частными.

getData();
setData(int i);

Следуйте соглашению по официальному коду Java от Sun ( кашель Oracle), и вы должны быть в порядке.

http://java.sun.com/docs/codeconv/

Попробуйте pcre . И pcrepp .

Хотя это болезненно, кодирование свойств с помощью getters и setters является большой победой, если вы когда-либо собираетесь использовать свои объекты в контексте, таком как JSP (язык выражения в частности), OGNL или другой язык шаблона. Если ваши объекты следуют добрым старым условностям Бина, то много вещей будет «просто работать» позже.

Я нахожу, что геттеры и сеттеры - это лучший способ программирования, и это не только вопрос соглашения о кодировании. Будущего никто не знает, поэтому сегодня можно написать простой строковый фоненумер, а завтра, возможно, придется поставить "-" между кодом области и номером, в таком случае, если у нас будет определен метод getPhonenumber(), то мы сможем сделать такие красивые вещи очень просто. Так что, я думаю, мы всегда должны следовать этому стилю кодирования для лучшей расширяемости.

Короче говоря, вы сказали: «Я спрашиваю, потому что я собираюсь заставить людей действительно перейти код впервые, и я хочу выглядеть так, будто я знаю, что делаю ». Итак, измените свой код, потому что он выглядит так, будто вы не знаете, что делаете.

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

Использование инкапсуляции является хорошей идеей даже для закрытых исходных кодов, как уже указывал JacobM. Но если ваш код действует как библиотека для другого приложения, вы не можете помешать другому приложению получить доступ к классам, определенным для внутреннего использования. Другими словами, вы не можете (?) Установить ограничение, согласно которому открытый класс X может использоваться только классами в моем приложении.

Здесь мне нравится архитектура плагинов Eclipse, где вы можете сказать, какие пакеты в моем плагине могут зависеть от доступа плагинов во время выполнения. JSR 277 был нацелен на привнесение таких модульных функций в JDK, но сейчас он мертв. Подробнее об этом читайте здесь, http://neilbartlett.name/blog/2008/12/08/hope-fear-and-project-jigsaw/

Теперь кажется, что единственный вариант - OSGi.

Существует ли фоновый процесс, такой как антивирусная или файловая индексация, блокирующая файл достаточно долго, чтобы вызвать проблемы с приложением? Попробуйте сделать паузу на 3 секунды, чтобы убедиться, что проблема исчезнет.

using System.Threading;

fs.Dispose();
Thread.Sleep(3000);
// Copy file

Как насчет с помощью ?

string source = @"C:\myTempDirectory\myFile.doc";
using(FileStream fs = new FileStream(
    source, FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
{
    BinaryWriter br = new BinaryWriter(fs);
    br.Write("BinaryDataFromDB");
}

File.Copy(sourceFileName, destinationFilename, true);

EDIT : попробуйте сообщить разрешение FileShare.Read .

Иногда я использую свойства public final w/o get/setter для короткоживущих объектов, которые просто несут некоторые данные (и никогда не будут делать ничего другого по проекту).

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

Неявные преобразования, которые необходимо учитывать:

• Identity
• sbyte to short, int, long, поплавковый, двойной или десятичный
• байт к короткому, ushort, int, uint, long, ulong, float, double или decimal
• short to int, long, float, double, или десятичное
• от int, uint, long, ulong, float, double или decimal
• int до long, от float, double или decimal
• uint до long, ulong, float, double или decimal
• long to float, double, или decimal
• ulong для плавания, double или decimal
• char для усхорта, int, uint, long, ulong, float, double или decimal
• float to double
• Преобразование типа NULL
• Ссылка на тип объекта
• Производный класс на базовый класс
• Класс на реализованный интерфейс
• Интерфейс на базовый интерфейс
• Массив на массив, если массивы имеют одинаковое количество измерений, есть неявное преобразование от исходного типа элемента до типа элемента назначения, и исходный тип элемента и тип элемента назначения - справочные типы
• тип Множества к Системе. Множество
• тип Множества к IList <> и его основные интерфейсы
• тип Делегата к Системе. Делегат
• Боксирующее преобразование
• Enum печатает к Системе. Пользователь Enum
• определил преобразование (op_implicit)

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

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

{-# LANGUAGE FlexibleContexts, ScopedTypeVariables #-}
module AccumST where 

import Control.Monad
import Control.Monad.ST
import Data.Array.Unboxed
import Data.Array.ST
import Data.Array.IArray

-- General one valid for all instances of Num.
-- accumST :: forall a. (IArray UArray a, Num a) => [a] -> Int -> a
accumST :: forall a. (IArray UArray a, Num a) => [a] -> Int -> a
accumST vals = (!) . runSTArray $ do
  arr <- newArray (0, length vals) 0 :: (Num a) => ST s (STArray s Int a)
  forM_ (zip vals [1 .. length vals]) $ \(val, i) ->
    readArray arr (i - 1)
    >>= writeArray arr i . (+ val)
  return arr

accumSTFloat vals = (!) . runSTUArray $ do
  arr <- newArray (0, length vals) 0 :: ST s (STUArray s Int Float)
  forM_ (zip vals [1 .. length vals]) $ \(val, i) ->
    readArray arr (i - 1)
    >>= writeArray arr i . (+ val)
  return arr

accumSTDouble vals = (!) . runSTUArray $ do
  arr <- newArray (0, length vals) 0 :: ST s (STUArray s Int Double)
  forM_ (zip vals [1 .. length vals]) $ \(val, i) ->
    readArray arr (i - 1)
    >>= writeArray arr i . (+ val)
  return arr

{-# RULES "accumST/Float" accumST = accumSTFloat #-}
{-# RULES "accumST/Double" accumST = accumSTDouble #-}

Версия Generic Unboxed (которая не работает) будет иметь ограничение типа, подобное следующему:

accumSTU :: forall a. (IArray UArray a, Num a, 
    forall s. MArray (STUArray s) a (ST s)) => [a] -> Int -> a

Можно упростить следующим образом:

-- accumST :: forall a. (IArray UArray a, Num a) => [a] -> Int -> a
accumST :: forall a. (IArray UArray a, Num a) => [a] -> Int -> a
accumST vals = (!) . runSTArray $ do
  arr <- newArray (0, length vals) 0 :: (Num a) => ST s (STArray s Int a)
  accumST_inner vals arr

accumST_inner vals arr = do
  forM_ (zip vals [1 .. length vals]) $ \(val, i) ->
    readArray arr (i - 1)
    >>= writeArray arr i . (+ val)
  return arr

accumSTFloat vals = (!) . runSTUArray $ do
  arr <- newArray (0, length vals) 0 :: ST s (STUArray s Int Float)
  accumST_inner vals arr

accumSTDouble vals = (!) . runSTUArray $ do
  arr <- newArray (0, length vals) 0 :: ST s (STUArray s Int Double)
  accumST_inner vals arr

{-# RULES "accumST/Float" accumST = accumSTFloat #-}
{-# RULES "accumST/Double" accumST = accumSTDouble #-}

Большинство разработчиков Java предпочтут видеть getters и setters.

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

Если вы публично раскрыли внутреннюю реализацию класса:

• Невозможно запретить потребителям использовать класс ненадлежащим образом
• Отсутствует контроль над точками входа/выхода; любое публичное поле может быть мутировано в любое время
• Увеличение связи между внутренней реализацией и внешними потребителями

Поддержание гетеров и установщиков может занять немного больше времени, но предлагает гораздо больше безопасности плюс:

• Вы можете повторно создать код в любое время, так сильно, как вы хотите, до тех пор, пока вы не нарушите ваш открытый API (getters, setters и public methods)
• Модульное тестирование хорошо инкапсулированных классов проще - вы тестируете открытый интерфейс и все (только ваши входы/выходы в «черный ящик»)
• Наследование, композиция и дизайн интерфейса все будут иметь больше смысла и быть проще в разработке с разъединенными классами
• Решите, что вам нужно добавить некоторую валидацию к мутатору, прежде чем он будет установлен? Одно хорошее место - внутри установщика.

Вы должны решить, стоит ли преимущества за дополнительное время.