关于javatransient修饰方法的信息

今天给各位分享javatransient修饰方法的知识，其中也会对进行解释，如果能碰巧解决你现在面临的问题，别忘了关注本站，现在开始吧！

本文目录一览：

1、transient关键字是什么？2、java 中的修饰符transient是什么意识他的原理是什么？3、java中的关键字transient是什么意思4、transient在java中的有什么作用？5、java 方法中含有 transient 是什么意思?6、transient在java中的作用

transient关键字是什么？

transient关键字是变量修饰符。如果用transient声明一个实例变量，当对象存储时它的值不需要维持，换句话来说就是，用transient关键字标记的成员变量不参与序列化过程，transient关键字只能修饰变量，而不能修饰方法和类。

transient关键字的特点

transient是Java语言的关键字，用来表示一个成员变量不是该对象序列化的一部分，当一个对象被序列化的时候，transient型变量的值不包括在序列化的结果中，而非transient型的变量是被包括进去的，注意static修饰的静态变量天然就是不可序列化的。

一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法被访问，本地变量是不能被transient关键字修饰的，变量如果是用户自定义类变量，则该类需要实现Serializable接口。

java 中的修饰符transient是什么意识他的原理是什么？

transient

Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的

class A implements Serializable {

private String name;

transient private String address;

}

那么你在串行化（IO流等）A类时 给它的name和address属性赋值，那么你在提取A时，拿到了name属性，但是却拿不到address属性。

java中的关键字transient是什么意思

变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持，即不持久化。也就是说不会为这个变量分配内存来保存，不知道我这样解释你明不明白?

transient在java中的有什么作用？

java 的transient关键字的作用是需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。

transient使用小结

1）一旦变量被transient修饰，变量将不再是对象持久化的一部分，该变量内容在序列化后无法获得访问。

2）transient关键字只能修饰变量，而不能修饰方法和类。注意，本地变量是不能被transient关键字修饰的。变量如果是用户自定义类变量，则该类需要实现Serializable接口。

3）被transient关键字修饰的变量不再能被序列化，一个静态变量不管是否被transient修饰，均不能被序列化。

java 方法中含有 transient 是什么意思?

“transient”——“瞬态”，先不说这个翻译是否恰当，这个变量关键字一直不曾使用，简单的说就是被瞬态定义的变量不可序列号。或者这么给他换个名字——“不可序列化状态”。

打个比方，如果一个用户有一些敏感信息（譬如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输。这些信息对应的变量就可以被定义为transient类型。换句话说，这个字段的生命周期仅存于调用者的内存中。

如定义类：

public class People implements Serializable {

private static final long serialVersionUID = 8294180014912103005L;

/**

* 用户名

*/

private String username;

/**

* 密码

*/

private transient String password;

}

密码字段为transient，这时候如果对该对象进行序列化，这个密码字段是不会被保存的。

以下例子展示了这个行为：

public static void main(String[] args) throws Exception {

People p = new People();

p.setUsername(“snowolf”);

p.setPassword(“123456”);

System.err.println(“——操作前——“);

System.err.println(“username: ” + p.getUsername());

System.err.println(“password: ” + p.getPassword());

ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(

“people.txt”));

oos.writeObject(p);

oos.flush();

oos.close();

ObjectInputStream ois = new ObjectInputStream(new FileInputStream(

“people.txt”));

p = (People) ois.readObject();

ois.close();

System.err.println(“——操作后——“);

System.err.println(“username: ” + p.getUsername());

System.err.println(“password: ” + p.getPassword());

}

执行结果是：

——操作前——

username: snowolf

password: 123456

——操作后——

username: snowolf

password: null

transient在java中的作用

java有个特点就是序列化，简单地来说就是可以将这个类存储在物理空间（当然还是以文件的形式存在），那么当你从本地还原这个文件时，你可以将它转换为它本身。这可以极大地方便网络上的一些操作，但同时，因为涉及到安全问题，所以并不希望把类里面所有的东西都能存储（因为那样，别人可以通过序列化知道类里面的内容），那么我们就可以用上transient这个关键字，它的意思是临时的，即不会随类一起序列化到本地，所以当还原后，这个关键字定义的变量也就不再存在。

通常,我们写的程序都要求特定信息能持久存在或保存到磁盘上,以供一个程序使用或用在同一个程序的另一次运行上.这种持久性可以通过几种方式来实现,包括写到数据库中或是利用JAVA为对象序列化提供的支持.不管我们选用什么方法,类实例的持久性都是通过保存类的域的状态来完成的,保存这些状态,以便以后可以对它们进行访问或使用它们来创建相同的实例.然而,有可能并不是所有的域都需要被保存起来.当一个实例被持久化时,其内部的一些域却不需要持久化,则可以用trainsient修饰符告诉编译器指定的域不需要被持久保存.

首先，让我们看一些Java serialization的代码：

public class LoggingInfo implements java.io.Serializable  {  

    private Date loggingDate = new Date();      

    private String uid;  

    private transient String pwd;       

    LoggingInfo(String user, String password){  

        uid = user;  

        pwd = password;      

    }  

    public String toString(){  

        String password=null;          

        if(pwd == null){  

            password = “NOT SET”;          

}else{  

            password = pwd;

}  

        return “logon info: \n   ” + “user: ” + uid +  

            “\n   logging date : ” + loggingDate.toString() + “\n   password: ” + password;      

    }  

}

现在我们创建一个这个类的实例，并且串行化(serialize)它 ,然后将这个串行化对象写入磁盘。

LoggingInfo logInfo = new LoggingInfo(“MIKE”, “MECHANICS”);  

System.out.println(logInfo.toString());  

try{  

    ObjectOutputStream o = new ObjectOutputStream(                 

    new FileOutputStream(“logInfo.out”));     

    o.writeObject(logInfo);     

    o.close();  

}catch(Exception e) 

    {//deal with exception}  

To read the object back, we can write 

try  {  

    ObjectInputStream in =new ObjectInputStream(

    new FileInputStream(“logInfo.out”));     

    LoggingInfo logInfo = (LoggingInfo)in.readObject();     

    System.out.println(logInfo.toString());  }  

catch(Exception e) 

    {//deal with exception}

如果我们运行这段代码，我们会注意到从磁盘中读回(read——back (de-serializing))的对象打印password为”NOT SET”。这是当我们定义pwd域为transient时，所期望的正确结果。 现在，让我们来看一下粗心对待transient域可能引起的潜在问题。假设我们修改了类定义，提供给transient域一个默认值， 代码如下：

public class GuestLoggingInfo implements java.io.Serializable  {  

    private Date loggingDate = new Date();      

    private String uid;  

    private transient String pwd;       

    GuestLoggingInfo(){  

        uid = “guest”;          

        pwd = “guest”;      

    }  

    public String toString() {  

        //same as above       

    }  

}

现在，如果我们穿行化GuestLoggingInfo的一个实例，将它写入磁盘，并且再将它从磁盘中读出，我们仍然看到读回的对象打印password 为 “NOT SET”。  当从磁盘中读出某个类的实例时，实际上并不会执行这个类的构造函数， 而是载入了一个该类对象的持久化状态，并将这个状态赋值给该类的另一个对象。

javatransient修饰方法的介绍就聊到这里吧，感谢你花时间阅读本站内容，更多关于、javatransient修饰方法的信息别忘了在本站进行查找喔。