Неизменный класс?
Есть несколько способов сделать это.
Одним из способов может быть создание комбинированного списка и назначение списка как ItemsSource. Затем вы можете сделать некоторые метки и ввести и назначить выбранного человека в поле со списком как DataContext для окна.
Скажем, например, что это XAML:
<ComboBox x:Name="personCombobox" HorizontalAlignment="Left" SelectionChanged="personCombobox_OnSelectionChanged">
<ComboBox.ItemTemplate>
<DataTemplate>
<StackPanel Orientation="Horizontal">
<TextBlock Text="{Binding FirstName, Mode=OneWay}" />
<TextBlock Text=" - " />
<TextBlock Text="{Binding LastName, Mode=OneWay}" />
</StackPanel>
</DataTemplate>
</ComboBox.ItemTemplate>
</ComboBox>
<Label Content="{Binding FirstName, Mode=OneWay}"/>
<Label Content="{Binding LastName, Mode=OneWay}" />
И тогда код будет выглядеть примерно так:
public MainWindow()
{
InitializeComponent();
personCombobox.ItemsSource = personRepository.GetAll();
personCombobox.SelectedIndex = 0;
}
private void personCombobox_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (personCombobox.SelectedIndex != -1)
{
this.DataContext = (Person)personCombobox.Items.GetItemAt(personCombobox.SelectedIndex);
}
}
5 ответов
Что такое неизменяемый объект?
Неизменяемый объект - это объект, состояние которого не меняется после создания его экземпляра.
Как сделать объект неизменным?
В общем, неизменяемый объект может быть создан путем определения класса, у которого нет открытых членов и нет никаких установщиков.
Следующий класс создаст неизменяемый объект:
class ImmutableInt {
private final int value;
public ImmutableInt(int i) {
value = i;
}
public int getValue() {
return value;
}
}
Как видно из приведенного выше примера, значение ImmutableInt может быть установлено только при создании экземпляра объекта и при наличии только getter ( getValue ) состояние объекта не может быть изменено после создания экземпляра.
Однако следует позаботиться о том, чтобы все объекты, на которые ссылается объект, также были неизменяемыми, иначе можно было бы изменить состояние объекта.
Например, разрешение получить ссылку на массив или ArrayList через геттер позволит внутреннему состоянию измениться путем изменения массива или коллекции:
class NotQuiteImmutableList<T> {
private final List<T> list;
public NotQuiteImmutableList(List<T> list) {
// creates a new ArrayList and keeps a reference to it.
this.list = new ArrayList(list);
}
public List<T> getList() {
return list;
}
}
Проблема с приведенным выше кодом заключается в , что ArrayList может быть получен с помощью getList и им можно будет управлять, что приводит к изменению состояния самого объекта, следовательно, не неизменяемому.
// notQuiteImmutableList contains "a", "b", "c"
List<String> notQuiteImmutableList= new NotQuiteImmutableList(Arrays.asList("a", "b", "c"));
// now the list contains "a", "b", "c", "d" -- this list is mutable.
notQuiteImmutableList.getList().add("d");
Один из способов обойти эту проблему - вернуть копию массива или коллекции при вызове из геттера:
public List<T> getList() {
// return a copy of the list so the internal state cannot be altered
return new ArrayList(list);
}
В чем преимущество неизменяемости?
Преимущество неизменности связано с параллелизмом. Трудно поддерживать правильность изменяемых объектов, поскольку несколько потоков могут пытаться изменить состояние одного и того же объекта, что приводит к тому, что некоторые потоки видят разное состояние одного и того же объекта, в зависимости от времени чтения и записи в указанный объект.
Имея неизменяемый объект, можно гарантировать, что все потоки, которые смотрят на объект, будут видеть одно и то же состояние, поскольку состояние неизменяемого объекта не изменится.
Неизменный класс является просто классом, экземпляры которого не могут быть изменены.
Вся информация, содержавшаяся в каждом экземпляре, фиксируется в течение времени жизни объекта, таким образом, никакие изменения никогда не могут наблюдаться.
Неизменные классы легче разработать, реализовать, и использовать, чем изменяемые классы.
Для создания класса неизменным следуйте этим пяти правилам:
-
Don’t предоставляют методы, которые изменяют состояние object’s
-
, Гарантируют, чтобы класс can’t был расширен.
-
Делают весь полевой финал.
-
Делают все поля частными.
-
Гарантируют эксклюзивный доступ к любым изменяемым компонентам.
Неизменные объекты по сути ориентированы на многопотоковое исполнение; они не требуют никакой синхронизации.
Неизменные объекты могут быть совместно использованы свободно.
Неизменные объекты делают большие стандартные блоки для других объектов
Вы делаете класс неизменяемым следующим образом:
public final class Immutable
{
private final String name;
public Immutable(String name)
{
this.name = name;
}
public String getName() { return this.name; }
// No setter;
}
Ниже приведены требования, чтобы сделать класс Java неизменяемым:
- Класс должен быть объявлен как
final(Чтобы дочерние классы могли ' t быть создан) - Члены в классе должны быть объявлены как
final(чтобы мы не могли изменить его значение после создания объекта) - Записать методы получения для всех переменных в нем, чтобы получить члены значения
- Нет методов Setters
Неизменяемые классы полезны, потому что
- Они потокобезопасны.
- Они также выражают нечто глубокое в вашем дизайне: «Этого нельзя изменить». Когда это применимо, это именно то, что вам нужно.
В дополнение к уже данным ответам, я бы рекомендовал прочитать о неизменяемости в Effective Java, 2nd Ed., поскольку там есть некоторые детали, которые легко упустить (например, защитные копии). Кроме того, Effective Java 2nd Ed. является обязательным чтением для каждого Java-разработчика.
Неизменяемость может быть достигнута в основном двумя способами:
- с использованием
finalатрибутов экземпляра, чтобы избежать переназначения - с использованием интерфейса класса, который просто не допускает никаких операций, способных изменить то, что является внутри вашего класса (только геттеров и нет сеттеров
). Преимущества неизменяемости - это допущения, которые вы можете сделать для этих объектов:
- вы получаете правило отсутствия побочных эффектов (что на самом деле популярны на языках функционального программирования) и позволяет вам проще использовать объекты в параллельной среде, поскольку вы знаете, что они не могут быть изменены атомарным или неатомарным способом, когда они используются многими потоками
- , реализации языков могут обрабатывать эти объекты по-другому, помещая их в зоны памяти, которые используются для статических данных, что позволяет более быстрое и безопасное использование этих объектов (это то, что происходит внутри JVM для строк)