transient修饰的成员变量,成员变量的实例

transient修饰的成员变量,成员变量的实例详细介绍

本文目录一览： MP实体中加入非表字段的三种处理方案

一、transient修饰该成员变量，不序列化此字段。

? ? 缺点：此方式只适用不需要给此字段序列化的场景。

二、static修饰该成员变量，变为静态变量，并生成静态getter和setter方法。

? ? 缺点：此方式全类只生成一份，只适用全类只要一份的变量。

三、 @TableField(exist =false) 修饰该变量，则表示此变量不在数据表中。

? ? 推荐使用：完美解决在实体类中添加非表字段的问题！！

java中transient的用法

transient
Java语言的关键字，用来表示一个域不是该对象串行化的一部分。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。
个人以为这个关键字很少能用得到
使用transient修饰符来标识一个成员变量在序列化子系统中应被忽略。
transient:
使用对象：字段
介绍：字段不是对象持久状态的一部分，不应该把字段和对象一起串起。
在JPA实体中，所有未使用Transient注释（由JPA定义）进行注释的非瞬态字段都是持久化字段。“持久化”意味着字段被映射到数据库中的列。请注意，Patient类中的一些持久化字段没有注释。这是由于JPA定义的默认值（如默认的列名称）对于这些字段来说是正确的。如果字段名称与其映射的数据库列名称不同，则必须使用Column注释来为数据库列指定一个不同的列名称。
详细内容见：http://dev2dev.bea.com.cn/techdoc/20060516791.html
一些其他的文章：
http://java.ccidnet.com/art/3741/20051208/527561_1.html
http://blog.matrix.org.cn/page/tswin

集合结构分析&线程并发库

们用的比较多List包括ArrayList和LinkedList
注意：transient：java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。换句话来说就是，用transient关键字标记的成员变量不参与序列化过程。
红黑树（Red Black Tree） 是一种自平衡二叉查找树，是在计算机科学中用到的一种数据结构，典型的用途是实现关联数组。
在树的结构发生改变时（插入或者删除操作），往往会破坏上述条件3或条件4，需要通过调整使得查找树重新满足红黑树的条件。如果有删除或者插入节点,使用左旋和右旋;
HashMap提供了4个构造函数：
在这里提到了两个参数：初始容量，加载因子。这两个参数是影响HashMap性能的重要参数，其中容量表示哈希表中桶的数量，初始容量是创建哈希表时的容量，加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度，它衡量的是一个散列表的空间的使用程度，负载因子越大表示散列表的装填程度越高，反之愈小。对于使用链表法的散列表来说，查找一个元素的平均时间是O(1+a)，因此如果负载因子越大，对空间的利用更充分，然而后果是查找效率的降低；如果负载因子太小，那么散列表的数据将过于稀疏，对空间造成严重浪费。系统默认负载因子为0.75，一般情况下我们是无需修改的。
强烈建议使用EntrySet进行遍历。
涉及问题：
进程是资源分配的最小单位，线程是程序执行的最小单位。
进程是资源（CPU、内存等）分配的基本单位，它是程序执行时的一个实例。程序运行时系统就会创建一个进程，并为它分配资源，然后把该进程放入进程就绪队列，进程调度器选中它的时候就会为它分配CPU时间，程序开始真正运行。
线程是程序执行时的最小单位，它是进程的一个执行流，是CPU调度和分派的基本单位，一个进程可以由很多个线程组成，线程间共享进程的所有资源，每个线程有自己的堆栈和局部变量。线程由CPU独立调度执行，在多CPU环境下就允许多个线程同时运行。同样多线程也可以实现并发操作，每个请求分配一个线程来处理。
实现 Runnable 和 Callable 接口的类只能当做一个可以在线程中运行的任务，不是真正意义上的线程，因此最后还需要通过 Thread 来调用。可以说任务是通过线程驱动从而执行的。
实现接口 VS 继承 Thread :
Thread和Runable的联系和区别
产生线程阻塞的原因：
给定一个进程内的所有线程，都共享同一存储空间，这样有好处又有坏处。这些线程就可以共享数据，非常有用。不过，在两个线程同时修改某一资源时，这也会造成一些问题。Java 提供了同步机制，以控制对共享资源的互斥访问。
Synchronized关键字
synchronized与Lock的区别
wait()、notify()、notifyAll()它们都属于 Object 的一部分，而不属于 Thread。而 sleep() 是 Thread 的静态方法。只有在同步控制方法或同步控制块里才能调用 wait() 、notify() 和 notifyAll()。
ThreadLocal 是解决线程安全问题一个很好的思路，它通过为每个线程提供一个独立的变量副本解决了变量并发访问的冲突问题。在很多情况下，ThreadLocal比直接使用synchronized同步机制解决线程安全问题更简单，更方便，且结果程序拥有更高的并发性。
ThreadLocal类提供的几个方法：
get()方法是用来获取ThreadLocal在当前线程中保存的变量副本，set()用来设置当前线程中变量的副本，remove()用来移除当前线程中变量的副本，initialValue()是一个protected方法，一般是用来在使用时进行重写的，它是一个延迟加载方法。
每个线程Thread内部有一个ThreadLocal.ThreadLocalMap类型的成员变量threadLocals，这个threadLocals就是用来存储实际的变量副本的，键值为当前ThreadLocal变量，value为变量副本（即T类型的变量）。
初始时，在Thread里面，threadLocals为空，当通过ThreadLocal变量调用get()方法或者set()方法，就会对Thread类中的threadLocals进行初始化，并且以当前ThreadLocal变量为键值，以ThreadLocal要保存的副本变量为value，存到threadLocals。 然后在当前线程里面，如果要使用副本变量，就可以通过get方法在threadLocals里面查找。 ThreadLocal配置多数据源

