Transient java что это
BestProg
Содержание
Поиск на других ресурсах:
1. Что такое сериализация? Преимущества сериализации
Язык программирования Java имеет мощные средства для обеспечения механизма сериализации. Сериализация – возможность объекта сохранять собственные данные (состояние объекта) в байтовом потоке с целью дальнейшего восстановления этих данных (состояния) при следующих запусках программы. Другими словами, текущие значения внутренних переменных в объекте можно сохранить (например, в файл), а затем восстановить в нужный момент.
Механизм сериализации дает следующие преимущества:
2. Реализация сериализации в программах на Java
так же класс, экземпляр которого сериализуется также должен реализовать интерфейс Serializable :
2.1. Запись объекта в файл
здесь filename – имя файла, в котором будет сохранен объект.
2. Упаковать файловый объект fOut в другой объект типа ObjectOutputStream
4. Закрыть оба созданных потока
2.2. Чтение объекта из файла
Если объект предварительно сохранен, то для того, чтобы восстановить его состояние из файла, нужно выполнить следующие действия.
1. Создать экземпляр fInput класса FileInputStream
здесь filename – имя файла (тип String ), в котором предварительно был сохранен объект.
4. Закрыть потоки fInput и objInput
Модификатор transient используется, если возникает необходимость сохранить объект (экземпляр) класса (выполнить сериализацию). Модификатор transient устанавливается перед объявлением внутренней переменной класса, значение которой не должно сохраняться в случае сохранения объекта. С помощью модификатора transient можно программно указать данные, которые не нужно сохранять при сериализации объекта.
В примере объявляется два класса:
В классе DataClass объявляются:
В классе SerializeClass объявляются:
5. Сохраняются ли методы класса во время сериализации?
Нет. При использовании механизма сериализации, сохраняются только данные (внутренние переменные).
6. Пример класса, который содержит методы сериализации экземпляра данного класса
Класс содержит методы сериализации экземпляра данного класса.
Ключевое слово transient в Java
Переходный процесс в Java используется для обозначения переменной, которую нельзя сериализовать, когда она сохраняется в потоках байтов. Это ключевое слово играет важную роль для ограничений безопасности в Java. Он игнорирует исходное значение переменной и сохраняет значение по умолчанию для этого типа данных переменной.
Что такое Transient в Java?
Transient – это модификатор переменных, который используется для сериализации. Теперь, что такое сериализация? Сериализация в Java – это механизм, который используется для преобразования состояния объекта в поток байтов. Во время сериализации, если вы не хотите сохранять значение определенной переменной в файле, используйте ключевое слово transient.
Если вы определите какой-либо элемент данных как временный, он не будет сериализован. Это связано с тем, что каждое поле, помеченное как переходное, не будет сериализовано. Это временное ключевое слово можно использовать, чтобы указать виртуальной машине Java (JVM), что временная переменная не является частью постоянного состояния объекта.
Давайте напишем очень простой пример, чтобы понять работу Transient в Java.
Здесь я создал класс под названием Demo, который реализует Serializable. Член данных возраста класса Demo объявлен как временный, его значение не будет сериализовано. Но если вы десериализуете объект, вы получите значение по умолчанию для временной переменной.
Для чего и когда использовать?
Transient в Java используется для указания того, что поле не должно быть частью процесса сериализации.
Модификатор Transient может применяться к переменным-членам класса, чтобы отключить сериализацию для этих переменных-членов. Каждое поле, помеченное как переходное, не будет сериализовано. Это временное ключевое слово можно использовать, чтобы указать виртуальной машине Java, что временная переменная не является частью постоянного состояния объекта.
Возможно, у вас возник вопрос в голове. Когда использовать?
Ответ на это будет:
Обратите внимание, что эти несериализуемые ссылки должны быть помечены как “переходные” перед сериализацией основного класса.
Как использовать Transient с ключевым словом Final?
Transient в Java может использоваться с ключевым словом final, потому что он ведет себя по-разному в разных ситуациях, что обычно не происходит с другими ключевыми словами в Java.
Посмотрите на этот пример.
Теперь, когда вы снова запустите сериализацию (запись / чтение), вы получите следующий вывод:
Kenny
Stark
password
null
Это потому, что Мы отметили «проход» для переходного процесса, и все же это поле было сериализовано. Для аналогичного объявления блокировка не была сериализована.
Причина в том, что всякий раз, когда любое конечное поле оценивается как константное выражение, оно сериализуется JVM, игнорируя наличие переходного ключевого слова.
Разница между Transient и Volatile
Volatile и Transient – это два совершенно разных ключевых слова, которые используются в Java. Transient используется во время сериализации Java-объекта. Volatile связана с видимостью переменных, измененных несколькими потоками.
Единственное сходство между этими ключевыми словами состоит в том, что они являются менее используемыми или необычными ключевыми словами и не так популярны, как общедоступные, статические или конечные.
Сериализация в Java. Не все так просто
Сериализация (Serialization) — это процесс, который переводит объект в последовательность байтов, по которой затем его можно полностью восстановить. Зачем это нужно? Дело в том, при обычном выполнении программы максимальный срок жизни любого объекта известен — от запуска программы до ее окончания. Сериализация позволяет расширить эти рамки и «дать жизнь» объекту так же между запусками программы.
Дополнительным бонусом ко всему является сохранение кроссплатформенности. Не важно какая у вас операционная система, сериализация переводит объект в поток байтов, который может быть восстановлен на любой ОС. Если вам необходимо передать объект по сети, вы можете сериализовать объект, сохранить его в файл и передать по сети получателю. Он сможет восстановить полученный объект. Так же сериализация позволяет осуществлять удаленный вызов методов (Java RMI), которые находятся на разных машинах с, возможно, разными операционными системами, и работать с ними так, словно они находятся на машине вызывающего java-процесса.
Реализовать механизм сериализации довольно просто. Необходимо, чтобы ваш класс реализовывал интерфейс Serializable. Это интерфейс — идентификатор, который не имеет методов, но он указывает jvm, что объекты этого класса могут быть сериализованы. Так как механизм сериализации связан с базовой системой ввода/вывода и переводит объект в поток байтов, для его выполнения необходимо создать выходной поток OutputStream, упаковать его в ObjectOutputStream и вызвать метод writeObject(). Для восстановления объекта нужно упаковать InputStream в ObjectInputStream и вызвать метод readObject().
В процессе сериализации вместе с сериализуемым объектом сохраняется его граф объектов. Т.е. все связанные с этим объекто, объекты других классов так же будут сериализованы вместе с ним.
Рассмотри пример сериализации объекта класса Person.
Вывод:
В данном примере класс Home создан для того чтобы продемонстрировать, что при сериализации объекта Person, с ним сериализуется и граф его объектов. Класс Home так же должен реализовывать интерфейс Serializable, иначе случится исключение java.io.NotSerializableException. Так же в примере описана сериализация с помощью класса ByteArrayOutputStream.
Из результатов выполнения программы можно сделать интересный вывод: при восстановлении объектов, у которых до сериализации была ссылка на один и тот же объект, этот объект будет восстановлен только один раз. Это видно по одинаковым ссылкам в объектах после восстановления:
Однако, так же видно, что при выполнении записи двумя потоками вывода (у нас это ObjectInputStream и ByteArrayOutputStream), объект home будет создан заново, несмотря на то, что он уже был создан до этого в одном из потоков. Мы видим это по разным адресам объектов home, полученных в двух потоках. Получается, что если выполнить сериализацию одним выходным поток, затем восстановить объект, то у нас есть гарантия восстановления полной сети объектов без лишних дубликатов. Конечно, в ходе выполнения программы состояние объектов может измениться, но это на совести программиста.
Проблема
Из примера так же видно, что при восстановлении объекта может возникнуть исключение ClassNotFoundException. С чем это связано? Дело в том, что мы легко можем сериализовать объект класса Person в файл, передать его по сети нашему товарищу, который может восстановить объект другим приложением, в котором класса Person попросту нет.
Своя сериализация. Как сделать?
Что делать, если вы хотите управлять сериализацией сами? Например, ваш объект хранит в себе логин и пароль пользователей. Вам необходимо сериализовать его для дальнейшей передачи его по сети. Передавать пароль в таком случае крайне ненадежно. Как решить эту задачу? Существует два способа. Первый, использовать ключевое слово transient. Второй, вместо реализации интереса Serializable использовать его расширение — интерфейс Externalizable. Рассмотрим примеры работы первого и второго способа для их сравнения.
Первый способ — Сериализация с использованием transient
Вывод:
Второй способ — Сериализация с реализацией интерфейса Externalizable
Вывод:
Первое отличие двух вариантов, которое бросается в глаза это размер кода. При реализации интерфейса Externalizable нам необходимо переопределить два метода: writeExternal() и readExternal(). В методе writeExternal() мы указываем какие поля будут сериализованы и как, в readExternal() как их прочитать. При использовании слова transient мы явно указываем, какое поле или поля не нужно сериализовывать. Так же заметим, что во втором способе мы явно создали конструктор по умолчанию, причем публичный. Зачем это сделано? Давайте попробуем запустить код без этого конструктора. И посмотрим на вывод:
Мы получили исключение java.io.InvalidClassException. С чем это связано? Если пройти по стек-трейсу можно выяснить, что в конструкторе класса ObjectStreamClass есть строчки:
Для интерфейса Externalizable будет вызван метод получения конструктора getExternalizableConstructor(), внутри которого мы через Reflection попробуем получить конструктор по умолчанию класса, для которого мы восстанавливаем объект. Если нам не удается его найти, или он не public, то мы получаем исключение. Обойти эту ситуацию можно следующим образом: не создавать явно никакого конструктора в классе и заполнять поля с помощью сеттеров и получать значение геттерами. Тогда при компиляции класса будет создан конструктор по умолчанию, который будет доступен для getExternalizableConstructor(). Для Serializable метод getSerializableConstructor() получает конструктор класса Object и от него ищет нужный класс, если не найдет, то получим исключение ClassNotFoundException. Выходит, что ключевое различие между Serializable и Externalizable в том, что первому не нужен конструктор для создания восстановления объекта. Он просто полностью восстановится из байтов. Для второго при восстановлении сначала будет создан объект с помощью конструктора в точке объявления, а затем в него будут записаны значения его полей из байтов, полученных при сериализации. Лично мне больше нравится первый способ, он гораздо проще. Причем, даже если нам нужно все таки задать поведение сериализации, мы можем не использовать Externalizable, а так же реализовать Serializable, добавив (не переопределив) в него методы writeObject() и readObject(). Но для того, чтобы они «работали» нужно точно соблюсти их сигнатуру.
Вывод:
Внутри наших добавленных методов вызываются defaultWriteObject() и defaultReadObject(). Они отвечают за сериализацию по умолчанию, как если бы она работала без добавленных нами методов.
На самом деле это только верхушка айсберга, если продолжить углубляться в механизм сериализации, то с высокой доли вероятности, можно отыскать еще нюансы, найдя которые мы скажем: «Сериализация… не все так просто».
Модификаторы в Java: static, final, abstract, synchronized, transient, volatile.
Сегодня, как и обещалось в статье о пакетах, мы поговорим о модификаторах: какие бывают модификаторы, области видимости, модификаторы для классов, полей, методов. Думаю, будет не скучно.
Модификаторы в Java – это ключевые слова, которые придают классу, полю класса или методу определенные свойства.
Для обозначения видимости класса его методов и полей есть 4 модификатора доступа:
Если Вы помните прошлую статью, то в конце, когда мы уже импортировали класс Cat, у нас все равно была ошибка компиляции.
package com.cat ; //заметьте, появилась новая строка объявления пакета
Cat ( ) < //конструктор без параметров
//сюда можно писать код, который будет выполняться при создании объекта
>
Cat ( String catsColor, int catsWeight, String catsSex ) < //конструктор с тремя параметрами
color = catsColor ;
weight = catsWeight ;
sex = catsSex ;
>
return color + » cat is walking» ;
>
Все дело в том, что мы не прописали никаких модификаторов доступа к нашим полям и методам и они имеют свойство по умолчанию (члены класса видны внутри пакета). Чтобы исправить ошибку компиляции для нашего кода и наконец то запустить его, нужно сделать наш конструктор и методы public. Тогда их можно будет вызывать с других пакетов.
Вы можете начать задаваться вопросом: а для чего все это нужно? Почему не сделать видимость кода из любого пакета или класса, а нужно разграничить доступ? Эти вопросы сами пропадут, когда придет время писать сложные и громоздкие проекты. Сейчас, когда мы пишем приложения, у которых функционал ограничен одним или двумя классами, то смысла что либо ограничить вроде как не видно.
Представьте, что у Вас есть класс который отображает объект некоего продукта. Например машина. У машины может быть цена. Вы создали поле цена и еще множество других полей, кучу методов которые отвечают за функционал. Все вроде хорошо. Ваш класс машина является частью огромного проекта и все довольны. Но допустим, что кто-то по ошибке или специально создал экземпляр класса автомобиль и поставил отрицательную цену. Разве может товар иметь отрицательную цену? Это очень примитивный пример и вряд ли такое может случиться в реальной жизни, но думаю, идея понятна. Иногда нужно дать доступ не напрямую, а через определенные методы. Может быть, что код отвечает за функционал другого кода, и Вы не хотите, чтобы кто-то изменял и редактировал часть Вашего. Для этого всего и есть ограничение доступа.
Модификатор доступа у конструкторов, методов и полей может быть любой. Класс может быть только либо public, либо default, причем в одном файле может находиться только один public класс. 
Пока об модификаторах доступа будет достаточно. В статье «Объектно ориентированное программирование» мы о них поговорим подробнее, а сейчас давайте поговорим о других модификаторах которых, к стати, немало.
Сейчас на очереди модификатор static. Его можно применять перед методом, полем и даже классом, когда хотим объявить вложенный класс. В Java можно писать классы внутри других классов и если модификатор перед классом внутри класса static, то такой класс называют вложенным, если другой модификатор или по умолчанию, то такой класс называется внутренним. О вложенных и внутренних классах будет отдельная статья, поскольку там не все так просто.
static модификатор перед методом или полем говорит о том, что они не принадлежат к экземпляру данного класса. Что это означает для нас? Когда мы описали поле класса или метод как static, его можно вызвать без использования экземпляра класса. То есть вместо такой конструкции: Cat cat = new Cat(); cat.method(), можно написать просто Cat.method(). При условии, что метод объявлен как static. Статические переменные едины для всех объектов класса. У них одна ссылка.
public class Modificators <
static String someField ;
static int anotherStaticField = 5 ;
String nonStaticField ;
public static void myStaticMethod ( ) <
someField = «My field» ;
//nonStaticField = «»; ошибка компиляции
//нельзя использовать нестатические поля
//в статических методах
>
public void myNonStaticMethod ( ) <
anotherStaticField = 4 ; //ститические поля можно использовать
//в нестатических методах
>
Еще одно важное замечание, которое нужно сказать по поводу static модификаторов: статические поля инициализируются во время загрузки класса. Часто в разного рода тестах по Java можно встретить такой код:
public class OftenQuestions <
Вопрос: что будет выведено на консоль? Нужно помнить, что static блок будет выведен первым при любом раскладе. Далее будет идти блок по умолчанию. Далее смотрите на скрин консоли: 
Следующий модификатор, который мы рассмотрим будет final.
Думаю, слово final говорит само за себя. Применяя final модификатор Вы говорите, что поля не могут быть изменены, методы переопределены, а классы нельзя наследовать (о наследовании будет отдельная статья). Этот модификатор применяется только к классам, методам и переменным (также и к локальным переменным).
public final class FinalModificator <
final static String CONSTANT = «Hi there» ; //полю CONSTANT нельзя дать новое значение
//таким образом в джаве можно объявлять константы.
//константы в языке Java обычно пишут в верхнем регистре
final int ANOTHER_CONSTANT ;
//константы нужно инициализировать при объявлении или в конструкторе.
public static void main ( String [ ] args ) <
// TODO Auto-generated method stub
FinalModificator. CONSTANT = «Bue there» ; //ошибка компиляции
//попытка переопределить константу
С модификатором final к методам и классам мы будем говорить в статье ООП.
Далее пойдут модификаторы, которые новичкам или читающим данный цикл статей с нуля будут не очень понятными. И хотя я пока не смогу Вам все объяснить (в силу того, что Вы не знаете сопутствующего материала), все же советую просто ознакомиться с ними. Когда придет время использования данных модификаторов, Вы уже будете понимать большинство терминов используемых ниже.
Модификатор synchronized — говорит о том, что метод может быть использован только одним потоком одновременно. Хотя, возможно, это Вам ни о чем не говорит, полезность этого модификатора будет видно, когда мы будем изучать многопоточность.
Модификатор transient — говорит о том, что во время сериализации объекта некоторое поле нужно игнорировать. Как правило, такие поля хранят промежуточные значения.
Модификатор volatile — используется при многопоточности. Когда поле с модификатором volatile будет использоваться и изменяться несколькими потоками, данный модификатор гарантирует, что поле будет изменяться по очереди и путаницы с ним не возникнет.
Модификатор native перед объявлением метода указывает что метод написан на другом языке программирования. Обычно на языке C.
Модификатор strictfp — Обеспечивает выполнение операций над числами типа float и double (с плавающей запятой) по стандарту IEEE 754. Или говоря проще, гарантирует что в пределах метода результаты вычислений будут одинаковыми на всех платформах.
Я еще не говорил о модификаторе abstract. О нем скажу вкратце, так как без знаний основ объектно ориентированного программирования говорить о нем не вижу смысла.
Класс, который имеет модификатор abstract не может создать экземпляр. Единственная цель для него быть расширенным. Класс abstract может содержать как абстрактные методы, а также и обычные.
Подробнее о модификаторе abstract будем говорить в статье ООП.
На этом можно и закончить статью о модификаторах. Многое о них не было сказано. Но это из-за того, что у нас еще нет понятий ООП. Через несколько статей, мы дополним знания о модификаторах и заполним пробелы.
Русские Блоги
Подробное объяснение ключевого слова transient в java
Предисловие
По правде говоря, друзья, которые некоторое время изучали java transient Это ключевое слово все еще очень незнакомо и редко используется, но transient Ключевые слова играют незаменимую позицию в java! Если вы хотите поговорить об этом, я думаю, что наиболее вероятным местом появления является поток объектов (также называемый потоком сериализации) в потоке ввода-вывода.
Каталог статей
1. Что такое сериализация?
Сериализация определений профессиональных терминов:
Java предоставляет механизм для сериализации объектов. Объект может быть представлен последовательностью байтов, которая содержит такую информацию, как данные объекта, тип объекта и атрибуты, хранящиеся в объекте. После того, как последовательность байтов записана в файл, это эквивалентно сохранению информации об объекте в файле. И наоборот, последовательность байтов также можно прочитать из файла, восстановить объект и десериализовать его. Данные объекта, тип объекта и информация о данных, хранящаяся в объекте, могут использоваться для создания объектов в памяти.
Сериализация определения термина Yichun:
Сериализация:Байт ——> объект
Фактически, то, что я резюмировал, является приведенным выше выводом. Если вы не понимаете, просто обратитесь к определению профессиональных терминов. После того, как вы поймете, просто запомните, что я сказал. Если вы не можете вспомнить, пожалуйста, забейте меня до смерти (я просто гений)
Схема понимания сериализации: 
Что? Вы не знаете, что такое байты? Фактически, я уже представил сериализацию в статье о потоках ввода-вывода, будьте уверены, это абсолютно подробноПросто посмотрите на название статьи
2. Почему сериализация?
Из предыдущего раздела упоминалась концепция сериализации, зная концепцию, мы должны знать, почему нам нужно сериализовать.
Прежде чем говорить о причинах сериализации, блогер, позвольте вам выделить каштан:
Точно так же, как когда вы идете на улицу за овощами, обычно их нужно упаковать в полиэтиленовые пакеты и вынуть, когда вы вернетесь домой, чтобы приготовить овощи. И эта серия операций похожа на сериализацию и десериализацию!
Если у пользователя есть пароль и другая информация в целях безопасности, и он не хочет, чтобы их передавали во время сетевых операций, переменная, соответствующая этой информации, может быть добавлена с помощью ключевого слова transient. Другими словами, жизненный цикл этого поля хранится только в памяти вызывающего объекта и не будет записан на диск для сохранения.
1. Значения полей в классе могут быть производными из других полей.
2. См. конкретные бизнес-требования, какие поля не нужно сериализовать;
Я не знаю, задумывались ли вы когда-нибудь о том, почему его не следует сериализовать? Фактически, это в основном для экономии места для хранения. Оптимизируйте программу!
PS: не забудьте прочитать перед HashMap В исходном коде я обнаружил, что используется поле transient Модификация, я думаю, имеет смысл. На самом деле нет необходимости сериализовать поле modCount, потому что это бессмысленно. ModCount в основном используется для определения того, был ли изменен HashMap (например, операции добавления и удаления, modCount Он будет увеличиваться автоматически. Для этого типа переменной это может быть любое значение в начале. Конечно, также возможно значение 0 (когда новая, десериализованная или клонированная, это 0), и нет необходимости сохранять ее значение.
3. Сериализация и использование переходных процессов.
1、 Класс объекта, который необходимо сериализовать, должен реализовывать интерфейс сериализации: Java.lang.Serializable interface (Интерфейс логотипа без каких-либо абстрактных методов), большинство классов в Java реализуют этот интерфейс, например: String ， Integer Классы и т. Д., Классы, которые не реализуют этот интерфейс, не будут сериализовать или десериализовать какое-либо состояние и будут вызывать NotSerializableException Исключение.
2. Нижний слой будет определять, является ли текущий объект Serializable Экземплярам разрешено выполнять сериализацию, объекты Java instanceof Serializable Судить.
3、 Использование объектных потоков в Java ObjectOutputStream Чтобы завершить сериализацию и ObjectInputStream Десериализация потока
ObjectOutputStream: сериализовать с помощью метода writeObject ()
ObjectInputStream: десериализация с помощью метода readObject ()
4. Все атрибуты этого класса должны быть сериализуемыми. Если есть атрибут, который не должен быть сериализуемым, атрибут должен быть помечен как временный, используйте transient Модификация ключевого слова. 
Из-за байта он должен включать в себя операцию потока, то есть поток объектов также называется сериализованным потоком ObjectOutputstream, а код операции сериализации анализируется в различных ситуациях!
3.1. Сериализация без реализации интерфейса Serializable
результат операции 
3.2. Реализуйте сериализацию интерфейса Serializable.
Когда мы добавим реализацию интерфейса Serializable, а затем запустим ее, мы обнаружим, что проект отображается userinfo.txt Содержимое файла выглядит так: 
На самом деле дело не в этом, дело в том, что операция сериализации прошла успешно!
3.3, общая ситуация сериализации
3.4, переходная ситуация сериализации
3.5, ситуация статической сериализации
В настоящее время вы можете ошибочно подумать, что статическая модификация тоже сериализуется. На самом деле это не так. На самом деле, здесь легко запутаться! Очевидно вынуть null (Значение по умолчанию) может объяснить, что оно не будет сериализовано, здесь оно явно не станет значением по умолчанию, почему вы хотите сказать static Он не будет сериализован?
Фактически, значение имени статической переменной в классе после десериализации на самом деле является значением соответствующей статической переменной в текущей JVM, это значение не получается путем десериализации в JVM. Другими словами, переменная, измененная static, не участвует в сериализации! Но мы не можем сказать, что нет никаких доказательств, да, тогда давайте посмотрим на сравнение двух программ, чтобы понять!
Первая программа: это программа с атрибутом имени, которая не изменяется статикой:
Из результатов работы программы видно, что перед десериализацией попытаться изменить значение name на старое изменение программиста, результат не удачный!
Вторая программа: это программа с атрибутом имени, измененная статикой:
Из результатов выполнения программы видно, что перед десериализацией попробуйте изменить значение name на старое изменение программиста, результат успешный! Понятно ли сейчас сравнивать две программы?
Если вы все еще не понимаете ключевое слово static, вы можете обратиться к этой статье, ее следует считать подходящей:Глубокое понимание статического ключевого слова
3.6, финальная ситуация сериализации
Для ключевого слова final последняя переменная будет напрямую участвовать в сериализации через значение. Что касается программы кода, я не буду ее больше публиковать. Вы можете попробовать использовать последнюю модификацию, чтобы проверить это!
Главное отметить, что final и transient могут изменять одну и ту же переменную в одно и то же время, и результат один и тот же. Это не влияет на переходный процесс. Я в основном упоминаю здесь. Надеюсь, вы не запутаетесь, столкнувшись с такими ситуациями в будущем!
4. Роль serialVersionUID в классе Java
5. Резюме временных ключевых слов
1. Переменная изменена переходным процессом, переменная не будет сериализована.
2. Ключевое слово transient может изменять только переменные, но не методы и классы.
3. Переменные, измененные ключевым словом static, не участвуют в сериализации. Статическая статическая переменная не может быть сериализована независимо от того, изменена ли она временным или нет.
4. Конечное значение переменной участвует в сериализации, final transient изменяет переменную одновременно, final не повлияет на переходный процесс и не будет участвовать в сериализации.
Во-вторых, следует отметить, что локальные переменные не могут быть изменены с помощью ключевого слова transient. Если переменная является определяемой пользователем переменной класса, класс должен реализовать интерфейс Serializable.
Заключение: Измененный ключевым словом transient, он не сериализуется, и его преимущество состоит в том, что он может сэкономить место для хранения. Оптимизируйте программу! Далее следует, что поля, измененные переходным процессом, будут пересчитаны и инициализированы!
Если эта статья немного полезна для вас, пожалуйста, дайте мне большой палец вверх, спасибо
Если есть какие-либо недостатки или неточности, вы можете их исправить и критиковать, и я вам благодарен! Если у вас есть вопросы, оставьте сообщение и ответьте как можно скорее!