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 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, он не сериализуется, и его преимущество состоит в том, что он может сэкономить место для хранения. Оптимизируйте программу! Далее следует, что поля, измененные переходным процессом, будут пересчитаны и инициализированы!
Если эта статья немного полезна для вас, пожалуйста, дайте мне большой палец вверх, спасибо
Если есть какие-либо недостатки или неточности, вы можете их исправить и критиковать, и я вам благодарен! Если у вас есть вопросы, оставьте сообщение и ответьте как можно скорее!
Модификаторы в 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 используется для обозначения переменной, которую нельзя сериализовать, когда она сохраняется в потоках байтов. Это ключевое слово играет важную роль для ограничений безопасности в 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 связана с видимостью переменных, измененных несколькими потоками.
Единственное сходство между этими ключевыми словами состоит в том, что они являются менее используемыми или необычными ключевыми словами и не так популярны, как общедоступные, статические или конечные.
Зачем использовать ключевое слово «transient» в java? [дубликат]
этот вопрос уже есть ответ здесь:
когда я гуглил, я нашел эти документы, но они говорят о сериализации. На самом деле мой класс не реализует сериализованные.
мой класс выглядит так :
у меня есть несколько вопросов.
1.зачем использовать transient ключевое слово перед частной переменной?
2.какова цель использования этого ключевого слова?
5 ответов
переходные переменные никогда не сериализуются в java.
он отмечает переменную-член, которая не сериализуется, когда она сохраняется в потоках байтов. Когда объект передается через сеть, объект должен быть сериализован’. Сериализация преобразует состояние объекта в последовательные байты. Эти байты отправляются по сети, и объект воссоздается из этих байтов. Переменные-члены, отмеченные ключевым словом Java transient, не передаются, они теряются намеренно.
пожалуйста, посмотрите на что сериализация есть.? а также см. этой
transient ключевое слово предполагает, что объект не следует сериализовывать, ни упорствовал. Вы можете использовать его, если не хотите сериализовать тяжелые объекты (например, Wrapper s, например, который может содержать много бизнес-логики).
@Transient аннотация предполагает, что объект не следует настаивать (если Вы играли с Hibernate, например), но это может быть сериализован.
Я включил пояснение аннотации, потому что я помню, что был смущен этими двумя. 🙂
Ключевое слово Transient может применяться только к переменным-членам.
Применение его к методу или локальной переменной является ошибкой компиляции.
transient используется для указания, какие свойства объекта не будут сохранены или сериализованный. Например, при сохранении объекта в файл transient указывает, какие свойства или атрибуты не будут сохранены в этом файле при сохранении этого объекта в файл.
когда объект повторно создается из файла, значение этого transient атрибут (или частная собственность) не будет повторно создан, поскольку он никогда не был сохранен или сериализован в этот файл. В в некоторых случаях может потребоваться избежать сохранения некоторых из этих частных переменных экземпляра или атрибутов объекта, transient позволяет вам это делать.