java中final和static修饰变量有什么好处

用final 修饰的变量就是常量,是程序运行的过程是不可以改变的
用static修饰的变量是公用变量,所有的实例都使用一个
如果一个对象修改了static变量,其它对象里这个变量的值也会改变
Stastic为静态变量，在一个类中的任何地方都可以调用，而final表示这个变量不能被修改。
final修饰的对象或者变量，在内存中是不可修改，如果是对象则不可继承该对象。
static修饰的对象或者变量，在内存有且只有1个备份，可以修改。
例，String对象是final修饰的，则你新建任何的java类不可继承String对象。
final修饰的对象或者变量，在内存中不能修改，如果修饰对象表示该对象不允许被继承。final修饰主要是从数据安全性上考虑的；
static修饰的对象或者变量，不管该对象是否被实例化，都会在内存创建且始终只有1个备份，不过可以进行修改。
举个例子：
假设一个班级类，它有一个变量统计班级学生数量，这个班级的学生数量变量就应该是static，另外班级的名称应该是final，应为班级名称是不变的。
class Classroom{
static int studentcount;
final String classroomName;//注意final成员变量必须在定义时或者初始化块或者构造器里初始化
}
final : 常量
static : 所属级别----类
补充一点，后面的回答部分有些误导，不是我说他们的不对，只是他们看的资料上写的不规范。
去看看Thinking in Java / C++ 中都讲到了修改常量的问题，
C++：const Thinking in C++中讲了三种策略
Java: final Thinking in Java 中讲了2个
但这两者修饰的都是可以改的，不要被误导。
Java transient关键字
Volatile修饰的成员变量在每次被线程访问时，都强迫从主内存中重读该成员变量的值。而且，当成员变量发生变化时，强迫线程将变化值回写到主内存。这样在任何时刻，两个不同的线程总是看到某个成员变量的同一个值。

Java语言规范中指出：为了获得最佳速度，允许线程保存共享成员变量的私有拷贝，而且只当线程进入或者离开同步代码块时才与共享成员变量的原始值对比。

这样当多个线程同时与某个对象交互时，就必须要注意到要让线程及时的得到共享成员变量的变化。

而volatile关键字就是提示VM：对于这个成员变量不能保存它的私有拷贝，而应直接与共享成员变量交互。

使用建议：在两个或者更多的线程访问的成员变量上使用volatile。当要访问的变量已在synchronized代码块中，或者为常量时，不必使用。

由于使用volatile屏蔽掉了VM中必要的代码优化，所以在效率上比较低，因此一定在必要时才使用此关键字。

java中修饰符有哪些

Java中共有四种访问限制修饰符:private,public,protected,friendly
friendly是默认的,而且不是Java中的关键字.
private:私有,内部访问,很好理解
public:共有,都可以访问,更加好理解
friendly:同一个包可以访问
protected:同一个包或者子类可以访问
类修饰符
Public——可以从其他类中访问
Abstract——本类不能被实例化
Final——不能再声明子类
构造函数修饰符
Public——可以从所有的类中访问
Protected——只能从自己的类和它的子类中访问
Private——只能在本类中访问
域/成员变量修饰符
Public——可以从所有的类中访问
Protected——只能从本类和它的子类中访问
Private——只能从本类中访问它
Static——对该类的所有实例只能有一个域值存在
transient{}——不是一个对象持久状态的一部份
Volatile——可以被异步的线程所修改
final——必须对它赋予初值并且不能修改它
局部变量 修饰符
final——必须对它赋予初值并且不能修改它
方法修饰符
Public——可以从所有的类中访问它
Protected——只能从本类及其子类中访问它
Private——只能从本类中访问它
abstract——没有方法体，属于一个抽象类
final——子类不能覆盖它
static——被绑定于类本身而不是类的实例
native——该方法由其他编程语言实现
asnchronized——在一个线程调用它之前必须先给它加
java的修饰符有：权限修饰符：public、protected、default、private
修饰符：abstract、static、final
public 使用对象：最广，类、接口、变量、方法
protected使用对象：变量、方法 注意：不能修饰类（外部类）
default 使用对象：类、接口、变量、方法。（即缺省，什么也不写）
private 使用对象：变量、方法 注意：不能修饰类（外部类）
abstract使用对象：类、接口、方法
static 使用对象：类、变量、方法、初始化函数（注意：修饰类时只能修饰 内部类 ）
final 使用对象：类、变量、方法
transient：告诉编译器，在类对象序列化的时候，此变量不需要持久保存
volatile：指出可能有多个线程修改此变量，要求编译器优化以保证对此变量的修改能够被正确的处理
native：用该修饰符定义的方法在类中没有实现，而大多数情况下该方法的实现是用C、C++编写的。
synchronized：修饰方法，多线程的支持
类分外部类和内部类，他们的访问控制是相同的吗
外部类是相对于内部类而言的，内部类是定义在类里面的类。
外部类的修饰符有：
default（缺省，不写）：类定义时前面未加任何修饰符，表示同一个包中可见。
public：修饰类时表示该类能被项目中所有类可见
abstract：表示是抽象类
final：表示类不可以被继承
scrictpf:(java关键字) 当对一个类或接口使用 strictfp 关键字时，该类中的所有代码，包括嵌套类型中的初始设定值和代码，都将严格地进行计算。严格约束意味着所有表达式的结果都必须是 IEEE 754 算法对操作数预期的结果，以单精度和双精度格式表示
内部类又分：成员内部类、局部内部类、静态内部类、匿名内部类
成员内部类：作为外部类的一个成员存在，与外部类的属性、方法并列
局部内部类：定义在外部类的方法体里面的类
静态内部类：使用static修饰的内部类
匿名内部类：就是没有名字的内部类
成员内部类修饰符有：
public：
protected：
private：private不能修饰外部类，
abstract：
final：
static：可以当做普通类使用，而不用先实例化一个外部类。（用他修饰后，就成了静态内部类了）
strictfp：（java关键字） 即 strict float point (精确浮点)。（可修饰类、接口、方法）
扩展资料：
java中的类修饰符、成员变量修饰符、方法修饰符。
类修饰符：
public（访问控制符），将一个类声明为公共类，他可以被任何对象访问，一个程序的主类必须是公共类。
abstract，将一个类声明为抽象类，没有实现的方法，需要子类提供方法实现。
final，将一个类生命为最终（即非继承类），表示他不能被其他类继承。
friendly，默认的修饰符，只有在相同包中的对象才能使用这样的类。
成员变量修饰符：
public（公共访问控制符），指定该变量为公共的，他可以被任何对象的方法访问。
private（私有访问控制符）指定该变量只允许自己的类的方法访问，其他任何类（包括子类）中的方法均不能访问。
protected（保护访问控制符）指定该变量可以别被自己的类和子类访问。在子类中可以覆盖此变量。
friendly ，在同一个包中的类可以访问，其他包中的类不能访问。
final，最终修饰符，指定此变量的值不能变。
static（静态修饰符）指定变量被所有对象共享，即所有实例都可以使用该变量。变量属于这个类。
transient（过度修饰符）指定该变量是系统保留，暂无特别作用的临时性变量。
volatile（易失修饰符）指定该变量可以同时被几个线程控制和修改。
方法修饰符：
public（公共控制符）
private（私有控制符）指定此方法只能有自己类等方法访问，其他的类不能访问（包括子类）
protected（保护访问控制符）指定该方法可以被它的类和子类进行访问。
final，指定该方法不能被重载。
static，指定不需要实例化就可以激活的一个方法。
synchronize，同步修饰符，在多个线程中，该修饰符用于在运行前，对他所属的方法加锁，以防止其他线程的访问，运行结束后解锁。
native，本地修饰符。指定此方法的方法体是用其他语言在程序外部编写的。
参考资料：百度百科-修饰符

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

我们都知道一个对象只要实现了Serilizable接口，这个对象就可以被序列化，java的这种序列化模式为开发者提供了很多便利，我们可以不必关系具体序列化的过程，只要这个类实现了Serilizable接口，这个类的所有属性和方法都会自动序列化。
然而在实际开发过程中，我们常常会遇到这样的问题，这个类的有些属性需要序列化，而其他属性不需要被序列化，打个比方，如果一个用户有一些敏感信息（如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输，这些信息对应的变量就可以加上transient关键字。换句话说，这个字段的生命周期仅存于调用者的内存中而不会写到磁盘里持久化。
总之，java 的transient关键字为我们提供了便利，你只需要实现Serilizable接口，将不需要序列化的属性前添加关键字transient，序列化对象的时候，这个属性就不会序列化到指定的目的地中。
想要知道更多请看下面的大牛写的笔记
摘录自： Java transient关键字使用小记 作者：敏敏Alexia
java的关键字，用transient关键字标记的成员变量不参与序列化过程
transient”——“瞬态”，先不说这个翻译是否恰当，这个变量关键字一直不曾使用，简单的说就是被瞬态定义的变量不可序列号。或者这么给他换个名字——“不可序列化状态”。打个比方，如果一个用户有一些敏感信息（譬如密码，银行卡号等），为了安全起见，不希望在网络操作（主要涉及到序列化操作，本地序列化缓存也适用）中被传输。这些信息对应的变量就可以被定义为transient类型。换句话说，这个字段的生命周期仅存于调用者的内存中。如定义类：public class People implements Serializable {private static final long serialVersionUID = 8294138003005L;/*** 用户名*/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: snowolfpassword: 123456------操作后------username: snowolfpassword: null

注解transient是什么意思

简单的说：就是Hibernate持久化数据库时，用@Transient标记出某个字段，这个字段就不会参与对数据库表的操作，是一个辅助字段。
简单的说：就是Hibernate持久化数据库时，用@Transient标记出某个字段，这个字段就不会参与对数据库表的操作，是一个辅助字段。
【单词】transient
【意思】短暂的，路过的
【短语】 transient current.瞬间电流
【例句】It is transient in the sense that it exists only during the running of the process.
它仅在流程运行的过程中存在，从这个角度来讲，它是瞬态 的。
java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。 Java的serialization提供了一种持久化对象实例的机制。当持久化对象时，可能有一个特殊的对象数据成员，我们不想用serialization机制来保存它。为了在一个特定对象的一个域上关闭serialization，可以在这个域前加上关键字transient。当一个对象被串行化的时候，transient型变量的值不包括在串行化的表示中，然而非transient型的变量是被包括进去的。

java的接口、类、属性、方法各有哪些修饰符

1、
接口的修饰符只有:public
2、
类的修饰符分为:可访问控制符和非访问控制符两种。
可访问控制符是:公共类修饰符
public
非访问控制符有:抽象类修饰符
abstract
;最终类修饰符
final
1、公共类修饰符public:
Java
语言中类
的可访问控制符只有一个:
public
即公共的。每个
Java
程序的主类都必须是
public
类作为公共工具供其它类和程序使用的应定义为
public
类。
2
、抽象类修饰符abstract:凡是用
abstract
修饰符修饰的类，被称为抽象类。所谓抽象类是指这种类没有具体对象的一种概念类。这样的类就是
Java
语言的
abstract
类。
3、最终类修饰符final:当一个类不可能有子类时可用修饰符
final
把它说明为最终类。被定义为
final
的类通常是一些有固定作用、用来完成某种标准功能的类。
4、类缺省访问控制符:如果一个类没有访问控制符，说明它具有缺省的访问控制符特性。此时，这个类只能被同一个包中的类访问或引用。这一访问特性又称为包访问性。
3、属性的控制修饰符也分为:可访问控制符和非访问控制符两类。
可访问控制符有
4
种:公共访问控制符:
public
;私有访问控制符:
private
;保护访问控制符:
protected
;私有保护访问控制符:
private
protected
非访问控制符有
4
种:静态域修饰符:
static
;最终域修饰符:
final
;易失
(
共享
)
域修饰符:
volatile
;暂时性域修饰符:
transient
1、公共访问控制符
public
:用
public
修饰的域称为公共域。如果公共域属于一个公共类，则可以被所有其它类所引用。由于
public
修饰符会降低运行的安全性和数据的封装性，所以一般应减少
public
域的使用。
2、私有访问控制符
private
:
用
private
修饰的成员变量
(
域
)
只能被该类自身所访问，而不能被任何其它类
(
包括子类
)
所引用。
3、保护访问控制符
protected
:用
protected
修饰的成员变量可以被三种类所引用:①该类自身;②与它在同一个包中的其它类;③在其它包中的该类的子类。使用修饰符
protected
的主要作用是允许其它包中它的子类来访问父类的特定属性。
4、私有保护访问控制符
private
protected
:用修饰符
private
protected
修饰的成员变量可以被该类本身或该类的子类两种类访问和引用。
5、静态域修饰符
static
:用
static
修饰的成员变量仅属于类的变量，而不属于任何一个具体的对象，静态成员变量的值是保存在类的内存区域的公共存储单元，而不是保存在某一个对象的内存区间。任何一个类的对象访问它时取到的都是相同的数据;任何一个类的对象修改它时
,
也都是对同一个内存单元进行操作。
6、最终域修饰符
final
:最终域修饰符
final
是用来定义符号常量的。一个类的域
(
成员变量
)
如果被修饰符
final
说明，则它的取值在程序的整个执行过程中都是不变的。
7、易失
(
共享
)
域修饰符
volatile
:易失
(
共享
)
域修饰符
volatile
是用来说明这个成员变量可能被几个线程所控制和修改。也就是说在程序运行过程中，这个成员变量有可能被其它的程序影响或改变它的取值。因此，在使用中要注意这种成员变量取值的变化。通常
volatile
用来修饰接受外部输入的域。
8、暂时性域修饰符
transient
:暂时性域修饰符
transient
用来定义一个暂时性变量。其特点是:用修饰符
transient
限定的暂时性变量，将指定
Java
虚拟机认定该暂时性变量不属于永久状态，以实现不同对象的存档功能。否则，类中所有变量都是对象的永久状态的一部分，存储对象时必须同时保存这些变量。
4、方法的控制修饰符也分为:可访问控制符和非访问控制符两类。
可访问控制符有
4
种:公共访问控制符:
public
;私有访问控制符:
private
;保护访问控制符:
protected
;私有保护访问控制符:
private
protected
非访问控制符有
5
种:抽象方法控制符:
abstract
;静态方法控制符:
static
;最终方法控制符:
final
;本地方法控制符:
native
;同步方法控制符:
synchronized
1、抽象方法控制符
abstract
:用修饰符
abstract
修饰的方法称为抽象方法。抽象方法是一种仅有方法头，没有方法体和操作实现的一种方法。
2、静态方法控制符
static
:用修饰符
static
修饰的方法称为静态方法。静态方法是属于整个类的类方法;而不使用
static
修饰、限定的方法是属于某个具体类对象的方法。
由于
static
方法是属于整个类的，所以它不能操纵和处理属于某个对象的成员变量，而只能处理属于整个类的成员变量，即
static
方法只能处理
static
的域。
3、最终方法控制符
final
:用修饰符
final
修饰的方法称为最终方法。最终方法是功能和内部语句不能更改的方法，即最终方法不能重载。这样，就固定了这个方法所具有的功能和操作，防止当前类的子类对父类关键方法的错误定义，保证了程序的安全性和正确性。所有被
private
修饰符限定为私有的方法，以及所有包含在
final
类
(
最终类
)
中的方法，都被认为是最终方法。
4、本地方法控制符
native
:用修饰符
native
修饰的方法称为本地方法。为了提高程序的运行速度，需要用其它的高级语言书写程序的方法体，那么该方法可定义为本地方法用修饰符
native
来修饰;
5、同步方法控制符
synchronized
:该修饰符主要用于多线程共存的程序中的协调和同步。

成员变量的实例

java成员变量和方法 成员变量：在类体的变量部分中定义的变量，也称为字段。我们先来看一个Clothes类的成员变量： package ch05.sample;public class Clothes{String id; //实例变量private String colorType; //实例变量private int size; //实例变量private static String depart; //类变量final String design=yangzi; //常量} 代码中的实例变量、类变量、常量都属于成员变量，那么其区分的依据是什么？这与变量的修饰符有关系，也就是上面代码中的private、static、final等修饰符。成员变量的修饰符见表5-1。表5-1 成员变量的修饰符 修饰符 说明 public 成员变量可以被项目中的任何方法访问，建议尽量少用 protected 不在同一个包中的类不能访问，但子类可以访问 private 只能在同一个类中使用 static 类变量，其值为该类的所有对象共享，不会因类的对象不同而不同 final 最终成员变量，其值保持不变，即常量 transient 当对象被持久化时（例如写入数据库），该成员变量的值不需要保存 volatile 同步多线程访问的成员变量的值，以便使不同的线程总是得到该成员变量的同一个值。关于线程，请参阅第11章 成员变量又称全局变量，定义在类中，和类的方法处于同一个层次。成员变量相当于银行中的取号机，银行中的人都可以对其使用。成员变量的语法如下：变量修饰符 类型 变量名；