当前页面: 在线文档首页 > JavaTM 2 Platform Standard Edition 5.0 API 规范中文版
序列化表格 (Java 2 Platform SE 5.0) - JavaTM 2 Platform Standard Edition 5.0 API 规范中文版
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| 上一个 下一个 | 框架 无框架 | |||||||||
序列化表格
| 软件包 java.applet |
|---|
| 类 java.applet.Applet 继承 Panel 实现 Serializable |
|---|
serialVersionUID: -5836846270535785031L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 从对象输入流读取 applet。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless()返回trueClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
- 另请参见：
GraphicsEnvironment.isHeadless()
| 序列化字段 |
|---|
accessibleContext
AccessibleContext accessibleContext
| 类 java.applet.Applet.AccessibleApplet 继承 Panel.AccessibleAWTPanel 实现 Serializable |
|---|
serialVersionUID: 8127374778187708896L
| 软件包 java.awt |
|---|
| 类 java.awt.AWTError 继承 Error 实现 Serializable |
|---|
serialVersionUID: -1819846354050686206L
| 类 java.awt.AWTEvent 继承 EventObject 实现 Serializable |
|---|
serialVersionUID: -1825314779160409405L
| 序列化字段 |
|---|
bdata
byte[] bdata
id
int id
- 事件的 id。
consumed
boolean consumed
- 在源处理了事件之后，控制是否将事件发送回同位体，false 表示将事件发送给同位体；true 则不发送。语义事件始终具有 'true' 值，因为它们由响应低级别事件的同位体生成。
| 类 java.awt.AWTException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: -1900414231151323879L
| 类 java.awt.AWTKeyStroke 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6430539691155161871L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws ObjectStreamException
- 返回
AWTKeyStroke的一个缓存实例（或AWTKeyStroke的子类），它与此实例相等。
| 序列化字段 |
|---|
keyChar
char keyChar
keyCode
int keyCode
modifiers
int modifiers
onKeyRelease
boolean onKeyRelease
| 类 java.awt.AWTPermission 继承 BasicPermission 实现 Serializable |
|---|
serialVersionUID: 8890392402588814465L
| 类 java.awt.BorderLayout 继承 Object 实现 Serializable |
|---|
serialVersionUID: -8658291919501921765L
| 序列化字段 |
|---|
hgap
int hgap
- Constructs a border layout with the horizontal gaps
between components.
The horizontal gap is specified by
hgap.
vgap
int vgap
- Constructs a border layout with the vertical gaps
between components.
The vertical gap is specified by
vgap.
north
Component north
- Constant to specify components location to be the
north portion of the border layout.
west
Component west
- Constant to specify components location to be the
west portion of the border layout.
east
Component east
- Constant to specify components location to be the
east portion of the border layout.
south
Component south
- Constant to specify components location to be the
south portion of the border layout.
center
Component center
- Constant to specify components location to be the
center portion of the border layout.
firstLine
Component firstLine
- A relative positioning constant, that can be used instead of
north, south, east, west or center.
mixing the two types of constants can lead to unpredicable results. If
you use both types, the relative constants will take precedence.
For example, if you add components using both the
NORTHandBEFORE_FIRST_LINEconstants in a container whose orientation isLEFT_TO_RIGHT, only theBEFORE_FIRST_LINEwill be layed out. This will be the same for lastLine, firstItem, lastItem. -
lastLine
Component lastLine
- A relative positioning constant, that can be used instead of
north, south, east, west or center.
Please read Description for firstLine.
-
firstItem
Component firstItem
- A relative positioning constant, that can be used instead of
north, south, east, west or center.
Please read Description for firstLine.
-
lastItem
Component lastItem
- A relative positioning constant, that can be used instead of
north, south, east, west or center.
Please read Description for firstLine.
-
| 类 java.awt.Button 继承 Component 实现 Serializable |
|---|
serialVersionUID: -8774683716313001058L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream，如果它不为null，则添加一个侦听器，以接收按钮激发的操作事件。未识别的键或值将被忽略。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
Button.removeActionListener(ActionListener),Button.addActionListener(ActionListener),GraphicsEnvironment.isHeadless(),Button.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流。写入可序列化
ActionListeners的一个列表作为可选数据。检测不可序列化的ActionListeners，不会试图对它们进行序列化。- 序列数据：
- 以
null终止的 0 或多对序列：该对由一个String和一个Object组成；String指示对象的类型，它是以下类型之一：指示ActionListener对象的actionListenerK - 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.actionListenerK,Button.readObject(ObjectInputStream)
| 序列化字段 |
|---|
label
String label
- The button's label. This value may be null.
-
- 另请参见：
Button.getLabel(),setLabel()
actionCommand
String actionCommand
- The action to be performed once a button has been
pressed. This value may be null.
-
- 另请参见：
Button.getActionCommand(),setActionCommand()
buttonSerializedDataVersion
int buttonSerializedDataVersion
| 类 java.awt.Button.AccessibleAWTButton 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: -5932203980244017102L
| 类 java.awt.Canvas 继承 Component 实现 Serializable |
|---|
serialVersionUID: -2284879212465893870L
| 类 java.awt.Canvas.AccessibleAWTCanvas 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: -6325592262103146699L
| 类 java.awt.CardLayout 继承 Object 实现 Serializable |
|---|
serialVersionUID: -4328196481005934313L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 从流中读取可序列化的字段。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 向流中写入可序列化的字段。
- 抛出：
IOException
| 序列化字段 |
|---|
currentCard
int currentCard
hgap
int hgap
tab
Hashtable<K,V> tab
- 已过时，仅用于向前兼容
vector
Vector<E> vector
vgap
int vgap
| 类 java.awt.Checkbox 继承 Component 实现 Serializable |
|---|
serialVersionUID: 7270714317450821763L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream，如果它不为null，则添加一个侦听器，以接收Checkbox触发的项事件。忽略未被识别的键或值。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
Checkbox.removeItemListener(ItemListener),Checkbox.addItemListener(ItemListener),GraphicsEnvironment.isHeadless(),Checkbox.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认可序列化字段写入流中。写入可序列化
ItemListeners的一个列表作为可选数据。检测不可序列化的ItemListeners，不要尝试对它们进行序列化。- 序列数据：
null表示终止 0 或多个对的序列；这种对是由String和Object组成的；String指示对象类型，它为以下类型之一：itemListenerK指示一个ItemListener对象- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.itemListenerK,Checkbox.readObject(ObjectInputStream)
| 序列化字段 |
|---|
label
String label
- The label of the Checkbox.
This field can be null.
-
- 另请参见：
Checkbox.getLabel(),#setLabel(label)
state
boolean state
- The state of the
Checkbox. -
- 另请参见：
Checkbox.getState(),#setState(state)
group
CheckboxGroup group
- The check box group.
This field can be null indicating that the checkbox
is not a group checkbox.
-
- 另请参见：
#getCheckBoxGroup(),#setCheckBoxGroup(CheckBoxGroup)
checkboxSerializedDataVersion
int checkboxSerializedDataVersion
| 类 java.awt.Checkbox.AccessibleAWTCheckbox 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: 7881579233144754107L
| 类 java.awt.CheckboxGroup 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3729780091441768983L
| 序列化字段 |
|---|
selectedCheckbox
Checkbox selectedCheckbox
- The current choice.
| 类 java.awt.CheckboxMenuItem 继承 MenuItem 实现 Serializable |
|---|
serialVersionUID: 6190621106981774043L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流。写入可序列化
ItemListeners的一个列表作为可选数据。检测不可序列化的ItemListeners，不要尝试对它们进行序列化。- 序列数据：
- 以
null终止的 0 或多对序列；该对由一个String和一个Object组成；String指示对象的类型，它是以下类型之一：指示ItemListener对象的itemListenerK - 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.itemListenerK,CheckboxMenuItem.readObject(ObjectInputStream)
| 序列化字段 |
|---|
state
boolean state
- The state of a checkbox menu item
checkboxMenuItemSerializedDataVersion
int checkboxMenuItemSerializedDataVersion
| 类 java.awt.CheckboxMenuItem.AccessibleAWTCheckboxMenuItem 继承 MenuItem.AccessibleAWTMenuItem 实现 Serializable |
|---|
serialVersionUID: -1122642964303476L
| 类 java.awt.Choice 继承 Component 实现 Serializable |
|---|
serialVersionUID: -4075310674757313071L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream，如果它不为null，则添加一个侦听器，以接收Choice项触发的项事件。忽略未被识别的键或值。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
Choice.removeItemListener(ItemListener),Choice.addItemListener(ItemListener),GraphicsEnvironment.isHeadless(),Choice.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认可序列化字段写入流中。写入可序列化
ItemListeners的一个列表作为可选数据。检测不可序列化的ItemListeners，不要尝试对它们进行序列化。- 序列数据：
null表示终止 0 或多个对的序列；这种对是由String和Object组成的；String指示对象类型，它为以下类型之一：itemListenerK指示一个ItemListener对象- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.itemListenerK,Choice.readObject(ObjectInputStream)
| 序列化字段 |
|---|
pItems
Vector<E> pItems
- The items for the
Choice. This can be anullvalue.
selectedIndex
int selectedIndex
- The index of the current choice for this
Choiceor -1 if nothing is selected.
choiceSerializedDataVersion
int choiceSerializedDataVersion
| 类 java.awt.Choice.AccessibleAWTChoice 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: 7175603582428509322L
| 类 java.awt.Color 继承 Object 实现 Serializable |
|---|
serialVersionUID: 118526816881161077L
| 序列化字段 |
|---|
value
int value
- The color value.
-
- 另请参见：
Color.getRGB()
frgbvalue
float[] frgbvalue
- 默认 sRGB
ColorSpace中的颜色值可看作是float分量（不带 alpha 值）。如果在构造对象之后颜色值为null，则此颜色必须是用 8 位精度构造的一种 sRGB 颜色，因此要从int颜色值开始计算。
fvalue
float[] fvalue
- 本机 sRGB
ColorSpace中的颜色值可看作是float分量（不带 alpha 值）。如果在构造对象之后颜色值为null，则此颜色必须是用 8 位精度构造的一种 sRGB 颜色，因此要从int颜色值开始计算。
falpha
float falpha
- alpha 值可看作是一个
float分量。如果frgbvalue为null，那么这是一个无效数据，因此要从int颜色值开始计算。
cs
ColorSpace cs
ColorSpace。如果 ColorSpace 为null，那么其默认值为 sRGB。
| 类 java.awt.Component 继承 Object 实现 Serializable |
|---|
serialVersionUID: -7644114512714619750L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 读取
ObjectInputStream并且如果它不为null，则添加一个侦听器，以便接收由组件所激发的各种事件。忽略未识别的键或值。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。将各种可序列化侦听器作为可选数据写入。检测不可序列化的侦听器并且不尝试对其进行序列化。
- 序列数据：
- 以
null终止的 0 或多对序列；该对由一个String和一个Object组成；String表示对象的类型并为下列类型之一（1.4 中）：componentListenerK表示ComponentListener对象；focusListenerK表示FocusListener对象；keyListenerK表示KeyListener对象；mouseListenerK表示MouseListener对象；mouseMotionListenerK表示MouseMotionListener对象；inputListenerK表示InputListener对象；hierarchyListenerK表示HierarchyListener对象；hierarchyBoundsListenerK表示HierarchyBoundsListener对象；mouseWheelListenerK表示MouseWheelListener对象, 一个可选的ComponentOrientation（在 1.2 中位于inputMethodListener之后） - 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener),Component.componentListenerK,Component.focusListenerK,Component.keyListenerK,Component.mouseListenerK,Component.mouseMotionListenerK,#inputListenerK,Component.hierarchyListenerK,Component.hierarchyBoundsListenerK,Component.mouseWheelListenerK,Component.readObject(ObjectInputStream)
| 序列化字段 |
|---|
x
int x
- The x position of the component in the parent's coordinate system.
y
int y
- The y position of the component in the parent's coordinate system.
width
int width
- The width of the component.
-
- 另请参见：
Component.getSize()
height
int height
- The height of the component.
-
- 另请参见：
Component.getSize()
foreground
Color foreground
- The foreground color for this component.
foregroundcan benull.
background
Color background
- The background color for this component.
backgroundcan benull.
font
Font font
- The font used by this component.
The
fontcan benull.
peerFont
Font peerFont
- The font which the peer is currently using.
(
nullif no peer exists.)
cursor
Cursor cursor
- The cursor displayed when pointer is over this component.
This value can be
null.
locale
Locale locale
- The locale for the component.
ignoreRepaint
boolean ignoreRepaint
- True when the object should ignore all repaint events.
-
- 从以下版本开始：
- 1.4
- 另请参见：
Component.setIgnoreRepaint(boolean),Component.getIgnoreRepaint()
visible
boolean visible
- True when the object is visible. An object that is not
visible is not drawn on the screen.
enabled
boolean enabled
- True when the object is enabled. An object that is not
enabled does not interact with the user.
valid
boolean valid
- True when the object is valid. An invalid object needs to
be layed out. This flag is set to false when the object
size is changed.
dropTarget
DropTarget dropTarget
- The
DropTargetassociated with this component. -
- 从以下版本开始：
- 1.2
- 另请参见：
Component.setDropTarget(java.awt.dnd.DropTarget),Component.getDropTarget()
popups
Vector<E> popups
name
String name
- 组件名称。该字段可以为
null。
nameExplicitlySet
boolean nameExplicitlySet
- 确定是否已显示地设置了名称的布尔值。如果尚未设置名称，则
nameExplicitlySet为 false；否则为 true。
focusable
boolean focusable
- 表示此 Component 是否可以获得焦点。
-
- 从以下版本开始：
- 1.4
- 另请参见：
Component.setFocusable(boolean),Component.isFocusable()
isFocusTraversableOverridden
int isFocusTraversableOverridden
- 跟踪此 Component 是否依赖于默认的焦点可遍历性。
-
- 从以下版本开始：
- 1.4
focusTraversalKeys
Set<E>[] focusTraversalKeys
- The focus traversal keys. These keys will generate focus traversal
behavior for Components for which focus traversal keys are enabled. If a
value of null is specified for a traversal key, this Component inherits
that traversal key from its parent. If all ancestors of this Component
have null specified for that traversal key, then the current
KeyboardFocusManager's default traversal key is used.
focusTraversalKeysEnabled
boolean focusTraversalKeysEnabled
- 表示是否为此 Component 启用了焦点遍历键。其焦点遍历键已禁用的 Component 接收这些焦点遍历键的按键事件。其焦点遍历键已启用的 Component 不会看到这些事件；相反，会将该事件自动转换为遍历操作。
minSize
Dimension minSize
- Minimum size.
(This field perhaps should have been transient).
-
minSizeSet
boolean minSizeSet
- Whether or not setMinimumSize has been invoked with a non-null value.
prefSize
Dimension prefSize
- Preferred size.
(This field perhaps should have been transient).
-
prefSizeSet
boolean prefSizeSet
- Whether or not setPreferredSize has been invoked with a non-null value.
maxSize
Dimension maxSize
- Maximum size
-
maxSizeSet
boolean maxSizeSet
- Whether or not setMaximumSize has been invoked with a non-null value.
newEventsOnly
boolean newEventsOnly
newEventsOnlywill be true if the event is one of the event types enabled for the component. It will then allow for normal processing to continue. If it is false the event is passed to the component's parent and up the ancestor tree until the event has been consumed.
eventMask
long eventMask
- The
eventMaskis ONLY set by subclasses viaenableEvents. The mask should NOT be set when listeners are registered so that we can distinguish the difference between when listeners request events and subclasses request them. One bit is used to indicate whether input methods are enabled; this bit is set byenableInputMethodsand is on by default.
changeSupport
PropertyChangeSupport changeSupport
- 如果已注册了任意
PropertyChangeListeners，则changeSupport字段负责描述它们。
isPacked
boolean isPacked
boundsOp
int boundsOp
- 直接用于几何学 API（setLocation、setBounds、setSize）的伪参数，通知 setBounds 发生了什么改变。应该在 TreeLock 下使用。需要它的惟一原因是无法改变公共和否决方法的交叉调用顺序。
componentSerializedDataVersion
int componentSerializedDataVersion
- 序列化的 Component 数据版本。
-
accessibleContext
AccessibleContext accessibleContext
| 类 java.awt.Component.AccessibleAWTComponent 继承 AccessibleContext 实现 Serializable |
|---|
serialVersionUID: 642321655757800191L
| 序列化字段 |
|---|
accessibleAWTComponentHandler
ComponentListener accessibleAWTComponentHandler
accessibleAWTFocusHandler
FocusListener accessibleAWTFocusHandler
| 类 java.awt.ComponentOrientation 继承 Object 实现 Serializable |
|---|
| 序列化字段 |
|---|
orientation
int orientation
| 类 java.awt.Container 继承 Component 实现 Serializable |
|---|
serialVersionUID: 4613797578919906343L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 反序列化来自指定
ObjectInputStream的Container。- 从流中读取默认可序列化字段。
- 读取可序列化 ContainerListener(s) 的一个列表作为可选数据。如果列表为 null，则不安装任何 Listener。
- 读取此 Container 的 FocusTraversalPolicy 作为可选数据，它可以为 null。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将此
Container序列化到指定的ObjectOutputStream中。- 将默认可序列化字段写入流中。
- 写入可序列化 ContainerListener(s) 的一个列表作为可选数据。检测不可序列化的 ContainerListner(s)，不要试图对它们进行序列化。
- 当且仅当此 Container 的 FocusTraversalPolicy 是可序列化的时候，才写入它；否则写入
null。
- 序列数据：
null表示终止 0 或多个对的序列；这种对是由String和Object组成的；String指示了对象类型，它为以下类型之一：指示ContainerListener对象的containerListenerK、Container的FocusTraversalPolicy或null- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener),Component.containerListenerK,Container.readObject(ObjectInputStream)
| 序列化字段 |
|---|
component
Component[] component
- 容器中的组件。
containerSerializedDataVersion
int containerSerializedDataVersion
- Container Serial Data Version。
dispatcher
java.awt.LightweightDispatcher dispatcher
- 轻量级组件的事件路由器。如果容器是本机的，则此调度程序会小心转发这些事件，将它们的目标重新指向所包含的轻量级组件（如果有）。
focusCycleRoot
boolean focusCycleRoot
- 指示此 Component 是否是某个焦点遍历循环的根。一旦焦点进入某个遍历循环，它通常无法通过焦点遍历离开，除非按下向上键或向下键之一。普通遍历被限定于此 Container，该 Container 的所有子代并不是下级焦点循环根的子代。
focusTraversalPolicyProvider
boolean focusTraversalPolicyProvider
- 存储 focusTraversalPolicyProvider 属性的值。
layoutMgr
LayoutManager layoutMgr
- 此容器的布局管理器。
maxSize
Dimension maxSize
- 此 Container 的最大大小。
ncomponents
int ncomponents
- 容器中组件的数量。该值可以为 null。
| 类 java.awt.Container.AccessibleAWTContainer 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: 5081320404842566097L
| 序列化字段 |
|---|
accessibleContainerHandler
ContainerListener accessibleContainerHandler
| 类 java.awt.ContainerOrderFocusTraversalPolicy 继承 FocusTraversalPolicy 实现 Serializable |
|---|
serialVersionUID: 486933713763926351L
| 序列化字段 |
|---|
implicitDownCycleTraversal
boolean implicitDownCycleTraversal
| 类 java.awt.Cursor 继承 Object 实现 Serializable |
|---|
serialVersionUID: 8028237497568985504L
| 序列化字段 |
|---|
type
int type
- The chosen cursor type initially set to
the
DEFAULT_CURSOR. -
- 另请参见：
Cursor.getType()
name
String name
- 光标的用户可视名称。
-
- 另请参见：
Cursor.getName()
| 类 java.awt.DefaultFocusTraversalPolicy 继承 ContainerOrderFocusTraversalPolicy 实现 Serializable |
|---|
| 类 java.awt.Dialog 继承 Window 实现 Serializable |
|---|
serialVersionUID: 5920926903803293709L
| 序列化字段 |
|---|
resizable
boolean resizable
- A dialog's resizable property. Will be true
if the Dialog is to be resizable, otherwise
it will be false.
undecorated
boolean undecorated
- This field indicates whether the dialog is undecorated.
This property can only be changed while the dialog is not displayable.
undecoratedwill be true if the dialog is undecorated, otherwise it will be false. -
- 从以下版本开始：
- 1.4
- 另请参见：
Dialog.setUndecorated(boolean),Dialog.isUndecorated(),Component.isDisplayable()
modal
boolean modal
- Will be true if the Dialog is modal,
otherwise the dialog will be modeless.
A modal Dialog grabs all the input to
the owner frame from the user.
title
String title
- Specifies the title of the Dialog.
This field can be null.
| 类 java.awt.Dialog.AccessibleAWTDialog 继承 Window.AccessibleAWTWindow 实现 Serializable |
|---|
serialVersionUID: 4837230331833941201L
| 类 java.awt.Dimension 继承 Dimension2D 实现 Serializable |
|---|
serialVersionUID: 4723952579491349524L
| 序列化字段 |
|---|
width
int width
- dimension 的宽度，可以使用负值。
height
int height
- dimension 的高度，可以使用负值。
| 类 java.awt.Event 继承 Object 实现 Serializable |
|---|
serialVersionUID: 5488922509400504703L
| 序列化字段 |
|---|
target
Object target
- 目标组件。这指示事件针对该组件发生，或事件与该组件关联。此对象已经由 AWTEvent.getSource() 取代。
when
long when
- 时间戳。由 InputEvent.getWhen() 取代。
-
- 另请参见：
InputEvent.getWhen()
id
int id
- 指示事件是什么类型的事件，其他哪个
Event变量与该事件有关。它已经由 AWTEvent.getID() 取代。 -
- 另请参见：
AWTEvent.getID()
x
int x
- 事件的 x 坐标。由 MouseEvent.getX() 取代。
-
- 另请参见：
MouseEvent.getX()
y
int y
- 事件的 y 坐标。由 MouseEvent.getY() 取代。
-
- 另请参见：
MouseEvent.getY()
key
int key
- 在键盘事件中被按下的键的键代码。这已经由 KeyEvent.getKeyCode() 取代。
modifiers
int modifiers
- 修饰符键的状态。这已经由 InputEvent.getModifiers() 取代。在 java 1.1 中，MouseEvent 和 KeyEvent 是 InputEvent 的子类。
clickCount
int clickCount
- 对于
MOUSE_DOWN事件来说，此字段指示连续点击的次数。对于其他事件，其值为0。此字段由 MouseEvent.getClickCount() 取代。
arg
Object arg
- 事件的任意参数。此字段的值取决于事件的类型。
arg已经由事件指定的属性取代。 -
evt
Event evt
- 下一事件。将事件放入到链接列表时设置此字段。这已经由 EventQueue 取代。
-
- 另请参见：
EventQueue
consumed
boolean consumed
- 此字段控制当目标处理完事件时，该事件是否发送回同位体——如果为 false，则发送回同位体，如果为 true，则不发送。
-
- 另请参见：
Event.isConsumed()
| 类 java.awt.FileDialog 继承 Dialog 实现 Serializable |
|---|
serialVersionUID: 5035145889651310422L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 读取
ObjectInputStream，并执行向后兼容检查，将dir或等于空字符串的file转换为null。
| 序列化字段 |
|---|
mode
int mode
dir
String dir
file
String file
filter
FilenameFilter filter
| 类 java.awt.FlowLayout 继承 Object 实现 Serializable |
|---|
serialVersionUID: -7262534875583282631L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 从序列化流读取此对象，处理由类的较旧版本写入的对象，该版本不包含我们现在使用的所有字段。
| 序列化字段 |
|---|
align
int align
alignis the property that determines how each row distributes empty space. It can be one of the following values:LEFTRIGHTCENTERLEADINGTRAILING
newAlign
int newAlign
newAlignis the property that determines how each row distributes empty space for the Java 2 platform, v1.2 and greater. It can be one of the following three values:LEFTRIGHTCENTERLEADINGTRAILING-
- 从以下版本开始：
- 1.2
- 另请参见：
FlowLayout.getAlignment(),FlowLayout.setAlignment(int)
hgap
int hgap
- The flow layout manager allows a seperation of
components with gaps. The horizontal gap will
specify the space between components and between
the components and the borders of the
Container.
vgap
int vgap
- The flow layout manager allows a seperation of
components with gaps. The vertical gap will
specify the space between rows and between the
the rows and the borders of the
Container.
serialVersionOnStream
int serialVersionOnStream
- 表示正被使用的
currentSerialVersion。它将是以下两个值之一：0，Java 2 平台 v1.2 之前的版本1，Java 2 平台 v1.2 之后的版本 -
- 从以下版本开始：
- 1.2
| 类 java.awt.Font 继承 Object 实现 Serializable |
|---|
serialVersionUID: -4206021311591459213L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 读取
ObjectInputStream。未识别的密钥或值将被忽略。
writeObject
private void writeObject(ObjectOutputStream s) throws ClassNotFoundException, IOException
- 将默认的可序列化字段写入流中。
| 序列化字段 |
|---|
fRequestedAttributes
Hashtable<K,V> fRequestedAttributes
- 此字体中可用的字体属性的映射。属性包括连字和字形替换。
-
- 另请参见：
Font.getAttributes()
name
String name
Font的逻辑名称，它被传递到构造方法中。-
- 从以下版本开始：
- JDK1.0
- 另请参见：
Font.getName()
style
int style
Font的样式，它被传递到构造方法中。此样式可以为 PLAIN、BOLD、ITALIC 或 BOLD+ITALIC。-
- 从以下版本开始：
- JDK1.0
- 另请参见：
Font.getStyle()
size
int size
Font的点大小，舍入为整数。-
- 从以下版本开始：
- JDK1.0
- 另请参见：
Font.getSize()
pointSize
float pointSize
- 以
float形式表示的Font的点大小。
fontSerializedDataVersion
int fontSerializedDataVersion
Font的可序列化数据形式。-
| 类 java.awt.FontFormatException 继承 Exception 实现 Serializable |
|---|
| 类 java.awt.FontMetrics 继承 Object 实现 Serializable |
|---|
serialVersionUID: 1681126225205050147L
| 序列化字段 |
|---|
font
Font font
- 实际的
Font，字体规格是由此创建的。它不能为 null。
| 类 java.awt.Frame 继承 Window 实现 Serializable |
|---|
serialVersionUID: 2673458971256075116L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream。尝试读取一个Icon，它是从 1.4 版本开始可用的可选数据。如果有一个Icon不可用，但是已经检测了除 EOF 之外的所有数据，则抛出OptionalDataException。未识别的键或值将被忽略。- 抛出：
OptionalDataException- 如果某个Icon不可用，但是已经检测了除 EOF 之外的所有数据HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless(),Icon,Frame.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。写入可选的序列化
Icon，从 1.4 开始，该图标是可用的。- 序列数据：
- 可选的
Icon - 抛出：
IOException- 另请参见：
Icon,Frame.readObject(ObjectInputStream)
| 序列化字段 |
|---|
maximizedBounds
Rectangle maximizedBounds
- Maximized bounds for this frame.
-
- 从以下版本开始：
- 1.4
- 另请参见：
Frame.setMaximizedBounds(Rectangle),Frame.getMaximizedBounds()
title
String title
- This is the title of the frame. It can be changed
at any time.
titlecan be null and if this is the case thetitle= "".
menuBar
MenuBar menuBar
- The frames menubar. If
menuBar= null the frame will not have a menubar.
resizable
boolean resizable
- This field indicates whether the frame is resizable.
This property can be changed at any time.
resizablewill be true if the frame is resizable, otherwise it will be false. -
- 另请参见：
Frame.isResizable()
undecorated
boolean undecorated
- This field indicates whether the frame is undecorated.
This property can only be changed while the frame is not displayable.
undecoratedwill be true if the frame is undecorated, otherwise it will be false. -
- 从以下版本开始：
- 1.4
- 另请参见：
Frame.setUndecorated(boolean),Frame.isUndecorated(),Component.isDisplayable()
mbManagement
boolean mbManagement
mbManagementis only used by the Motif implementation.-
state
int state
ownedWindows
Vector<E> ownedWindows
frameSerializedDataVersion
int frameSerializedDataVersion
Frame的序列化数据版本。-
| 类 java.awt.Frame.AccessibleAWTFrame 继承 Window.AccessibleAWTWindow 实现 Serializable |
|---|
serialVersionUID: -6172960752956030250L
| 类 java.awt.GraphicsConfigTemplate 继承 Object 实现 Serializable |
|---|
| 类 java.awt.GridBagConstraints 继承 Object 实现 Serializable |
|---|
serialVersionUID: -1000070633030801713L
| 序列化字段 |
|---|
gridx
int gridx
- 指定包含组件的显示区域开始边的单元格，其中行的第一个单元格为
gridx=0。组件显示区域的开始边指的是水平、从左到右容器的左边缘和水平、从右到左容器的右边缘。值RELATIVE指定将组件放置在添加此组件之前刚刚添加到容器的组件的后面。默认值为
RELATIVE。gridx应为非负值。
gridy
int gridy
- 指定位于组件显示区域的顶部的单元格，其中最上边的单元格为
gridy=0。值RELATIVE指定将组件放置在添加此组件之前刚刚添加到容器的组件的下面。默认值为
RELATIVE。gridy应为非负值。
gridwidth
int gridwidth
- 指定在组件显示区域的一行中的单元格数。
使用
REMAINDER指定组件的显示区域从gridx到该行的最后一个单元格。使用RELATIVE指定组件的显示区域从gridx到它所在行的倒数第二个单元格。gridwidth应为非负，默认值为 1。
gridheight
int gridheight
- 指定在组件显示区域的一列中的单元格数。
使用
REMAINDER指定组件的显示区域从gridy到该列的最后一个单元格。使用RELATIVE指定组件的显示区域从gridy到它所在列的倒数第二个单元格。gridheight应为非负，默认值为 1。
weightx
double weightx
- 指定如何分布额外的水平空间。
网格包布局管理器计算出列的权重就是列的所有组件中最大的
weightx。如果得到的布局在水平方向上比需要填充的区域小，则系统会将额外的空间按照其权重比例分布到每一列。权重为零的列不会得到额外的空间。如果所有的权重都为零，则所有的额外空间都将出现在单元格的网格之间和左右边缘之间。
此字段的默认值为
0。weightx应为非负值。
weighty
double weighty
- 指定如何分布额外的垂直空间。
网格包布局管理器计算出行的权重就是行的所有组件中最大的
weighty。如果得到的布局在垂直方向上比需要填充的区域小，则系统会将额外的空间按照其权重比例分布到每一行。权重为零的行不会得到额外的空间。如果所有的权重都为零，则所有的额外空间都将出现在单元格的网格之间和上下边缘之间。
此字段的默认值为
0。weighty应为非负值。
anchor
int anchor
- 当组件小于其显示区域时使用此字段。它可以确定在显示区域中放置组件的位置。
可能的值有两种：相对和绝对。相对值的解释是相对于容器的组件方向属性，而绝对值则不然。绝对值有：
CENTER、NORTH、NORTHEAST、EAST、SOUTHEAST、SOUTH、SOUTHWEST、WEST和NORTHWEST。相对值有：PAGE_START、PAGE_END、LINE_START、LINE_END、FIRST_LINE_START、FIRST_LINE_END、LAST_LINE_START和LAST_LINE_END。默认值为CENTER。
fill
int fill
- 当组件的显示区域大于它所请求的显示区域的大小时使用此字段。它可以确定是否调整组件大小，以及如果需要，如何调整。
以下值适用于
fill：-
NONE：不调整组件大小。 -
HORIZONTAL：加宽组件，使它在水平方向上得以填满其显示区域，但是不改变高度。 -
VERTICAL：加高组件，使它在垂直方向上得以填满其显示区域，但是不改变宽度。 -
BOTH：使组件完全填满其显示区域。
默认值为
NONE。 -
insets
Insets insets
- 此字段指定组件的外部填充，即组件与其显示区域边缘之间间距的最小量。
默认值为
new Insets(0, 0, 0, 0)。
ipadx
int ipadx
- 此字段指定组件的内部填充，即给组件的最小宽度添加多大的空间。组件的宽度至少为其最小宽度加上
ipadx像素。默认值为
0。
ipady
int ipady
- 此字段指定内部填充，即给组件的最小高度添加多大的空间。组件的高度至少为其最小高度加上
ipady像素。默认值为 0。
tempX
int tempX
- Temporary place holder for the x coordinate.
-
tempY
int tempY
- Temporary place holder for the y coordinate.
-
tempWidth
int tempWidth
- Temporary place holder for the Width of the component.
-
tempHeight
int tempHeight
- Temporary place holder for the Height of the component.
-
minWidth
int minWidth
- The minimum width of the component. It is used to calculate
ipady, where the default will be 0.
minHeight
int minHeight
- The minimum height of the component. It is used to calculate
ipadx, where the default will be 0.
| 类 java.awt.GridBagLayout 继承 Object 实现 Serializable |
|---|
serialVersionUID: 8838754796412211005L
| 序列化字段 |
|---|
comptable
Hashtable<K,V> comptable
- 此哈希表维持组件与其网格包约束之间的关联。
comptable中的键是组件，值是GridBagConstraints的实例。 -
- 另请参见：
GridBagConstraints
defaultConstraints
GridBagConstraints defaultConstraints
- 此字段保持包含默认值的网格包约束实例，因此如果某个组件没有与其相关联的网格包约束，则会分配给该组件一个
defaultConstraints的副本。
layoutInfo
java.awt.GridBagLayoutInfo layoutInfo
- 此字段保持网格包的布局信息。此字段中的信息以最近验证的网格包为基础。如果
layoutInfo为null，这指示网格包中不存在组件，或者即使存在，也是尚未经过验证的组件。
columnWidths
int[] columnWidths
- 此字段保持对列最小宽度的重写。如果此字段为非
null，则在计算全部最小列宽度之后将该值应用到网格包。如果 columnWidths 的元素多于列数，则在网格包中添加列以匹配 columnWidth 中的元素数。
rowHeights
int[] rowHeights
- 此字段保持对行最小高度的重写。如果此字段为非 null，则在计算全部最小行高度之后将值应用到网格包。如果
rowHeights的元素多于行数，则在网格包中添加行以匹配rowHeights中的元素数。
columnWeights
double[] columnWeights
- 此字段保持对列权重的重写。如果此字段为非
null，则在计算全部列权重之后将值应用到网格包。如果columnWeights[i]大于列 i 的权重，则将columnWeights[i]中的权重分配给列 i。如果columnWeights的元素多于列数，则多余的元素将被忽略——它们不会导致更多列的创建。 -
rowWeights
double[] rowWeights
- 此字段保持对行权重的重写。如果此字段为非 null，则在计算全部行权重之后将值应用到网格包。如果
rowWeights[i]大于行 i 的权重，则将rowWeights[i]中的权重分配给行 i。如果rowWeights的元素多于行数，则多余的元素将被忽略——它们不会导致更多行的创建。 -
| 类 java.awt.GridLayout 继承 Object 实现 Serializable |
|---|
| 序列化字段 |
|---|
hgap
int hgap
- This is the horizontal gap (in pixels) which specifies the space
between columns. They can be changed at any time.
This should be a non-negative integer.
vgap
int vgap
- This is the vertical gap (in pixels) which specifies the space
between rows. They can be changed at any time.
This should be a non negative integer.
rows
int rows
- This is the number of rows specified for the grid. The number
of rows can be changed at any time.
This should be a non negative integer, where '0' means
'any number' meaning that the number of Rows in that
dimension depends on the other dimension.
cols
int cols
- This is the number of columns specified for the grid. The number
of columns can be changed at any time.
This should be a non negative integer, where '0' means
'any number' meaning that the number of Columns in that
dimension depends on the other dimension.
| 类 java.awt.HeadlessException 继承 UnsupportedOperationException 实现 Serializable |
|---|
serialVersionUID: 167183644944358563L
| 类 java.awt.IllegalComponentStateException 继承 IllegalStateException 实现 Serializable |
|---|
serialVersionUID: -1889339587208144238L
| 类 java.awt.Insets 继承 Object 实现 Serializable |
|---|
serialVersionUID: -2272572637695466749L
| 序列化字段 |
|---|
top
int top
- 顶部的 inset。将此值添加到长方形的 Top，以产生一个新的 Top 位置。
-
- 另请参见：
Insets.clone()
left
int left
- 左边的 inset。将此值添加到长方形的 Left，以产生一个新的 Left 边缘位置。
-
- 另请参见：
Insets.clone()
bottom
int bottom
- 底部的 inset。从长方形的 Bottom 减去此值，以产生一个新的 Bottom 位置。
-
- 另请参见：
Insets.clone()
right
int right
- 右边的 inset。从长方形的 Right 减去此值，以产生一个新的 Right 边缘位置。
-
- 另请参见：
Insets.clone()
| 类 java.awt.Label 继承 Component 实现 Serializable |
|---|
serialVersionUID: 3094126758329070636L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 从对象输入流读取标签。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless()返回trueClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
- 另请参见：
GraphicsEnvironment.isHeadless()
| 序列化字段 |
|---|
text
String text
- The text of this label.
This text can be modified by the program
but never by the user.
alignment
int alignment
- The label's alignment. The default alignment is set
to be left justified.
| 类 java.awt.Label.AccessibleAWTLabel 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: -3568967560160480438L
| 类 java.awt.List 继承 Component 实现 Serializable |
|---|
serialVersionUID: -3304312411574666869L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream，如果它不为null，则添加侦听器以接收由List激活的项事件和操作事件（由存储在流中的键指定）。未识别的键或值将被忽略。- 抛出：
HeadlessException- 如果为GraphicsEnvironment.isHeadless，则返回trueClassNotFoundExceptionIOException- 另请参见：
List.removeItemListener(ItemListener),List.addItemListener(ItemListener),GraphicsEnvironment.isHeadless(),List.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。写入可序列化的
ItemListeners和ActionListeners的列表作为可选数据。检测不可序列化的侦听器并且不尝试对其进行序列化。- 序列数据：
null终止 0 或更多对的序列；这些对由一个String和一个Object组成；String指示对象类型，为以下任意一种：itemListenerK指示一个ItemListener对象；actionListenerK指示一个ActionListener对象。- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.itemListenerK,Component.actionListenerK,List.readObject(ObjectInputStream)
| 序列化字段 |
|---|
items
Vector<E> items
- A vector created to contain items which will become
part of the List Component.
rows
int rows
- This field will represent the number of visible rows in the
ListComponent. It is specified only once, and that is when the list component is actually created. It will never change. -
- 另请参见：
List.getRows()
multipleMode
boolean multipleMode
multipleModeis a variable that will be set totrueif a list component is to be set to multiple selection mode, that is where the user can select more than one item in a list at one time.multipleModewill be set to false if the list component is set to single selection, that is where the user can only select one item on the list at any one time.
selected
int[] selected
selectedis an array that will contain the indices of items that have been selected.
visibleIndex
int visibleIndex
- This variable contains the value that will be used
when trying to make a particular list item visible.
listSerializedDataVersion
int listSerializedDataVersion
List组件的序列化数据版本 (Serialized Data Version)。-
| 类 java.awt.List.AccessibleAWTList 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: 7924617370136012829L
| 类 java.awt.List.AccessibleAWTList.AccessibleAWTListChild 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: 4412022926028300317L
| 序列化字段 |
|---|
parent
List parent
indexInParent
int indexInParent
| 类 java.awt.MediaTracker 继承 Object 实现 Serializable |
|---|
serialVersionUID: -483174189758638095L
| 序列化字段 |
|---|
target
Component target
- A given
Componentthat will be tracked by a media tracker where the image will eventually be drawn.
head
java.awt.MediaEntry head
- The head of the list of
Imagesthat is being tracked by theMediaTracker.
| 类 java.awt.Menu 继承 MenuItem 实现 Serializable |
|---|
serialVersionUID: -8809584163345499784L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException, HeadlessException
- 读取
ObjectInputStream。未识别的密钥或值将被忽略。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueIOExceptionClassNotFoundException- 另请参见：
GraphicsEnvironment.isHeadless(),Menu.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认可序列化字段写入流中。
| 序列化字段 |
|---|
items
Vector<E> items
- A vector of the items that will be part of the Menu.
-
- 另请参见：
Menu.countItems()
tearOff
boolean tearOff
- This field indicates whether the menu has the
tear of property or not. It will be set to
trueif the menu has the tear off property and it will be set tofalse>if it does not. A torn off menu can be deleted by a user when it is no longer needed. -
- 另请参见：
Menu.isTearOff()
isHelpMenu
boolean isHelpMenu
- This field will be set to
trueif the Menu in question is actually a help menu. Otherwise it will be set tofalse. -
menuSerializedDataVersion
int menuSerializedDataVersion
- 菜单序列化的数据版本。
-
| 类 java.awt.Menu.AccessibleAWTMenu 继承 MenuItem.AccessibleAWTMenuItem 实现 Serializable |
|---|
serialVersionUID: 5228160894980069094L
| 类 java.awt.MenuBar 继承 MenuComponent 实现 Serializable |
|---|
serialVersionUID: -4930327919388951260L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream。未识别的键或值将被忽略。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless(),MenuBar.writeObject(java.io.ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws ClassNotFoundException, IOException
- 将默认的可序列化字段写入流中。
| 序列化字段 |
|---|
menus
Vector<E> menus
- This field represents a vector of the
actual menus that will be part of the MenuBar.
-
- 另请参见：
MenuBar.countMenus()
helpMenu
Menu helpMenu
- This menu is a special menu dedicated to
help. The one thing to note about this menu
is that on some platforms it appears at the
right edge of the menubar.
menuBarSerializedDataVersion
int menuBarSerializedDataVersion
- MenuBar 的序列化数据版本。
-
| 类 java.awt.MenuBar.AccessibleAWTMenuBar 继承 MenuComponent.AccessibleAWTMenuComponent 实现 Serializable |
|---|
serialVersionUID: -8577604491830083815L
| 类 java.awt.MenuComponent 继承 Object 实现 Serializable |
|---|
serialVersionUID: -4536902356223894379L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 从对象输入流读取该菜单组件。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless()
| 序列化字段 |
|---|
font
Font font
- The menu component's font. This value can be
nullat which point a default will be used. This defaults tonull.
name
String name
- 该菜单组件的名称，默认为
null。
nameExplicitlySet
boolean nameExplicitlySet
- 指示是否显式设置名称的变量。如果为
true，将以显式方式设置该名称。此变量默认为false。
newEventsOnly
boolean newEventsOnly
- Defaults to
false.
accessibleContext
AccessibleContext accessibleContext
| 类 java.awt.MenuComponent.AccessibleAWTMenuComponent 继承 AccessibleContext 实现 Serializable |
|---|
serialVersionUID: -4269533416223798698L
| 类 java.awt.MenuItem 继承 MenuComponent 实现 Serializable |
|---|
serialVersionUID: -21757335363267194L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream，如果它不为null，则添加一个侦听器，以接收由Menu项引发的操作事件。未识别的键或值将被忽略。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
#removeActionListener(actionListener),#addActionListener(actionListener),MenuItem.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。将一个可序列化的
ActionListeners列表作为可选数据写入。检测不可序列化的侦听器并且不尝试对其进行序列化。- 序列数据：
null表示终止 0 或更多对的序列；这种对是由String和Object组成的；String指示对象类型，它为以下类型之一：指示ActionListener对象的 actionListenerK- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),MenuItem.readObject(ObjectInputStream)
| 序列化字段 |
|---|
enabled
boolean enabled
- A value to indicate whether a menu item is enabled
or not. If it is enabled,
enabledwill be set to true. Elseenabledwill be set to false.
label
String label
labelis the label of a menu item. It can be any string.
actionCommand
String actionCommand
- This field indicates the command tha has been issued
by a particular menu item.
By default the
actionCommandis the label of the menu item, unless it has been set using setActionCommand.
eventMask
long eventMask
- The eventMask is ONLY set by subclasses via enableEvents.
The mask should NOT be set when listeners are registered
so that we can distinguish the difference between when
listeners request events and subclasses request them.
-
shortcut
MenuShortcut shortcut
- 与菜单项关联的关键字序列。注意，在 1.1.2 中，必须使用菜单项上的 setActionCommand()，才可以使快捷方式工作。
menuItemSerializedDataVersion
int menuItemSerializedDataVersion
- 菜单项的序列化数据版本。
-
| 类 java.awt.MenuItem.AccessibleAWTMenuItem 继承 MenuComponent.AccessibleAWTMenuComponent 实现 Serializable |
|---|
serialVersionUID: -217847831945965825L
| 类 java.awt.MenuShortcut 继承 Object 实现 Serializable |
|---|
serialVersionUID: 143448358473180225L
| 序列化字段 |
|---|
key
int key
- The virtual keycode for the menu shortcut.
This is the keycode with which the menu shortcut will be created.
Note that it is a virtual keycode, not a character,
e.g. KeyEvent.VK_A, not 'a'.
Note: in 1.1.x you must use setActionCommand() on a menu item
in order for its shortcut to work, otherwise it will fire a null
action command.
-
- 从以下版本开始：
- JDK1.1
- 另请参见：
MenuShortcut.getKey(),MenuShortcut.usesShiftModifier(),KeyEvent
usesShift
boolean usesShift
- Indicates whether the shft key was pressed.
If true, the shift key was pressed.
If false, the shift key was not pressed
-
- 从以下版本开始：
- JDK1.1
- 另请参见：
MenuShortcut.usesShiftModifier()
| 类 java.awt.Panel 继承 Container 实现 Serializable |
|---|
serialVersionUID: -2728009084054400034L
| 类 java.awt.Panel.AccessibleAWTPanel 继承 Container.AccessibleAWTContainer 实现 Serializable |
|---|
serialVersionUID: -6409552226660031050L
| 类 java.awt.Point 继承 Point2D 实现 Serializable |
|---|
serialVersionUID: -5276940640259749850L
| 序列化字段 |
|---|
x
int x
- x 坐标。如果未设置 x 坐标，则默认为 0。
y
int y
- y 坐标。如果未设置 y 坐标，则默认为 0。
| 类 java.awt.Polygon 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6460061437900069969L
| 序列化字段 |
|---|
npoints
int npoints
xpoints
int[] xpoints
- x 坐标的数组。此数组中元素的个数可以大于此
Polygon中 x 坐标的个数。额外的元素允许新的点添加到此Polygon中，而无需重新创建此数组。npoints的值等于此Polygon中有效点的个数。
ypoints
int[] ypoints
- y 坐标的数组。此数组中元素的个数可以大于此
Polygon中 y 坐标的个数。额外的元素允许新的点添加到Polygon中，而无需重新创建此数组。npoints的值等于此Polygon中有效点的个数。
bounds
Rectangle bounds
- 多边形的边界。此值可以为 NULL。请参见 javadoc 注释 getBounds()。
| 类 java.awt.PopupMenu 继承 Menu 实现 Serializable |
|---|
serialVersionUID: -4620452533522760060L
| 类 java.awt.PopupMenu.AccessibleAWTPopupMenu 继承 Menu.AccessibleAWTMenu 实现 Serializable |
|---|
serialVersionUID: -4282044795947239955L
| 类 java.awt.Rectangle 继承 Rectangle2D 实现 Serializable |
|---|
serialVersionUID: -4345857070255674764L
| 序列化字段 |
|---|
x
int x
Rectangle的 x 坐标。
y
int y
Rectangle的 y 坐标。
width
int width
Rectangle的宽度。-
- 从以下版本开始：
- JDK1.0.
- 另请参见：
Rectangle.setSize(int, int),Rectangle.getSize()
height
int height
Rectangle的高度。
| 类 java.awt.Scrollbar 继承 Component 实现 Serializable |
|---|
serialVersionUID: 8451667562882310543L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream，如果它不为null，则添加一个侦听器，以接收Scrollbar触发的调整事件。忽略未被识别的键或值。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless(),Scrollbar.writeObject(ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认可序列化字段写入流中。写入可序列化
AdjustmentListeners的一个列表作为可选数据。检测不可序列化的侦听器并且不尝试对其进行序列化。- 序列数据：
null表示终止 0 或更多对的序列；这种对是由String和Object组成的；String指示对象类型，它为以下类型之一：指示AdjustmentListener对象的adjustmentListenerK- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.adjustmentListenerK,Scrollbar.readObject(ObjectInputStream)
| 序列化字段 |
|---|
value
int value
- The value of the
Scrollbar. This property must be greater than or equal tominimumand less than or equal tomaximum - visibleAmount
maximum
int maximum
- The maximum value of the
Scrollbar. This value must be greater than theminimumvalue.
minimum
int minimum
- The minimum value of the
Scrollbar. This value must be less than themaximumvalue.
visibleAmount
int visibleAmount
- The size of the
Scrollbar's bubble. When a scroll bar is used to select a range of values, the visibleAmount represents the size of this range. This is visually indicated by the size of the bubble.
orientation
int orientation
- The
Scrollbar's orientation--being either horizontal or vertical. This value should be specified when the scrollbar is created.
orientation can be either :VERTICALorHORIZONTALonly.
lineIncrement
int lineIncrement
- The amount by which the scrollbar value will change when going
up or down by a line.
This value must be greater than zero.
pageIncrement
int pageIncrement
- The amount by which the scrollbar value will change when going
up or down by a page.
This value must be greater than zero.
scrollbarSerializedDataVersion
int scrollbarSerializedDataVersion
- 滚动条的序列化 Data Version。
-
| 类 java.awt.Scrollbar.AccessibleAWTScrollBar 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: -344337268523697807L
| 类 java.awt.ScrollPane 继承 Container 实现 Serializable |
|---|
serialVersionUID: 7956609840827222915L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 将默认可序列化字段读入流中。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless()返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless()
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认可序列化字段写入流中。
- 抛出：
IOException
| 序列化字段 |
|---|
scrollbarDisplayPolicy
int scrollbarDisplayPolicy
- 有三种显示滚动条的方法。此整数将显示三种显示方法之一——（SCROLLBARS_ALWAYS、SCROLLBARS_AS_NEEDED 和 SCROLLBARS_NEVER）
vAdjustable
ScrollPaneAdjustable vAdjustable
- 一个可调整的垂直滚动条。注意到不必 调用三种
Adjustable方法非常重要，这三种方法是：setMinimum()、setMaximum()和setVisibleAmount()。
hAdjustable
ScrollPaneAdjustable hAdjustable
- 一个可调整的水平滚动条。注意到不必 调用三种
Adjustable方法非常重要，这三种方法是：setMinimum()、setMaximum()和setVisibleAmount()。
wheelScrollingEnabled
boolean wheelScrollingEnabled
- 指示是否应该在接收 MouseWheelEvent 时进行滚动。
-
- 从以下版本开始：
- 1.4
| 类 java.awt.ScrollPane.AccessibleAWTScrollPane 继承 Container.AccessibleAWTContainer 实现 Serializable |
|---|
serialVersionUID: 6100703663886637L
| 类 java.awt.ScrollPaneAdjustable 继承 Object 实现 Serializable |
|---|
serialVersionUID: -3359745691033257079L
| 序列化字段 |
|---|
sp
ScrollPane sp
- 此对象是其滚动条的
ScrollPane。 -
orientation
int orientation
value
int value
- 此滚动条的值。
value应该大于minimum且小于maximum
minimum
int minimum
- 此滚动条的最小值。只能通过
ScrollPane设置此值。ATTN： 在当前实现中，
minimum总是为0。只能通过setSpan方法更改此字段，并且ScrollPane总是调用 minimum 为0的此方法。getMinimum方法总是返回0而不检查此字段。
maximum
int maximum
- 此滚动条的最大值。只能通过
ScrollPane设置此值。
visibleAmount
int visibleAmount
- 此滚动条可视部分的大小。只能通过
ScrollPane设置此值。
unitIncrement
int unitIncrement
- 当滚动条向上或向下移动一行时，滚动条值更改的量。该值应该是一个非负整数。
blockIncrement
int blockIncrement
- 当滚动条向上或向下移动一页时，滚动条值更改的量。该值应该是一个非负整数。
adjustmentListener
AdjustmentListener adjustmentListener
| 类 java.awt.SystemColor 继承 Color 实现 Serializable |
|---|
serialVersionUID: 4503142729533789064L
| 类 java.awt.TextArea 继承 TextComponent 实现 Serializable |
|---|
serialVersionUID: 3692302836626095722L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取 ObjectInputStream。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless()返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless()
| 序列化字段 |
|---|
rows
int rows
- The number of rows in the
TextArea. This parameter will determine the text area's height. Guaranteed to be non-negative.
columns
int columns
- The number of columns in the
TextArea. A column is an approximate average character width that is platform-dependent. This parameter will determine the text area's width. Guaranteed to be non-negative.
scrollbarVisibility
int scrollbarVisibility
- 确定为文本区创建哪种滚动条。它可以是以下四个值之一：
SCROLLBARS_BOTH= 两种滚动条都创建。
SCROLLBARS_HORIZONTAL_ONLY= 只创建水平滚动条。SCROLLBARS_VERTICAL_ONLY= 只创建垂直滚动条。SCROLLBARS_NONE= 不创建滚动条。
textAreaSerializedDataVersion
int textAreaSerializedDataVersion
- The textArea Serialized Data Version.
-
| 类 java.awt.TextArea.AccessibleAWTTextArea 继承 TextComponent.AccessibleAWTTextComponent 实现 Serializable |
|---|
serialVersionUID: 3472827823632144419L
| 类 java.awt.TextComponent 继承 Component 实现 Serializable |
|---|
serialVersionUID: -2214773872412987419L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取 ObjectInputStream，如果它不为 null，则添加一个侦听器，以接收 TextComponent 触发的文本事件。未识别的密钥或值将被忽略。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless()返回trueClassNotFoundExceptionIOException- 另请参见：
#removeTextListener(),#addTextListener(),GraphicsEnvironment.isHeadless()
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。写入可序列化 TextListener 的一个列表作为可选数据。检测不可序列化的 TextListener，并且不尝试对其进行序列化。
- 序列数据：
- 以 null 终止的 0 或多对序列。由 String 和 Object 组成的一对序列。String 指示对象类型，它是以下之一： textListenerK 指示 TextListener 对象。
- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.textListenerK
| 序列化字段 |
|---|
text
String text
- The value of the text.
A
nullvalue is the same as "".
editable
boolean editable
- A boolean indicating whether or not this
TextComponentis editable. It will betrueif the text component is editable andfalseif not.
selectionStart
int selectionStart
- The selection refers to the selected text, and the
selectionStartis the start position of the selected text.
selectionEnd
int selectionEnd
- The selection refers to the selected text, and the
selectionEndis the end position of the selected text.
backgroundSetByClientCode
boolean backgroundSetByClientCode
textComponentSerializedDataVersion
int textComponentSerializedDataVersion
- textComponent 的 SerializedDataVersion。
-
checkForEnableIM
boolean checkForEnableIM
| 类 java.awt.TextComponent.AccessibleAWTTextComponent 继承 Component.AccessibleAWTComponent 实现 Serializable |
|---|
serialVersionUID: 3631432373506317811L
| 类 java.awt.TextField 继承 TextComponent 实现 Serializable |
|---|
serialVersionUID: -2966288784432217853L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取 ObjectInputStream，如果它不为 null，则添加一个侦听器，以接收 TextField 触发的操作事件。未识别的密钥或值将被忽略。
- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless()返回trueClassNotFoundExceptionIOException- 另请参见：
TextField.removeActionListener(ActionListener),TextField.addActionListener(ActionListener),GraphicsEnvironment.isHeadless()
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。写入可序列化 ActionListener 的一个列表作为可选数据。检测不可序列化的 ActionListener，并且不尝试对其进行序列化。
- 序列数据：
- 以 null 终止的 0 或多对序列。由 String 和 Object 组成的一对序列。String 指示对象类型，它是以下类型之一：指示 ActionListener 对象的 ActionListenerK。
- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(ObjectOutputStream, String, EventListener),Component.actionListenerK
| 序列化字段 |
|---|
columns
int columns
- The number of columns in the text field.
A column is an approximate average character
width that is platform-dependent.
Guaranteed to be non-negative.
echoChar
char echoChar
- The echo character, which is used when
the user wishes to disguise the characters
typed into the text field.
The disguises are removed if echoChar =
0.
textFieldSerializedDataVersion
int textFieldSerializedDataVersion
- textField 的 Serialized Data Version。
-
| 类 java.awt.TextField.AccessibleAWTTextField 继承 TextComponent.AccessibleAWTTextComponent 实现 Serializable |
|---|
serialVersionUID: 6219164359235943158L
| 类 java.awt.Window 继承 Container 实现 Serializable |
|---|
serialVersionUID: 4497834738069338734L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException, HeadlessException
- 读取
ObjectInputStream和侦听器的可选列表，以接收由该组件引发的各种事件；并且读取子窗口（可能为null）的列表。未识别的键或值将被忽略。- 抛出：
HeadlessException- 如果GraphicsEnvironment.isHeadless返回trueClassNotFoundExceptionIOException- 另请参见：
GraphicsEnvironment.isHeadless(),Window.writeObject(java.io.ObjectOutputStream)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流中。写入可序列化的
WindowListener和WindowFocusListener的列表作为可选数据。将子窗口的列表作为可选数据写入。- 序列数据：
null表示终止 0 或更多对的序列；这种对是由String和Object组成的；String指示对象类型，它为以下类型之一：windowListenerK指示WindowListener对象；windowFocusWindowK指示WindowFocusListener对象；ownedWindowK指示Window子对象- 抛出：
IOException- 另请参见：
AWTEventMulticaster.save(java.io.ObjectOutputStream, java.lang.String, java.util.EventListener),Component.windowListenerK,Component.windowFocusListenerK,Component.ownedWindowK,Window.readObject(ObjectInputStream)
| 序列化字段 |
|---|
warningString
String warningString
- This represents the warning message that is
to be displayed in a non secure window. ie :
a window that has a security manager installed for
which calling SecurityManager.checkTopLevelWindow()
is false. This message can be displayed anywhere in
the window.
syncLWRequests
boolean syncLWRequests
state
int state
- An Integer value representing the Window State.
-
- 从以下版本开始：
- 1.2
- 另请参见：
Window.show()
alwaysOnTop
boolean alwaysOnTop
- 表示窗口 always-on-top 状态的布尔值
-
- 从以下版本开始：
- 1.5
- 另请参见：
Window.setAlwaysOnTop(boolean),Window.isAlwaysOnTop()
focusMgr
java.awt.FocusManager focusMgr
- 未使用。为序列化向后兼容性而维护。
-
- 从以下版本开始：
- 1.2
focusableWindowState
boolean focusableWindowState
- 指示此窗口是否可以成为聚焦窗口。
-
- 从以下版本开始：
- 1.4
- 另请参见：
Window.getFocusableWindowState(),Window.setFocusableWindowState(boolean)
windowSerializedDataVersion
int windowSerializedDataVersion
- 窗口序列化的数据版本。
-
locationByPlatform
boolean locationByPlatform
| 类 java.awt.Window.AccessibleAWTWindow 继承 Container.AccessibleAWTContainer 实现 Serializable |
|---|
serialVersionUID: 4215068635060671780L
| 软件包 java.awt.color |
|---|
| 类 java.awt.color.CMMException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.awt.color.ColorSpace 继承 Object 实现 Serializable |
|---|
serialVersionUID: -409452704308689724L
| 序列化字段 |
|---|
type
int type
numComponents
int numComponents
| 类 java.awt.color.ICC_ColorSpace 继承 ColorSpace 实现 Serializable |
|---|
serialVersionUID: 3455889114070431483L
| 序列化字段 |
|---|
thisProfile
ICC_Profile thisProfile
minVal
float[] minVal
maxVal
float[] maxVal
diffMinMax
float[] diffMinMax
invDiffMinMax
float[] invDiffMinMax
needScaleInit
boolean needScaleInit
| 类 java.awt.color.ICC_Profile 继承 Object 实现 Serializable |
|---|
serialVersionUID: -3938515861990936766L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中读取默认的可序列化字段。从流中读取 string 和 byte 数组作为额外的数据。
- 序列数据：
- 如果 profile 对象是预定义颜色空间（如
"CS_sRGB"）的某个配置文件，则String是ColorSpace类中所定义的CS_*常量之一。否则 string 为null。byte[]数组是该配置文件的配置文件数据。对于预定义的配置文件而言，它通常为null。如果将该 string 识别为预定义颜色空间的常量名，则将对象解析为使用
getInstance(int cspace)所获得的配置文件，并且忽略配置文件数据。否则将对象解析为使用getInstance(byte[] data)所获得的配置文件。 - 抛出：
IOException- 由ObjectInputStream抛出。ClassNotFoundException- 由ObjectInputStream抛出。- 另请参见：
ICC_Profile.readResolve(),ICC_Profile.getInstance(int),ICC_Profile.getInstance(byte[])
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将默认的可序列化字段写入流。向流中写入 string 和 byte 数组作为额外的数据。
- 序列数据：
- 如果 profile 对象是预定义颜色空间（如
"CS_sRGB"）的某个配置文件，则String是ColorSpace类中所定义的CS_*常量之一。否则 string 为null。byte[]数组是该配置文件的配置文件数据。对于预定义的颜色空间，写入的是null而不是配置文件数据。如果在以后的 Java API 版本中添加了新的预定义颜色空间，则此类的以后版本中可能会选择这条道：不但写入新预定义颜色空间的颜色空间名称，而且还要写入配置文件数据，以使旧版本仍能反序列化对象。 - 抛出：
IOException- 由ObjectInputStream抛出。
readResolve
protected Object readResolve() throws ObjectStreamException
- 解析将被反序列化为用 CMM 注册的实例的实例。
- 抛出：
永远不会抛出- ObjectStreamException，但是要受序列化规范的限制。ObjectStreamException
| 序列化字段 |
|---|
iccProfileSerializedDataVersion
int iccProfileSerializedDataVersion
- 流中其他序列化数据的格式版本。版本
1对应于 Java 2 平台，1.3 版 -
- 从以下版本开始：
- 1.3
| 类 java.awt.color.ICC_ProfileGray 继承 ICC_Profile 实现 Serializable |
|---|
| 类 java.awt.color.ICC_ProfileRGB 继承 ICC_Profile 实现 Serializable |
|---|
| 类 java.awt.color.ProfileDataException 继承 RuntimeException 实现 Serializable |
|---|
| 软件包 java.awt.datatransfer |
|---|
| 类 java.awt.datatransfer.DataFlavor 继承 Object 实现 Serializable |
|---|
serialVersionUID: 8367026044764648243L
| 序列化方法 |
|---|
readExternal
public void readExternal(ObjectInput is) throws IOException, ClassNotFoundException
- 从 Serialized 状态还原此
DataFlavor。- 抛出：
IOException- 如果发生 I/O 错误ClassNotFoundException- 如果无法找到需要恢复的某个对象的类。
writeExternal
public void writeExternal(ObjectOutput os) throws IOException
- 序列化此
DataFlavor。- 抛出：
IOException- 包含可能发生的所有 I/O 异常
| 类 java.awt.datatransfer.FlavorEvent 继承 EventObject 实现 Serializable |
|---|
| 类 java.awt.datatransfer.UnsupportedFlavorException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 5383814944251665601L
| 软件包 java.awt.dnd |
|---|
| 类 java.awt.dnd.DragGestureEvent 继承 EventObject 实现 Serializable |
|---|
serialVersionUID: 9080172649166731306L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 反序列化此
DragGestureEvent。此方法首先为所有的非transient字段执行默认的反序列化。然后还要尝试反序列化此对象动作事件的List。通过反序列化字段events来进行首次尝试，因为在发布版本 1.4 之前，此名称的非transient字段存储动作事件的List。如果此尝试失败，则使用流中的下一个对象。如果结果List为null，则设置此对象的动作事件List为空List。- 抛出：
ClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列化此
DragGestureEvent。当且仅当可以序列化此对象的动作事件List时才执行默认的序列化，然后写出该List。如果无法序列化，则写出null。在这种情况下，从得到的反序列化流中创建的DragGestureEvent将包含一个空的动作事件List。- 序列数据：
- 按字母顺序排列的默认可序列化字段，后跟
List实例或null。 - 抛出：
IOException- 从以下版本开始：
- 1.4
| 序列化字段 |
|---|
dragSource
DragSource dragSource
- 与此 DragGestureEvent 关联的 DragSource。
-
component
Component component
- 与此 DragGestureEvent 关联的 Component。
-
origin
Point origin
- 拖动的原点。
-
action
int action
- 用户的首选操作。
-
| 类 java.awt.dnd.DragGestureRecognizer 继承 Object 实现 Serializable |
|---|
serialVersionUID: 8996673345831063337L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 反序列化此
DragGestureRecognizer。此方法首先为所有的非transient字段执行默认的反序列化。然后通过使用流中的下一个对象，还要反序列化此对象的DragGestureListener。- 抛出：
ClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列化此
DragGestureRecognizer。此方法首先执行默认的序列化。然后当且仅当可以序列化此对象的DragGestureListener时将其写出。如果无法序列化，则写出null。- 序列数据：
- 按字母顺序排列的默认可序列化字段，后跟
DragGestureListener或null。 - 抛出：
IOException- 从以下版本开始：
- 1.4
| 序列化字段 |
|---|
dragSource
DragSource dragSource
- 与此
DragGestureRecognizer关联的DragSource。 -
component
Component component
- 与此
DragGestureRecognizer关联的Component。 -
sourceActions
int sourceActions
- 此 Drag 和 Drop 操作中所用动作类型的
int表示形式。 -
events
ArrayList<E> events
DragGestureRecognizer“识别”为触发拖动的“动作”事件列表（按顺序）。-
| 类 java.awt.dnd.DragSource 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6236096958971414066L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 反序列化此
DragSource。此方法首先执行默认的反序列化。然后使用流中的下一个对象反序列化此对象的FlavorMap。如果得到的FlavorMap为null，则将此对象的FlavorMap设置为此线程的ClassLoader的默认 FlavorMap。然后反序列化此对象的侦听器，方法是从流中读取以null终止的 0 序列或者更多的键/值对：- 如果键对象是等于
dragSourceListenerK的String，则使用相应的值对象反序列化一个DragSourceListener并添加到此DragSource中。 - 如果键对象是等于
dragSourceMotionListenerK的String，则使用相应的值对象反序列化一个DragSourceMotionListener并添加到此DragSource中。 - 否则跳过该键/值对。
- 抛出：
ClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
- 另请参见：
SystemFlavorMap.getDefaultFlavorMap()
- 如果键对象是等于
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列化此
DragSource。此方法首先执行默认的序列化。然后当且仅当可以序列化此对象的FlavorMap时写出该 FlavorMap。如果无法序列化，则写出null。然后写出向此对象注册的Serializable侦听器。使用以null终止的 0 序列或更多数据对的形式写出这些侦听器。该数据对由String和Object组成；String指示该Object的类型，为以下某个值：dragSourceListenerK表示DragSourceListener对象；dragSourceMotionListenerK表示DragSourceMotionListener对象。
- 序列数据：
FlavorMap实例或null，后跟以null终止的 0 序列或更多数据对；该数据对由String和Object组成；String指示该Object的类型，为以下某个值：dragSourceListenerK表示DragSourceListener对象；dragSourceMotionListenerK表示DragSourceMotionListener对象。
- 抛出：
IOException- 从以下版本开始：
- 1.4
| 类 java.awt.dnd.DragSourceContext 继承 Object 实现 Serializable |
|---|
serialVersionUID: -115407898692194719L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 反序列化此
DragSourceContext此方法首先为所有的非transient字段执行默认的反序列化。然后通过使用流中的下两个对象，还要反序列化此对象的Transferable和DragSourceListener如果得到的Transferable为null，则将此对象的Transferable设置为支持无DataFlavor的哑Transferable。- 抛出：
ClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列化此
DragSourceContext此方法首先执行默认的序列化。然后当且仅当可以序列化此对象的Transferable时将其写出。如果无法序列化，则写出null在这种情况下，从得到的反序列化流中创建的DragSourceContext将包含一个支持无DataFlavor的哑Transferable。最后，当且仅当可以序列化此对象的DragSourceListener时将其写出。如果无法序列化，则写出null。- 序列数据：
- 按字母顺序排列的默认可序列化字段，后跟
Transferable实例或null，然后是DragSourceListener实例或null。 - 抛出：
IOException- 从以下版本开始：
- 1.4
| 序列化字段 |
|---|
trigger
DragGestureEvent trigger
- 触发拖动开始的事件。
-
cursor
Cursor cursor
- 当前的拖动光标。
-
useCustomCursor
boolean useCustomCursor
- 如果使用了自定义的拖动光标，而不是默认的拖动光标，则为
true。 -
sourceActions
int sourceActions
DnDConstants的位掩码，表示拖动源针对与此DragSourceContext关联的拖动操作所支持的放置动作集合。-
| 类 java.awt.dnd.DragSourceDragEvent 继承 DragSourceEvent 实现 Serializable |
|---|
serialVersionUID: 481346297933902471L
| 序列化字段 |
|---|
targetActions
int targetActions
- 目标放置动作。
-
dropAction
int dropAction
- 用户放置动作。
-
gestureModifiers
int gestureModifiers
- 与用户动作关联的输入设备组合键状态。
-
invalidModifiers
boolean invalidModifiers
- 指示
gestureModifiers是否无效。 -
| 类 java.awt.dnd.DragSourceDropEvent 继承 DragSourceEvent 实现 Serializable |
|---|
serialVersionUID: -5571321229470821891L
| 序列化字段 |
|---|
dropSuccess
boolean dropSuccess
- 如果放置成功，则为
true。 -
dropAction
int dropAction
- 放置操作。
-
| 类 java.awt.dnd.DragSourceEvent 继承 EventObject 实现 Serializable |
|---|
serialVersionUID: -763287114604032641L
| 序列化字段 |
|---|
locationSpecified
boolean locationSpecified
- 指示是否为此事件指定了光标位置的
boolean值。 -
x
int x
- 如果为此事件指定了光标位置，则为事件发生时该光标位置的水平坐标；否则为零。
-
y
int y
- 如果为此事件指定了光标位置，则为事件发生时该光标位置的垂直坐标；否则为零。
-
| 类 java.awt.dnd.DropTarget 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6283860791671019047L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 反序列化此
DropTarget此方法首先为所有的非transient字段执行默认的反序列化。然后还要尝试反序列化此对象的DropTargetListener通过反序列化字段dtListener来进行首次尝试，因为在发布版本 1.4 之前，此名称的非transient字段存储DropTargetListener如果此尝试失败，则使用流中的下一个对象。- 抛出：
ClassNotFoundExceptionIOException- 从以下版本开始：
- 1.4
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列化此
DropTarget当且仅当可以执行序列化时才执行默认的序列化，然后写出此对象的DropTargetListener如果无法序列化，则写出null。- 序列数据：
- 按字母顺序排列的默认可序列化字段，后跟
DropTargetListener实例或null。 - 抛出：
IOException- 从以下版本开始：
- 1.4
| 序列化字段 |
|---|
dropTargetContext
DropTargetContext dropTargetContext
- 与此 DropTarget 关联的 DropTargetContext。
-
component
Component component
- 与此 DropTarget 关联的 Component。
-
actions
int actions
- Default permissible actions supported by this DropTarget.
active
boolean active
trueif the DropTarget is accepting Drag & Drop operations.-
| 类 java.awt.dnd.DropTargetContext 继承 Object 实现 Serializable |
|---|
serialVersionUID: -634158968993743371L
| 序列化字段 |
|---|
dropTarget
DropTarget dropTarget
- 与此 DropTargetContext 相关的 DropTarget。
-
| 类 java.awt.dnd.DropTargetDragEvent 继承 DropTargetEvent 实现 Serializable |
|---|
serialVersionUID: -8422265619058953682L
| 序列化字段 |
|---|
location
Point location
- Component 坐标中 drag 光标的热点位置。
-
actions
int actions
- 源 drop 操作。
-
dropAction
int dropAction
- 用户 drop 操作。
-
| 类 java.awt.dnd.DropTargetDropEvent 继承 DropTargetEvent 实现 Serializable |
|---|
serialVersionUID: -1721911170440459322L
| 序列化字段 |
|---|
location
Point location
- Component 坐标中 drag 光标的热点位置。
-
actions
int actions
- 源 drop 操作。
-
dropAction
int dropAction
- 用户 drop 操作。
-
isLocalTx
boolean isLocalTx
- 如果源对象与目标对象处于相同的 JVM 中，则为
true。 -
| 类 java.awt.dnd.DropTargetEvent 继承 EventObject 实现 Serializable |
|---|
serialVersionUID: 2821229066521922993L
| 序列化字段 |
|---|
context
DropTargetContext context
- 与此
DropTargetEvent相关的DropTargetContext。 -
| 类 java.awt.dnd.InvalidDnDOperationException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.awt.dnd.MouseDragGestureRecognizer 继承 DragGestureRecognizer 实现 Serializable |
|---|
serialVersionUID: 6220099344182281120L
| 软件包 java.awt.event |
|---|
| 类 java.awt.event.ActionEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: -7671078796273832149L
| 序列化字段 |
|---|
actionCommand
String actionCommand
- The nonlocalized string that gives more details
of what actually caused the event.
This information is very specific to the component
that fired it.
when
long when
- Timestamp of when this event occurred. Because an ActionEvent is a high-
level, semantic event, the timestamp is typically the same as an
underlying InputEvent.
modifiers
int modifiers
- This represents the key modifier that was selected,
and is used to determine the state of the selected key.
If no modifier has been selected it will default to
zero.
| 类 java.awt.event.AdjustmentEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: 5700290645205279921L
| 序列化字段 |
|---|
adjustable
Adjustable adjustable
- The adjustable object that fired the event.
value
int value
valuewill contain the new value of the adjustable object. This value will always be in a range associated adjustable object.
adjustmentType
int adjustmentType
- The
adjustmentTypedescribes how the adjustable object value has changed. This value can be increased/decreased by a block or unit amount where the block is associated with page increments/decrements, and a unit is associated with line increments/decrements.
isAdjusting
boolean isAdjusting
- The
isAdjustingis true if the event is one of the series of multiple adjustment events. -
- 从以下版本开始：
- 1.4
- 另请参见：
AdjustmentEvent.getValueIsAdjusting()
| 类 java.awt.event.ComponentEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: 8101406823902992965L
| 类 java.awt.event.ContainerEvent 继承 ComponentEvent 实现 Serializable |
|---|
serialVersionUID: -4114942250539772041L
| 序列化字段 |
|---|
child
Component child
- The non-null component that is being added or
removed from the Container.
| 类 java.awt.event.FocusEvent 继承 ComponentEvent 实现 Serializable |
|---|
serialVersionUID: 523753786457416396L
| 序列化字段 |
|---|
temporary
boolean temporary
- A focus event can have two different levels, permanent and temporary.
It will be set to true if some operation takes away the focus
temporarily and intends on getting it back once the event is completed.
Otherwise it will be set to false.
| 类 java.awt.event.HierarchyEvent 继承 AWTEvent 实现 Serializable |
|---|
| 序列化字段 |
|---|
changed
Component changed
changedParent
Container changedParent
changeFlags
long changeFlags
| 类 java.awt.event.InputEvent 继承 ComponentEvent 实现 Serializable |
|---|
serialVersionUID: -2482525981698309786L
| 序列化字段 |
|---|
when
long when
- The input event's Time stamp in UTC format. The time stamp
indicates when the input event was created.
-
- 另请参见：
InputEvent.getWhen()
modifiers
int modifiers
- The state of the modifier mask at the time the input
event was fired.
| 类 java.awt.event.InputMethodEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: 4727190874778922661L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 如果
when字段未出现在对象输入流中，则初始化它。在这种情况下，将通过调用EventQueue.getMostRecentEventTime()来初始化该字段。
| 序列化字段 |
|---|
when
long when
- The time stamp that indicates when the event was created.
-
- 从以下版本开始：
- 1.4
- 另请参见：
InputMethodEvent.getWhen()
| 类 java.awt.event.InvocationEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: 436056344909459450L
| 序列化字段 |
|---|
runnable
Runnable runnable
- 调用其 run() 方法的 Runnable。
notifier
Object notifier
- 在 Runnable.run() 方法返回之后立即调用其 notifyAll() 方法的对象（可能为 null）。
catchExceptions
boolean catchExceptions
- 如果 dispatch() 捕获了 Throwable 并将其存储在异常实例变量中，则设置为 true。如果设置为 false，则会将 Throwable 传播到 EventDispatchThread 的调度循环中。
exception
Exception exception
- 在执行 Runnable.run() 方法期间抛出的 Exception（可能为 null）。如果特定实例没有捕获异常，则此变量也为 null。
throwable
Throwable throwable
- 在执行 Runnable.run() 方法期间抛出的 Throwable（可能为 null）。如果特定实例没有捕获异常，则此变量也为 null。
when
long when
- 此事件发生时的时间戳。
| 类 java.awt.event.ItemEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: -608708132447206933L
| 序列化字段 |
|---|
item
Object item
- The item whose selection state has changed.
-
- 另请参见：
ItemEvent.getItem()
stateChange
int stateChange
stateChangeindicates whether theitemwas selected or deselected.
| 类 java.awt.event.KeyEvent 继承 InputEvent 实现 Serializable |
|---|
serialVersionUID: -2352130953028126954L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 根据旧的修饰符来设置新的修饰符。键修饰符可重写与鼠标修饰符重合的部分。
| 序列化字段 |
|---|
isProxyActive
boolean isProxyActive
- 存储本机事件调度系统的状态。如果创建事件时事件代理机制是活动的，则为 true；如果是非活动的，则为 false。该状态用于 Component.dispatchEventImpl 中，以在代理是活动的情况下正确地调度事件。
keyCode
int keyCode
- The unique value assigned to each of the keys on the
keyboard. There is a common set of key codes that
can be fired by most keyboards.
The symbolic name for a key code should be used rather
than the code value itself.
keyChar
char keyChar
keyCharis a valid unicode character that is fired by a key or a key combination on a keyboard.
keyLocation
int keyLocation
- The location of the key on the keyboard.
Some keys occur more than once on a keyboard, e.g. the left and
right shift keys. Additionally, some keys occur on the numeric
keypad. This variable is used to distinguish such keys.
The only legal values are
KEY_LOCATION_UNKNOWN,KEY_LOCATION_STANDARD,KEY_LOCATION_LEFT,KEY_LOCATION_RIGHT, andKEY_LOCATION_NUMPAD.
| 类 java.awt.event.MouseEvent 继承 InputEvent 实现 Serializable |
|---|
serialVersionUID: -991214153494842848L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 根据旧的修饰符来设置新的修饰符。
| 序列化字段 |
|---|
x
int x
- The mouse event's x coordinate.
The x value is relative to the component that fired the event.
-
- 另请参见：
MouseEvent.getX()
y
int y
- The mouse event's y coordinate.
The y value is relative to the component that fired the event.
-
- 另请参见：
MouseEvent.getY()
clickCount
int clickCount
- Indicates the number of quick consecutive clicks of
a mouse button.
clickCount will be valid for only three mouse events :
MOUSE_CLICKED,MOUSE_PRESSEDandMOUSE_RELEASED. For the above, theclickCountwill be at least 1. For all other events the count will be 0.
button
int button
- Indicates which, if any, of the mouse buttons has changed state.
The only legal values are the following constants:
NOBUTTON,BUTTON1,BUTTON2orBUTTON3.
popupTrigger
boolean popupTrigger
- A property used to indicate whether a Popup Menu
should appear with a certain gestures.
If
popupTrigger=false, no popup menu should appear. If it istruethen a popup menu should appear.
| 类 java.awt.event.MouseWheelEvent 继承 MouseEvent 实现 Serializable |
|---|
| 序列化字段 |
|---|
scrollType
int scrollType
- Indicates what sort of scrolling should take place in response to this
event, based on platform settings. Legal values are:
- WHEEL_UNIT_SCROLL
- WHEEL_BLOCK_SCROLL
scrollAmount
int scrollAmount
- Only valid for scrollType WHEEL_UNIT_SCROLL.
Indicates number of units that should be scrolled per
click of mouse wheel rotation, based on platform settings.
wheelRotation
int wheelRotation
- Indicates how far the mouse wheel was rotated.
| 类 java.awt.event.PaintEvent 继承 ComponentEvent 实现 Serializable |
|---|
serialVersionUID: 1267492026433337593L
| 序列化字段 |
|---|
updateRect
Rectangle updateRect
- This is the rectangle that represents the area on the source
component that requires a repaint.
This rectangle should be non null.
| 类 java.awt.event.TextEvent 继承 AWTEvent 实现 Serializable |
|---|
serialVersionUID: 6269902291250941179L
| 类 java.awt.event.WindowEvent 继承 ComponentEvent 实现 Serializable |
|---|
serialVersionUID: -1567959133147912127L
| 序列化字段 |
|---|
oldState
int oldState
- TBS
newState
int newState
| 软件包 java.awt.font |
|---|
| 类 java.awt.font.NumericShaper 继承 Object 实现 Serializable |
|---|
| 序列化字段 |
|---|
key
int key
- 针对上下文成形的上下文索引，值的范围是 0 到 18
mask
int mask
- 此标志指示是否以上下文方式成形（高位），以及要成形哪些数字范围（0-18 位）
| 类 java.awt.font.TextAttribute 继承 AttributedCharacterIterator.Attribute 实现 Serializable |
|---|
serialVersionUID: 7744112784117861702L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws InvalidObjectException
- 将反序列化的实例解析成预定义常量。
| 类 java.awt.font.TransformAttribute 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3356247357827709530L
| 序列化方法 |
|---|
writeObject
private void writeObject(ObjectOutputStream s) throws ClassNotFoundException, IOException
| 序列化字段 |
|---|
transform
AffineTransform transform
- 此
TransformAttribute的AffineTransform；如果AffineTransform为恒等变换，则为null。
| 软件包 java.awt.geom |
|---|
| 类 java.awt.geom.AffineTransform 继承 Object 实现 Serializable |
|---|
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
writeObject
private void writeObject(ObjectOutputStream s) throws ClassNotFoundException, IOException
| 序列化字段 |
|---|
m00
double m00
- The X coordinate scaling element of the 3x3
affine transformation matrix.
-
m10
double m10
- The Y coordinate shearing element of the 3x3
affine transformation matrix.
-
m01
double m01
- The X coordinate shearing element of the 3x3
affine transformation matrix.
-
m11
double m11
- The Y coordinate scaling element of the 3x3
affine transformation matrix.
-
m02
double m02
- The X coordinate of the translation element of the
3x3 affine transformation matrix.
-
m12
double m12
- The Y coordinate of the translation element of the
3x3 affine transformation matrix.
-
| 类 java.awt.geom.IllegalPathStateException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.awt.geom.NoninvertibleTransformException 继承 Exception 实现 Serializable |
|---|
| 软件包 java.awt.image |
|---|
| 类 java.awt.image.ImagingOpException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.awt.image.RasterFormatException 继承 RuntimeException 实现 Serializable |
|---|
| 软件包 java.awt.image.renderable |
|---|
| 类 java.awt.image.renderable.ParameterBlock 继承 Object 实现 Serializable |
|---|
| 序列化字段 |
|---|
sources
Vector<E> sources
- 源的 Vector，存储为任意 Objects。
parameters
Vector<E> parameters
- 一个非源参数的 Vector，存储为任意 Object。
| 软件包 java.awt.print |
|---|
| 类 java.awt.print.PrinterAbortException 继承 PrinterException 实现 Serializable |
|---|
| 类 java.awt.print.PrinterException 继承 Exception 实现 Serializable |
|---|
| 类 java.awt.print.PrinterIOException 继承 PrinterException 实现 Serializable |
|---|
serialVersionUID: 5850870712125932846L
| 序列化字段 |
|---|
mException
IOException mException
- 终止打印作业的 IO 错误。
-
| 软件包 java.beans |
|---|
| 类 java.beans.IndexedPropertyChangeEvent 继承 PropertyChangeEvent 实现 Serializable |
|---|
| 序列化字段 |
|---|
index
int index
| 类 java.beans.IntrospectionException 继承 Exception 实现 Serializable |
|---|
| 类 java.beans.PropertyChangeEvent 继承 EventObject 实现 Serializable |
|---|
| 序列化字段 |
|---|
propertyName
String propertyName
- 已更改属性的名称。如果该名称未知，则为 null。
-
newValue
Object newValue
- 属性的新值。如果该值未知，则为 null。
-
oldValue
Object oldValue
- 属性以前的值。如果该值未知，则为 null。
-
propagationId
Object propagationId
- 传播 ID。可能为 null。
-
- 另请参见：
#getPropagationId.
| 类 java.beans.PropertyChangeSupport 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6401253773779951803L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列数据：
- Null terminated list of
PropertyChangeListeners。在进行序列化时，跳过不可序列化的侦听器，只序列化可序列化的侦听器。
- 抛出：
IOException
| 序列化字段 |
|---|
children
Hashtable<K,V> children
- 管理特定属性的侦听器的哈希表。将属性名称映射到 PropertyChangeSupport 对象。
-
- 从以下版本开始：
- 1.2
source
Object source
- 将作为所有已生成事件的“源”提供的对象。
-
propertyChangeSupportSerializedDataVersion
int propertyChangeSupportSerializedDataVersion
- 内部版本号
-
- 从以下版本开始：
| 类 java.beans.PropertyVetoException 继承 Exception 实现 Serializable |
|---|
| 序列化字段 |
|---|
evt
PropertyChangeEvent evt
- 描述所禁止的更改的 PropertyChangeEvent。
-
| 类 java.beans.VetoableChangeSupport 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5090210921595982017L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 序列数据：
- Null terminated list of
VetoableChangeListeners.在进行序列化时，跳过不可序列化的侦听器，只序列化可序列化的侦听器。
- 抛出：
IOException
| 序列化字段 |
|---|
children
Hashtable<K,V> children
- 管理特定属性的侦听器的哈希表。将属性名称映射到 VetoableChangeSupport 对象。
-
- 从以下版本开始：
- 1.2
source
Object source
- 将作为所有已生成事件的“源”而提供的对象。
-
vetoableChangeSupportSerializedDataVersion
int vetoableChangeSupportSerializedDataVersion
- 内部版本号
-
| 软件包 java.beans.beancontext |
|---|
| 类 java.beans.beancontext.BeanContextChildSupport 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6328947014421475877L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
- 恢复一个持久对象，必须等待后续 setBeanContext() 完全恢复从新的嵌套 BeanContext 中获得的所有资源
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 写入对象的持久状态。
- 抛出：
IOException
| 序列化字段 |
|---|
beanContextChildPeer
BeanContextChild beanContextChildPeer
- 在其中嵌套此
BeanContextChild的BeanContext。
pcSupport
PropertyChangeSupport pcSupport
- 与此 BeanContextChildSupport 相关联的 PropertyChangeSupport。
vcSupport
VetoableChangeSupport vcSupport
- 与此 BeanContextChildSupport 相关联的 VetoableChangeSupport。
| 类 java.beans.beancontext.BeanContextEvent 继承 EventObject 实现 Serializable |
|---|
| 序列化字段 |
|---|
propagatedFrom
BeanContext propagatedFrom
- 作为此事件的传播源的
BeanContext
| 类 java.beans.beancontext.BeanContextMembershipEvent 继承 BeanContextEvent 实现 Serializable |
|---|
| 序列化字段 |
|---|
children
Collection<E> children
- 受此事件通知影响的子级的列表。
| 类 java.beans.beancontext.BeanContextServiceAvailableEvent 继承 BeanContextEvent 实现 Serializable |
|---|
| 序列化字段 |
|---|
serviceClass
Class<T> serviceClass
- 新近可用服务的
Class引用
| 类 java.beans.beancontext.BeanContextServiceRevokedEvent 继承 BeanContextEvent 实现 Serializable |
|---|
| 序列化字段 |
|---|
serviceClass
Class<T> serviceClass
- 将被取消服务的
Class引用。
invalidateRefs
boolean invalidateRefs
| 类 java.beans.beancontext.BeanContextServicesSupport 继承 BeanContextSupport 实现 Serializable |
|---|
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
- 反序列化实例。
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 序列化实例。
- 抛出：
IOException
| 类 java.beans.beancontext.BeanContextServicesSupport.BCSSChild 继承 BeanContextSupport.BCSChild 实现 Serializable |
|---|
serialVersionUID: -3263851306889194873L
| 类 java.beans.beancontext.BeanContextServicesSupport.BCSSServiceProvider 继承 Object 实现 Serializable |
|---|
| 序列化字段 |
|---|
serviceProvider
BeanContextServiceProvider serviceProvider
| 类 java.beans.beancontext.BeanContextSupport 继承 BeanContextChildSupport 实现 Serializable |
|---|
serialVersionUID: -4879613978649577204L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
- 反序列化内容。如果此实例有截然不同的同位体，则子级在这里“不”被序列化，同位体的 readObject() 必须在反序列化此实例之后调用 readChildren()。
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException, ClassNotFoundException
- 序列化 BeanContextSupport，如果此实例有一个截然不同的同位体（即此对象正充当另一个对象的代理），则此实例的子级在这里不被序列化，因为在序列化此实例的同时反序列化其子级会产生“先有鸡还是先有蛋”的问题。
所以，在具有此实例的截然不同同位体的情况下，应该总是在调用 writeObject() 之后调用 writeChildren()，并在调用 readObject() 之后调用 readChildren()。
| 序列化字段 |
|---|
serializable
int serializable
locale
Locale locale
- 此 BeanContext 的当前语言环境。
okToUseGui
boolean okToUseGui
- 指示此实例现在能否呈现 GUI 的 boolean 值。
designTime
boolean designTime
- 指示此对象目前是否处于设计时间模式下的 boolean 值。
| 类 java.beans.beancontext.BeanContextSupport.BCSChild 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5815286101609939109L
| 序列化字段 |
|---|
child
Object child
proxyPeer
Object proxyPeer
| 软件包 java.io |
|---|
| 类 java.io.CharConversionException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.EOFException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.File 继承 Object 实现 Serializable |
|---|
serialVersionUID: 301077366599181567L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject 来恢复此文件名。读取原有的分隔符字符。如果它于此系统上的分隔符字符不同，则使用本地分隔符替换原有的分隔符。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 调用 WriteObject 保存此文件名。还要保存分隔符字符，以便用不同主机类型重构该路径时可以对它进行替换。
- 抛出：
IOException
| 序列化字段 |
|---|
path
String path
- 此抽象路径名的规范化路径名字符串。规范化路径名字符串使用默认名称分隔符，并且不包含任何重复或多余的分隔符。
-
| 类 java.io.FileNotFoundException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.FilePermissionCollection 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: 2202956749081564585L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- "permissions" field (a Vector containing the FilePermissions).
- 抛出：
IOException
| 序列化字段 |
|---|
permissions
Vector<E> permissions
- A list of FilePermission objects.
| 类 java.io.InterruptedIOException 继承 IOException 实现 Serializable |
|---|
| 序列化字段 |
|---|
bytesTransferred
int bytesTransferred
- 报告 I/O 操作中断之前传输了其中多少字节。
-
| 类 java.io.InvalidClassException 继承 ObjectStreamException 实现 Serializable |
|---|
| 序列化字段 |
|---|
classname
String classname
- 无效类的名称。
- 无效类的名称。
| 类 java.io.InvalidObjectException 继承 ObjectStreamException 实现 Serializable |
|---|
| 类 java.io.IOException 继承 Exception 实现 Serializable |
|---|
| 类 java.io.NotActiveException 继承 ObjectStreamException 实现 Serializable |
|---|
| 类 java.io.NotSerializableException 继承 ObjectStreamException 实现 Serializable |
|---|
| 类 java.io.ObjectStreamClass 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6120832682080437368L
| 序列化字段 |
|---|
| 类 java.io.ObjectStreamException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.OptionalDataException 继承 ObjectStreamException 实现 Serializable |
|---|
| 序列化字段 |
|---|
length
int length
- 当前缓冲区中可读取的基本数据的字节数。
-
eof
boolean eof
- 如果流的缓冲部分不再有数据，则为 True。
-
| 类 java.io.SerializablePermission 继承 BasicPermission 实现 Serializable |
|---|
| 序列化字段 |
|---|
actions
String actions
| 类 java.io.StreamCorruptedException 继承 ObjectStreamException 实现 Serializable |
|---|
| 类 java.io.SyncFailedException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.UnsupportedEncodingException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.UTFDataFormatException 继承 IOException 实现 Serializable |
|---|
| 类 java.io.WriteAbortedException 继承 ObjectStreamException 实现 Serializable |
|---|
serialVersionUID: -3326426625597282442L
| 序列化字段 |
|---|
detail
Exception detail
- 在写入 ObjectStream 时捕获的异常。
此字段早于通用异常链设施。
Throwable.getCause()方法现在是获取此信息的首选方法。 -
| 软件包 java.lang |
|---|
| 类 java.lang.AbstractMethodError 继承 IncompatibleClassChangeError 实现 Serializable |
|---|
| 类 java.lang.ArithmeticException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.ArrayIndexOutOfBoundsException 继承 IndexOutOfBoundsException 实现 Serializable |
|---|
| 类 java.lang.ArrayStoreException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.AssertionError 继承 Error 实现 Serializable |
|---|
| 类 java.lang.Boolean 继承 Object 实现 Serializable |
|---|
serialVersionUID: -3665804199014368530L
| 序列化字段 |
|---|
value
boolean value
- 布尔值。
-
| 类 java.lang.Byte 继承 Number 实现 Serializable |
|---|
serialVersionUID: -7183698231559129828L
| 序列化字段 |
|---|
value
byte value
Byte的值。-
| 类 java.lang.Character 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3786198910865385080L
| 序列化字段 |
|---|
value
char value
Character的值。-
| 类 java.lang.Class 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3206093459760846163L
| 序列化概述 |
|---|
- Class 类是 Serialization Stream Protocol 中的一个特例。
Class 实例最初是以下列格式写入 ObjectOutputStream 的：
TC_CLASSClassDescriptor ClassDescriptor 是java.io.ObjectStreamClass实例的一个特殊序列化。- 另请参见：
ObjectStreamClass
| 序列化字段 |
|---|
| 类 java.lang.ClassCastException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.ClassCircularityError 继承 LinkageError 实现 Serializable |
|---|
| 类 java.lang.ClassFormatError 继承 LinkageError 实现 Serializable |
|---|
| 类 java.lang.ClassNotFoundException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 9176873029745254542L
| 序列化字段 |
|---|
ex
Throwable ex
- 如果使用 ClassNotFoundException(String s, Throwable ex) 构造方法来实例化对象，则此字段保持异常 ex。
-
- 从以下版本开始：
- 1.2
| 类 java.lang.CloneNotSupportedException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.Double 继承 Number 实现 Serializable |
|---|
serialVersionUID: -9172774392245257468L
| 序列化字段 |
|---|
value
double value
- Double 的值。
-
| 类 java.lang.Enum 继承 Object 实现 Serializable |
|---|
| 序列化字段 |
|---|
name
String name
- 此枚举常量的名称，在枚举声明中声明。大多数程序员应该使用
Enum.toString()方法，而不是访问此字段。
ordinal
int ordinal
| 类 java.lang.EnumConstantNotPresentException 继承 RuntimeException 实现 Serializable |
|---|
| 序列化字段 |
|---|
enumType
Class<T> enumType
- 缺少的枚举常量的类型。
constantName
String constantName
- 缺少的枚举常量的名称。
| 类 java.lang.Error 继承 Throwable 实现 Serializable |
|---|
serialVersionUID: 4980196508277280342L
| 类 java.lang.Exception 继承 Throwable 实现 Serializable |
|---|
serialVersionUID: -3387516993124229948L
| 类 java.lang.ExceptionInInitializerError 继承 LinkageError 实现 Serializable |
|---|
serialVersionUID: 1521711792217232256L
| 序列化字段 |
|---|
exception
Throwable exception
- 如果使用 ExceptionInInitializerError(Throwable thrown) 构造方法来实例化此对象，则该字段将保持异常
-
| 类 java.lang.Float 继承 Number 实现 Serializable |
|---|
serialVersionUID: -2671257302660747028L
| 序列化字段 |
|---|
value
float value
- Float 的值。
-
| 类 java.lang.IllegalAccessError 继承 IncompatibleClassChangeError 实现 Serializable |
|---|
| 类 java.lang.IllegalAccessException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.IllegalArgumentException 继承 RuntimeException 实现 Serializable |
|---|
serialVersionUID: -5365630128856068164L
| 类 java.lang.IllegalMonitorStateException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.IllegalStateException 继承 RuntimeException 实现 Serializable |
|---|
serialVersionUID: -1848914673093119416L
| 类 java.lang.IllegalThreadStateException 继承 IllegalArgumentException 实现 Serializable |
|---|
| 类 java.lang.IncompatibleClassChangeError 继承 LinkageError 实现 Serializable |
|---|
| 类 java.lang.IndexOutOfBoundsException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.InstantiationError 继承 IncompatibleClassChangeError 实现 Serializable |
|---|
| 类 java.lang.InstantiationException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.Integer 继承 Number 实现 Serializable |
|---|
serialVersionUID: 1360826667806852920L
| 序列化字段 |
|---|
value
int value
Integer的值。-
| 类 java.lang.InternalError 继承 VirtualMachineError 实现 Serializable |
|---|
| 类 java.lang.InterruptedException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.LinkageError 继承 Error 实现 Serializable |
|---|
| 类 java.lang.Long 继承 Number 实现 Serializable |
|---|
serialVersionUID: 4290774380558885855L
| 序列化字段 |
|---|
value
long value
Long的值。-
| 类 java.lang.NegativeArraySizeException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.NoClassDefFoundError 继承 LinkageError 实现 Serializable |
|---|
| 类 java.lang.NoSuchFieldError 继承 IncompatibleClassChangeError 实现 Serializable |
|---|
| 类 java.lang.NoSuchFieldException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.NoSuchMethodError 继承 IncompatibleClassChangeError 实现 Serializable |
|---|
| 类 java.lang.NoSuchMethodException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.NullPointerException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.Number 继承 Object 实现 Serializable |
|---|
serialVersionUID: -8742448824652078965L
| 类 java.lang.NumberFormatException 继承 IllegalArgumentException 实现 Serializable |
|---|
serialVersionUID: -2848938806368998894L
| 类 java.lang.OutOfMemoryError 继承 VirtualMachineError 实现 Serializable |
|---|
| 类 java.lang.RuntimeException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: -7034897190745766939L
| 类 java.lang.RuntimePermission 继承 BasicPermission 实现 Serializable |
|---|
serialVersionUID: 7399184964622342223L
| 类 java.lang.SecurityException 继承 RuntimeException 实现 Serializable |
|---|
serialVersionUID: 6878364983674394167L
| 类 java.lang.Short 继承 Number 实现 Serializable |
|---|
serialVersionUID: 7515723908773894738L
| 序列化字段 |
|---|
value
short value
Short值。-
| 类 java.lang.StackOverflowError 继承 VirtualMachineError 实现 Serializable |
|---|
| 类 java.lang.StackTraceElement 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6992337162326171013L
| 序列化字段 |
|---|
declaringClass
String declaringClass
methodName
String methodName
fileName
String fileName
lineNumber
int lineNumber
| 类 java.lang.String 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6849794470754667710L
| 序列化概述 |
|---|
- String 类被专门放入 Serialization Stream Protocol。
String 实例最初以如下格式被写入 ObjectOutputStream：
TC_STRING(utf String)DataOutput.writeUTF写入。生成一个新句柄以访问流中对此字符串实例的所有将来引用。
| 序列化字段 |
|---|
| 类 java.lang.StringBuffer 继承 java.lang.AbstractStringBuilder 实现 Serializable |
|---|
serialVersionUID: 3388685877147921107L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject，从流中恢复 StringBuffer 的状态。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 调用 readObject，从流中恢复 StringBuffer 的状态。
- 抛出：
IOException
| 序列化概述 |
|---|
- StringBuffer 的可序列化字段。
| 序列化字段 |
|---|
count
int count
- 该 StringBuffer 中的字符数。
shared
boolean shared
- 指示是否共享底层数组的标志。在反序列化时忽略该值。
value
char[] value
- 该 StringBuffer 的底层字符数组。
| 类 java.lang.StringBuilder 继承 java.lang.AbstractStringBuilder 实现 Serializable |
|---|
serialVersionUID: 4383685877147921099L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject，从流中恢复 StringBuffer 的状态。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 StringBuilder 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 当前存储在字符串生成器中的字符数（int），后跟字符串生成器中的字符（char[]）。char 数组的长度可能大于当前存储在字符串生成器中的字符数，在这种情况下，将忽略多出的字符。
- 抛出：
IOException
| 类 java.lang.StringIndexOutOfBoundsException 继承 IndexOutOfBoundsException 实现 Serializable |
|---|
| 类 java.lang.ThreadDeath 继承 Error 实现 Serializable |
|---|
| 类 java.lang.Throwable 继承 Object 实现 Serializable |
|---|
serialVersionUID: -3042686055658047285L
| 序列化方法 |
|---|
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 抛出：
IOException
| 序列化字段 |
|---|
detailMessage
String detailMessage
- 有关 Throwable 的详细信息。例如，对于 FileNotFoundException，这包含了无法找到的文件名称。
-
cause
Throwable cause
- 由此 throwable 引起的 throwable 被抛出，如果 throwable 未由其他 throwable 引起，或作为 cause 的 throwable 未知，则为空。如果此字段等于该 throwable 本身，它表示该 throwable 的 cause 尚未初始化。
-
- 从以下版本开始：
- 1.4
stackTrace
StackTraceElement[] stackTrace
- 堆栈跟踪，由
Throwable.getStackTrace()返回。 -
- 从以下版本开始：
- 1.4
| 类 java.lang.TypeNotPresentException 继承 RuntimeException 实现 Serializable |
|---|
| 序列化字段 |
|---|
typeName
String typeName
| 类 java.lang.UnknownError 继承 VirtualMachineError 实现 Serializable |
|---|
| 类 java.lang.UnsatisfiedLinkError 继承 LinkageError 实现 Serializable |
|---|
| 类 java.lang.UnsupportedClassVersionError 继承 ClassFormatError 实现 Serializable |
|---|
| 类 java.lang.UnsupportedOperationException 继承 RuntimeException 实现 Serializable |
|---|
serialVersionUID: -1242599979055084673L
| 类 java.lang.VerifyError 继承 LinkageError 实现 Serializable |
|---|
| 类 java.lang.VirtualMachineError 继承 Error 实现 Serializable |
|---|
| 软件包 java.lang.annotation |
|---|
| 类 java.lang.annotation.AnnotationFormatError 继承 Error 实现 Serializable |
|---|
| 类 java.lang.annotation.AnnotationTypeMismatchException 继承 RuntimeException 实现 Serializable |
|---|
| 序列化字段 |
|---|
element
Method element
- 注释元素的 Method 对象。
foundType
String foundType
- 在注释中找到的数据（错误）类型。该字符串可以，但不一定包含该值。字符串的确切格式没有指定。
| 类 java.lang.annotation.IncompleteAnnotationException 继承 RuntimeException 实现 Serializable |
|---|
| 序列化字段 |
|---|
annotationType
Class<T> annotationType
elementName
String elementName
| 软件包 java.lang.instrument |
|---|
| 类 java.lang.instrument.IllegalClassFormatException 继承 Exception 实现 Serializable |
|---|
| 类 java.lang.instrument.UnmodifiableClassException 继承 Exception 实现 Serializable |
|---|
| 软件包 java.lang.management |
|---|
| 类 java.lang.management.ManagementPermission 继承 BasicPermission 实现 Serializable |
|---|
| 软件包 java.lang.reflect |
|---|
| 类 java.lang.reflect.GenericSignatureFormatError 继承 ClassFormatError 实现 Serializable |
|---|
| 类 java.lang.reflect.InvocationTargetException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 4085088731926701167L
| 序列化字段 |
|---|
target
Throwable target
- 如果使用 InvocationTargetException(Throwable target) 构造方法来实例化该对象，则此字段将保持目标
-
| 类 java.lang.reflect.MalformedParameterizedTypeException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.lang.reflect.Proxy 继承 Object 实现 Serializable |
|---|
serialVersionUID: -2222568056686623797L
| 序列化字段 |
|---|
h
InvocationHandler h
- 此代理实例的调用处理程序。
-
| 类 java.lang.reflect.ReflectPermission 继承 BasicPermission 实现 Serializable |
|---|
serialVersionUID: 7412737110241507485L
| 类 java.lang.reflect.UndeclaredThrowableException 继承 RuntimeException 实现 Serializable |
|---|
serialVersionUID: 330127114055056639L
| 序列化字段 |
|---|
undeclaredThrowable
Throwable undeclaredThrowable
- 抛出的经过检查的未声明异常
-
| 软件包 java.math |
|---|
| 类 java.math.BigDecimal 继承 Number 实现 Serializable |
|---|
serialVersionUID: 6108874887143696463L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 BigDecimal 实例（也就是将其反序列化）。
| 序列化字段 |
|---|
intVal
BigInteger intVal
- 此 BigDecimal 的非标度值，由
BigDecimal.unscaledValue()返回。
scale
int scale
- 此 BigDecimal 的标度，由
BigDecimal.scale返回。 -
- 另请参见：
BigDecimal.scale
| 类 java.math.BigInteger 继承 Number 实现 Serializable |
|---|
serialVersionUID: -8287574255936472291L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重构 BigInteger 实例（也就是将其反序列化）。由于历史原因，该大小作为一个字节数组读入，但它被转换为一个 int 数组，并丢弃字节数组。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 BigInteger 实例保存到流。由于历史原因，BigInteger 的大小被序列化为一个字节数组。
- 序列数据：
- 将写入两个必需字段和一些过时字段，以便与较旧版本兼容。
- 抛出：
IOException
| 序列化概述 |
|---|
- BigInteger 的可序列化字段。
| 序列化字段 |
|---|
bitCount
int bitCount
- 此 BigInteger 中的位数
bitLength
int bitLength
- 此 BigInteger 最小的二进制补码表示形式的位数
lowestSetBit
int lowestSetBit
- 二进制补码表示形式的最低设置位
magnitude
int[] magnitude
- 此 BigInteger 的大小数组。
signum
int signum
- 此 BigInteger 的正负号。
| 类 java.math.MathContext 继承 Object 实现 Serializable |
|---|
serialVersionUID: 5579720004786848255L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 MathContext 实例（也就是将其反序列化）。
| 序列化字段 |
|---|
precision
int precision
- 某个操作使用的数位。值为 0 指示将使用无限精度（需要多少位就用多少位）。注意，前导零（在某个数的系数中）不是有效数字。
precision 始终为非负数。
-
roundingMode
RoundingMode roundingMode
- 某个操作使用的舍入算法。
-
- 另请参见：
RoundingMode
| 软件包 java.net |
|---|
| 类 java.net.BindException 继承 SocketException 实现 Serializable |
|---|
| 类 java.net.ConnectException 继承 SocketException 实现 Serializable |
|---|
| 类 java.net.HttpRetryException 继承 IOException 实现 Serializable |
|---|
| 序列化字段 |
|---|
responseCode
int responseCode
location
String location
| 类 java.net.Inet4Address 继承 InetAddress 实现 Serializable |
|---|
serialVersionUID: 3286316764910316507L
| 序列化方法 |
|---|
writeReplace
private Object writeReplace() throws ObjectStreamException
- 用 InetAddress 对象取代要序列化的对象。
- 抛出：
ObjectStreamException- 如果无法创建取代此对象的新对象
| 类 java.net.Inet6Address 继承 InetAddress 实现 Serializable |
|---|
serialVersionUID: 6880410070516793377L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 仅当范围接口名称在此系统上有效时，从包括范围信息的流还原此对象的状态。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 重写默认行为以便以 String 的形式，而不是以不可序列化的 NetworkInterface 的形式写入 scope_ifname 字段。
- 抛出：
IOException
| 序列化字段 |
|---|
ipaddress
byte[] ipaddress
- Holds a 128-bit (16 bytes) IPv6 address.
-
scope_id
int scope_id
- scope_id。创建对象时指定的范围。如果对象是使用接口名称创建的，则到需要时才确定 scope_id。
scope_id_set
boolean scope_id_set
- 当 scope_id 字段包含有效的整数 scope_id 时，将其设置为 true。
scope_ifname_set
boolean scope_ifname_set
- 在使用范围接口而不是数字范围 id 构造对象时设置。
ifname
String ifname
- 仅在序列化/反序列化期间才使用后跟字段
| 类 java.net.InetAddress 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3286316764910316507L
| 序列化方法 |
|---|
readResolve
private Object readResolve() throws ObjectStreamException
- 用 Inet4Address 对象取代反序列化对象。
- 抛出：
ObjectStreamException- 如果无法创建取代此对象的新对象
| 序列化字段 |
|---|
hostName
String hostName
address
int address
- Holds a 32-bit IPv4 address.
-
family
int family
- Specifies the address family type, for instance, '1' for IPv4
addresses, and '2' for IPv6 addresses.
-
| 类 java.net.InetSocketAddress 继承 SocketAddress 实现 Serializable |
|---|
serialVersionUID: 5076001401234631237L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
| 序列化字段 |
|---|
hostname
String hostname
addr
InetAddress addr
port
int port
| 类 java.net.MalformedURLException 继承 IOException 实现 Serializable |
|---|
| 类 java.net.NetPermission 继承 BasicPermission 实现 Serializable |
|---|
serialVersionUID: -8343910153355041693L
| 类 java.net.NoRouteToHostException 继承 SocketException 实现 Serializable |
|---|
| 类 java.net.PortUnreachableException 继承 SocketException 实现 Serializable |
|---|
| 类 java.net.ProtocolException 继承 IOException 实现 Serializable |
|---|
| 类 java.net.SocketAddress 继承 Object 实现 Serializable |
|---|
| 类 java.net.SocketException 继承 IOException 实现 Serializable |
|---|
| 类 java.net.SocketPermissionCollection 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: 2787186408602843674L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- "permissions" field (a Vector containing the SocketPermissions).
- 抛出：
IOException
| 序列化字段 |
|---|
permissions
Vector<E> permissions
- A list of the SocketPermissions for this set.
| 类 java.net.SocketTimeoutException 继承 InterruptedIOException 实现 Serializable |
|---|
| 类 java.net.UnknownHostException 继承 IOException 实现 Serializable |
|---|
| 类 java.net.UnknownServiceException 继承 IOException 实现 Serializable |
|---|
| 类 java.net.URI 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6052424284110960213L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream is) throws ClassNotFoundException, IOException
- 从给定的串行流重构 URI。
调用
ObjectInputStream.defaultReadObject()方法以读取 string 字段的值。然后按通常方式对结果进行解析。
writeObject
private void writeObject(ObjectOutputStream os) throws IOException
- 将此 URI 的内容保存到给定的串行流中。
URI 实例的惟一可序列化字段是 string 字段。如果该字段原来没有值，则给定一个值，然后调用给定对象输出流的
ObjectOutputStream.defaultWriteObject()方法。- 抛出：
IOException
| 序列化字段 |
|---|
string
String string
- 此 URI 的字符串表示形式。
-
| 类 java.net.URISyntaxException 继承 Exception 实现 Serializable |
|---|
| 序列化字段 |
|---|
input
String input
index
int index
| 类 java.net.URL 继承 Object 实现 Serializable |
|---|
serialVersionUID: -7627629688361524110L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject，以便从流中恢复 URL 的状态。它读取 URL 的各个组成部分并查找本地流处理程序。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 调用 WriteObject，将 URL 的状态保存到 ObjectOutputStream 中。不保存该处理程序，因为它特定于此系统。
- 序列数据：
- 默认的写入对象的值。当读取返回时，reader 必须确保调用的具有协议变量的 getURLStreamHandler 返回有效的 URLStreamHandler，如果返回无效的 URLStreamHandler，则抛出 IOException 异常。
- 抛出：
IOException
| 序列化字段 |
|---|
protocol
String protocol
- 要使用的协议（ftp、http、nntp，...等）。
-
host
String host
- 要连接的主机名。
-
port
int port
- 要连接的协议端口。
-
file
String file
- 相应主机上的指定文件名。
file定义的格式为path[?query] -
authority
String authority
- 此 URL 的授权部分。
-
ref
String ref
- # 引用。
-
hashCode
int hashCode
| 软件包 java.nio |
|---|
| 类 java.nio.BufferOverflowException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.nio.BufferUnderflowException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.nio.InvalidMarkException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.ReadOnlyBufferException 继承 UnsupportedOperationException 实现 Serializable |
|---|
| 软件包 java.nio.channels |
|---|
| 类 java.nio.channels.AlreadyConnectedException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.AsynchronousCloseException 继承 ClosedChannelException 实现 Serializable |
|---|
| 类 java.nio.channels.CancelledKeyException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.ClosedByInterruptException 继承 AsynchronousCloseException 实现 Serializable |
|---|
| 类 java.nio.channels.ClosedChannelException 继承 IOException 实现 Serializable |
|---|
| 类 java.nio.channels.ClosedSelectorException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.ConnectionPendingException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.FileLockInterruptionException 继承 IOException 实现 Serializable |
|---|
| 类 java.nio.channels.IllegalBlockingModeException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.IllegalSelectorException 继承 IllegalArgumentException 实现 Serializable |
|---|
| 类 java.nio.channels.NoConnectionPendingException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.NonReadableChannelException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.NonWritableChannelException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.NotYetBoundException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.NotYetConnectedException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.OverlappingFileLockException 继承 IllegalStateException 实现 Serializable |
|---|
| 类 java.nio.channels.UnresolvedAddressException 继承 IllegalArgumentException 实现 Serializable |
|---|
| 类 java.nio.channels.UnsupportedAddressTypeException 继承 IllegalArgumentException 实现 Serializable |
|---|
| 软件包 java.nio.charset |
|---|
| 类 java.nio.charset.CharacterCodingException 继承 IOException 实现 Serializable |
|---|
| 类 java.nio.charset.CoderMalfunctionError 继承 Error 实现 Serializable |
|---|
| 类 java.nio.charset.IllegalCharsetNameException 继承 IllegalArgumentException 实现 Serializable |
|---|
| 序列化字段 |
|---|
charsetName
String charsetName
| 类 java.nio.charset.MalformedInputException 继承 CharacterCodingException 实现 Serializable |
|---|
| 序列化字段 |
|---|
inputLength
int inputLength
| 类 java.nio.charset.UnmappableCharacterException 继承 CharacterCodingException 实现 Serializable |
|---|
| 序列化字段 |
|---|
inputLength
int inputLength
| 类 java.nio.charset.UnsupportedCharsetException 继承 IllegalArgumentException 实现 Serializable |
|---|
| 序列化字段 |
|---|
charsetName
String charsetName
| 软件包 java.rmi |
|---|
| 类 java.rmi.AccessException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 6314925228044966088L
| 类 java.rmi.AlreadyBoundException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 9218657361741657110L
| 类 java.rmi.ConnectException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 4863550261346652506L
| 类 java.rmi.ConnectIOException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -8087809532704668744L
| 类 java.rmi.MarshalException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 6223554758134037936L
| 类 java.rmi.MarshalledObject 继承 Object 实现 Serializable |
|---|
serialVersionUID: 8988374069173025854L
| 序列化字段 |
|---|
objBytes
byte[] objBytes
- 字节的序列化表示形式。如果
objBytes为null，则已编组的对象为null引用。
locBytes
byte[] locBytes
- 由
equals忽略的字节位置注释。如果locBytes为 null，则在编组过程中存在非null注释。
hash
int hash
- 所包含对象存储的哈希码。
| 类 java.rmi.NoSuchObjectException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 6619395951570472985L
| 类 java.rmi.NotBoundException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: -1857741824849069317L
| 类 java.rmi.RemoteException 继承 IOException 实现 Serializable |
|---|
serialVersionUID: -5148567311918794206L
| 序列化字段 |
|---|
detail
Throwable detail
- 远程异常的原因。
此字段早于通用异常链设施。
Throwable.getCause()方法现在是获取此信息的首选方法。 -
| 类 java.rmi.RMISecurityException 继承 SecurityException 实现 Serializable |
|---|
serialVersionUID: -8433406075740433514L
| 类 java.rmi.ServerError 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 8455284893909696482L
| 类 java.rmi.ServerException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -4775845313121906682L
| 类 java.rmi.ServerRuntimeException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 7054464920481467219L
| 类 java.rmi.StubNotFoundException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -7088199405468872373L
| 类 java.rmi.UnexpectedException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 1800467484195073863L
| 类 java.rmi.UnknownHostException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -8152710247442114228L
| 类 java.rmi.UnmarshalException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 594380845140740218L
| 软件包 java.rmi.activation |
|---|
| 类 java.rmi.activation.Activatable 继承 RemoteServer 实现 Serializable |
|---|
serialVersionUID: -3120617863591563455L
| 序列化字段 |
|---|
id
ActivationID id
- 此对象的激活标识符。
| 类 java.rmi.activation.ActivateFailedException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: 4863550261346652506L
| 类 java.rmi.activation.ActivationDesc 继承 Object 实现 Serializable |
|---|
serialVersionUID: 7455834104417690957L
| 序列化字段 |
|---|
groupID
ActivationGroupID groupID
- 组标识符
className
String className
- 对象的类名
location
String location
- 对象的代码基
data
MarshalledObject data
- 对象的初始化数据
restart
boolean restart
- 表示对象是否应当被重新启动。
| 类 java.rmi.activation.ActivationException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: -4320118837291406071L
| 序列化字段 |
|---|
detail
Throwable detail
- 激活异常的原因。
此字段早于通用异常链设施。
Throwable.getCause()方法现在是获取此信息的首选方法。 -
| 类 java.rmi.activation.ActivationGroup 继承 UnicastRemoteObject 实现 Serializable |
|---|
serialVersionUID: -7696947875314805420L
| 序列化字段 |
|---|
groupID
ActivationGroupID groupID
- 组标识符
monitor
ActivationMonitor monitor
- 组监视器
incarnation
long incarnation
- 组的代号
| 类 java.rmi.activation.ActivationGroup_Stub 继承 RemoteStub 实现 Serializable |
|---|
| 类 java.rmi.activation.ActivationGroupDesc 继承 Object 实现 Serializable |
|---|
serialVersionUID: -4936225423168276595L
| 序列化字段 |
|---|
className
String className
- 组的完全限定包的类名。
location
String location
- 要加载组类的位置。
data
MarshalledObject data
- 组的初始化数据。
env
ActivationGroupDesc.CommandEnvironment env
- 在另一个进程中执行 VM 的控制选项。
props
Properties props
- 一个将重写子进程环境中默认设置的属性映射表。
| 类 java.rmi.activation.ActivationGroupDesc.CommandEnvironment 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6165754737887770191L
| 序列化字段 |
|---|
command
String command
options
String[] options
| 类 java.rmi.activation.ActivationGroupID 继承 Object 实现 Serializable |
|---|
serialVersionUID: -1648432278909740833L
| 序列化字段 |
|---|
system
ActivationSystem system
- 组的激活系统。
uid
UID uid
- 组的惟一 id。
| 类 java.rmi.activation.ActivationID 继承 Object 实现 Serializable |
|---|
serialVersionUID: -4608673054848209235L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 针对自定义序列化的
readObject。此方法为此类读取此对象的序列化形式，方式如下：
readObject方法在in被调用，以读取此对象的惟一标识符（一个UID实例）。接下来，
readUTF方法在in上被调用，以读取此对象的激活器的RemoteRef实例的外部引用类型名称。然后，对应于外部引用类型名称（由readUTF返回），RemoteRef实例由一个特定于实现的类创建，并且readExternal方法在该RemoteRef实例上被调用，以读取对应于外部引用类型名称的外部形式。注：如果外部引用类型名称为
"UnicastRef"、"UnicastServerRef"、"UnicastRef2"、"UnicastServerRef2"或"ActivatableRef"，则必须找到对应的特定于实现的类，并且其readExternal方法必须为外部类型名称读取序列数据，正如指定将此类写入 serialData 文档一样。如果外部引用类型名称是任何其他字符串（长度不为零），则将抛出ClassNotFoundException，除非该实现提供了对应于外部引用类型名称的特定于实现的类，在这种情况下，RemoteRef将是特定于实现的类的一个实例。
writeObject
private void writeObject(ObjectOutputStream out) throws IOException, ClassNotFoundException
- 针对自定义序列化的
writeObject。此方法为此类写入此对象的序列化形式，方式如下：
传入此对象的惟一标识符（一个
UID实例）作为参数，writeObject方法在out上被调用。接下来，
getRefClass方法在激活器的RemoteRef实例上被调用，以获得其外部引用类型名称。然后，writeUTF方法使用getRefClass返回的值在out上被调用，接着writeExternal方法传递out作为参数在RemoteRef实例上被调用。- 序列数据：
- 此类的序列化数据组成一个
java.rmi.server.UID（用ObjectOutput.writeObject方法写入），后面紧跟激活器RemoteRef实例（用ObjectOutput.writeUTF写入的一个字符串）的外部类型名称，后面紧跟由其writeExternal方法写入的RemoteRef实例的外部形式。使用在
RemoteObject的writeObject方法serialData规范中指定的外部引用类型名称的定义来确定 RemoteRef 实例的外部引用类型名称。类似地，通过RemoteRef实现类的writeExternal方法写入和通过readExternal方法读取的数据对应于在RemoteObjectwriteObject方法 serialData 规范中指定的每一个已定义外部引用类型名称。 - 抛出：
IOExceptionClassNotFoundException
| 类 java.rmi.activation.UnknownGroupException 继承 ActivationException 实现 Serializable |
|---|
serialVersionUID: 7056094974750002460L
| 类 java.rmi.activation.UnknownObjectException 继承 ActivationException 实现 Serializable |
|---|
serialVersionUID: 3425547551622251430L
| 软件包 java.rmi.dgc |
|---|
| 类 java.rmi.dgc.Lease 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5713411624328831948L
| 序列化字段 |
|---|
vmid
VMID vmid
- 与此 Lease 关联的虚拟机 ID。
- 另请参见：
Lease.getVMID()
value
long value
- 此 lease 的期限。
- 另请参见：
Lease.getValue()
| 类 java.rmi.dgc.VMID 继承 Object 实现 Serializable |
|---|
serialVersionUID: -538642295484486218L
| 序列化字段 |
|---|
addr
byte[] addr
- 惟一地标识创建于其上的主机的字节数组
uid
UID uid
- 有关创建于其上的主机的惟一标识符
| 软件包 java.rmi.server |
|---|
| 类 java.rmi.server.ExportException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -9155485338494060170L
| 类 java.rmi.server.ObjID 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6386392263968365220L
| 序列化字段 |
|---|
objNum
long objNum
- object number
- 另请参见：
ObjID.hashCode()
space
UID space
- address space identifier (unique to host over time)
| 类 java.rmi.server.RemoteObject 继承 Object 实现 Serializable |
|---|
serialVersionUID: -3215090123894869218L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 用于自定义序列化的
readObject。此方法按以下方式读取该类的此对象的序列化形式：
在
in上调用readUTF方法来读取RemoteRef实例的外部 ref 类型名称，以将其填充到此对象的ref字段。如果readUTF返回的字符串长度为 0，则在in上调用readObject方法，然后将readObject返回的值转换为RemoteRef，并将此对象的ref字段设置为该值。否则，此对象的ref字段将设置为从与readUTF返回的外部 ref 类型名称相对应的特定于实现的类创建的RemoteRef实例，然后在此对象的ref字段上调用readExternal方法。如果外部 ref 类型名称为
"UnicastRef"、"UnicastServerRef"、"UnicastRef2"、"UnicastServerRef2"或"ActivatableRef"，则必须找到一个相应的特定于实现的类，并且其readExternal方法在指定要写入此类的 serialData 文档时必须读取外部 ref 类型名称的序列数据。如果外部 ref 类型名称是任何其他字符串（长度不是 0），则将抛出ClassNotFoundException，除非该实现提供相对于该外部 ref 类型名称的特定于实现的类，在这种情况下，将把此对象的ref字段设置为一个该特定于实现的类的实例。
writeObject
private void writeObject(ObjectOutputStream out) throws IOException, ClassNotFoundException
- 用于自定义序列化的
writeObject。此方法按以下方式写入该类的此对象的序列化形式：
在此对象的
ref字段上调用getRefClass方法，以获得其外部 ref 类型名称。如果getRefClass返回的值是长度大于 0 的非null字符串，则在具有getRefClass返回的值的out上调用writeUTF方法，然后在作为参数传递out的此对象的ref字段上调用writeExternal方法；否则，在具有 0 长度字符串 ("") 的out上调用writeUTF方法，然后在作为参数传递此对象的ref字段的out上调用writeObject方法。- 序列数据：
- 此类的序列化数据包含一个字符串（用
ObjectOutput.writeUTF写入），该字符串可以是包含的RemoteRef实例（ref字段）的外部 ref 类型名称，也可以是一个 0 长度字符串，如果该字符串的长度不是 0，则后跟writeExternal方法写入的ref字段的外部形式；如果该字符串的长度为 0，则后跟将其传递到序列化流的writeObject时写入的ref字段的序列化形式。如果此对象是一个从任何
UnicastRemoteObject.exportObject方法返回的RemoteStub或RemoteObjectInvocationHandler的实例，且未使用自定义套接字工厂，则外部 ref 类型名称为"UnicastRef"。 如果此对象是一个从任何UnicastRemoteObject.exportObject方法返回的RemoteStub或RemoteObjectInvocationHandler的实例，且使用自定义套接字工厂，则外部 ref 类型名称为"UnicastRef2"。 如果此对象是一个从任何java.rmi.activation.Activatable.exportObject方法返回的RemoteStub或RemoteObjectInvocationHandler的实例，则外部 ref 类型名称为"ActivatableRef"。 如果此对象是一个从RemoteObject.toStub方法返回的RemoteStub或RemoteObjectInvocationHandler的实例（并且传入toStub的参数本身不是RemoteStub），则外部 ref 类型名称是一个传入toStub的远程对象的导出方式的函数，如上所述。 如果此对象是一个最初通过反序列化创建的RemoteStub或RemoteObjectInvocationHandler的实例，则外部 ref 类型名称与此对象进行反序列化时读取的类型名称相同。如果此对象是一个未使用自定义套接字工厂的
java.rmi.server.UnicastRemoteObject的实例，则外部 ref 类型名称为"UnicastServerRef"。 如果此对象是一个使用自定义套接字工厂的UnicastRemoteObject实例，则外部 ref 类型名称为"UnicastServerRef2"。下面是必须由
writeExternal方法写入且由RemoteRef实现类的readExternal方法读取的数据，该实现类对应于每个定义的外部 ref 类型名称：对于
"UnicastRef"：- 引用的远程对象的主机名，由
DataOutput.writeUTF(String)写入 - 引用的远程对象的端口，由
DataOutput.writeInt(int)写入 - 作为引用中包含的
ObjID实例上调用 {link java.rmi.server.ObjID#write(java.io.ObjectOutput)} 的结果写入的数据 - boolean 值
false，由DataOutput.writeBoolean(boolean)写入
对于具有
null客户机套接字工厂的"UnicastRef2"：- 字节值
0x00（指示null客户机套接字工厂），由DataOutput.writeByte(int)写入 - 引用的远程对象的主机名，由
DataOutput.writeUTF(String)写入 - 引用的远程对象的端口，由
DataOutput.writeInt(int)写入 - 作为引用中包含的
ObjID实例上调用 {link java.rmi.server.ObjID#write(java.io.ObjectOutput)} 的结果写入的数据 - boolean 值
false，由DataOutput.writeBoolean(boolean)写入
对于具有非
null客户机套接字工厂的"UnicastRef2"：- 字节值
0x01（指示非null客户机套接字工厂），由DataOutput.writeByte(int)写入 - 引用的远程对象的主机名，由
DataOutput.writeUTF(String)写入 - 引用的远程对象的端口，由
DataOutput.writeInt(int)写入 - 客户机套接字工厂（类型
java.rmi.server.RMIClientSocketFactory的对象），通过将其传递到流实例上的writeObject的调用写入 - 作为引用中包含的
ObjID实例上调用 {link java.rmi.server.ObjID#write(java.io.ObjectOutput)} 的结果写入的数据 - boolean 值
false，由DataOutput.writeBoolean(boolean)写入
对于具有
null嵌入远程引用的"ActivatableRef"：java.rmi.activation.ActivationID的实例，通过将其传递到流实例上的writeObject的调用写入- 0 长度字符串 (
"")，由DataOutput.writeUTF(String)写入
对于具有非
null嵌入远程引用的"ActivatableRef"：java.rmi.activation.ActivationID的实例，通过将其传递到流实例上的writeObject的调用写入- 嵌入的远程引用的外部 ref 类型名称（必须是
"UnicastRef2"），由DataOutput.writeUTF(String)写入 - 嵌入的远程引用的外部形式，通过调用其具有流实例的
writeExternal方法写入（请参阅上述"UnicastRef2"的外部形式的描述）
对于
"UnicastServerRef"和"UnicastServerRef2"，不能通过writeExternal方法写入数据，也不能通过readExternal方法读取数据。 - 引用的远程对象的主机名，由
- 抛出：
IOExceptionClassNotFoundException
| 类 java.rmi.server.RemoteObjectInvocationHandler 继承 RemoteObject 实现 Serializable |
|---|
serialVersionUID: 2L
| 序列化方法 |
|---|
readObjectNoData
private void readObjectNoData()
throws InvalidObjectException
- 抛出：
InvalidObjectException- 无条件抛出
| 类 java.rmi.server.RemoteServer 继承 RemoteObject 实现 Serializable |
|---|
serialVersionUID: -4100238210092549637L
| 类 java.rmi.server.RemoteStub 继承 RemoteObject 实现 Serializable |
|---|
serialVersionUID: -1585587260594494182L
| 类 java.rmi.server.ServerCloneException 继承 CloneNotSupportedException 实现 Serializable |
|---|
serialVersionUID: 6617456357664815945L
| 序列化字段 |
|---|
detail
Exception detail
- 异常原因。
此字段早于通用异常链设施。
Throwable.getCause()方法现在是获取此信息的首选方法。 -
| 类 java.rmi.server.ServerNotActiveException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 4687940720827538231L
| 类 java.rmi.server.SkeletonMismatchException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -7780460454818859281L
| 类 java.rmi.server.SkeletonNotFoundException 继承 RemoteException 实现 Serializable |
|---|
serialVersionUID: -7860299673822761231L
| 类 java.rmi.server.SocketSecurityException 继承 ExportException 实现 Serializable |
|---|
serialVersionUID: -7622072999407781979L
| 类 java.rmi.server.UID 继承 Object 实现 Serializable |
|---|
serialVersionUID: 1086053664494604050L
| 序列化字段 |
|---|
unique
int unique
- 惟一标识此
UID在其中生成的 VM 的数字，该数字和主机和给定的时间有关 -
time
long time
- 此
UID在其中生成的 VM 处于活动状态时的时间（由System.currentTimeMillis()返回） -
count
short count
- 用来区分按同一时间在同一 VM 中创建的
UID实例的 16 位数字 -
| 类 java.rmi.server.UnicastRemoteObject 继承 RemoteServer 实现 Serializable |
|---|
serialVersionUID: 4974527148936298033L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 将远程对象进行反序列化时重新将其导出。
| 序列化字段 |
|---|
port
int port
- 要在其上导出对象的端口号
csf
RMIClientSocketFactory csf
- 客户端套接字工厂（如果有）
ssf
RMIServerSocketFactory ssf
- 导出对象时使用的服务器端套接字工厂（如果有）
| 软件包 java.security |
|---|
| 类 java.security.AccessControlException 继承 SecurityException 实现 Serializable |
|---|
serialVersionUID: 5138225684096988535L
| 序列化字段 |
|---|
perm
Permission perm
| 类 java.security.AllPermissionCollection 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: -4023755556366636806L
| 序列化字段 |
|---|
all_allowed
boolean all_allowed
| 类 java.security.AuthProvider 继承 Provider 实现 Serializable |
|---|
| 类 java.security.BasicPermission 继承 Permission 实现 Serializable |
|---|
serialVersionUID: 6279438298436773498L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject，从流中恢复 BasicPermission 的状态。
| 类 java.security.BasicPermissionCollection 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: 739301742472979399L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- readObject is called to restore the state of the
BasicPermissionCollection from a stream.
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- Default fields.
- 抛出：
IOException
| 序列化字段 |
|---|
all_allowed
boolean all_allowed
- This is set to
trueif this BasicPermissionCollection contains a BasicPermission with '*' as its permission name.
permClass
Class<T> permClass
- The class to which all BasicPermissions in this BasicPermissionCollection belongs.
permissions
Hashtable<K,V> permissions
- The BasicPermissions in this BasicPermissionCollection. All BasicPermissions in the collection must belong to the same class. The Hashtable is indexed by the BasicPermission name; the value of the Hashtable entry is the permission.
| 类 java.security.CodeSigner 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6819288105193937581L
| 序列化字段 |
|---|
signerCertPath
CertPath signerCertPath
- 签名者的证书路径。
-
timestamp
Timestamp timestamp
| 类 java.security.CodeSource 继承 Object 实现 Serializable |
|---|
serialVersionUID: 4977541819976013951L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
- 从流还原此对象（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 将此对象写出到流中（也就是将其序列化）。
- 序列数据：
- 初始
URL后跟一个int，指示要遵守的证书数（值“零”表示不存在与此对象关联的证书）。所有证书的撰写都以表示证书类型的String开头，后跟一个指定证书编码长度的int，再后跟作为字节数组写出的证书编码本身。最后，如果出现代码签名者，则同时序列化和写出代码签名者的数组。 - 抛出：
IOException
| 序列化字段 |
|---|
location
URL location
- 代码位置。
-
| 类 java.security.DigestException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 5821450303093652515L
| 类 java.security.GeneralSecurityException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 894798122053539237L
| 类 java.security.GuardedObject 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5240450096227834308L
| 序列化方法 |
|---|
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 将此对象写出到流中（即将其序列化）。如果存在 guard，则检查它。
- 抛出：
IOException
| 序列化字段 |
|---|
object
Object object
guard
Guard guard
| 类 java.security.Identity 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3609922007826600659L
| 序列化字段 |
|---|
name
String name
- 已过时。
- 此 Identity 的名称。
- 此 Identity 的名称。
-
publicKey
PublicKey publicKey
- 已过时。
- 此 Identity 的公钥。
- 此 Identity 的公钥。
-
info
String info
- 已过时。
- Generic, descriptive information about the identity.
- Generic, descriptive information about the identity.
-
scope
IdentityScope scope
- 已过时。
- The scope of the identity.
- The scope of the identity.
-
certificates
Vector<E> certificates
- 已过时。
- The certificates for this identity.
- The certificates for this identity.
-
| 类 java.security.IdentityScope 继承 Identity 实现 Serializable |
|---|
serialVersionUID: -2337346281189773310L
| 类 java.security.InvalidAlgorithmParameterException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 2864672297499471472L
| 类 java.security.InvalidKeyException 继承 KeyException 实现 Serializable |
|---|
serialVersionUID: 5698479920593359816L
| 类 java.security.InvalidParameterException 继承 IllegalArgumentException 实现 Serializable |
|---|
serialVersionUID: -857968536935667808L
| 类 java.security.KeyException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -7483676942812432108L
| 类 java.security.KeyManagementException 继承 KeyException 实现 Serializable |
|---|
serialVersionUID: 947674216157062695L
| 类 java.security.KeyPair 继承 Object 实现 Serializable |
|---|
serialVersionUID: -7565189502268009837L
| 序列化字段 |
|---|
privateKey
PrivateKey privateKey
publicKey
PublicKey publicKey
| 类 java.security.KeyRep 继承 Object 实现 Serializable |
|---|
serialVersionUID: -4757683898830641853L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws ObjectStreamException
- 解析 Key 对象。
此方法支持三种 Type/format 组合：
- Type.SECRET/"RAW" - 返回使用编码的密钥字节和算法构建的 SecretKeySpec 对象
- Type.PUBLIC/"X.509" - 获取该密钥算法的 KeyFactory 实例，用编码的密钥字节构建 X509EncodedKeySpec，根据 spec 生成公钥
- Type.PRIVATE/"PKCS#8" - 获取该密钥算法的 KeyFactory 实例，用编码的密钥字节构造 PKCS8EncodedKeySpec，根据 spec 生成私钥
- 抛出：
NotSerializableException- 如果 Type/format 组合是不能识别的；如果算法、密钥格式或编码的密钥字节是不能识别的/无效的；如果由于任何原因密钥解析失败。ObjectStreamException
| 序列化字段 |
|---|
type
KeyRep.Type type
- Type.SECRET、Type.PUBLIC 或 Type.PRIVATE 之一。
-
algorithm
String algorithm
- Key 算法
-
format
String format
- Key 编码格式
-
encoded
byte[] encoded
- 编码的 Key 的字节
-
| 类 java.security.KeyStoreException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -1119353179322377262L
| 类 java.security.NoSuchAlgorithmException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -7443947487218346562L
| 类 java.security.NoSuchProviderException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 8488111756688534474L
| 类 java.security.Permission 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5636570222231596674L
| 序列化字段 |
|---|
name
String name
| 类 java.security.PermissionCollection 继承 Object 实现 Serializable |
|---|
serialVersionUID: -6727011328946861783L
| 序列化字段 |
|---|
readOnly
boolean readOnly
| 类 java.security.PermissionsHash 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: -8491988220802933440L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- Default fields.
- 抛出：
IOException
| 序列化字段 |
|---|
perms
Hashtable<K,V> perms
- A table of the Permissions (both key and value are same).
| 类 java.security.PrivilegedActionException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 4724086851538908602L
| 序列化字段 |
|---|
exception
Exception exception
| 类 java.security.Provider 继承 Properties 实现 Serializable |
|---|
serialVersionUID: -4298000515446427739L
| 序列化字段 |
|---|
name
String name
- provider 名称
-
info
String info
- provider 及其服务的描述。
-
version
double version
- provider 版本号。
-
| 类 java.security.ProviderException 继承 RuntimeException 实现 Serializable |
|---|
serialVersionUID: 5256023526693665674L
| 类 java.security.SecureRandom 继承 Random 实现 Serializable |
|---|
serialVersionUID: 4940670005562187L
| 序列化字段 |
|---|
provider
Provider provider
- 提供程序。
-
- 从以下版本开始：
- 1.2
secureRandomSpi
SecureRandomSpi secureRandomSpi
- 提供程序实现。
-
- 从以下版本开始：
- 1.2
algorithm
String algorithm
state
byte[] state
digest
MessageDigest digest
randomBytes
byte[] randomBytes
- 我们知道，MessageDigest 类不实现 java.io.Serializable。但由于不再使用此字段，所以它始终为 NULL，不会影响 SecureRandom 类本身的序列化。
randomBytesUsed
int randomBytesUsed
counter
long counter
| 类 java.security.SecureRandomSpi 继承 Object 实现 Serializable |
|---|
serialVersionUID: -2991854161009191830L
| 类 java.security.SecurityPermission 继承 BasicPermission 实现 Serializable |
|---|
serialVersionUID: 5236109936224050470L
| 类 java.security.SignatureException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 7509989324975124438L
| 类 java.security.SignedObject 继承 Object 实现 Serializable |
|---|
serialVersionUID: 720502720485447167L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject，从流中恢复 SignedObject 的状态。
| 序列化字段 |
|---|
content
byte[] content
signature
byte[] signature
thealgorithm
String thealgorithm
| 类 java.security.Signer 继承 Identity 实现 Serializable |
|---|
serialVersionUID: -1763464102261361480L
| 序列化字段 |
|---|
privateKey
PrivateKey privateKey
- 已过时。
- signer 的私钥。
- signer 的私钥。
-
| 类 java.security.Timestamp 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5502683707821851294L
| 序列化字段 |
|---|
timestamp
Date timestamp
- 时间戳的日期和时间
-
signerCertPath
CertPath signerCertPath
- TSA 的证书路径。
-
| 类 java.security.UnrecoverableEntryException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -4527142945246286535L
| 类 java.security.UnrecoverableKeyException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 7275063078190151277L
| 类 java.security.UnresolvedPermission 继承 Permission 实现 Serializable |
|---|
serialVersionUID: -4821973115467008846L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
- 从流还原此对象（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 将此对象写入流中（也就是将其序列化）。
- 序列数据：
- 初始
String（表示type）后跟一个String（表示name），其后又跟一个String（表示actions），它后面又跟一个int，指示要使用的证书数量；如果该值为“零”，则表示没有与此对象相关的证书。每个证书的编写都从一个表示证书类型的String开始，其后是int，用来指定证书编码的长度，再向后是以字节数组形式写出的证书编码本身。 - 抛出：
IOException
| 序列化字段 |
|---|
type
String type
- 解析此未解析的权限时将创建 Permission 类的类名称。
-
name
String name
- 权限名称。
-
actions
String actions
- 对权限的操作。
-
| 类 java.security.UnresolvedPermissionCollection 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: -7176153071733132400L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- Default field.
- 抛出：
IOException
| 序列化字段 |
|---|
permissions
Hashtable<K,V> permissions
- A table of the UnresolvedPermissions keyed on type, value is Vector of permissions
| 软件包 java.security.acl |
|---|
| 类 java.security.acl.AclNotFoundException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: 5684295034092681791L
| 类 java.security.acl.LastOwnerException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: -5141997548211140359L
| 类 java.security.acl.NotOwnerException 继承 Exception 实现 Serializable |
|---|
serialVersionUID: -5555597911163362399L
| 软件包 java.security.cert |
|---|
| 类 java.security.cert.Certificate 继承 Object 实现 Serializable |
|---|
serialVersionUID: -3585440601605666277L
| 序列化方法 |
|---|
writeReplace
protected Object writeReplace() throws ObjectStreamException
- 替换要被序列化的 Certificate。
- 抛出：
ObjectStreamException- 如果新对象表示无法创建此 Certificate
| 序列化字段 |
|---|
type
String type
| 类 java.security.cert.Certificate.CertificateRep 继承 Object 实现 Serializable |
|---|
serialVersionUID: -8563758940495660020L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws ObjectStreamException
- 解析该 Certificate 对象。
- 抛出：
ObjectStreamException- 如果无法解析该 Certificate
| 序列化字段 |
|---|
type
String type
data
byte[] data
| 类 java.security.cert.CertificateEncodingException 继承 CertificateException 实现 Serializable |
|---|
serialVersionUID: 6219492851589449162L
| 类 java.security.cert.CertificateException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 3192535253797119798L
| 类 java.security.cert.CertificateExpiredException 继承 CertificateException 实现 Serializable |
|---|
serialVersionUID: 9071001339691533771L
| 类 java.security.cert.CertificateNotYetValidException 继承 CertificateException 实现 Serializable |
|---|
serialVersionUID: 4355919900041064702L
| 类 java.security.cert.CertificateParsingException 继承 CertificateException 实现 Serializable |
|---|
serialVersionUID: -7989222416793322029L
| 类 java.security.cert.CertPath 继承 Object 实现 Serializable |
|---|
serialVersionUID: 6068470306649138683L
| 序列化方法 |
|---|
writeReplace
protected Object writeReplace() throws ObjectStreamException
- 使用
CertPathRep对象替换要被序列化的CertPath。- 抛出：
ObjectStreamException- 如果不能创建表示此证书路径的CertPathRep对象
| 序列化字段 |
|---|
type
String type
| 类 java.security.cert.CertPath.CertPathRep 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3015633072427920915L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws ObjectStreamException
- 返回根据类型和数据所构造的
CertPath。- 抛出：
ObjectStreamException- 如果无法构造CertPath
| 序列化字段 |
|---|
type
String type
- Certificate 类型。
data
byte[] data
- CertPath 的编码形式。
| 类 java.security.cert.CertPathBuilderException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 5316471420178794402L
| 类 java.security.cert.CertPathValidatorException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -3083180014971893139L
| 序列化字段 |
|---|
index
int index
- 导致该异常抛出的证书在证书路径中的索引
certPath
CertPath certPath
- 异常抛出时所验证的
CertPath
| 类 java.security.cert.CertStoreException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 2395296107471573245L
| 类 java.security.cert.CRLException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -6694728944094197147L
| 类 java.security.cert.X509Certificate 继承 Certificate 实现 Serializable |
|---|
serialVersionUID: -2491127588187038216L
| 软件包 java.security.interfaces |
|---|
| 软件包 java.security.spec |
|---|
| 类 java.security.spec.InvalidKeySpecException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: 3546139293998810778L
| 类 java.security.spec.InvalidParameterSpecException 继承 GeneralSecurityException 实现 Serializable |
|---|
serialVersionUID: -970468769593399342L
| 软件包 java.sql |
|---|
| 类 java.sql.BatchUpdateException 继承 SQLException 实现 Serializable |
|---|
| 序列化字段 |
|---|
updateCounts
int[] updateCounts
- 描述批处理执行结果的数组。
-
- 从以下版本开始：
- 1.2
| 类 java.sql.DataTruncation 继承 SQLWarning 实现 Serializable |
|---|
| 序列化字段 |
|---|
index
int index
parameter
boolean parameter
read
boolean read
dataSize
int dataSize
transferSize
int transferSize
| 类 java.sql.Date 继承 Date 实现 Serializable |
|---|
serialVersionUID: 1511598038487230103L
| 类 java.sql.SQLException 继承 Exception 实现 Serializable |
|---|
| 序列化字段 |
|---|
SQLState
String SQLState
vendorCode
int vendorCode
next
SQLException next
| 类 java.sql.SQLPermission 继承 BasicPermission 实现 Serializable |
|---|
serialVersionUID: -1439323187199563495L
| 类 java.sql.SQLWarning 继承 SQLException 实现 Serializable |
|---|
| 类 java.sql.Time 继承 Date 实现 Serializable |
|---|
serialVersionUID: 8397324403548013681L
| 类 java.sql.Timestamp 继承 Date 实现 Serializable |
|---|
serialVersionUID: 2745179027874758501L
| 序列化字段 |
|---|
nanos
int nanos
| 软件包 java.text |
|---|
| 类 java.text.AttributedCharacterIterator.Attribute 继承 Object 实现 Serializable |
|---|
serialVersionUID: -9142742483513960612L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws InvalidObjectException
- 解析将被反序列化为预定义常量的实例。
| 序列化字段 |
|---|
name
String name
- 属性的名称。名称主要由 readResolve 方法在反序列化一个实例时用于查找相应的预定义实例。
-
| 类 java.text.ChoiceFormat 继承 NumberFormat 实现 Serializable |
|---|
serialVersionUID: 1795184449645032964L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从输入流读取一个对象后，进行简单的验证，以维护类的不变量。
- 抛出：
InvalidObjectException- 如果从该流读取的对象无效。IOExceptionClassNotFoundException
| 序列化字段 |
|---|
choiceLimits
double[] choiceLimits
- choice 的较低边界的列表。如果正在格式化的数大于或等于
choiceLimits[i]且小于choiceLimits[i+1]，则该 formatter 将返回choiceFormats[i]。 -
choiceFormats
String[] choiceFormats
- choice 字符串列表。如果正在格式化的数大于或等于
choiceLimits[i]且小于choiceLimits[i+1]，则该 formatter 将返回choiceFormats[i]。 -
| 类 java.text.DateFormat 继承 Format 实现 Serializable |
|---|
serialVersionUID: 7218322306649953788L
| 序列化字段 |
|---|
calendar
Calendar calendar
DateFormat使用 calendar 来生成实现日期和时间格式化所需的时间字段值。子类应将此 calendar 初始化为适合于与此DateFormat关联的语言环境的日历。-
numberFormat
NumberFormat numberFormat
- 数字 formatter，
DateFormat用其来格式化日期和时间中的数字。子类应将此 numberFormat 初始化为适合于与此DateFormat关联的语言环境的数字格式。 -
| 类 java.text.DateFormat.Field 继承 Format.Field 实现 Serializable |
|---|
serialVersionUID: 7441350119349544720L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws InvalidObjectException
- 将反序列化的实例解析成预定义的常量。
- 抛出：
InvalidObjectException- 如果无法解析该常量。
| 序列化字段 |
|---|
calendarField
int calendarField
- Calendar 字段。
| 类 java.text.DateFormatSymbols 继承 Object 实现 Serializable |
|---|
serialVersionUID: -5987973545549424702L
| 序列化字段 |
|---|
eras
String[] eras
- Era strings. For example: "AD" and "BC". An array of 2 strings,
indexed by
Calendar.BCandCalendar.AD. -
months
String[] months
- Month strings. For example: "January", "February", etc. An array
of 13 strings (some calendars have 13 months), indexed by
Calendar.JANUARY,Calendar.FEBRUARY, etc. -
shortMonths
String[] shortMonths
- Short month strings. For example: "Jan", "Feb", etc. An array of
13 strings (some calendars have 13 months), indexed by
Calendar.JANUARY,Calendar.FEBRUARY, etc. -
weekdays
String[] weekdays
- Weekday strings. For example: "Sunday", "Monday", etc. An array
of 8 strings, indexed by
Calendar.SUNDAY,Calendar.MONDAY, etc. The elementweekdays[0]is ignored. -
shortWeekdays
String[] shortWeekdays
- Short weekday strings. For example: "Sun", "Mon", etc. An array
of 8 strings, indexed by
Calendar.SUNDAY,Calendar.MONDAY, etc. The elementshortWeekdays[0]is ignored. -
ampms
String[] ampms
- AM and PM strings. For example: "AM" and "PM". An array of
2 strings, indexed by
Calendar.AMandCalendar.PM. -
zoneStrings
String[][] zoneStrings
- Localized names of time zones in this locale. This is a
two-dimensional array of strings of size n by m,
where m is at least 5. Each of the n rows is an
entry containing the localized names for a single
TimeZone. Each such row contains (withiranging from 0..n-1):zoneStrings[i][0]- time zone IDzoneStrings[i][1]- long name of zone in standard timezoneStrings[i][2]- short name of zone in standard timezoneStrings[i][3]- long name of zone in daylight savings timezoneStrings[i][4]- short name of zone in daylight savings time
-
- 另请参见：
TimeZone
localPatternChars
String localPatternChars
- Localized date-time pattern characters. For example, a locale may
wish to use 'u' rather than 'y' to represent years in its date format
pattern strings.
This string must be exactly 18 characters long, with the index of
the characters described by
DateFormat.ERA_FIELD,DateFormat.YEAR_FIELD, etc. Thus, if the string were "Xz...", then localized patterns would use 'X' for era and 'z' for year. -
| 类 java.text.DecimalFormat 继承 NumberFormat 实现 Serializable |
|---|
serialVersionUID: 864413376551465018L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 从流中读取默认的可序列化字段，并对较旧的序列化版本执行验证和调整。该验证和调整有：
-
验证超类的位数计数字段是否正确地反映了在除
BigInteger和BigDecimal对象之外的格式化数字上所施加的限制。这些限制存储在与较旧版本序列化兼容的超类中，而BigInteger和BigDecimal对象的限制也保存在此类中。在该超类中，如果最小或最大整数位数计数大于DOUBLE_INTEGER_DIGITS，或者最小或最大小数位数计数大于DOUBLE_FRACTION_DIGITS，则流数据无效并且此方法抛出InvalidObjectException。 -
如果
serialVersionOnStream小于 3，则为最小和最大整数和小数位数调用具有相应超类 getter 值的 setter，以初始化此类中的各个字段。此类中的各个字段是版本 3 的新字段。 -
如果
serialVersionOnStream小于 1，则指示该流是用 JDK 1.1 所编写的，初始化useExponentialNotation会得到 false，因为在 JDK 1.1 中没有它。 -
如果再次流出此对象，则可将
serialVersionOnStream设置为最大的允许值，以使默认的序列化可以正常工作。
版本早于 2 的流没有前后缀模式变量
posPrefixPattern等。所以将其初始化为null，这意味着前后缀字符串将采用字面量值。这正是我们想要的，因为这对应于早于版本 2 的版本行为。 -
验证超类的位数计数字段是否正确地反映了在除
| 序列化字段 |
|---|
positivePrefix
String positivePrefix
- 格式化正数时用作前缀的符号，例如 "+"。
positiveSuffix
String positiveSuffix
- 格式化正数时用作后缀的符号。这通常是一个空字符串。
negativePrefix
String negativePrefix
- 格式化负数时用作前缀的符号，例如 "-"。
negativeSuffix
String negativeSuffix
- 格式化负数时用作后缀的符号。这通常是一个空字符串。
posPrefixPattern
String posPrefixPattern
- 非负数的前缀模式。此变量对应于
positivePrefix。此模式由方法
expandAffix()对positivePrefix进行扩展得到，以更新后者从而反映symbols中的改变。如果此变量为null，则将positivePrefix用作字面量值，在symbols改变时不改变该值。对于从早于流版本 2 的流中恢复的DecimalFormat对象而言，此变量始终为null。 -
- 从以下版本开始：
- 1.3
posSuffixPattern
String posSuffixPattern
- 非负数的后缀模式。此变量对应于
positiveSuffix。此变量类似于posPrefixPattern；有关进一步的内容，请参见该变量。 -
- 从以下版本开始：
- 1.3
negPrefixPattern
String negPrefixPattern
- 负数的前缀模式。此变量对应于
negativePrefix。此变量类似于posPrefixPattern；有关进一步的内容，请参见该变量。 -
- 从以下版本开始：
- 1.3
negSuffixPattern
String negSuffixPattern
- 负数的后缀模式。此变量对应于
negativeSuffix。此变量类似于posPrefixPattern；有关进一步的内容，请参见该变量。 -
- 从以下版本开始：
- 1.3
multiplier
int multiplier
- 百分数、千分数等使用的乘数。
groupingSize
byte groupingSize
- 数的整数部分中分组分隔符之间的数字位数。如果
NumberFormat.groupingUsed为 true，则该值必须大于 0。
decimalSeparatorAlwaysShown
boolean decimalSeparatorAlwaysShown
- 如果为 true，则强制小数分隔符总是出现在已格式化的数中，即使数的小数部分为零也是如此。
parseBigDecimal
boolean parseBigDecimal
- 如果为 true，则只要有可能，分析就返回 BigDecimal。
-
- 从以下版本开始：
- 1.5
- 另请参见：
DecimalFormat.isParseBigDecimal()
symbols
DecimalFormatSymbols symbols
- 此格式使用的
DecimalFormatSymbols对象。它包含用于格式化数的符号，例如分组分隔符、小数分隔符等等。
useExponentialNotation
boolean useExponentialNotation
- 如果为 True，则在格式化数时强制使用指数（也就是科学）计数法。
-
- 从以下版本开始：
- 1.2
minExponentDigits
byte minExponentDigits
- 以科学计数法格式化数时，用于显示指数的最小数字位数。如果
useExponentialNotation不为 true，则忽略此字段。 -
- 从以下版本开始：
- 1.2
maximumIntegerDigits
int maximumIntegerDigits
BigInteger或BigDecimal的整数部分中所允许的最大数字位数。maximumIntegerDigits必须大于或等于minimumIntegerDigits。-
- 从以下版本开始：
- 1.5
- 另请参见：
DecimalFormat.getMaximumIntegerDigits()
minimumIntegerDigits
int minimumIntegerDigits
BigInteger或BigDecimal的整数部分中所允许的最小数字位数。minimumIntegerDigits必须小于或等于maximumIntegerDigits。-
- 从以下版本开始：
- 1.5
- 另请参见：
DecimalFormat.getMinimumIntegerDigits()
maximumFractionDigits
int maximumFractionDigits
BigInteger或BigDecimal的小数部分中所允许的最大数字位数。maximumFractionDigits必须大于或等于minimumFractionDigits。-
- 从以下版本开始：
- 1.5
- 另请参见：
DecimalFormat.getMaximumFractionDigits()
minimumFractionDigits
int minimumFractionDigits
BigInteger或BigDecimal的小数部分中所允许的最小数字位数。minimumFractionDigits必须小于或等于maximumFractionDigits。-
- 从以下版本开始：
- 1.5
- 另请参见：
DecimalFormat.getMinimumFractionDigits()
serialVersionOnStream
int serialVersionOnStream
- 声明写入何种版本的内部系列版本。可能的值为：
- 0（默认值）：Java 2 平台 v1.2 之前的版本
- 1：1.2 版本，包括两个新字段
useExponentialNotation和minExponentDigits。 - 2：1.3 和以后版本，添加了四个新字段：
posPrefixPattern、posSuffixPattern、negPrefixPattern和negSuffixPattern。 - 3：5 和以后版本，添加了五个新字段：
maximumIntegerDigits、minimumIntegerDigits、maximumFractionDigits、minimumFractionDigits和parseBigDecimal。
-
- 从以下版本开始：
- 1.2
| 类 java.text.DecimalFormatSymbols 继承 Object 实现 Serializable |
|---|
serialVersionUID: 5772796243397350300L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 读取默认的可序列化字段、为较旧系列版本的对象提供默认值，并对不可序列化的字段进行初始化。如果
serialVersionOnStream小于 1，则将monetarySeparator初始化为与decimalSeparator相同，并将exponential初始化为 'E'。如果serialVersionOnStream小于 2，则将locale初始化为根语言环境。如果再次流出此对象，则可将serialVersionOnStream设置回最大的允许值，以使默认的序列化可以正常工作。根据 intlCurrencySymbol 字段来初始化货币。- 抛出：
IOExceptionClassNotFoundException- 从以下版本开始：
- JDK 1.1.6
| 序列化字段 |
|---|
zeroDigit
char zeroDigit
- 用于零的字符。
groupingSeparator
char groupingSeparator
- 用于千位分隔符的字符。
decimalSeparator
char decimalSeparator
- 用于十进制符号的字符。
perMill
char perMill
- 用于千分数符号的字符。
percent
char percent
- 用于百分数符号的字符。
digit
char digit
- 用于某种模式中数字的字符。
patternSeparator
char patternSeparator
- 用于在模式中分隔正数和负数子模式的字符。
infinity
String infinity
- 用于表示无穷大的字符串。
NaN
String NaN
- 用于表示“非数字”的字符串。
minusSign
char minusSign
- 用于表示减号的字符。
currencySymbol
String currencySymbol
- 表示本地货币的字符串，如 "$"。
intlCurrencySymbol
String intlCurrencySymbol
- 表示本地货币的 ISO 4217 货币代码，如 "USD"。
monetarySeparator
char monetarySeparator
- 格式化货币值时使用的小数点。
-
- 从以下版本开始：
- JDK 1.1.6
- 另请参见：
DecimalFormatSymbols.getMonetaryDecimalSeparator()
exponential
char exponential
- 用于以指数计数法格式化数字时，区分数字中指数的字符，例如像数字 "1.23E45" 中的 'E'。
注意，公共的 API 没有提供设置此字段的方法，即使实现和流格式支持该设置也是如此。在以后会将该功能添加到 API 中。
-
- 从以下版本开始：
- JDK 1.1.6
locale
Locale locale
- 这些货币格式符号的语言环境。
-
- 从以下版本开始：
- 1.4
serialVersionOnStream
int serialVersionOnStream
- 描述流中存在的
DecimalFormatSymbols的版本。可能的值为：- 0（或未初始化的）：JDK 1.1.6 之前的版本。
- 1：使用 JDK 1.1.6 或更高版本所编写，包括两个新字段：
monetarySeparator和exponential。 - 2：使用 J2SE 1.4 或更高版本所编写，包括新的
locale字段。
DecimalFormatSymbols时，总是写入最新的格式（对应于允许的最高serialVersionOnStream）。 -
- 从以下版本开始：
- JDK 1.1.6
| 类 java.text.Format 继承 Object 实现 Serializable |
|---|
serialVersionUID: -299282585814624189L
| 类 java.text.Format.Field 继承 AttributedCharacterIterator.Attribute 实现 Serializable |
|---|
serialVersionUID: 276966692217360283L
| 类 java.text.MessageFormat 继承 Format 实现 Serializable |
|---|
serialVersionUID: 6479157306784022952L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从输入流中读取一个对象后，进行简单的验证以维护类常量。
- 抛出：
InvalidObjectException- 如果从流读入的对象无效。IOExceptionClassNotFoundException
| 序列化字段 |
|---|
locale
Locale locale
- 用于格式化数字和日期的语言环境。
-
pattern
String pattern
- 要插入格式化后的值的字符串。换句话说，这是对所有取出的 {} 表达式进行构造所提供的方法。
-
formats
Format[] formats
- 格式化程序的数组，它们用于对参数进行格式化。
-
offsets
int[] offsets
- 每个参数格式化结果要插入到模式中的位置。
-
argumentNumbers
int[] argumentNumbers
- 对应于每个格式化程序的参数个数。（格式化程序按照它们在模式中出现的顺序进行存储，而不是按照参数被指定的顺序）。
-
maxOffset
int maxOffset
- 比
offsets中的条目数少 1。也可以看作正被使用的offsets中的最高数字的元素的索引。所有这些数组必须具有与offsets相同个数的元素，因此该变量能够告知我们数组中有多少个条目。 -
| 类 java.text.MessageFormat.Field 继承 Format.Field 实现 Serializable |
|---|
serialVersionUID: 7899943957617360810L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws InvalidObjectException
- 把正被反序列化的实例解析为预定义的常量。
- 抛出：
InvalidObjectException- 如果常量无法解析。
| 类 java.text.NumberFormat 继承 Format 实现 Serializable |
|---|
serialVersionUID: -2308460125733713944L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 首先，读取默认的序列化数据。
然后，如果
serialVersionOnStream小于 1，指示流是用 JDK 1.1 编写的，则设置int字段（例如maximumIntegerDigits）等于byte字段（例如maxIntegerDigits），因为int字段在 JDK 1.1 中不存在。最后，将 serialVersionOnStream 重新设置为允许的最大值，这样如果此对象再次流出时，默认的序列化可以正常工作。如果
minimumIntegerDigits大于maximumIntegerDigits，或者minimumFractionDigits大于maximumFractionDigits，则流数据无效且此方法抛出InvalidObjectException。此外，如果这些值中的任何一个是负数，则此方法抛出InvalidObjectException。- 抛出：
IOExceptionClassNotFoundException- 从以下版本开始：
- 1.2
writeObject
private void writeObject(ObjectOutputStream stream) throws IOException
- 为了与流格式的 JDK 1.1 版本保持兼容，首先设置
byte字段（例如maxIntegerDigits）等于int字段（例如maximumIntegerDigits）（或者等于Byte.MAX_VALUE，取决于二者中那个值更小），然后写出默认的序列化数据。- 抛出：
IOException- 从以下版本开始：
- 1.2
| 序列化字段 |
|---|
groupingUsed
boolean groupingUsed
- 如果格式化和分析数字时使用了组（即千位）分隔符，则返回 true。
maxIntegerDigits
byte maxIntegerDigits
- 数字的整数部分允许的最大位数。
maxIntegerDigits必须大于或等于minIntegerDigits。注：此字段仅在与 JDK 1.1 兼容的序列化中存在。在 Java 2 平台 的 v1.2 和更高版本中，用
int字段maximumIntegerDigits来替代。当写入一个流时，maxIntegerDigits被设置为maximumIntegerDigits或Byte.MAX_VALUE中较小的一个。当从一个流读取时，仅当serialVersionOnStream小于 1 时使用此字段。
minIntegerDigits
byte minIntegerDigits
- 数的整数部分允许的最小位数，
minimumIntegerDigits必须小于或等于maximumIntegerDigits。注：此字段仅在与 JDK 1.1 兼容的序列化中存在。在 Java 2 平台 的 v1.2 和更高版本中，用新的
int字段minimumIntegerDigits来替代。当写入一个流时，minIntegerDigits被设置为minimumIntegerDigits或Byte.MAX_VALUE中较小的一个。当从一个流读取时，仅当serialVersionOnStream小于 1 时使用此字段。
maxFractionDigits
byte maxFractionDigits
- 数的小数部分允许的最大位数，
maximumFractionDigits必须大于或等于minimumFractionDigits。注： 此字段仅在与 JDK 1.1 兼容的序列化中存在。在 Java 2 平台 的 v1.2 和更高版本中，用新的
int字段maximumFractionDigits来替代。当写入一个流时，maxFractionDigits被设置为maximumFractionDigits或Byte.MAX_VALUE中较小的一个。当从一个流读取时，仅当serialVersionOnStream小于 1 时使用此字段。
minFractionDigits
byte minFractionDigits
- 数的小数部分允许的最小位数。
minimumFractionDigits必须小于或等于maximumFractionDigits。注：此字段仅在与 JDK 1.1 兼容的序列化中存在。在 Java 2 平台 的 v1.2 和更高版本中，用新的
intfieldminimumFractionDigits来替代。当写入一个流时，minFractionDigits被设置为minimumFractionDigits或Byte.MAX_VALUE中较小的一个。当从一个流读取时，仅当serialVersionOnStream小于 1 时使用此字段。
parseIntegerOnly
boolean parseIntegerOnly
- 如果此格式仅将数作为整数分析，则返回 true。
maximumIntegerDigits
int maximumIntegerDigits
- 数的整数部分允许的最大位数。
maximumIntegerDigits必须大于或等于minimumIntegerDigits。 -
- 从以下版本开始：
- 1.2
- 另请参见：
NumberFormat.getMaximumIntegerDigits()
minimumIntegerDigits
int minimumIntegerDigits
- 数的整数部分允许的最小位数。
minimumIntegerDigits必须小于或等于maximumIntegerDigits。 -
- 从以下版本开始：
- 1.2
- 另请参见：
NumberFormat.getMinimumIntegerDigits()
maximumFractionDigits
int maximumFractionDigits
- 数的小数部分允许的最大位数。
maximumFractionDigits必须大于或等于minimumFractionDigits。 -
- 从以下版本开始：
- 1.2
- 另请参见：
NumberFormat.getMaximumFractionDigits()
minimumFractionDigits
int minimumFractionDigits
- 数的小数部分允许的最小位数。
minimumFractionDigits必须小于或等于maximumFractionDigits。 -
- 从以下版本开始：
- 1.2
- 另请参见：
NumberFormat.getMinimumFractionDigits()
serialVersionOnStream
int serialVersionOnStream
- 描述了流上存在的
NumberFormat的版本。可能的值为：- 0（或未初始化）：流格式的 JDK 1.1 版本。在此版本中，诸如
maximumIntegerDigits之类的int字段不存在，而使用如maxIntegerDigits这样的byte字段来替代。 - 1：流格式的 1.2 版本。诸如
maxIntegerDigits之类的byte字段的值被忽略，而使用如maximumIntegerDigits这样的int字段来替代。
NumberFormat时，总是写入最近的格式（对应于允许的最高serialVersionOnStream）。 - 0（或未初始化）：流格式的 JDK 1.1 版本。在此版本中，诸如
-
- 从以下版本开始：
- 1.2
| 类 java.text.NumberFormat.Field 继承 Format.Field 实现 Serializable |
|---|
serialVersionUID: 7494728892700160890L
| 序列化方法 |
|---|
readResolve
protected Object readResolve() throws InvalidObjectException
- 将正被反序列化的实例解析为预定义的常量。
- 抛出：
InvalidObjectException- 如果无法解析常量。
| 类 java.text.ParseException 继承 Exception 实现 Serializable |
|---|
| 序列化字段 |
|---|
errorOffset
int errorOffset
- 从零开始的字符偏移量，在分析过程中，在字符串中的此处发现错误。
-
| 类 java.text.SimpleDateFormat 继承 DateFormat 实现 Serializable |
|---|
serialVersionUID: 4774881970558875024L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 在从输入流中读取对象后，验证对象中的格式模式。
- 抛出：
InvalidObjectException- 如果模式无效IOExceptionClassNotFoundException
| 序列化字段 |
|---|
serialVersionOnStream
int serialVersionOnStream
- 流上序列化数据的版本。可能的值：
- 0 或者不出现在流上：JDK 1.1.3。此版本在流上没有
defaultCenturyStart。 - 1 JDK 1.1.4 或更高版本。此版本增加了
defaultCenturyStart。
serialVersionOnStream。 - 0 或者不出现在流上：JDK 1.1.3。此版本在流上没有
-
- 从以下版本开始：
- JDK1.1.4
pattern
String pattern
- 此格式化程序的模式字符串。这始终是一个非本地化的模式。不能为 null。有关详细信息请查阅类文档。
-
formatData
DateFormatSymbols formatData
- 此格式化程序为周名称、月名称等使用的符号。不能为 null。
-
- 另请参见：
DateFormatSymbols
defaultCenturyStart
Date defaultCenturyStart
- 我们将两位数字的年份日期映射到从
defaultCenturyStart开始的世纪（可以为任何日期）。不能为 null。 -
- 从以下版本开始：
- JDK1.1.4
| 软件包 java.util |
|---|
| 类 java.util.AbstractMap$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.AbstractMap$1$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.AbstractMap$2 继承 Object 实现 Serializable |
|---|
| 类 java.util.AbstractMap$2$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.ArrayList 继承 AbstractList<E> 实现 Serializable |
|---|
serialVersionUID: 8683452581122892189L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重构 ArrayList 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 ArrayList 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 支持发出 ArrayList 实例的数组的长度 (int)，后面是以适当顺序排列的所有元素（每个元素都是一个 Object）。
- 抛出：
IOException
| 序列化字段 |
|---|
size
int size
- ArrayList 的大小（它包含的元素数）。
-
| 类 java.util.Arrays.ArrayList 继承 AbstractList<E> 实现 Serializable |
|---|
serialVersionUID: -2764017481108945198L
| 序列化字段 |
|---|
a
Object[] a
| 类 java.util.BitSet 继承 Object 实现 Serializable |
|---|
serialVersionUID: 7997698588986878753L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 重写 readObject 方法可以确保 bitset 在反序列化时正确地设置 unitsInUse
| 序列化字段 |
|---|
bits
long[] bits
- 此 BitSet 中的位。第 i 个位存储在数位位置为 i % 64 的 bits[i/64]中（其中数位位置 0 表示最低有效位，数位位置 63 表示最高有效位）。常量：bits[] 中超出 unitsInUse-1 的字恒为零。
-
| 类 java.util.Calendar 继承 Object 实现 Serializable |
|---|
serialVersionUID: -1807547505821590642L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 从流重构此对象（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream stream) throws IOException
- 将此对象的状态保存到流中（也就是将其序列化）。
理想情况下，
Calendar将只写出其状态数据和当前时间，并且不会写出任何字段数据，比如fields[]、isTimeSet、areFieldsSet和isSet[]。nextStamp不应该是持久存储状态的一部分。不幸的是，在发行 JDK 1.1 之前，事情并非如此。为了与 JDK 1.1 兼容，必须总是写出字段值和状态标志。不过，可以从序列化流中移除nextStamp；可能在以后会实现。- 抛出：
IOException
| 序列化字段 |
|---|
fields
int[] fields
- 此日历当前设置时间的日历字段值。这是一个
FIELD_COUNT整数数组，索引值为 ERA 到DST_OFFSET。 -
isSet
boolean[] isSet
- 通知是否设置了该日历某一指定日历字段的标志。新的对象没有设置任何字段。在第一次调用生成该字段的某一方法后，这些字段都将保留调用之后的设置。这是一个
FIELD_COUNT布尔值数组，索引值为 ERA 到DST_OFFSET。 -
time
long time
- 日历的当前设置时间，以毫秒为单位，表示自格林威治标准时间 1970 年 1月 1 日 0:00:00 后经过的时间。
-
- 另请参见：
Calendar.isTimeSet
isTimeSet
boolean isTimeSet
- 如果
time值是一个有效值，则返回 true。通过更改field[]的项，可以使时间无效。 -
- 另请参见：
Calendar.time
areFieldsSet
boolean areFieldsSet
- 如果
fields[]与当前的设置时间同步，则返回 true。如果返回 false，则在下一次试图获得某一字段的值时，将强行重新计算time当前值中的所有字段。 -
lenient
boolean lenient
- 如果此日历允许在计算
fields[]中的time时使用超出范围的字段值，则返回True。
zone
TimeZone zone
- 此日历使用的
TimeZone。Calendar使用时区数据来实现语言环境与 GMT 时间的转换。 -
firstDayOfWeek
int firstDayOfWeek
- 一星期中的第一天，可能的值是
SUNDAY、MONDAY，等等。这是一个同语言环境有关的值。 -
minimalDaysInFirstWeek
int minimalDaysInFirstWeek
- 一月或一年中第一个星期所需的天数，可能的值是从 1 到 7。这是一个同语言环境有关的值。
-
nextStamp
int nextStamp
stamp[]（一个内部数组）的下一个可用值。实际上不应该将该方法写出到流中，在以后，可能从流中将其移除。同时，应该使用MINIMUM_USER_STAMP值。-
serialVersionOnStream
int serialVersionOnStream
- 流中序列化数据的版本。可能的值是：
- 0 或流中不存在该数据
- JDK 1.1.5 或更早的版本。
- 1
- JDK 1.1.6 或更高的版本。为其他字段编写一个正确的 'time' 值以及兼容的值。这是一种过渡格式。
serialVersionOnStream。 -
- 从以下版本开始：
- JDK1.1.6
| 类 java.util.Collections.CheckedCollection 继承 Object 实现 Serializable |
|---|
serialVersionUID: 1578914078182001775L
| 序列化字段 |
|---|
c
Collection<E> c
type
Class<T> type
zeroLengthElementArray
Object[] zeroLengthElementArray
| 类 java.util.Collections.CheckedList 继承 java.util.Collections.CheckedCollection<E> 实现 Serializable |
|---|
serialVersionUID: 65247728283967356L
| 序列化字段 |
|---|
list
List<E> list
| 类 java.util.Collections.CheckedMap 继承 Object 实现 Serializable |
|---|
serialVersionUID: 5742860141034234728L
| 序列化字段 |
|---|
m
Map<K,V> m
keyType
Class<T> keyType
valueType
Class<T> valueType
zeroLengthKeyArray
Object[] zeroLengthKeyArray
zeroLengthValueArray
Object[] zeroLengthValueArray
| 类 java.util.Collections.CheckedRandomAccessList 继承 java.util.Collections.CheckedList<E> 实现 Serializable |
|---|
serialVersionUID: 1638200125423088369L
| 类 java.util.Collections.CheckedSet 继承 java.util.Collections.CheckedCollection<E> 实现 Serializable |
|---|
serialVersionUID: 4694047833775013803L
| 类 java.util.Collections.CheckedSortedMap 继承 java.util.Collections.CheckedMap<K,V> 实现 Serializable |
|---|
serialVersionUID: 1599671320688067438L
| 序列化字段 |
|---|
sm
SortedMap<K,V> sm
| 类 java.util.Collections.CheckedSortedSet 继承 java.util.Collections.CheckedSet<E> 实现 Serializable |
|---|
serialVersionUID: 1599911165492914959L
| 序列化字段 |
|---|
ss
SortedSet<E> ss
| 类 java.util.Collections.CopiesList 继承 AbstractList<E> 实现 Serializable |
|---|
serialVersionUID: 2739099268398711800L
| 序列化字段 |
|---|
n
int n
element
Object element
| 类 java.util.Collections.EmptyList 继承 AbstractList<Object> 实现 Serializable |
|---|
serialVersionUID: 8842843931221139166L
| 序列化方法 |
|---|
readResolve
private Object readResolve()
| 类 java.util.Collections.EmptySet 继承 AbstractSet<Object> 实现 Serializable |
|---|
serialVersionUID: 1582296315990362920L
| 序列化方法 |
|---|
readResolve
private Object readResolve()
| 类 java.util.Collections.ReverseComparator 继承 Object 实现 Serializable |
|---|
serialVersionUID: 7207038068494060240L
| 类 java.util.Collections.ReverseComparator2 继承 Object 实现 Serializable |
|---|
serialVersionUID: 4374092139857L
| 序列化字段 |
|---|
cmp
Comparator<T> cmp
- The comparator specified in the static factory. This will never
be null, as the static factory returns a ReverseComparator
instance if its argument is null.
-
| 类 java.util.Collections.SingletonSet 继承 AbstractSet<E> 实现 Serializable |
|---|
serialVersionUID: 3193687207550431679L
| 序列化字段 |
|---|
element
Object element
| 类 java.util.Collections.SynchronizedCollection 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3053995032091335093L
| 序列化方法 |
|---|
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 抛出：
IOException
| 序列化字段 |
|---|
c
Collection<E> c
mutex
Object mutex
| 类 java.util.Collections.SynchronizedList 继承 java.util.Collections.SynchronizedCollection<E> 实现 Serializable |
|---|
serialVersionUID: -7754090372962971524L
| 序列化方法 |
|---|
readResolve
private Object readResolve()
- SynchronizedRandomAccessList instances are serialized as
SynchronizedList instances to allow them to be deserialized
in pre-1.4 JREs (which do not have SynchronizedRandomAccessList).
This method inverts the transformation. As a beneficial
side-effect, it also grafts the RandomAccess marker onto
SynchronizedList instances that were serialized in pre-1.4 JREs.
Note: Unfortunately, SynchronizedRandomAccessList instances
serialized in 1.4.1 and deserialized in 1.4 will become
SynchronizedList instances, as this method was missing in 1.4.
| 序列化字段 |
|---|
list
List<E> list
| 类 java.util.Collections.SynchronizedMap 继承 Object 实现 Serializable |
|---|
serialVersionUID: 1978198479659022715L
| 序列化方法 |
|---|
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 抛出：
IOException
| 序列化字段 |
|---|
m
Map<K,V> m
mutex
Object mutex
| 类 java.util.Collections.SynchronizedRandomAccessList 继承 java.util.Collections.SynchronizedList<E> 实现 Serializable |
|---|
serialVersionUID: 1530674583602358482L
| 序列化方法 |
|---|
writeReplace
private Object writeReplace()
- Allows instances to be deserialized in pre-1.4 JREs (which do
not have SynchronizedRandomAccessList). SynchronizedList has
a readResolve method that inverts this transformation upon
deserialization.
| 类 java.util.Collections.SynchronizedSet 继承 java.util.Collections.SynchronizedCollection<E> 实现 Serializable |
|---|
serialVersionUID: 487447009682186044L
| 类 java.util.Collections.SynchronizedSortedMap 继承 java.util.Collections.SynchronizedMap<K,V> 实现 Serializable |
|---|
serialVersionUID: -8798146769416483793L
| 序列化字段 |
|---|
sm
SortedMap<K,V> sm
| 类 java.util.Collections.SynchronizedSortedSet 继承 java.util.Collections.SynchronizedSet<E> 实现 Serializable |
|---|
serialVersionUID: 8695801310862127406L
| 序列化字段 |
|---|
ss
SortedSet<E> ss
| 类 java.util.Collections.UnmodifiableCollection 继承 Object 实现 Serializable |
|---|
serialVersionUID: 1820017752578914078L
| 序列化字段 |
|---|
c
Collection<E> c
| 类 java.util.Collections.UnmodifiableList 继承 java.util.Collections.UnmodifiableCollection<E> 实现 Serializable |
|---|
serialVersionUID: -283967356065247728L
| 序列化方法 |
|---|
readResolve
private Object readResolve()
- UnmodifiableRandomAccessList instances are serialized as
UnmodifiableList instances to allow them to be deserialized
in pre-1.4 JREs (which do not have UnmodifiableRandomAccessList).
This method inverts the transformation. As a beneficial
side-effect, it also grafts the RandomAccess marker onto
UnmodifiableList instances that were serialized in pre-1.4 JREs.
Note: Unfortunately, UnmodifiableRandomAccessList instances
serialized in 1.4.1 and deserialized in 1.4 will become
UnmodifiableList instances, as this method was missing in 1.4.
| 序列化字段 |
|---|
list
List<E> list
| 类 java.util.Collections.UnmodifiableMap 继承 Object 实现 Serializable |
|---|
serialVersionUID: -1034234728574286014L
| 序列化字段 |
|---|
m
Map<K,V> m
| 类 java.util.Collections.UnmodifiableMap.UnmodifiableEntrySet 继承 java.util.Collections.UnmodifiableSet<Map.Entry<K,V>> 实现 Serializable |
|---|
serialVersionUID: 7854390611657943733L
| 类 java.util.Collections.UnmodifiableRandomAccessList 继承 java.util.Collections.UnmodifiableList<E> 实现 Serializable |
|---|
serialVersionUID: -2542308836966382001L
| 序列化方法 |
|---|
writeReplace
private Object writeReplace()
- Allows instances to be deserialized in pre-1.4 JREs (which do
not have UnmodifiableRandomAccessList). UnmodifiableList has
a readResolve method that inverts this transformation upon
deserialization.
| 类 java.util.Collections.UnmodifiableSet 继承 java.util.Collections.UnmodifiableCollection<E> 实现 Serializable |
|---|
serialVersionUID: -9215047833775013803L
| 类 java.util.Collections.UnmodifiableSortedMap 继承 java.util.Collections.UnmodifiableMap<K,V> 实现 Serializable |
|---|
serialVersionUID: -8806743815996713206L
| 序列化字段 |
|---|
sm
SortedMap<K,V> sm
| 类 java.util.Collections.UnmodifiableSortedSet 继承 java.util.Collections.UnmodifiableSet<E> 实现 Serializable |
|---|
serialVersionUID: -4929149591599911165L
| 序列化字段 |
|---|
ss
SortedSet<E> ss
| 类 java.util.Collections$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.Collections$CheckedList$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.Collections$CheckedMap$CheckedEntrySet$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.Collections$SingletonSet$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.Collections$UnmodifiableCollection$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.Collections$UnmodifiableList$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.Collections$UnmodifiableMap$UnmodifiableEntrySet$1 继承 Object 实现 Serializable |
|---|
| 类 java.util.ConcurrentModificationException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.util.Currency 继承 Object 实现 Serializable |
|---|
serialVersionUID: -158308464356906721L
| 序列化方法 |
|---|
readResolve
private Object readResolve()
- 把正被反序列化的实例分析为每种货币的单个实例。
| 序列化字段 |
|---|
currencyCode
String currencyCode
- 此货币的 ISO 4217 货币代码。
-
| 类 java.util.Date 继承 Object 实现 Serializable |
|---|
serialVersionUID: 7523967970034938905L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构此对象（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将此对象的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出由
getTime()返回的值 (long)。它表示自 1970 年 1 月 1 日 00:00:00 GMT 的偏移量（以毫秒为单位）。 - 抛出：
IOException
| 类 java.util.DuplicateFormatFlagsException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 18890531L
| 序列化字段 |
|---|
flags
String flags
| 类 java.util.EmptyStackException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.util.EnumMap 继承 AbstractMap<K extends Enum<K>,V> 实现 Serializable |
|---|
serialVersionUID: 458661240069192865L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 重新构造来自流的 EnumMap 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 EnumMap 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出枚举映射的 size（键-值映射关系数），后跟由枚举映射表示的每个键-值映射关系的键 (Object) 和值 (Object)。
- 抛出：
IOException
| 序列化字段 |
|---|
keyType
Class<T> keyType
- 此映射所有键的枚举类型的 Class 对象。
-
| 类 java.util.EnumSet.SerializationProxy 继承 Object 实现 Serializable |
|---|
serialVersionUID: 362491234563181265L
| 序列化方法 |
|---|
readResolve
private Object readResolve()
| 序列化字段 |
|---|
elementType
Class<T> elementType
- The element type of this enum set.
-
elements
Enum<E extends Enum<E>>[] elements
- The elements contained in this enum set.
-
| 类 java.util.EventObject 继承 Object 实现 Serializable |
|---|
serialVersionUID: 5516075349620653480L
| 类 java.util.FormatFlagsConversionMismatchException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 19120414L
| 序列化字段 |
|---|
f
String f
c
char c
| 类 java.util.FormatterClosedException 继承 IllegalStateException 实现 Serializable |
|---|
serialVersionUID: 18111216L
| 类 java.util.GregorianCalendar 继承 Calendar 实现 Serializable |
|---|
serialVersionUID: -8125100834729963327L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 更新内部状态。
| 序列化字段 |
|---|
gregorianCutover
long gregorianCutover
- 格里高利历规则的使用点，从标准新纪元开始以毫秒为单位来测量。默认时间 1582 年 10 月 15 日（格里高利历）00:00:00 UTC 或 -12219292800000L。对此默认值，1582 年 10 月 4 日（儒略历）之后是 1582 年 10 月 15 日（格里高利历）。这对应于儒略历日期号 2299161。
-
| 类 java.util.HashMap 继承 AbstractMap<K,V> 实现 Serializable |
|---|
serialVersionUID: 362498820763181265L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 HashMap 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 HashMap 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出 HashMap 的容量（桶数组的长度，为 int 值），后跟 HashMap 的 size（键-值映射关系数），后跟由 HashMap 所表示的每个键-值映射关系的键 (Object) 和值 (Object)，发出键-值映射关系是为了它们可以由 entrySet().iterator() 返回。
- 抛出：
IOException
| 序列化字段 |
|---|
threshold
int threshold
- The next size value at which to resize (capacity * load factor).
-
loadFactor
float loadFactor
- 哈希表的加载因子。
-
| 类 java.util.HashSet 继承 AbstractSet<E> 实现 Serializable |
|---|
serialVersionUID: -5024744406713321676L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 HashSet 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 HashSet 实例的状态保存到流中（也就是将此集合序列化）。
- 序列数据：
- 发出底层 HashMap 实例的容量（int）及其加载因子（float），后跟集合的大小（所包含元素的数量（int）），再后跟着它的所有元素（每个元素都是一个对象），这些元素没有按特定顺序排列。
- 抛出：
IOException
| 类 java.util.Hashtable 继承 Dictionary<K,V> 实现 Serializable |
|---|
serialVersionUID: 1421746759512286392L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 Hashtable（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 Hashtable 的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出 Hashtable 的容量（桶数组的长度（为 int）），后跟 Hashtable 的大小（键-值映射关系的数量），再后面是由 Hashtable 表示的每个键-值映射关系的键（Object）和值（Object），发出这些键-值映射关系没有按照任何特定顺序。
- 抛出：
IOException
| 序列化字段 |
|---|
threshold
int threshold
- 如果表的大小超出此阈值，则要对其执行 rehash 操作。（阈值是一个 int 值，等于容量与加载因子的乘积。）
-
loadFactor
float loadFactor
- 哈希表的加载因子。
-
| 类 java.util.IdentityHashMap 继承 AbstractMap<K,V> 实现 Serializable |
|---|
serialVersionUID: 8188218128353913216L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 IdentityHashMap 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 IdentityHashMap 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- HashMap（键-值映射关系数）的大小 (int)，然后是 IdentityHashMap 所表示的每个键-值映射关系的键（对象）和值（对象）。发出的键-值映射关系没有特定顺序。
- 抛出：
IOException
| 序列化字段 |
|---|
size
int size
- 返回此标识哈希映射中的键-值映射关系数。
-
| 类 java.util.IllegalFormatCodePointException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 19080630L
| 序列化字段 |
|---|
c
int c
| 类 java.util.IllegalFormatConversionException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 17000126L
| 序列化字段 |
|---|
c
char c
arg
Class<T> arg
| 类 java.util.IllegalFormatException 继承 IllegalArgumentException 实现 Serializable |
|---|
serialVersionUID: 18830826L
| 类 java.util.IllegalFormatFlagsException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 790824L
| 序列化字段 |
|---|
flags
String flags
| 类 java.util.IllegalFormatPrecisionException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 18711008L
| 序列化字段 |
|---|
p
int p
| 类 java.util.IllegalFormatWidthException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 16660902L
| 序列化字段 |
|---|
w
int w
| 类 java.util.InputMismatchException 继承 NoSuchElementException 实现 Serializable |
|---|
| 类 java.util.LinkedHashMap 继承 HashMap<K,V> 实现 Serializable |
|---|
serialVersionUID: 3801124242820219131L
| 序列化字段 |
|---|
accessOrder
boolean accessOrder
- 此链接哈希映射的迭代排序方法：访问顺序为 true；插入顺序为 false。
-
| 类 java.util.LinkedHashSet 继承 HashSet<E> 实现 Serializable |
|---|
serialVersionUID: -2851667679971038690L
| 类 java.util.LinkedList 继承 AbstractSequentialList<E> 实现 Serializable |
|---|
serialVersionUID: 876323262645176354L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构此 LinkedList 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将此 LinkedList 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 列表的大小（它所包含的元素数）(int)，然后是其按正确顺序排列的所有元素（每个对象）。
- 抛出：
IOException
| 类 java.util.Locale 继承 Object 实现 Serializable |
|---|
serialVersionUID: 9149081749638150636L
| 序列化方法 |
|---|
readResolve
private Object readResolve() throws ObjectStreamException
- 用新创建的对象替换已反序列化的 Locale 对象。用较新的 ISO 代码替换较旧的语言代码。用内部 String 副本替换国家/地区和变量代码。
| 序列化字段 |
|---|
language
String language
-
- 另请参见：
Locale.getLanguage()
country
String country
-
- 另请参见：
Locale.getCountry()
variant
String variant
-
- 另请参见：
Locale.getVariant()
hashcode
int hashcode
- 对象的哈希码的占位符。总为 -1。
-
| 类 java.util.MissingFormatArgumentException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 19190115L
| 序列化字段 |
|---|
s
String s
| 类 java.util.MissingFormatWidthException 继承 IllegalFormatException 实现 Serializable |
|---|
serialVersionUID: 15560123L
| 序列化字段 |
|---|
s
String s
| 类 java.util.MissingResourceException 继承 RuntimeException 实现 Serializable |
|---|
| 序列化字段 |
|---|
className
String className
- 用户所请求的资源包的类名。
-
key
String key
- 用户所请求的特定资源名。
-
| 类 java.util.NoSuchElementException 继承 RuntimeException 实现 Serializable |
|---|
| 类 java.util.PriorityQueue 继承 AbstractQueue<E> 实现 Serializable |
|---|
serialVersionUID: -7720805057305804111L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 ArrayList 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 底层实例数组的长度 (int)，然后是其按正确顺序排列的所有元素（每个 Object）。
- 抛出：
IOException
| 序列化字段 |
|---|
size
int size
- 优先级队列中的元素数目。
comparator
Comparator<T> comparator
- 比较器，如果优先级队列使用元素的自然排序，则为 null。
| 类 java.util.Properties 继承 Hashtable<Object,Object> 实现 Serializable |
|---|
serialVersionUID: 4112578634029874840L
| 序列化字段 |
|---|
defaults
Properties defaults
- 一个属性列表，包含属性列表中所有未找到值的键的默认值。
-
| 类 java.util.PropertyPermissionCollection 继承 PermissionCollection 实现 Serializable |
|---|
serialVersionUID: 7015263904581634791L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- Default fields.
- 抛出：
IOException
| 序列化字段 |
|---|
all_allowed
boolean all_allowed
- boolean saying if "*" is in the collection.
permissions
Hashtable<K,V> permissions
- A table of the PropertyPermissions.
| 类 java.util.Random 继承 Object 实现 Serializable |
|---|
serialVersionUID: 3905348978240129619L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重构 Random 实例（也就是将其反序列化）。出于历史原因，会以 long 读取种子，但会将其转换为 AtomicLong。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 Random 实例保存到流中。出于历史原因，会将 Random 的种子作为 long 进行序列化。
- 抛出：
IOException
| 序列化概述 |
|---|
- Random 的可序列化字段。
| 序列化字段 |
|---|
haveNextNextGaussian
boolean haveNextNextGaussian
- nextNextGaussian 是有效的
nextNextGaussian
double；要返回的下一个 nextNextGaussian
- Gaussian
seed
long； seed
- 随机计算的种子
| 类 java.util.SimpleTimeZone 继承 TimeZone 实现 Serializable |
|---|
serialVersionUID: -403250971215465050L
| 序列化方法 |
|---|
readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 从流重构此对象（也就是将其反序列化）。
我们同时处理 JDK 1.1 二进制格式和具有打包字节数组的完全格式。
writeObject
private void writeObject(ObjectOutputStream stream) throws IOException
- 将此对象的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 我们编写了两种格式，JDK 1.1 兼容格式，它使用
DOW_IN_MONTH_MODE规则，在必需部分中后跟完全规则，在可选部分中则使用打包格式。在流入时 JDK 1.1 代码将忽略可选部分。可选部分的内容：发出字节数组的长度 (int)；对于此版本为 4。发出给定长度的字节数组。字节数组的内容是字段
startDay、startDayOfWeek、endDay和endDayOfWeek的 true 值。在必需部分中这些字段的值是适合于规则模式DOW_IN_MONTH_MODE的近似值，它是 JDK 1.1 惟一可识别的模式。 - 抛出：
IOException
| 序列化字段 |
|---|
startMonth
int startMonth
- 夏令时开始的月份。此值必须介于
Calendar.JANUARY和Calendar.DECEMBER（包含）之间。此值必须不能等于endMonth。如果
useDaylight为 false，则忽略此值。 -
startDay
int startDay
- 此字段有两种可能的解释：
startMode == DOW_IN_MONTH-
startDay指示夏令时是在startMonth月份中的哪个日期开始的，该日期可以是从 1 到 28、30 或 31，具体取决于startMonth。 startMode != DOW_IN_MONTH-
startDay指示夏令时是在startMonth月份中的哪个startDayOfWeek开始。例如，一个 +1 值和一个Calendar.SUNDAY的startDayOfWeek指示startMonth的第一个星期日。同样，+2 则指示第二个星期日，-1 指示最后一个星期日。0 值是非法的。 -
如果
useDaylight为 false，则忽略此值。
startDayOfWeek
int startDayOfWeek
- 夏令时开始时是一周的星期几。此值必须介于
Calendar.SUNDAY和Calendar.SATURDAY（包括）之间。如果
useDaylight为 false 或startMode == DAY_OF_MONTH，则忽略此值。 -
startTime
int startTime
- 夏令时开始日的子夜之后以毫秒表示的时间。此值表示为挂钟时间、标准时间或 UTC 时间，具体取决于
startTimeMode的设置。如果
useDaylight为 false，则忽略此值。 -
startTimeMode
int startTimeMode
- startTime 的格式，可为 WALL_TIME、STANDARD_TIME 或 UTC_TIME。
-
- 从以下版本开始：
- 1.3
endMonth
int endMonth
- 夏令时结束的月份。此值必须介于
Calendar.JANUARY和Calendar.UNDECIMBER之间。此值必须不能等于startMonth。如果
useDaylight为 false，则忽略此值。 -
endDay
int endDay
- 此字段有两种可能的解释：
endMode == DOW_IN_MONTH-
endDay指示夏令时是在endMonth月份中的哪个日期结束的，该日期可以是从 1 到 28、30 或 31，具体取决于endMonth。 endMode != DOW_IN_MONTH-
endDay指示夏令时是在endMonth月份中哪个endDayOfWeek结束。例如，一个 +1 值和一个Calendar.SUNDAY的endDayOfWeek指示endMonth的第一个星期日。同样，+2 则指示第二个星期日，-1 指示最后一个星期日。0 值是非法的。 -
如果
useDaylight为 false，则忽略此值。
endDayOfWeek
int endDayOfWeek
- 夏令时结束时，一周的星期几。此值必须介于
Calendar.SUNDAY和Calendar.SATURDAY（包括）之间。如果
useDaylight为 false 或endMode == DAY_OF_MONTH，则忽略此值。 -
endTime
int endTime
- 夏令时结束日的子夜之后以毫秒表示的时间。此值表示为挂钟时间、标准时间或 UTC 时间，具体取决于
endTimeMode的设置。如果
useDaylight为 false，则忽略此值。 -
endTimeMode
int endTimeMode
- endTime 的格式，可为
WALL_TIME、STANDARD_TIME或UTC_TIME。 -
- 从以下版本开始：
- 1.3
startYear
int startYear
- 夏令时首次实施的年份。它是一个
AD值。如果此值小于 1，则在所有的AD年份中都实施夏令时。如果
useDaylight为 false，则忽略此值。 -
rawOffset
int rawOffset
- 此时区与 GMT 之间以毫秒为单位的偏移量。负偏移表示西时区。要获得本地标准 时间，可用偏移量加上 GMT 时间。要获取本地挂钟时间，则还须加上
dstSavings。 -
useDaylight
boolean useDaylight
- 一个布尔值，当且仅当此时区使用夏令时时才为 true。如果此值为 false，则忽略其他几个字段。
-
monthLength
byte[] monthLength
- 此字段在 JDK 1.1 中是序列化的，因此，我们必须保持该顺序，以维护序列化的兼容性。不过，无需在每次创建新时区时都重新创建此数组。
- 包含值 {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} 的字节数组。从 Java 2 平台 v1.2 开始忽略了此顺序，但为了保持与 JDK 1.1 的兼容性，还必须保持它的有序性。
startMode
int startMode
- 指定开始规则模式的变量。采用下面的值：
DOM_MODE- 具体日期；例如，3 月 1 日。
DOW_IN_MONTH_MODE- 一个月中的星期几；例如，3 月的最后一个星期日。
DOW_GE_DOM_MODE- 一个月的某一天之后的星期几；例如，3 月 15 日或之后的星期日。
DOW_LE_DOM_MODE- 一个月的某一天之前的星期几；例如，3 月 15 日或之前的星期日。
startDay字段的解释。如果
useDaylight为 false，则忽略此值。 -
- 从以下版本开始：
- 1.1.4
endMode
int endMode
- 指定结束规则模式的变量。采用下面的值：
DOM_MODE- 具体日期；例如，3 月 1 日。
DOW_IN_MONTH_MODE- 一个月中的星期几；例如，3 月的最后一个星期日。
DOW_GE_DOM_MODE- 一个月的某一天之后的星期几；例如，3 月 15 日或之后的星期日。
DOW_LE_DOM_MODE- 一个月的某一天之前的星期几；例如，3 月 15 日或之前的星期日。
endDay字段的解释。如果
useDaylight为 false，则忽略此值。 -
- 从以下版本开始：
- 1.1.4
dstSavings
int dstSavings
- 正值指示在 DST 期间节省的时间量（以毫秒为单位）。一般为 1 小时 (3600000)，有时为 30 分钟 (1800000)。
如果
useDaylight为 false，则忽略此值。 -
- 从以下版本开始：
- 1.1.4
serialVersionOnStream
int serialVersionOnStream
- 流上序列化数据的版本。可能的值：
- 0 或者在流上不出现
- JDK 1.1.3 或较早版本。
- 1
-
JDK 1.1.4 或更高版本。包括三个新字段：
startMode、endMode和dstSavings。 - 2
-
JDK 1.3 或更高版本。包括两个新字段：
startTimeMode和endTimeMode。
serialVersionOnStream。 -
- 从以下版本开始：
- 1.1.4
类 java.util.Stack 继承 Vector<E> 实现 Serializable serialVersionUID: 1224463164541339165L
类 java.util.SubList$1 继承 Object 实现 Serializable 类 java.util.TimeZone 继承 Object 实现 Serializable serialVersionUID: 3581463369166924961L
序列化字段 ID
String ID
- 此
TimeZone的字符串标识符。这是一个编程标识符，供内部用于从系统表中查询TimeZone对象，也用于把它们映射到它们的本地化显示名称。ID值在系统表中是惟一的，但可能不是针对动态创建的区域。 -
类 java.util.TooManyListenersException 继承 Exception 实现 Serializable 类 java.util.TreeMap 继承 AbstractMap<K,V> 实现 Serializable serialVersionUID: 919286545866124006L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 重新构造来自流的 TreeMap 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 TreeMap 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出 TreeMap（键-值映射关系数）的大小 (int)，然后是 TreeMap 表示的每个键-值映射关系的键 (Object) 和值 (Object)。键-值映射关系按照键的顺序发出（由 TreeMap 的 Comparator 确定，如果 TreeMap 没有 Comparator，则由键的自然排序确定）。
- 抛出：
IOException
序列化字段 comparator
Comparator<T> comparator
- 用于保持此 TreeMap 中的顺序的 Comparator，如果此 TreeMap 使用它的元素自然排序，则为 null。
-
类 java.util.TreeMap$1 继承 Object 实现 Serializable 类 java.util.TreeMap$2 继承 Object 实现 Serializable 类 java.util.TreeMap$3 继承 Object 实现 Serializable 类 java.util.TreeSet 继承 AbstractSet<E> 实现 Serializable serialVersionUID: -2479143000061671589L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构 TreeSet 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 TreeSet 实例的状态保存到流中（也就是将其序列化）
- 序列数据：
- 发出用于对此 set 进行排序的比较器，如果其元素遵循自然顺序 (Object)，则发出 null，然后是集合的大小（其包含的元素数） (int)，再后面是其按顺序排列的所有元素（每个元素是一个 Object）（该顺序由 set 的 Comparator 确定，如果 set 没有 Comparator，则由元素的自然顺序确定）。
- 抛出：
IOException
类 java.util.UnknownFormatConversionException 继承 IllegalFormatException 实现 Serializable serialVersionUID: 19060418L
序列化字段 s
String s
类 java.util.UnknownFormatFlagsException 继承 IllegalFormatException 实现 Serializable serialVersionUID: 19370506L
序列化字段 flags
String flags
类 java.util.UUID 继承 Object 实现 Serializable serialVersionUID: -4856846361193249489L
序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从流重构 UUID 实例（也就是将其反序列化）。这对于将各个 transient 字段设置为其正确的未初始化的值以便按需重新计算很有必要。
序列化字段 mostSigBits
long mostSigBits
leastSigBits
long leastSigBits
类 java.util.Vector 继承 AbstractList<E> 实现 Serializable serialVersionUID: -2767605614048989439L
序列化方法 writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 Vector 实例的状态保存到流中（也就是将其序列化）。此方法只在同步时使用。它仅调用默认的 readObject 方法。
- 抛出：
IOException
序列化字段 elementData
Object[] elementData
- 存储向量组件的数组缓冲区。vector 的容量就是此数据缓冲区的长度，该长度至少要足以包含向量的所有元素。
Vector 中的最后一个元素后的任何数组元素都为 null。
-
elementCount
int elementCount
- Vector 对象中的有效组件数。从 elementData[0] 到 elementData[elementCount-1] 的组件均为实际项。
-
capacityIncrement
int capacityIncrement
- 向量的大小大于其容量时，容量自动增加的量。如果容量的增量小于或等于零，则每次需要增大容量时，向量的容量将增大一倍。
-
类 java.util.Vector$1 继承 Object 实现 Serializable
软件包 java.util.concurrent 类 java.util.concurrent.ArrayBlockingQueue 继承 AbstractQueue<E> 实现 Serializable serialVersionUID: -817911632652898426L
序列化字段 items
Object[] items
- 已加入队列的项
count
int count
- 队列中的项的数量
lock
ReentrantLock lock
- 保护所有访问的主锁
notEmpty
Condition notEmpty
- 等待取出的条件
notFull
Condition notFull
- 等待放入的条件
类 java.util.concurrent.BrokenBarrierException 继承 Exception 实现 Serializable serialVersionUID: 7117394618823254244L
类 java.util.concurrent.CancellationException 继承 IllegalStateException 实现 Serializable serialVersionUID: -9202173006928992231L
类 java.util.concurrent.ConcurrentHashMap 继承 AbstractMap<K,V> 实现 Serializable serialVersionUID: 7249069246763182397L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重构 ConcurrentHashMap 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 ConcurrentHashMap 实例的状态保存到流中（也就是将其序列化）。
- 序列数据：
- 每个键-值映射关系的键 (Object) 和值 (Object)，后跟一个 null 对。键-值映射关系的发出没有任何特定顺序。
- 抛出：
IOException
序列化字段 segmentMask
int segmentMask
- 用来对段进行索引的掩码值。哈希表的键的高位被用来选择段。
segmentShift
int segmentShift
- 用来在段中进行索引的移位值。
segments
java.util.concurrent.ConcurrentHashMap.Segment<K,V>[] segments
- 每个段都是一个专门的哈希表。
类 java.util.concurrent.ConcurrentLinkedQueue 继承 AbstractQueue<E> 实现 Serializable serialVersionUID: 196745693267521676L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重构 Queue 实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将状态保存到流中（也就是将其序列化）。
- 序列数据：
- 以正确顺序排列的所有元素（每个元素是一个 E），后跟一个 null
- 抛出：
IOException
类 java.util.concurrent.CopyOnWriteArrayList 继承 Object 实现 Serializable serialVersionUID: 8673264195747942595L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重构列表（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将列表状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出支持列表的数组的长度 (int)，后跟以适当顺序排列的所有数组元素（均为对象）。
- 抛出：
IOException
类 java.util.concurrent.CopyOnWriteArraySet 继承 AbstractSet<E> 实现 Serializable serialVersionUID: 5457747651344034263L
序列化字段 al
CopyOnWriteArrayList<E> al
类 java.util.concurrent.ExecutionException 继承 Exception 实现 Serializable serialVersionUID: 7830266012832686185L
类 java.util.concurrent.LinkedBlockingQueue 继承 AbstractQueue<E> 实现 Serializable serialVersionUID: -6903933977591709194L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流重构此队列实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将状态保存到流中（也就是将其序列化）。
- 序列数据：
- 发出容量 (int)，后跟以正确顺序排列的所有元素（每个都是顺序正确的 Object），后跟 null。
- 抛出：
IOException
序列化字段 capacity
int capacity
- 容量上限，如果没有则为 Integer.MAX_VALUE。
count
AtomicInteger count
- 当前的元素数。
takeLock
ReentrantLock takeLock
- 由 take、poll 等所保持的锁定。
notEmpty
Condition notEmpty
- 等待 take 的等待队列。
putLock
ReentrantLock putLock
- 由 put、offer 等所保持的锁定。
notFull
Condition notFull
- 等待 put 的等待队列。
类 java.util.concurrent.PriorityBlockingQueue 继承 AbstractQueue<E> 实现 Serializable serialVersionUID: 5595510919245408276L
序列化方法 writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将状态保存到流中（也就是将其序列化）。这只包装锁定内的默认序列化内容。该内容的序列化策略留给基础的 Queue 负责。注意，不需要对反序列化进行锁定，所以并未定义 readObject，使用默认值即可。
- 抛出：
IOException
序列化字段 q
PriorityQueue<E> q
lock
ReentrantLock lock
notEmpty
Condition notEmpty
类 java.util.concurrent.RejectedExecutionException 继承 RuntimeException 实现 Serializable serialVersionUID: -375805702767069545L
类 java.util.concurrent.Semaphore 继承 Object 实现 Serializable serialVersionUID: -3222578661600680210L
序列化字段 sync
java.util.concurrent.Semaphore.Sync sync
- 通过 AbstractQueuedSynchronizer 子类实现的所有机制。
类 java.util.concurrent.SynchronousQueue 继承 AbstractQueue<E> 实现 Serializable serialVersionUID: -3223113410248163686L
序列化字段 qlock
ReentrantLock qlock
- 锁定保护两个等待队列
waitingProducers
java.util.concurrent.SynchronousQueue.WaitQueue waitingProducers
- 保持等待放入内容的队列
waitingConsumers
java.util.concurrent.SynchronousQueue.WaitQueue waitingConsumers
- 保持等待取得内容的队列
类 java.util.concurrent.TimeoutException 继承 Exception 实现 Serializable serialVersionUID: 1900926677490660714L
软件包 java.util.concurrent.atomic 类 java.util.concurrent.atomic.AtomicBoolean 继承 Object 实现 Serializable serialVersionUID: 4654671469794556979L
序列化字段 value
int value
类 java.util.concurrent.atomic.AtomicInteger 继承 Number 实现 Serializable serialVersionUID: 6214790243416807050L
序列化字段 value
int value
类 java.util.concurrent.atomic.AtomicIntegerArray 继承 Object 实现 Serializable serialVersionUID: 2862133569453604235L
序列化字段 array
int[] array
类 java.util.concurrent.atomic.AtomicLong 继承 Number 实现 Serializable serialVersionUID: 1927816293512124184L
序列化字段 value
long value
类 java.util.concurrent.atomic.AtomicLongArray 继承 Object 实现 Serializable serialVersionUID: -2308431214976778248L
序列化字段 array
long[] array
类 java.util.concurrent.atomic.AtomicReference 继承 Object 实现 Serializable serialVersionUID: -1848883965231344442L
序列化字段 value
Object value
类 java.util.concurrent.atomic.AtomicReferenceArray 继承 Object 实现 Serializable serialVersionUID: -6209656149925076980L
序列化字段 array
Object[] array
软件包 java.util.concurrent.locks 类 java.util.concurrent.locks.AbstractQueuedSynchronizer 继承 Object 实现 Serializable serialVersionUID: 7373984972572414691L
序列化字段 state
int state
- 同步状态。
类 java.util.concurrent.locks.AbstractQueuedSynchronizer.ConditionObject 继承 Object 实现 Serializable serialVersionUID: 1173984872572414699L
类 java.util.concurrent.locks.ReentrantLock 继承 Object 实现 Serializable serialVersionUID: 7373984872572414699L
序列化字段 sync
java.util.concurrent.locks.ReentrantLock.Sync sync
- 提供所有实现机制的同步器
类 java.util.concurrent.locks.ReentrantReadWriteLock 继承 Object 实现 Serializable serialVersionUID: -6992448646407690164L
序列化字段 readerLock
ReentrantReadWriteLock.ReadLock readerLock
- 提供读取锁定的内部类
writerLock
ReentrantReadWriteLock.WriteLock writerLock
- 提供写入锁定的内部类
sync
java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync
- 执行所有同步机制
类 java.util.concurrent.locks.ReentrantReadWriteLock.ReadLock 继承 Object 实现 Serializable serialVersionUID: -5992448646407690164L
序列化字段 sync
java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync
类 java.util.concurrent.locks.ReentrantReadWriteLock.WriteLock 继承 Object 实现 Serializable serialVersionUID: -4992448646407690164L
序列化字段 sync
java.util.concurrent.locks.ReentrantReadWriteLock.Sync sync
软件包 java.util.jar 类 java.util.jar.JarException 继承 ZipException 实现 Serializable
软件包 java.util.logging 类 java.util.logging.Level 继承 Object 实现 Serializable serialVersionUID: -8176160795706313070L
序列化方法 readResolve
private Object readResolve()
序列化字段 name
String name
- 级别的非本地化名称。
value
int value
- 级别的整数值。
resourceBundleName
String resourceBundleName
- 本地化级别名称时使用的资源包名称。
类 java.util.logging.LoggingPermission 继承 BasicPermission 实现 Serializable serialVersionUID: 63564341580231582L
类 java.util.logging.LogRecord 继承 Object 实现 Serializable serialVersionUID: 5372048053134512534L
序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 序列数据：
- 默认字段，后跟两个字节的版本号（前面是主字节，后面是次字节），后跟关于日志记录参数数组的信息。如果不存在参数数组，则写入 -1。如果存在参数数组（可能长度为零），则作为整数写入数组长度，后跟每个参数的 String 值。如果参数为 null，则写入 null String。否则，写入 Object.toString() 的输出。
- 抛出：
IOException
序列化字段 level
Level level
- 日志消息级别
sequenceNumber
long sequenceNumber
- 序列号
sourceClassName
String sourceClassName
- 发出日志调用的类
sourceMethodName
String sourceMethodName
- 发出日志调用的方法
message
String message
- 非本地化的原始消息文本
threadID
int threadID
- 发出日志调用的线程的线程 ID。
millis
long millis
- 自从 1970 年以毫秒为单位的事件时间
thrown
Throwable thrown
- 与日志消息相关联的 Throwable（如果有）
loggerName
String loggerName
- 源 Logger 的名称。
resourceBundleName
String resourceBundleName
- 本地化日志消息的资源包名称。
软件包 java.util.prefs 类 java.util.prefs.BackingStoreException 继承 Exception 实现 Serializable serialVersionUID: 859796500401108469L
类 java.util.prefs.InvalidPreferencesFormatException 继承 Exception 实现 Serializable serialVersionUID: -791715184232119669L
软件包 java.util.regex 类 java.util.regex.Pattern 继承 Object 实现 Serializable serialVersionUID: 5073258162644648461L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中重新编译 Pattern 实例。读入初始模式字符串并从中重新编译对象树。
序列化字段 pattern
String pattern
- 初始正则表达式模式字符串。
-
flags
int flags
- 初始模式标志。
-
类 java.util.regex.PatternSyntaxException 继承 IllegalArgumentException 实现 Serializable 序列化字段 desc
String desc
pattern
String pattern
index
int index
软件包 java.util.zip 类 java.util.zip.DataFormatException 继承 Exception 实现 Serializable 类 java.util.zip.ZipException 继承 IOException 实现 Serializable
软件包 javax.activity 类 javax.activity.ActivityCompletedException 继承 RemoteException 实现 Serializable 类 javax.activity.ActivityRequiredException 继承 RemoteException 实现 Serializable 类 javax.activity.InvalidActivityException 继承 RemoteException 实现 Serializable
软件包 javax.crypto 类 javax.crypto.BadPaddingException 继承 GeneralSecurityException 实现 Serializable 类 javax.crypto.ExemptionMechanismException 继承 GeneralSecurityException 实现 Serializable 类 javax.crypto.IllegalBlockSizeException 继承 GeneralSecurityException 实现 Serializable 类 javax.crypto.NoSuchPaddingException 继承 GeneralSecurityException 实现 Serializable 类 javax.crypto.SealedObject 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流中还原 SealedObject 的状态。
- 抛出：
NullPointerException- 如果 s 为 null。IOExceptionClassNotFoundException
序列化字段 encodedParams
byte[] encodedParams
- 已编码的参数。
-
encryptedContent
byte[] encryptedContent
- 以加密格式存在的序列化对象内容。
-
sealAlg
String sealAlg
- 用于密封此对象的算法。
-
paramsAlg
String paramsAlg
- 所用的参数算法。
-
类 javax.crypto.ShortBufferException 继承 GeneralSecurityException 实现 Serializable
软件包 javax.crypto.interfaces
软件包 javax.crypto.spec 类 javax.crypto.spec.SecretKeySpec 继承 Object 实现 Serializable 序列化字段 key
byte[] key
- 密钥。
-
algorithm
String algorithm
- 与此密钥关联的算法名称。
-
软件包 javax.imageio 类 javax.imageio.IIOException 继承 IOException 实现 Serializable
软件包 javax.imageio.metadata 类 javax.imageio.metadata.IIOInvalidTreeException 继承 IIOException 实现 Serializable 序列化字段 offendingNode
Node offendingNode
- 导致解析错误的
Node，或null。
软件包 javax.management 类 javax.management.AndQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: -1081892073854801359L
序列化字段 exp1
QueryExp exp1
- The first QueryExp of the conjunction
exp2
QueryExp exp2
- The second QueryExp of the conjunction
类 javax.management.Attribute 继承 Object 实现 Serializable serialVersionUID: 2484220110589082382L
序列化字段 name
String name
- Attribute 名称。
value
Object value
- Attribute 值。
类 javax.management.AttributeChangeNotification 继承 Notification 实现 Serializable serialVersionUID: 535176054565814134L
序列化字段 attributeName
String attributeName
- MBean 属性名称。
attributeType
String attributeType
- MBean 属性类型。
oldValue
Object oldValue
- MBean 属性的旧值。
newValue
Object newValue
- MBean 属性的新值。
类 javax.management.AttributeChangeNotificationFilter 继承 Object 实现 Serializable serialVersionUID: -6347317584796410029L
序列化字段 enabledAttributes
Vector<E> enabledAttributes
- 包含已启用属性名称的
Vector。默认值是一个空向量。
类 javax.management.AttributeList 继承 ArrayList 实现 Serializable serialVersionUID: -4077085769279709076L
类 javax.management.AttributeNotFoundException 继承 OperationsException 实现 Serializable serialVersionUID: 6511584241791106926L
类 javax.management.AttributeValueExp 继承 Object 实现 Serializable serialVersionUID: -7768025046539163385L
序列化字段 attr
String attr
类 javax.management.BadAttributeValueExpException 继承 Exception 实现 Serializable serialVersionUID: -3105272988410493376L
序列化字段 val
Object val
- 产生此异常的属性值
类 javax.management.BadBinaryOpValueExpException 继承 Exception 实现 Serializable serialVersionUID: 5068475589449021227L
序列化字段 exp
ValueExp exp
- 产生此异常的
ValueExp
类 javax.management.BadStringOperationException 继承 Exception 实现 Serializable serialVersionUID: 7802201238441662100L
序列化字段 op
String op
- 对产生此异常的操作的描述
类 javax.management.BetweenQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: -2933597532866307444L
序列化字段 exp1
ValueExp exp1
- The checked value
exp2
ValueExp exp2
- The lower bound value
exp3
ValueExp exp3
- The upper bound value
类 javax.management.BinaryOpValueExp 继承 QueryEval 实现 Serializable serialVersionUID: 1216286847881456786L
序列化字段 op
int op
- The operator
exp1
ValueExp exp1
- The first value
exp2
ValueExp exp2
- The second value
类 javax.management.BinaryRelQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: -5690656271650491000L
序列化字段 relOp
int relOp
- The operator
exp1
ValueExp exp1
- The first value
exp2
ValueExp exp2
- The second value
类 javax.management.BooleanValueExp 继承 QueryEval 实现 Serializable serialVersionUID: 7754922052666594581L
序列化字段 val
boolean val
- The boolean value
类 javax.management.ClassAttributeValueExp 继承 AttributeValueExp 实现 Serializable 序列化字段 attr
String attr
- The name of the attribute
类 javax.management.InQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: -5801329450358952434L
序列化字段 val
ValueExp val
- The
ValueExpto be found
valueList
ValueExp[] valueList
- The array of
ValueExpto be searched
类 javax.management.InstanceAlreadyExistsException 继承 OperationsException 实现 Serializable serialVersionUID: 8893743928912733931L
类 javax.management.InstanceNotFoundException 继承 OperationsException 实现 Serializable serialVersionUID: -882579438394773049L
类 javax.management.IntrospectionException 继承 OperationsException 实现 Serializable serialVersionUID: 1054516935875481725L
类 javax.management.InvalidApplicationException 继承 Exception 实现 Serializable serialVersionUID: -3048022274675537269L
序列化字段 val
Object val
- 表示 MBean 的类的对象
类 javax.management.InvalidAttributeValueException 继承 OperationsException 实现 Serializable serialVersionUID: 2164571879317142449L
类 javax.management.JMException 继承 Exception 实现 Serializable serialVersionUID: 350520924977331825L
类 javax.management.JMRuntimeException 继承 RuntimeException 实现 Serializable serialVersionUID: 6573344628407841861L
类 javax.management.ListenerNotFoundException 继承 OperationsException 实现 Serializable serialVersionUID: -7242605822448519061L
类 javax.management.MalformedObjectNameException 继承 OperationsException 实现 Serializable serialVersionUID: -572689714442915824L
类 javax.management.MatchQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: -7156603696948215014L
序列化字段 exp
AttributeValueExp exp
- The attribute value to be matched
pattern
String pattern
- The pattern to be matched
类 javax.management.MBeanAttributeInfo 继承 MBeanFeatureInfo 实现 Serializable 序列化字段 attributeType
String attributeType
- The actual attribute type.
isWrite
boolean isWrite
- The attribute write right.
isRead
boolean isRead
- The attribute read right.
is
boolean is
- Indicates if this method is a "is"
类 javax.management.MBeanConstructorInfo 继承 MBeanFeatureInfo 实现 Serializable serialVersionUID: 4433990064191844427L
序列化字段 signature
MBeanParameterInfo[] signature
- The signature of the method, that is, the class names of the arguments.
类 javax.management.MBeanException 继承 JMException 实现 Serializable serialVersionUID: 4066342430588744142L
序列化字段 exception
Exception exception
- Encapsulated
Exception
类 javax.management.MBeanFeatureInfo 继承 Object 实现 Serializable serialVersionUID: 3952882688968447265L
序列化字段 name
String name
- 该功能的名称。推荐子类调用
MBeanFeatureInfo.getName()方法，而不是读取此字段，并且子类不能更改该字段。 - 该功能的名称。
description
String description
- 该功能的可读描述。推荐子类调用
MBeanFeatureInfo.getDescription()方法，而不是读取此字段，并且子类不能更改该字段。 - 该功能的可读描述。
类 javax.management.MBeanInfo 继承 Object 实现 Serializable serialVersionUID: -6451021435135161911L
序列化字段 description
String description
- The human readable description of the class.
className
String className
- The MBean qualified name.
attributes
MBeanAttributeInfo[] attributes
- The MBean attribute descriptors.
operations
MBeanOperationInfo[] operations
- The MBean operation descriptors.
constructors
MBeanConstructorInfo[] constructors
- The MBean constructor descriptors.
notifications
MBeanNotificationInfo[] notifications
- The MBean notification descriptors.
类 javax.management.MBeanNotificationInfo 继承 MBeanFeatureInfo 实现 Serializable serialVersionUID: -3888371564530107064L
序列化字段 types
String[] types
- The different types of the notification.
类 javax.management.MBeanOperationInfo 继承 MBeanFeatureInfo 实现 Serializable serialVersionUID: -6178860474881375330L
序列化字段 type
String type
- The method's return value.
signature
MBeanParameterInfo[] signature
- The signature of the method, that is, the class names of the arguments.
impact
int impact
- 返回该方法的影响，为
INFO、ACTION、ACTION_INFO、UNKNOWN之一。
类 javax.management.MBeanParameterInfo 继承 MBeanFeatureInfo 实现 Serializable serialVersionUID: 7432616882776782338L
序列化字段 type
String type
- The type or class name of the data.
类 javax.management.MBeanPermission 继承 Permission 实现 Serializable serialVersionUID: -2416928705275160661L
序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 根据此对象的名称和操作反序列化它。
序列化字段 actions
String actions
- 操作字符串。
类 javax.management.MBeanRegistrationException 继承 MBeanException 实现 Serializable serialVersionUID: 4482382455277067805L
类 javax.management.MBeanServerNotification 继承 Notification 实现 Serializable serialVersionUID: 2876477500475969677L
序列化字段 objectName
ObjectName objectName
- 与此通知有关的 MBean 的对象名
类 javax.management.MBeanServerPermission 继承 BasicPermission 实现 Serializable serialVersionUID: -5661980843569388590L
序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
类 javax.management.MBeanServerPermissionCollection 继承 PermissionCollection 实现 Serializable serialVersionUID: -5661980843569388590L
序列化字段 collectionPermission
MBeanServerPermission collectionPermission
- Null if no permissions in collection, otherwise a
single permission that is the union of all permissions that
have been added.
类 javax.management.MBeanTrustPermission 继承 BasicPermission 实现 Serializable serialVersionUID: -2952178077029018140L
类 javax.management.NotCompliantMBeanException 继承 OperationsException 实现 Serializable serialVersionUID: 5175579583207963577L
类 javax.management.Notification 继承 EventObject 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从
ObjectInputStream中反序列化Notification。
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
Notification序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 message
String message
- 通知消息。
sequenceNumber
long sequenceNumber
- 通知序列号。序列号在通知源的上下文中标识特定的通知实例。
source
Object source
- 最初发生通知的对象。
timeStamp
long timeStamp
- 通知时间戳。指示通知的生成时间
type
String type
- 通知类型。用和 Java 属性类似的点标注法表示的 string。通知类型的示例：network.alarm.router
userData
Object userData
- 通知的用户数据。用于通知源希望与其使用者所交流的所有其他数据
类 javax.management.NotificationFilterSupport 继承 Object 实现 Serializable serialVersionUID: 6579080007561786969L
序列化字段 enabledTypes
List<E> enabledTypes
- 包含已启用通知类型的
Vector。默认值是一个空向量。
类 javax.management.NotQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: 5269643775896723397L
序列化字段 exp
QueryExp exp
- The negated
QueryExp
类 javax.management.NumericValueExp 继承 QueryEval 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- Deserializes a
NumericValueExpfrom anObjectInputStream.
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- Serializes a
NumericValueExpto anObjectOutputStream.- 抛出：
IOException
序列化字段 val
Number val
- The {@link Number} representing the numeric value
类 javax.management.ObjectInstance 继承 Object 实现 Serializable serialVersionUID: -4099952623687795850L
序列化字段 name
ObjectName name
- Object name.
className
String className
- Class name.
类 javax.management.ObjectName 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 根据
ObjectInputStream反序列化ObjectName。- 序列数据：
- 在目前的序列形式中（属性
jmx.serial.form的值不是1.0）：字符串 "<域>:<属性><通配符>"，其中：- <域> 表示
ObjectName的域部分 - <属性> 表示属性列表，由
ObjectName.getKeyPropertyListString()所返回 - 如果
isPropertyPattern返回 false，则 <通配符> 为空；如果isPropertyPattern和 <属性> 为空，则 <通配符> 为字符 "*"；如果isPropertyPattern和 <属性> 不为空，则 <通配符> 为 ",*"。
ObjectName.ObjectName(String)构造方法，以生成等效的ObjectName。 - <域> 表示
- 在旧的序列形式中（属性
jmx.serial.form的值是1.0）：<域> <属性列表> <属性列表 String> <规范名> <模式> <属性模式>，其中：- <域> 表示
ObjectName的域部分 - <属性列表> 是包含此
ObjectName所有键值对的Hashtable - <属性列表 String> 是以任意顺序出现的属性列表的
String表示形式（并不强制使用规范的表示形式） - <规范名> 是包含此
ObjectName的规范名称的String - <模式> 是一个 boolean 值，如果此
ObjectName包含模式，则为true - <属性模式> 是一个 boolean 值，如果此
ObjectName在属性列表中包含模式，则为true
- <域> 表示
- 在目前的序列形式中（属性
- 抛出：
IOExceptionClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
ObjectName序列化为ObjectOutputStream。- 序列数据：
- 在目前的序列形式中（属性
jmx.serial.form的值不是1.0）：字符串 "<域>:<属性><通配符>"，其中：- <域> 表示
ObjectName的域部分 - <属性> 表示属性列表，由
ObjectName.getKeyPropertyListString()所返回 - 如果
isPropertyPattern返回 false，则 <通配符> 为空；如果此isPropertyPattern和 <属性> 为空，则 <通配符> 为字符 "*"；如果isPropertyPattern和 <属性> 不为空，则 <通配符> 为 ",*"。
ObjectName.ObjectName(String)构造方法，以生成等效的ObjectName。 - <域> 表示
- 在旧的序列形式中（属性
jmx.serial.form的值是1.0）：<域> <属性列表> <属性列表 String> <规范名> <模式> <属性模式>，其中：- <域> 表示
ObjectName的域部分 - <属性列表> 是包含此
ObjectName所有键值对的Hashtable - <属性列表 String> 是以任意顺序出现的属性列表的
String表示形式（并不强制使用规范的表示形式） - <规范名> 是包含此
ObjectName的规范名称的String - <模式> 是一个 boolean 值，如果此
ObjectName包含模式，则为true - <属性模式> 是一个 boolean 值，如果此
ObjectName在属性列表中包含模式，则为true
- <域> 表示
- 在目前的序列形式中（属性
- 抛出：
IOException
序列化字段 类 javax.management.OperationsException 继承 JMException 实现 Serializable serialVersionUID: -4967597595580536216L
类 javax.management.OrQueryExp 继承 QueryEval 实现 Serializable serialVersionUID: 2962973084421716523L
序列化字段 exp1
QueryExp exp1
- The left query expression
exp2
QueryExp exp2
- The right query expression
类 javax.management.QualifiedAttributeValueExp 继承 AttributeValueExp 实现 Serializable serialVersionUID: 8832517277410933254L
序列化字段 className
String className
- The attribute class name
类 javax.management.QueryEval 继承 Object 实现 Serializable serialVersionUID: 2675899265640874796L
类 javax.management.ReflectionException 继承 JMException 实现 Serializable serialVersionUID: 9170809325636915553L
序列化字段 exception
Exception exception
- 包装的
Exception
类 javax.management.RuntimeErrorException 继承 JMRuntimeException 实现 Serializable serialVersionUID: 704338937753949796L
序列化字段 error
Error error
- 封装的
Error
类 javax.management.RuntimeMBeanException 继承 JMRuntimeException 实现 Serializable serialVersionUID: 5274912751982730171L
序列化字段 runtimeException
RuntimeException runtimeException
- 封装的
RuntimeException
类 javax.management.RuntimeOperationsException 继承 JMRuntimeException 实现 Serializable serialVersionUID: -8408923047489133588L
序列化字段 runtimeException
RuntimeException runtimeException
- 封装的
RuntimeException
类 javax.management.ServiceNotFoundException 继承 OperationsException 实现 Serializable serialVersionUID: -3990675661956646827L
类 javax.management.StringValueExp 继承 Object 实现 Serializable serialVersionUID: -3256390509806284044L
序列化字段 val
String val
- 字符串文本
软件包 javax.management.loading 类 javax.management.loading.MLet 继承 URLClassLoader 实现 Serializable serialVersionUID: 3636148327800330130L
序列化方法 readExternal
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException, UnsupportedOperationException
从给定的
ObjectInput恢复此 MLet 的内容。不是所有的实现都支持此方法。不支持此方法的实现将抛出UnsupportedOperationException。子类可以重写此方法以支持它或更改读取数据的格式。读取数据的格式是未指定的，但如果某个实现支持
MLet.readExternal(java.io.ObjectInput)，则它必须也支持MLet.writeExternal(java.io.ObjectOutput)，以便前者可以读取后者所写入的内容。- 抛出：
IOException- 如果在读取时出现问题。ClassNotFoundException- 如果找不到要被恢复的对象的类。UnsupportedOperationException- 如果此实现不支持此操作。
writeExternal
public void writeExternal(ObjectOutput out) throws IOException, UnsupportedOperationException
将此 MLet 的内容保存到给定的
ObjectOutput。不是所有的实现都支持此方法。不支持此方法的实现将抛出UnsupportedOperationException。子类可以重写此方法以支持它或更改写入数据的格式。写入数据的格式是未指定的，但如果某个实现支持
MLet.writeExternal(java.io.ObjectOutput)，则它必须也支持MLet.readExternal(java.io.ObjectInput)，以便后者可以读取前者所写入的内容。- 抛出：
IOException- 如果在写入时出现问题。UnsupportedOperationException- 如果此实现不支持此操作。
类 javax.management.loading.PrivateMLet 继承 MLet 实现 Serializable serialVersionUID: 2503458973393711979L
序列化方法 readExternal
public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException, UnsupportedOperationException
从给定的
ObjectInput恢复此 MLet 的内容。不是所有的实现都支持此方法。不支持此方法的实现将抛出UnsupportedOperationException。子类可以重写此方法以支持它或更改读取数据的格式。读取数据的格式是未指定的，但如果某个实现支持
MLet.readExternal(java.io.ObjectInput)，则它必须也支持MLet.writeExternal(java.io.ObjectOutput)，以便前者可以读取后者所写入的内容。- 抛出：
IOException- 如果在读取时出现问题。ClassNotFoundException- 如果找不到要被恢复的对象的类。UnsupportedOperationException- 如果此实现不支持此操作。
writeExternal
public void writeExternal(ObjectOutput out) throws IOException, UnsupportedOperationException
将此 MLet 的内容保存到给定的
ObjectOutput。不是所有的实现都支持此方法。不支持此方法的实现将抛出UnsupportedOperationException。子类可以重写此方法以支持它或更改写入数据的格式。写入数据的格式是未指定的，但如果某个实现支持
MLet.writeExternal(java.io.ObjectOutput)，则它必须也支持MLet.readExternal(java.io.ObjectInput)，以便后者可以读取前者所写入的内容。- 抛出：
IOException- 如果在写入时出现问题。UnsupportedOperationException- 如果此实现不支持此操作。
软件包 javax.management.modelmbean 类 javax.management.modelmbean.DescriptorSupport 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
DescriptorSupport序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 descriptor
HashMap<K,V> descriptor
- 表示此描述符的字段的集合
类 javax.management.modelmbean.InvalidTargetObjectTypeException 继承 Exception 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
序列化字段 exception
Exception exception
- 封装的 {@link Exception}
类 javax.management.modelmbean.ModelMBeanAttributeInfo 继承 MBeanAttributeInfo 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
ModelMBeanAttributeInfo序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 attrDescriptor
Descriptor attrDescriptor
- 包含对应于此属性的元数据的 {@link Descriptor}
类 javax.management.modelmbean.ModelMBeanConstructorInfo 继承 MBeanConstructorInfo 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
ModelMBeanConstructorInfo序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 consDescriptor
Descriptor consDescriptor
- 包含此实例的元数据的 {@link Descriptor}
类 javax.management.modelmbean.ModelMBeanInfoSupport 继承 MBeanInfo 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
ModelMBeanInfoSupport序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 modelMBeanAttributes
ModelMBeanAttributeInfo[] modelMBeanAttributes
- 带有描述符的 {@link ModelMBeanAttributeInfo} 对象数组
modelMBeanConstructors
MBeanConstructorInfo[] modelMBeanConstructors
- 带有描述符的 {@link ModelMBeanConstructorInfo} 对象数组
modelMBeanDescriptor
Descriptor modelMBeanDescriptor
- 包含 MBean 级策略的描述符
modelMBeanNotifications
MBeanNotificationInfo[] modelMBeanNotifications
- 带有描述符的 {@link ModelMBeanNotificationInfo} 对象数组
modelMBeanOperations
MBeanOperationInfo[] modelMBeanOperations
- 带有描述符的 {@link ModelMBeanOperationInfo} 对象数组
类 javax.management.modelmbean.ModelMBeanNotificationInfo 继承 MBeanNotificationInfo 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
ModelMBeanNotificationInfo序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 notificationDescriptor
Descriptor notificationDescriptor
- 包含此实例的适当元数据的描述符
类 javax.management.modelmbean.ModelMBeanOperationInfo 继承 MBeanOperationInfo 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
ModelMBeanOperationInfo序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 operationDescriptor
Descriptor operationDescriptor
- 包含此实例的适当元数据的描述符
类 javax.management.modelmbean.XMLParseException 继承 Exception 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
XMLParseException序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段
软件包 javax.management.monitor 类 javax.management.monitor.MonitorNotification 继承 Notification 实现 Serializable serialVersionUID: -4608189663661929204L
序列化字段 observedObject
ObjectName observedObject
- Monitor notification observed object.
observedAttribute
String observedAttribute
- Monitor notification observed attribute.
derivedGauge
Object derivedGauge
- Monitor notification derived gauge.
trigger
Object trigger
- Monitor notification release mechanism.此值用来保留触发此通知的阈值/字符串（取决于监视器类型）。
类 javax.management.monitor.MonitorSettingException 继承 JMRuntimeException 实现 Serializable serialVersionUID: -8807913418190202007L
软件包 javax.management.openmbean 类 javax.management.openmbean.ArrayType 继承 OpenType 实现 Serializable serialVersionUID: 720504429830309770L
序列化字段 dimension
int dimension
- 此
ArrayType实例描述的数组的维度
elementType
OpenType elementType
- 此
ArrayType实例描述的数组中包含的元素值的开放类型
类 javax.management.openmbean.CompositeDataSupport 继承 Object 实现 Serializable serialVersionUID: 8003518976613702244L
序列化字段 contents
SortedMap<K,V> contents
- 它们各自值的项名称的映射关系的内部表示形式。
SortedMap用于较快速的元素检索。
compositeType
CompositeType compositeType
- 此复合数据 实例的复合类型。
类 javax.management.openmbean.CompositeType 继承 OpenType 实现 Serializable serialVersionUID: -5366242454346948798L
序列化字段 nameToDescription
TreeMap<K,V> nameToDescription
- 项名称到其描述的有序映射
nameToType
TreeMap<K,V> nameToType
- 项名称到其开放类型的有序映射
类 javax.management.openmbean.InvalidKeyException 继承 IllegalArgumentException 实现 Serializable serialVersionUID: 4224269443946322062L
类 javax.management.openmbean.InvalidOpenTypeException 继承 IllegalArgumentException 实现 Serializable serialVersionUID: -2837312755412327534L
类 javax.management.openmbean.KeyAlreadyExistsException 继承 IllegalArgumentException 实现 Serializable serialVersionUID: 1845183636745282866L
类 javax.management.openmbean.OpenDataException 继承 JMException 实现 Serializable serialVersionUID: 8346311255433349870L
类 javax.management.openmbean.OpenMBeanAttributeInfoSupport 继承 MBeanAttributeInfo 实现 Serializable serialVersionUID: -4867215622149721849L
序列化字段 openType
OpenType openType
- open mbean 属性的开放类型
defaultValue
Object defaultValue
- open mbean 属性的默认值
legalValues
Set<E> legalValues
- open mbean 属性的合法值。此
Set是不可修改的。
minValue
Comparable<T> minValue
- open mbean 属性的最小值
maxValue
Comparable<T> maxValue
- open mbean 属性的最大值
类 javax.management.openmbean.OpenMBeanConstructorInfoSupport 继承 MBeanConstructorInfo 实现 Serializable serialVersionUID: -4400441579007477003L
类 javax.management.openmbean.OpenMBeanInfoSupport 继承 MBeanInfo 实现 Serializable serialVersionUID: 4349395935420511492L
类 javax.management.openmbean.OpenMBeanOperationInfoSupport 继承 MBeanOperationInfo 实现 Serializable serialVersionUID: 4996859732565369366L
序列化字段 returnOpenType
OpenType returnOpenType
- 此
OpenMBeanOperationInfo实例描述的操作所返回的值的开放类型。
类 javax.management.openmbean.OpenMBeanParameterInfoSupport 继承 MBeanParameterInfo 实现 Serializable serialVersionUID: -7235016873758443122L
序列化字段 openType
OpenType openType
- open mbean 参数的开放类型
defaultValue
Object defaultValue
- open mbean 参数的默认值
legalValues
Set<E> legalValues
- open mbean 参数的合法值。此
Set是不可修改的。
minValue
Comparable<T> minValue
- open mbean 参数的最小值
maxValue
Comparable<T> maxValue
- open mbean 参数的最大值
类 javax.management.openmbean.OpenType 继承 Object 实现 Serializable serialVersionUID: -9195195325186646468L
序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从
ObjectInputStream反序列化OpenType。
序列化字段 className
String className
- 此类型描述的开放数据值的完全限定的 Java 类名。
description
String description
- 类型描述（不应为 null 或空）。
typeName
String typeName
- 为此类型提供的名称（不应为 null 或空）。
类 javax.management.openmbean.SimpleType 继承 OpenType 实现 Serializable serialVersionUID: 2215577471957694503L
序列化方法 readResolve
public Object readResolve() throws ObjectStreamException
- 使用该值的惟一实例替换从
ObjectInputStream读取的对象。- 抛出：
ObjectStreamException- 如果读取对象不能被解析。
类 javax.management.openmbean.TabularDataSupport 继承 Object 实现 Serializable serialVersionUID: 5720150593236309827L
序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
序列化字段 dataMap
Map<K,V> dataMap
- 此表格数据实例的内容：一个
HashMap
tabularType
TabularType tabularType
- 此表格数据实例的表格类型
类 javax.management.openmbean.TabularType 继承 OpenType 实现 Serializable serialVersionUID: 6554071860220659261L
序列化字段 rowType
CompositeType rowType
- 行的复合类型
indexNames
List<E> indexNames
- 用于索引每个行元素的项，它保持用户给定的顺序。这是一个不可修改的
ArrayList
软件包 javax.management.relation 类 javax.management.relation.InvalidRelationIdException 继承 RelationException 实现 Serializable serialVersionUID: -7115040321202754171L
类 javax.management.relation.InvalidRelationServiceException 继承 RelationException 实现 Serializable serialVersionUID: 3400722103759507559L
类 javax.management.relation.InvalidRelationTypeException 继承 RelationException 实现 Serializable serialVersionUID: 3007446608299169961L
类 javax.management.relation.InvalidRoleInfoException 继承 RelationException 实现 Serializable serialVersionUID: 7517834705158932074L
类 javax.management.relation.InvalidRoleValueException 继承 RelationException 实现 Serializable serialVersionUID: -2066091747301983721L
类 javax.management.relation.MBeanServerNotificationFilter 继承 NotificationFilterSupport 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
序列化字段 deselectedNames
List<E> deselectedNames
- List of {@link ObjectName}s with no interest
null意味着隐式地取消选中所有 {@link ObjectName}（复选表示显式选择）- 空向量意味着没有任何 {@link ObjectName} 被显式取消选中。
selectedNames
List<E> selectedNames
- List of {@link ObjectName}s of interest
null意味着隐式选中所有 {@link ObjectName}（复选表示显式取消选择）- 空向量意味着没有任何 {@link ObjectName} 被显式选中。
类 javax.management.relation.RelationException 继承 JMException 实现 Serializable serialVersionUID: 5434016005679159613L
类 javax.management.relation.RelationNotFoundException 继承 RelationException 实现 Serializable serialVersionUID: -3793951411158559116L
类 javax.management.relation.RelationNotification 继承 Notification 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
RelationNotification序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 newRoleValue
List<E> newRoleValue
- New role value ({@link ArrayList} of {@link ObjectName}s) (only for role update)
oldRoleValue
List<E> oldRoleValue
- Old role value ({@link ArrayList} of {@link ObjectName}s) (only for role update)
relationId
String relationId
- Relation identifier of created/removed/updated relation
relationObjName
ObjectName relationObjName
- {@link ObjectName} of the relation MBean of created/removed/updated relation (only if the relation is represented by an MBean)
relationTypeName
String relationTypeName
- Relation type name of created/removed/updated relation
roleName
String roleName
- Name of updated role (only for role update)
unregisterMBeanList
List<E> unregisterMBeanList
- List of {@link ObjectName}s of referenced MBeans to be unregistered due to relation removal
类 javax.management.relation.RelationServiceNotRegisteredException 继承 RelationException 实现 Serializable serialVersionUID: 8454744887157122910L
类 javax.management.relation.RelationTypeNotFoundException 继承 RelationException 实现 Serializable serialVersionUID: 1274155316284300752L
类 javax.management.relation.RelationTypeSupport 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
RelationTypeSupport序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 isInRelationService
boolean isInRelationService
- Flag specifying whether the relation type has been declared in the Relation Service (so can no longer be updated)
roleName2InfoMap
Map<K,V> roleName2InfoMap
- {@link Map} holding the mapping: <role name ({@link String})> -> <role info ({@link RoleInfo} object)>
typeName
String typeName
- Relation type name
类 javax.management.relation.Role 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从
ObjectInputStream反序列化Role。
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
Role序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 name
String name
- Role name
objectNameList
List<E> objectNameList
- {@link List} of {@link ObjectName}s of referenced MBeans
类 javax.management.relation.RoleInfo 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从
ObjectInputStream反序列化RoleInfo。
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
RoleInfo序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 description
String description
- Role description
isReadable
boolean isReadable
- Read access mode:
trueif role is readable
isWritable
boolean isWritable
- Write access mode:
trueif role is writable
maxDegree
int maxDegree
- Maximum degree (i.e. maximum number of referenced MBeans in corresponding role)
minDegree
int minDegree
- Minimum degree (i.e. minimum number of referenced MBeans in corresponding role)
name
String name
- Role name
referencedMBeanClassName
String referencedMBeanClassName
- Name of class of MBean(s) expected to be referenced in corresponding role
类 javax.management.relation.RoleInfoNotFoundException 继承 RelationException 实现 Serializable serialVersionUID: 4394092234999959939L
类 javax.management.relation.RoleList 继承 ArrayList 实现 Serializable serialVersionUID: 5568344346499649313L
类 javax.management.relation.RoleNotFoundException 继承 RelationException 实现 Serializable serialVersionUID: -2986406101364031481L
类 javax.management.relation.RoleResult 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
- 从
ObjectInputStream反序列化RoleResult。
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
RoleResult序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 roleList
RoleList roleList
- List of roles successfully accessed
unresolvedRoleList
RoleUnresolvedList unresolvedRoleList
- List of roles unsuccessfully accessed
类 javax.management.relation.RoleUnresolved 继承 Object 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream out) throws IOException
- 将
RoleUnresolved序列化为ObjectOutputStream。- 抛出：
IOException
序列化字段 problemType
int problemType
- Problem type
roleName
String roleName
- Role name
roleValue
List<E> roleValue
- Role value ({@link List} of {@link ObjectName} objects)
类 javax.management.relation.RoleUnresolvedList 继承 ArrayList 实现 Serializable serialVersionUID: 4054902803091433324L
软件包 javax.management.remote 类 javax.management.remote.JMXConnectionNotification 继承 Notification 实现 Serializable serialVersionUID: -2331308725952627538L
序列化字段 connectionId
String connectionId
- The connection ID to which this notification pertains.
类 javax.management.remote.JMXPrincipal 继承 Object 实现 Serializable serialVersionUID: -4184480100214577411L
序列化字段 name
String name
- The JMX Remote API name for the identity represented by this
JMXPrincipalobject.
类 javax.management.remote.JMXProviderException 继承 IOException 实现 Serializable serialVersionUID: -3166703627550447198L
序列化字段 cause
Throwable cause
- An exception that caused this exception to be thrown.此字段可以为 null。
类 javax.management.remote.JMXServerErrorException 继承 IOException 实现 Serializable serialVersionUID: 3996732239558744666L
序列化字段 cause
Error cause
- An
Errorthat caused this exception to be thrown.
类 javax.management.remote.JMXServiceURL 继承 Object 实现 Serializable serialVersionUID: 8173364409860779292L
序列化字段 protocol
String protocol
- 由
JMXServiceURL.getProtocol()返回的值。
host
String host
- 由
JMXServiceURL.getHost()返回的值。
port
int port
- 由
JMXServiceURL.getPort()返回的值。
urlPath
String urlPath
- 由
JMXServiceURL.getURLPath()返回的值。
类 javax.management.remote.NotificationResult 继承 Object 实现 Serializable serialVersionUID: 1191800228721395279L
序列化字段 earliestSequenceNumber
long earliestSequenceNumber
nextSequenceNumber
long nextSequenceNumber
targetedNotifications
TargetedNotification[] targetedNotifications
类 javax.management.remote.SubjectDelegationPermission 继承 BasicPermission 实现 Serializable serialVersionUID: 1481618113008682343L
类 javax.management.remote.TargetedNotification 继承 Object 实现 Serializable serialVersionUID: 7676132089779300926L
序列化字段 notif
Notification notif
- A notification to transmit to the other side.
id
Integer id
- The ID of the listener to which the notification is targeted.
软件包 javax.management.remote.rmi 类 javax.management.remote.rmi.RMIConnectionImpl_Stub 继承 RemoteStub 实现 Serializable serialVersionUID: 2L
类 javax.management.remote.rmi.RMIConnector 继承 Object 实现 Serializable serialVersionUID: 817323035842634473L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从
ObjectInputStream读入 RMIConnector 字段。调用s.defaultReadObject()并接着初始化所有需要初始化的中间变量。- 抛出：
InvalidObjectException- 如果 rmiServer stub 或 jmxServiceURL 均未设置。IOExceptionClassNotFoundException- 另请参见：
RMIConnector.RMIConnector(JMXServiceURL,Map),RMIConnector.RMIConnector(RMIServer,Map)
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 RMIConnector 字段写入到
ObjectOutputStream。如果需要的话，在初始化之前，将基础 RMIServer stub 连接到一个 ORB。通过使用为构造方法提供的环境映射（如果有）来完成此连接，如在
javax.management.remote.rmi中描述的那样。然后此方法调用
s.defaultWriteObject()。通常情况下，如果此对象是使用 JMXServiceURL 构造的，则 rmiServer 为 null，如果此对象是使用 RMIServer stub 构造的，则 jmxServiceURL 为 null。注意，环境 Map 并未序列化，因为假定它包含的对象只对于本地环境（类加载器、ORB，等等）而言是上下文相关的。
对 RMIConnector 反序列化后，假定用户将调用
RMIConnector.connect(Map)，则它提供了一个包含与新本地环境上下文相关的值的 Map。由于在序列化之前需要连接到 ORB，并且要连接到的 ORB 为上下文相关的参数之一，不建议对刚刚序列化过的对象重新序列化，因为反序列化的对象不具有映射。因此，需要将一个 RMIConnector 对象序列化或传输到一个远程应用程序时，建议通过调用
RMIConnectorServer.toJMXConnector(Map)获得新的 RMIConnector stub。- 抛出：
InvalidObjectException- 如果 rmiServer stub 或 jmxServiceURL 均未设置。IOException- 另请参见：
RMIConnector.RMIConnector(JMXServiceURL,Map),RMIConnector.RMIConnector(RMIServer,Map)
序列化字段 rmiServer
RMIServer rmiServer
- The RMIServer stub of the RMI JMX Connector server to which this client connector is (or will be) connected.当 jmxServiceURL 不为 null 时，此字段可以为 null。这包括了 jmxServiceURL 包含序列化的 RMIServer stub 的情况。如果 rmiServer 和 jmxServiceURL 都为 null，则序列化将失败。
jmxServiceURL
JMXServiceURL jmxServiceURL
- The JMXServiceURL of the RMI JMX Connector server to which this client connector will be connected.当 rmiServer 不为 null 时，此字段可以为 null。如果 rmiServer 和 jmxServiceURL 都为 null，则序列化将失败。
clientNotifID
long clientNotifID
类 javax.management.remote.rmi.RMIServerImpl_Stub 继承 RemoteStub 实现 Serializable serialVersionUID: 2L
软件包 javax.management.timer 类 javax.management.timer.TimerAlarmClockNotification 继承 Notification 实现 Serializable serialVersionUID: -4841061275673620641L
类 javax.management.timer.TimerNotification 继承 Notification 实现 Serializable serialVersionUID: 1798492029603825750L
序列化字段 notificationID
Integer notificationID
- Timer notification identifier.此标识符用来从通知的计时器列表中检索计时器通知。
软件包 javax.naming 类 javax.naming.AuthenticationException 继承 NamingSecurityException 实现 Serializable serialVersionUID: 3678497619904568096L
类 javax.naming.AuthenticationNotSupportedException 继承 NamingSecurityException 实现 Serializable serialVersionUID: -7149033933259492300L
类 javax.naming.BinaryRefAddr 继承 RefAddr 实现 Serializable serialVersionUID: -3415254970957330361L
序列化字段 buf
byte[] buf
- 包含地址字节。此字段由构造方法初始化，并使用 getAddressBytes() 和 getAddressContents() 返回。
-
类 javax.naming.Binding 继承 NameClassPair 实现 Serializable serialVersionUID: 8839217842691845890L
序列化字段 boundObj
Object boundObj
- 包含此绑定的对象。它由构造方法初始化，可以使用 setObject 更新。
类 javax.naming.CannotProceedException 继承 NamingException 实现 Serializable serialVersionUID: 1219724816191576813L
序列化字段 remainingNewName
Name remainingNewName
- 包含 Context.rename() 第二个 "name" 参数的剩余未解析部分。此信息对于继续 Context.rename() 操作是必需的。
此字段被初始化为 null。不应该直接操作它：应该使用 getRemainingName() 和 setRemainingName() 访问和更新。
environment
Hashtable<K,V> environment
- 包含与无法继续进行的 Context 或 DirContext 方法有关的环境。
此字段被初始化为 null。不应该直接操作它：应该使用 getEnvironment() 和 setEnvironment() 访问和更新。
altName
Name altName
- 包含已解析对象的名称，该名称相对于上下文
altNameCtx。该名称是一个复合名称。如果为 null，则不指定任何名称。有关如何使用此方法的详细信息，请参见javax.naming.spi.ObjectFactory.getObjectInstance方法。此字段被初始化为 null。不应该直接操作它：应该使用 getAltName() 和 setAltName() 访问和更新。
altNameCtx
Context altNameCtx
- 包含上下文，
altName是相对于该上下文指定的。如果为 null，则暗指默认初始上下文。有关如何使用此方法的详细信息，请参见javax.naming.spi.ObjectFactory.getObjectInstance方法。此字段被初始化为 null。不应该直接操作它：应该使用 getAltNameCtx() 和 setAltNameCtx() 访问和更新。
类 javax.naming.CommunicationException 继承 NamingException 实现 Serializable serialVersionUID: 3618507780299986611L
类 javax.naming.CompositeName 继承 Object 实现 Serializable serialVersionUID: 1667768148915813118L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 重写以避免存在实现依赖关系。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 重写以避免存在实现依赖关系。
- 序列数据：
- 个别组件后跟着的组件数（一个 int），每个组件都是一个 String。
- 抛出：
IOException
类 javax.naming.CompoundName 继承 Object 实现 Serializable serialVersionUID: 3513100557083972036L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 重写以避免存在实现依赖关系。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 重写以避免存在实现依赖关系。
- 序列数据：
- 语法 Properties，后跟组件数（一个 int），以及个别组件，每个组件都是一个 String。
- 抛出：
IOException
类 javax.naming.ConfigurationException 继承 NamingException 实现 Serializable serialVersionUID: -2535156726228855704L
类 javax.naming.ContextNotEmptyException 继承 NamingException 实现 Serializable serialVersionUID: 1090963683348219877L
类 javax.naming.InsufficientResourcesException 继承 NamingException 实现 Serializable serialVersionUID: 6227672693037844532L
类 javax.naming.InterruptedNamingException 继承 NamingException 实现 Serializable serialVersionUID: 6404516648893194728L
类 javax.naming.InvalidNameException 继承 NamingException 实现 Serializable serialVersionUID: -8370672380823801105L
类 javax.naming.LimitExceededException 继承 NamingException 实现 Serializable serialVersionUID: -776898738660207856L
类 javax.naming.LinkException 继承 NamingException 实现 Serializable serialVersionUID: -7967662604076777712L
序列化字段 linkResolvedName
Name linkResolvedName
- 包含已成功解析的链接部分。它可以是一个复合名称，并且可以为 null。此字段由构造方法初始化。应该通过其 get 和 set 方法访问和操作此字段。
linkResolvedObj
Object linkResolvedObj
- 包含一个对象，已成功解析的链接部分一直到达该对象。可以为 null。此字段由构造方法初始化。应该通过其 get 和 set 方法访问和操作此字段。
linkRemainingName
Name linkRemainingName
- 包含尚未解析的剩余链接名称。它可以是一个复合名称，并且可以为 null。此字段由构造方法初始化。应该通过其 get 和 set 方法访问和操作此字段。
linkExplanation
String linkExplanation
- 包含链接解析失败原因的异常。可以为 null。此字段由构造方法初始化。应该通过其 get 和 set 方法访问和操作此字段。
类 javax.naming.LinkLoopException 继承 LinkException 实现 Serializable serialVersionUID: -3119189944325198009L
类 javax.naming.LinkRef 继承 Reference 实现 Serializable serialVersionUID: -5386290613498931298L
类 javax.naming.MalformedLinkException 继承 LinkException 实现 Serializable serialVersionUID: -3066740437737830242L
类 javax.naming.NameAlreadyBoundException 继承 NamingException 实现 Serializable serialVersionUID: -8491441000356780586L
类 javax.naming.NameClassPair 继承 Object 实现 Serializable serialVersionUID: 5620776610160863339L
序列化字段 name
String name
- 包含此 NameClassPair 的名称。它由构造方法初始化，可以使用 setName() 更新。
className
String className
- 包含此 NameClassPair 中包含的类名称。它由构造方法初始化，可以使用 setClassName() 更新。
fullName
String fullName
- 包含其自己的名称空间中此 NameClassPair 的完全名称。它使用 setNameInNamespace() 初始化
isRel
boolean isRel
- 记录此 NameClassPair 的名称是否相对于目标上下文。它由构造方法初始化，可以使用 setRelative() 更新。
类 javax.naming.NameNotFoundException 继承 NamingException 实现 Serializable serialVersionUID: -8007156725367842053L
类 javax.naming.NamingException 继承 Exception 实现 Serializable serialVersionUID: -1299181962103167177L
序列化字段 resolvedName
Name resolvedName
- 包含已成功解析的名称部分。它可以是一个复合名称，并且可以为 null。此字段由构造方法初始化。应该通过其 get 和 set 方法访问和操作此字段。
resolvedObj
Object resolvedObj
- 包含一个对象，已成功解析的名称部分进行到该对象。可以为 null。此字段由构造方法初始化。应该通过其 get 和 set 方法访问和操作此字段。
remainingName
Name remainingName
- 包含尚未解析的剩余名称。它可以是一个复合名称，并且可以为 null。此字段由构造方法初始化。应该通过其 get、set 和 "append" 方法访问和操作此字段。
rootException
Throwable rootException
- 包含导致抛出此 NamingException 的原始异常。如果存在可以从原始异常中获得的附加信息，或者无法将原始异常映射到 NamingException 的子类，则设置此字段。可以为 null。
此字段早于通用异常链设施。
NamingException.initCause(Throwable)和NamingException.getCause()方法现在是访问此信息的首选方法。
类 javax.naming.NamingSecurityException 继承 NamingException 实现 Serializable serialVersionUID: 5855287647294685775L
类 javax.naming.NoInitialContextException 继承 NamingException 实现 Serializable serialVersionUID: -3413733186901258623L
类 javax.naming.NoPermissionException 继承 NamingSecurityException 实现 Serializable serialVersionUID: 8395332708699751775L
类 javax.naming.NotContextException 继承 NamingException 实现 Serializable serialVersionUID: 849752551644540417L
类 javax.naming.OperationNotSupportedException 继承 NamingException 实现 Serializable serialVersionUID: 5493232822427682064L
类 javax.naming.PartialResultException 继承 NamingException 实现 Serializable serialVersionUID: 2572144970049426786L
类 javax.naming.RefAddr 继承 Object 实现 Serializable serialVersionUID: -1468165120479154358L
序列化字段 addrType
String addrType
- 包含此地址的类型。
-
类 javax.naming.Reference 继承 Object 实现 Serializable serialVersionUID: -1673475790065791735L
序列化字段 className
String className
- 包含此 Reference 所引用的对象类的完全限定名称。
-
- 另请参见：
Class.getName()
addrs
Vector<E> addrs
- 包含此 Reference 中所包含的地址。由构造方法初始化。
-
classFactory
String classFactory
- 包含用来创建此 Reference 所引用的对象实例的工厂类名称。被初始化为 null。
-
classFactoryLocation
String classFactoryLocation
- 包含工厂类的位置。被初始化为 null。
-
类 javax.naming.ReferralException 继承 NamingException 实现 Serializable serialVersionUID: -2881363844695698876L
类 javax.naming.ServiceUnavailableException 继承 NamingException 实现 Serializable serialVersionUID: -4996964726566773444L
类 javax.naming.SizeLimitExceededException 继承 LimitExceededException 实现 Serializable serialVersionUID: 7129289564879168579L
类 javax.naming.StringRefAddr 继承 RefAddr 实现 Serializable serialVersionUID: -8913762495138505527L
序列化字段 contents
String contents
- 包含此地址的内容。可以为 null。
-
类 javax.naming.TimeLimitExceededException 继承 LimitExceededException 实现 Serializable serialVersionUID: -3597009011385034696L
软件包 javax.naming.directory 类 javax.naming.directory.AttributeInUseException 继承 NamingException 实现 Serializable serialVersionUID: 4437710305529322564L
类 javax.naming.directory.AttributeModificationException 继承 NamingException 实现 Serializable serialVersionUID: 8060676069678710186L
序列化字段 unexecs
ModificationItem[] unexecs
- 包含未执行修改的可能为 null 的列表。
-
类 javax.naming.directory.BasicAttribute 继承 Object 实现 Serializable serialVersionUID: 6743528196119291326L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 重写以避免公开实现细节。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 重写以避免公开实现细节
- 序列数据：
- Default field (the attribute ID -- a String), followed by the number of values (an int), and the individual values.
- 抛出：
IOException
序列化字段 attrID
String attrID
- 保存属性的 id。其由公共构造方法初始化且不能为 null，除非已经重写 BasicAttribute 中使用 attrID 的方法。
-
ordered
boolean ordered
- 记录此属性的值是否有序的标志。
-
类 javax.naming.directory.BasicAttributes 继承 Object 实现 Serializable serialVersionUID: 4980164073184639448L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 重写以避免公开实现细节。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 重写以避免公开实现细节。
- 序列数据：
- Default field (ignoreCase flag -- a boolean), followed by the number of attributes in the set (an int), and then the individual Attribute objects.
- 抛出：
IOException
序列化字段 ignoreCase
boolean ignoreCase
- 指示是否忽略属性 id 的大小写。
-
类 javax.naming.directory.InvalidAttributeIdentifierException 继承 NamingException 实现 Serializable serialVersionUID: -9036920266322999923L
类 javax.naming.directory.InvalidAttributesException 继承 NamingException 实现 Serializable serialVersionUID: 2607612850539889765L
类 javax.naming.directory.InvalidAttributeValueException 继承 NamingException 实现 Serializable serialVersionUID: 8720050295499275011L
类 javax.naming.directory.InvalidSearchControlsException 继承 NamingException 实现 Serializable serialVersionUID: -5124108943352665777L
类 javax.naming.directory.InvalidSearchFilterException 继承 NamingException 实现 Serializable serialVersionUID: 2902700940682875441L
类 javax.naming.directory.ModificationItem 继承 Object 实现 Serializable serialVersionUID: 7573258562534746850L
序列化字段 mod_op
int mod_op
- 包含标识要执行的修改的整数。
-
attr
Attribute attr
- 包含标识要应用于修改的属性和/或其值的属性。
-
类 javax.naming.directory.NoSuchAttributeException 继承 NamingException 实现 Serializable serialVersionUID: 4836415647935888137L
类 javax.naming.directory.SchemaViolationException 继承 NamingException 实现 Serializable serialVersionUID: -3041762429525049663L
类 javax.naming.directory.SearchControls 继承 Object 实现 Serializable serialVersionUID: -2480540967773454797L
序列化字段 searchScope
int searchScope
- 包含应用搜索的范围。ONELEVEL_SCOPE、OBJECT_SCOPE 或 SUBTREE_SCOPE 之一。
-
timeLimit
int timeLimit
- 包含从搜索返回前要等待的毫秒数。
-
derefLink
boolean derefLink
- 指示在搜索期间是否取消对 JNDI 链接的引用。
-
returnObj
boolean returnObj
- 指示是否在 SearchResult 中返回对象。
-
countLimit
long countLimit
- 包含要返回的最大 SearchResults 数。
-
attributesToReturn
String[] attributesToReturn
- 包含要为搜索的每个匹配项在 SearchResult 中返回的属性所组成的列表。null 指示要返回所有属性。
-
类 javax.naming.directory.SearchResult 继承 Binding 实现 Serializable serialVersionUID: -9158063327699723172L
序列化字段 attrs
Attributes attrs
- 包含与对象一起返回的属性。
-
软件包 javax.naming.event 类 javax.naming.event.NamingEvent 继承 EventObject 实现 Serializable serialVersionUID: -7126752885365133499L
序列化字段 changeInfo
Object changeInfo
- 包含关于生成此事件的更改的信息。
-
type
int type
- 包含此事件的类型。
oldBinding
Binding oldBinding
- 包含关于更改前对象的信息。
-
newBinding
Binding newBinding
- 包含关于更改后对象的信息。
-
类 javax.naming.event.NamingExceptionEvent 继承 EventObject 实现 Serializable serialVersionUID: -4877678086134736336L
序列化字段 exception
NamingException exception
- 包含抛出过的异常
-
软件包 javax.naming.ldap 类 javax.naming.ldap.BasicControl 继承 Object 实现 Serializable serialVersionUID: -4233907508771791687L
序列化字段 id
String id
- 控件的对象标识符字符串。
-
criticality
boolean criticality
- 控件的关键性。
-
value
byte[] value
- 控件的 ASN.1 BER 编码值。
-
类 javax.naming.ldap.LdapName 继承 Object 实现 Serializable serialVersionUID: -1595520034788997356L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 仅序列化未解析的 DN，以更紧密并避免任何实现依赖关系。
- 序列数据：
- The DN string
- 抛出：
IOException
类 javax.naming.ldap.LdapReferralException 继承 ReferralException 实现 Serializable serialVersionUID: -1668992791764950804L
类 javax.naming.ldap.ManageReferralControl 继承 BasicControl 实现 Serializable serialVersionUID: 3017756160149982566L
类 javax.naming.ldap.PagedResultsControl 继承 BasicControl 实现 Serializable serialVersionUID: 6684806685736844298L
类 javax.naming.ldap.PagedResultsResponseControl 继承 BasicControl 实现 Serializable serialVersionUID: -8819778744844514666L
序列化字段 resultSize
int resultSize
- 搜索结果中的项数的估计值。
-
cookie
byte[] cookie
- 服务器生成的 cookie。
-
类 javax.naming.ldap.Rdn 继承 Object 实现 Serializable serialVersionUID: -5994465067210009656L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 仅序列化未解析的 RDN，以更紧密并避免任何实现依赖关系。
- 序列数据：
- The RDN string
- 抛出：
IOException
类 javax.naming.ldap.SortControl 继承 BasicControl 实现 Serializable serialVersionUID: -1965961680233330744L
类 javax.naming.ldap.SortResponseControl 继承 BasicControl 实现 Serializable serialVersionUID: 5142939176006310877L
序列化字段 resultCode
int resultCode
- 排序结果代码。
-
badAttrId
String badAttrId
- 导致排序失败的属性的 ID。
-
类 javax.naming.ldap.StartTlsRequest 继承 Object 实现 Serializable serialVersionUID: 4441679576360753397L
类 javax.naming.ldap.StartTlsResponse 继承 Object 实现 Serializable serialVersionUID: 8372842182579276418L
类 javax.naming.ldap.UnsolicitedNotificationEvent 继承 EventObject 实现 Serializable serialVersionUID: -2382603380799883705L
序列化字段 notice
UnsolicitedNotification notice
- 导致触发此事件的通知。
-
软件包 javax.naming.spi 类 javax.naming.spi.ResolveResult 继承 Object 实现 Serializable serialVersionUID: -4552108072002407559L
序列化字段 resolvedObj
Object resolvedObj
- 该字段包含已成功解析成的 Object。它只在使用子类构造时可以为 null。构造方法应该总是初始化此字段。
-
remainingName
Name remainingName
- 该字段包含要解析的剩余名称。它只在使用子类构造时可以为 null。构造方法应该总是初始化此字段。
-
软件包 javax.net.ssl 类 javax.net.ssl.HandshakeCompletedEvent 继承 EventObject 实现 Serializable 类 javax.net.ssl.SSLException 继承 IOException 实现 Serializable 类 javax.net.ssl.SSLHandshakeException 继承 SSLException 实现 Serializable 类 javax.net.ssl.SSLKeyException 继承 SSLException 实现 Serializable 类 javax.net.ssl.SSLPeerUnverifiedException 继承 SSLException 实现 Serializable 类 javax.net.ssl.SSLPermission 继承 BasicPermission 实现 Serializable 类 javax.net.ssl.SSLProtocolException 继承 SSLException 实现 Serializable 类 javax.net.ssl.SSLSessionBindingEvent 继承 EventObject 实现 Serializable 序列化字段 name
String name
- 将对象绑定到的或从其解除绑定的名称
软件包 javax.print 类 javax.print.DocFlavor 继承 Object 实现 Serializable serialVersionUID: -4512080796965449721L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 从流重构实例（也就是将其反序列化）。
- 序列数据：
- DocFlavor 的序列化形式是名称为表示形式类的 String，后跟表示 MIME 类型规范形式的 String。
- 抛出：
ClassNotFoundExceptionIOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将实例写入流中（也就是序列化该对象）。
- 抛出：
IOException
序列化字段 myClassName
String myClassName
- 表示形式类名。
-
类 javax.print.DocFlavor.BYTE_ARRAY 继承 DocFlavor 实现 Serializable serialVersionUID: -9065578006593857475L
类 javax.print.DocFlavor.CHAR_ARRAY 继承 DocFlavor 实现 Serializable serialVersionUID: -8720590903724405128L
类 javax.print.DocFlavor.INPUT_STREAM 继承 DocFlavor 实现 Serializable serialVersionUID: -7045842700749194127L
类 javax.print.DocFlavor.READER 继承 DocFlavor 实现 Serializable serialVersionUID: 7100295812579351567L
类 javax.print.DocFlavor.SERVICE_FORMATTED 继承 DocFlavor 实现 Serializable serialVersionUID: 6181337766266637256L
类 javax.print.DocFlavor.STRING 继承 DocFlavor 实现 Serializable serialVersionUID: 4414407504887034035L
类 javax.print.DocFlavor.URL 继承 DocFlavor 实现 Serializable 类 javax.print.PrintException 继承 Exception 实现 Serializable
软件包 javax.print.attribute 类 javax.print.attribute.AttributeSetUtilities.SynchronizedAttributeSet 继承 Object 实现 Serializable 序列化字段 attrset
AttributeSet attrset
类 javax.print.attribute.AttributeSetUtilities.SynchronizedDocAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.SynchronizedAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.SynchronizedPrintJobAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.SynchronizedAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.SynchronizedPrintRequestAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.SynchronizedAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.SynchronizedPrintServiceAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.SynchronizedAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.UnmodifiableAttributeSet 继承 Object 实现 Serializable 序列化字段 attrset
AttributeSet attrset
类 javax.print.attribute.AttributeSetUtilities.UnmodifiableDocAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.UnmodifiableAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.UnmodifiablePrintJobAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.UnmodifiableAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.UnmodifiablePrintRequestAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.UnmodifiableAttributeSet 实现 Serializable 类 javax.print.attribute.AttributeSetUtilities.UnmodifiablePrintServiceAttributeSet 继承 javax.print.attribute.AttributeSetUtilities.UnmodifiableAttributeSet 实现 Serializable 类 javax.print.attribute.DateTimeSyntax 继承 Object 实现 Serializable serialVersionUID: -1400819079791208582L
序列化字段 value
Date value
- 此日期-时间属性的
java.util.Date值。 -
类 javax.print.attribute.EnumSyntax 继承 Object 实现 Serializable serialVersionUID: -2739521845085831642L
序列化方法 readResolve
protected Object readResolve() throws ObjectStreamException
- 在对象输入过程中，将此反序列化的枚举实例转换为枚举属性类中定义的适当枚举值。
- 抛出：
ObjectStreamException- 如果无法对流反序列化InvalidObjectException- 如果枚举值表为 null，此枚举值的整数值与枚举值表中的元素不对应，或枚举值表中的对应元素为 null，则抛出该异常。（注：InvalidObjectException是ObjectStreamException的一个子类，ObjectStreamException由readResolve()声明抛出。
序列化字段 value
int value
- 此枚举值的整数值。
-
类 javax.print.attribute.HashAttributeSet 继承 Object 实现 Serializable serialVersionUID: 5311560590283707917L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException
- 从流重构一个实例（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将该实例写入到流（即：将该对象序列化）
- 序列数据：
- 属性集的序列化形式显式写入该集合中的属性的数量和每个属性。这不保证序列化形式的相等性，因为未定义写入属性的顺序。
- 抛出：
IOException
序列化字段 myInterface
Class<T> myInterface
- 此属性集的所有成员必须是其实例的接口。假设是接口
Attribute或其子接口。 -
类 javax.print.attribute.HashDocAttributeSet 继承 HashAttributeSet 实现 Serializable serialVersionUID: -1128534486061432528L
类 javax.print.attribute.HashPrintJobAttributeSet 继承 HashAttributeSet 实现 Serializable serialVersionUID: -4204473656070350348L
类 javax.print.attribute.HashPrintRequestAttributeSet 继承 HashAttributeSet 实现 Serializable serialVersionUID: 2364756266107751933L
类 javax.print.attribute.HashPrintServiceAttributeSet 继承 HashAttributeSet 实现 Serializable serialVersionUID: 6642904616179203070L
类 javax.print.attribute.IntegerSyntax 继承 Object 实现 Serializable serialVersionUID: 3644574816328081943L
序列化字段 value
int value
- 此整数属性的整数值。
-
类 javax.print.attribute.ResolutionSyntax 继承 Object 实现 Serializable serialVersionUID: 2706743076526672017L
序列化字段 crossFeedResolution
int crossFeedResolution
- 以每 100 英寸点数 (dphi) 为单位的反向进纸分辨率。
-
feedResolution
int feedResolution
- 以每 100 英寸点数 (dphi) 为单位的进纸分辨率。
-
类 javax.print.attribute.SetOfIntegerSyntax 继承 Object 实现 Serializable serialVersionUID: 3666874174847632203L
序列化字段 members
int[][] members
- 规范数组形式表示的此集合的成员。
-
类 javax.print.attribute.Size2DSyntax 继承 Object 实现 Serializable serialVersionUID: 5584439964938660530L
序列化字段 x
int x
- 以微米 (µm) 为单位的 X 维度。
-
y
int y
- 以微米 (µm) 为单位的 Y 维度。
-
类 javax.print.attribute.TextSyntax 继承 Object 实现 Serializable serialVersionUID: -8130648736378144102L
序列化字段 value
String value
- 此文本属性的字符串值。
-
locale
Locale locale
- 此文本属性的语言环境。
-
类 javax.print.attribute.UnmodifiableSetException 继承 RuntimeException 实现 Serializable 类 javax.print.attribute.URISyntax 继承 Object 实现 Serializable serialVersionUID: -7842661210486401678L
序列化字段 uri
URI uri
- 此 URI 属性的 URI 值。
-
软件包 javax.print.attribute.standard 类 javax.print.attribute.standard.Chromaticity 继承 EnumSyntax 实现 Serializable serialVersionUID: 4660543931355214012L
类 javax.print.attribute.standard.ColorSupported 继承 EnumSyntax 实现 Serializable serialVersionUID: -2700555589688535545L
类 javax.print.attribute.standard.Compression 继承 EnumSyntax 实现 Serializable serialVersionUID: -5716748913324997674L
类 javax.print.attribute.standard.Copies 继承 IntegerSyntax 实现 Serializable serialVersionUID: -6426631521680023833L
类 javax.print.attribute.standard.CopiesSupported 继承 SetOfIntegerSyntax 实现 Serializable serialVersionUID: 6927711687034846001L
类 javax.print.attribute.standard.DateTimeAtCompleted 继承 DateTimeSyntax 实现 Serializable serialVersionUID: 6497399708058490000L
类 javax.print.attribute.standard.DateTimeAtCreation 继承 DateTimeSyntax 实现 Serializable serialVersionUID: -2923732231056647903L
类 javax.print.attribute.standard.DateTimeAtProcessing 继承 DateTimeSyntax 实现 Serializable serialVersionUID: -3710068197278263244L
类 javax.print.attribute.standard.Destination 继承 URISyntax 实现 Serializable serialVersionUID: 6776739171700415321L
类 javax.print.attribute.standard.DocumentName 继承 TextSyntax 实现 Serializable serialVersionUID: 7883105848533280430L
类 javax.print.attribute.standard.Fidelity 继承 EnumSyntax 实现 Serializable serialVersionUID: 6320827847329172308L
类 javax.print.attribute.standard.Finishings 继承 EnumSyntax 实现 Serializable serialVersionUID: -627840419548391754L
类 javax.print.attribute.standard.JobHoldUntil 继承 DateTimeSyntax 实现 Serializable serialVersionUID: -1664471048860415024L
类 javax.print.attribute.standard.JobImpressions 继承 IntegerSyntax 实现 Serializable serialVersionUID: 8225537206784322464L
类 javax.print.attribute.standard.JobImpressionsCompleted 继承 IntegerSyntax 实现 Serializable serialVersionUID: 6722648442432393294L
类 javax.print.attribute.standard.JobImpressionsSupported 继承 SetOfIntegerSyntax 实现 Serializable serialVersionUID: -4887354803843173692L
类 javax.print.attribute.standard.JobKOctets 继承 IntegerSyntax 实现 Serializable serialVersionUID: -8959710146498202869L
类 javax.print.attribute.standard.JobKOctetsProcessed 继承 IntegerSyntax 实现 Serializable serialVersionUID: -6265238509657881806L
类 javax.print.attribute.standard.JobKOctetsSupported 继承 SetOfIntegerSyntax 实现 Serializable serialVersionUID: -2867871140549897443L
类 javax.print.attribute.standard.JobMediaSheets 继承 IntegerSyntax 实现 Serializable serialVersionUID: 408871131531979741L
类 javax.print.attribute.standard.JobMediaSheetsCompleted 继承 IntegerSyntax 实现 Serializable serialVersionUID: 1739595973810840475L
类 javax.print.attribute.standard.JobMediaSheetsSupported 继承 SetOfIntegerSyntax 实现 Serializable serialVersionUID: 2953685470388672940L
类 javax.print.attribute.standard.JobMessageFromOperator 继承 TextSyntax 实现 Serializable serialVersionUID: -4620751846003142047L
类 javax.print.attribute.standard.JobName 继承 TextSyntax 实现 Serializable serialVersionUID: 4660359192078689545L
类 javax.print.attribute.standard.JobOriginatingUserName 继承 TextSyntax 实现 Serializable serialVersionUID: -8052537926362933477L
类 javax.print.attribute.standard.JobPriority 继承 IntegerSyntax 实现 Serializable serialVersionUID: -4599900369040602769L
类 javax.print.attribute.standard.JobPrioritySupported 继承 IntegerSyntax 实现 Serializable serialVersionUID: 2564840378013555894L
类 javax.print.attribute.standard.JobSheets 继承 EnumSyntax 实现 Serializable serialVersionUID: -4735258056132519759L
类 javax.print.attribute.standard.JobState 继承 EnumSyntax 实现 Serializable serialVersionUID: 400465010094018920L
类 javax.print.attribute.standard.JobStateReason 继承 EnumSyntax 实现 Serializable serialVersionUID: -8765894420449009168L
类 javax.print.attribute.standard.JobStateReasons 继承 HashSet<JobStateReason> 实现 Serializable serialVersionUID: 8849088261264331812L
类 javax.print.attribute.standard.Media 继承 EnumSyntax 实现 Serializable serialVersionUID: -2823970704630722439L
类 javax.print.attribute.standard.MediaName 继承 Media 实现 Serializable serialVersionUID: 4653117714524155448L
类 javax.print.attribute.standard.MediaPrintableArea 继承 Object 实现 Serializable serialVersionUID: -1597171464050795793L
序列化字段 x
int x
y
int y
w
int w
h
int h
units
int units
类 javax.print.attribute.standard.MediaSize 继承 Size2DSyntax 实现 Serializable serialVersionUID: -1967958664615414771L
序列化字段 mediaName
MediaSizeName mediaName
类 javax.print.attribute.standard.MediaSizeName 继承 Media 实现 Serializable serialVersionUID: 2778798329756942747L
类 javax.print.attribute.standard.MediaTray 继承 Media 实现 Serializable serialVersionUID: -982503611095214703L
类 javax.print.attribute.standard.MultipleDocumentHandling 继承 EnumSyntax 实现 Serializable serialVersionUID: 8098326460746413466L
类 javax.print.attribute.standard.NumberOfDocuments 继承 IntegerSyntax 实现 Serializable serialVersionUID: 7891881310684461097L
类 javax.print.attribute.standard.NumberOfInterveningJobs 继承 IntegerSyntax 实现 Serializable serialVersionUID: 2568141124844982746L
类 javax.print.attribute.standard.NumberUp 继承 IntegerSyntax 实现 Serializable serialVersionUID: -3040436486786527811L
类 javax.print.attribute.standard.NumberUpSupported 继承 SetOfIntegerSyntax 实现 Serializable serialVersionUID: -1041573395759141805L
类 javax.print.attribute.standard.OrientationRequested 继承 EnumSyntax 实现 Serializable serialVersionUID: -4447437289862822276L
类 javax.print.attribute.standard.OutputDeviceAssigned 继承 TextSyntax 实现 Serializable serialVersionUID: 5486733778854271081L
类 javax.print.attribute.standard.PageRanges 继承 SetOfIntegerSyntax 实现 Serializable serialVersionUID: 8639895197656148392L
类 javax.print.attribute.standard.PagesPerMinute 继承 IntegerSyntax 实现 Serializable serialVersionUID: -6366403993072862015L
类 javax.print.attribute.standard.PagesPerMinuteColor 继承 IntegerSyntax 实现 Serializable serialVersionUID: 1684993151687470944L
类 javax.print.attribute.standard.PDLOverrideSupported 继承 EnumSyntax 实现 Serializable serialVersionUID: -4393264467928463934L
类 javax.print.attribute.standard.PresentationDirection 继承 EnumSyntax 实现 Serializable serialVersionUID: 8294728067230931780L
类 javax.print.attribute.standard.PrinterInfo 继承 TextSyntax 实现 Serializable serialVersionUID: 7765280618777599727L
类 javax.print.attribute.standard.PrinterIsAcceptingJobs 继承 EnumSyntax 实现 Serializable serialVersionUID: -5052010680537678061L
类 javax.print.attribute.standard.PrinterLocation 继承 TextSyntax 实现 Serializable serialVersionUID: -1598610039865566337L
类 javax.print.attribute.standard.PrinterMakeAndModel 继承 TextSyntax 实现 Serializable serialVersionUID: 4580461489499351411L
类 javax.print.attribute.standard.PrinterMessageFromOperator 继承 TextSyntax 实现 Serializable serialVersionUID: -4486871203218629318L
类 javax.print.attribute.standard.PrinterMoreInfo 继承 URISyntax 实现 Serializable serialVersionUID: 4555850007675338574L
类 javax.print.attribute.standard.PrinterMoreInfoManufacturer 继承 URISyntax 实现 Serializable serialVersionUID: 3323271346485076608L
类 javax.print.attribute.standard.PrinterName 继承 TextSyntax 实现 Serializable serialVersionUID: 299740639137803127L
类 javax.print.attribute.standard.PrinterResolution 继承 ResolutionSyntax 实现 Serializable serialVersionUID: 13090306561090558L
类 javax.print.attribute.standard.PrinterState 继承 EnumSyntax 实现 Serializable serialVersionUID: -649578618346507718L
类 javax.print.attribute.standard.PrinterStateReason 继承 EnumSyntax 实现 Serializable serialVersionUID: -1623720656201472593L
类 javax.print.attribute.standard.PrinterStateReasons 继承 HashMap<PrinterStateReason,Severity> 实现 Serializable serialVersionUID: -3731791085163619457L
类 javax.print.attribute.standard.PrinterURI 继承 URISyntax 实现 Serializable serialVersionUID: 7923912792485606497L
类 javax.print.attribute.standard.PrintQuality 继承 EnumSyntax 实现 Serializable serialVersionUID: -3072341285225858365L
类 javax.print.attribute.standard.QueuedJobCount 继承 IntegerSyntax 实现 Serializable serialVersionUID: 7499723077864047742L
类 javax.print.attribute.standard.ReferenceUriSchemesSupported 继承 EnumSyntax 实现 Serializable serialVersionUID: -8989076942813442805L
类 javax.print.attribute.standard.RequestingUserName 继承 TextSyntax 实现 Serializable serialVersionUID: -2683049894310331454L
类 javax.print.attribute.standard.Severity 继承 EnumSyntax 实现 Serializable serialVersionUID: 8781881462717925380L
类 javax.print.attribute.standard.SheetCollate 继承 EnumSyntax 实现 Serializable serialVersionUID: 7080587914259873003L
类 javax.print.attribute.standard.Sides 继承 EnumSyntax 实现 Serializable serialVersionUID: -6890309414893262822L
软件包 javax.print.event 类 javax.print.event.PrintEvent 继承 EventObject 实现 Serializable serialVersionUID: 2286914924430763847L
类 javax.print.event.PrintJobAttributeEvent 继承 PrintEvent 实现 Serializable serialVersionUID: -6534469883874742101L
序列化字段 attributes
PrintJobAttributeSet attributes
类 javax.print.event.PrintJobEvent 继承 PrintEvent 实现 Serializable serialVersionUID: -1711656903622072997L
序列化字段 reason
int reason
类 javax.print.event.PrintServiceAttributeEvent 继承 PrintEvent 实现 Serializable serialVersionUID: -7565987018140326600L
序列化字段 attributes
PrintServiceAttributeSet attributes
软件包 javax.rmi.CORBA 类 javax.rmi.CORBA.ClassDesc 继承 Object 实现 Serializable 序列化字段 repid
String repid
- 该类的 RepositoryId。
codebase
String codebase
- 代码基 URL 的空格分隔的列表。
类 javax.rmi.CORBA.Stub 继承 ObjectImpl 实现 Serializable serialVersionUID: 1087775603798577179L
序列化方法 readObject
private void readObject(ObjectInputStream stream) throws IOException, ClassNotFoundException
- 恢复 IOR 状态的序列化方法。
writeObject
private void writeObject(ObjectOutputStream stream) throws IOException
- 保存 IOR 状态的序列化方法。
- 序列数据：
- IOR 类型 ID (int) 的长度，后跟 IOR 类型 ID（使用 ISO8859-1 编码的字节数组），后跟 IOR 配置文件数 (int)，后跟 IOR 配置文件。每个 IOR 配置文件作为配置文件标签 (int) 写入，后跟配置文件数据 (int) 的长度，后跟配置文件数据（字节数组）。
- 抛出：
IOException
软件包 javax.rmi.ssl 类 javax.rmi.ssl.SslRMIClientSocketFactory 继承 Object 实现 Serializable serialVersionUID: -8310631444933958385L
软件包 javax.security.auth 类 javax.security.auth.AuthPermission 继承 BasicPermission 实现 Serializable serialVersionUID: 5806031445061587174L
类 javax.security.auth.DestroyFailedException 继承 Exception 实现 Serializable serialVersionUID: -7790152857282749162L
类 javax.security.auth.PrivateCredentialPermission 继承 Permission 实现 Serializable serialVersionUID: 5284372143517237068L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流读取此对象（也就是将其反序列化）。
序列化字段 credentialClass
String credentialClass
principals
Set<E> principals
- 与此 permission 相关联的 Principals 。该集合包含
PrivateCredentialPermission.CredOwner类型的元素。
testing
boolean testing
类 javax.security.auth.PrivateCredentialPermission.CredOwner 继承 Object 实现 Serializable serialVersionUID: -5607449830436408266L
序列化字段 principalClass
String principalClass
principalName
String principalName
类 javax.security.auth.RefreshFailedException 继承 Exception 实现 Serializable serialVersionUID: 5058444488565265840L
类 javax.security.auth.Subject 继承 Object 实现 Serializable serialVersionUID: -8308522755600156056L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 从流读取此对象（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 将此对象写入到流中（也就是将其序列化）。
- 抛出：
IOException
序列化字段 principals
Set<E> principals
- A
Setthat provides a view of all of this Subject's Principals - Each element in this set is a
java.security.Principal. The set is aSubject.SecureSet.
readOnly
boolean readOnly
- 此 Subject 是否为只读的
-
类 javax.security.auth.Subject.SecureSet 继承 AbstractSet 实现 Serializable serialVersionUID: 7911754171111800359L
序列化方法 readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- Writes this object out to a stream (i.e., serializes it).
- 序列数据：
- If this is a private credential set, a security check is performed to ensure that the caller has permission to access each credential in the set. If the security check passes, the set is serialized.
- 抛出：
IOException
序列化字段 elements
LinkedList<E> elements
- The elements in this set.
this$0
Subject this$0
- The outer Subject instance.
软件包 javax.security.auth.callback 类 javax.security.auth.callback.ChoiceCallback 继承 Object 实现 Serializable serialVersionUID: -3975664071579892167L
序列化字段 prompt
String prompt
-
- 从以下版本开始：
- 1.4
choices
String[] choices
- 选项列表
- 从以下版本开始：
- 1.4
defaultChoice
int defaultChoice
- 用作默认选项的选项
- 从以下版本开始：
- 1.4
multipleSelectionsAllowed
boolean multipleSelectionsAllowed
- 选项列表中是否允许进行多重选择
- 从以下版本开始：
- 1.4
selections
int[] selections
- 选中的选项，表示为
choices列表中的索引。- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.ConfirmationCallback 继承 Object 实现 Serializable serialVersionUID: -9095656433782481624L
序列化字段 prompt
String prompt
-
- 从以下版本开始：
- 1.4
messageType
int messageType
-
- 从以下版本开始：
- 1.4
optionType
int optionType
-
- 从以下版本开始：
- 1.4
defaultOption
int defaultOption
-
- 从以下版本开始：
- 1.4
options
String[] options
-
- 从以下版本开始：
- 1.4
selection
int selection
-
- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.LanguageCallback 继承 Object 实现 Serializable serialVersionUID: 2019050433478903213L
序列化字段 locale
Locale locale
-
- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.NameCallback 继承 Object 实现 Serializable serialVersionUID: 3770938795909392253L
序列化字段 prompt
String prompt
-
- 从以下版本开始：
- 1.4
defaultName
String defaultName
-
- 从以下版本开始：
- 1.4
inputName
String inputName
-
- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.PasswordCallback 继承 Object 实现 Serializable serialVersionUID: 2267422647454909926L
序列化字段 prompt
String prompt
-
- 从以下版本开始：
- 1.4
echoOn
boolean echoOn
-
- 从以下版本开始：
- 1.4
inputPassword
char[] inputPassword
-
- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.TextInputCallback 继承 Object 实现 Serializable serialVersionUID: -8064222478852811804L
序列化字段 prompt
String prompt
-
- 从以下版本开始：
- 1.4
defaultText
String defaultText
-
- 从以下版本开始：
- 1.4
inputText
String inputText
-
- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.TextOutputCallback 继承 Object 实现 Serializable serialVersionUID: 1689502495511663102L
序列化字段 messageType
int messageType
-
- 从以下版本开始：
- 1.4
message
String message
-
- 从以下版本开始：
- 1.4
类 javax.security.auth.callback.UnsupportedCallbackException 继承 Exception 实现 Serializable serialVersionUID: -6873556327655666839L
序列化字段 callback
Callback callback
软件包 javax.security.auth.kerberos 类 javax.security.auth.kerberos.DelegationPermission 继承 BasicPermission 实现 Serializable serialVersionUID: 883133252142523922L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject 从流中恢复 DelegationPermission 的状态。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 调用 WriteObject 将 DelegationPermission 的状态保存到流中。操作已被序列化，超类负责管理名称。
- 抛出：
IOException
类 javax.security.auth.kerberos.KerberosKey 继承 Object 实现 Serializable serialVersionUID: -4625402278148246993L
序列化字段 principal
KerberosPrincipal principal
- 此秘密密钥所属的主体。
-
versionNum
int versionNum
- 此秘密密钥的版本号。
-
key
javax.security.auth.kerberos.KeyImpl key
- 通过写出加密密钥的 ASN1 Encoded 字节来序列化
KeyImpl。ASN1 编码在 RFC1510 中得到定义，如下所示：EncryptionKey ::= SEQUENCE { keytype[0] INTEGER, keyvalue[1] OCTET STRING } -
类 javax.security.auth.kerberos.KerberosPrincipal 继承 Object 实现 Serializable serialVersionUID: -7374788026156829911L
序列化方法 readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
- 从流读取此对象（也就是将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream oos) throws IOException
- 将 KerberosPrincipal 对象保存到流中。
- 序列数据：
- 通过以 DER-encoded 形式（在 RFC1510 的 5.2 小节中指定）写出 PrincipalName 和域来序列化
KerberosPrincipal。 - 抛出：
IOException
类 javax.security.auth.kerberos.KerberosTicket 继承 Object 实现 Serializable serialVersionUID: 7395334370157380539L
序列化字段 asn1Encoding
byte[] asn1Encoding
- 定义在 Kerberos Protocol Specification RFC1510 中的 Ticket ASN.1 DER Encoding。
-
sessionKey
javax.security.auth.kerberos.KeyImpl sessionKey
- 通过写出加密密钥的 ASN1 Encoded 字节来序列化
KeyImpl。ASN1 编码在 RFC1510 中定义如下：EncryptionKey ::= SEQUENCE { keytype[0] INTEGER, keyvalue[1] OCTET STRING } -
flags
boolean[] flags
- Kerberos Protocol Specification RFC1510 中定义了票据标志。
-
authTime
Date authTime
- 初始身份验证的时间。
-
startTime
Date startTime
- 经过这段时间后票据开始生效。
-
endTime
Date endTime
- 经过这段时间后将不再支持此票据。（其过期时间）。
-
renewTill
Date renewTill
- 对于可更新的 Ticket，它指示包含在某一更新中的最长终止时间。可以认为它是票据的绝对过期时间，其中包括所有的更新。对于不可更新的票据，此字段可以为 null。
-
client
KerberosPrincipal client
- 拥有服务票据的客户端。
-
server
KerberosPrincipal server
- 一项服务，已将票据发送给它。
-
clientAddresses
InetAddress[] clientAddresses
- 客户端可以从其所在位置使用票据的地址。如果票据在任何地址都是可用的，则此字段可以为 null。
-
类 javax.security.auth.kerberos.KeyImpl 继承 Object 实现 Serializable serialVersionUID: -7889313790214321193L
序列化方法 readObject
private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException
writeObject
private void writeObject(ObjectOutputStream ois) throws IOException
- 序列数据：
- this
KeyImplis serialized by writing out the ASN1 Encoded bytes of the encryption key. The ASN1 encoding is defined in RFC1510 and as follows: EncryptionKey ::= SEQUENCE { keytype[0] INTEGER, keyvalue[1] OCTET STRING } - 抛出：
IOException
类 javax.security.auth.kerberos.ServicePermission 继承 Permission 实现 Serializable serialVersionUID: -1227585031618624935L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, ClassNotFoundException
- 调用 readObject 从流中恢复 ServicePermission 的状态。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 调用 WriteObject 将 ServicePermission 的状态保存到流中。操作已被序列化，超类负责管理名称。
- 抛出：
IOException
序列化字段 actions
String actions
- 动作字符串。
-
软件包 javax.security.auth.login 类 javax.security.auth.login.AccountException 继承 LoginException 实现 Serializable serialVersionUID: -2112878680072211787L
类 javax.security.auth.login.AccountExpiredException 继承 AccountException 实现 Serializable serialVersionUID: -6064064890162661560L
类 javax.security.auth.login.AccountLockedException 继承 AccountException 实现 Serializable serialVersionUID: 8280345554014066334L
类 javax.security.auth.login.AccountNotFoundException 继承 AccountException 实现 Serializable serialVersionUID: 1498349563916294614L
类 javax.security.auth.login.CredentialException 继承 LoginException 实现 Serializable serialVersionUID: -4772893876810601859L
类 javax.security.auth.login.CredentialExpiredException 继承 CredentialException 实现 Serializable serialVersionUID: -5344739593859737937L
类 javax.security.auth.login.CredentialNotFoundException 继承 CredentialException 实现 Serializable serialVersionUID: -7779934467214319475L
类 javax.security.auth.login.FailedLoginException 继承 LoginException 实现 Serializable serialVersionUID: 802556922354616286L
类 javax.security.auth.login.LoginException 继承 GeneralSecurityException 实现 Serializable serialVersionUID: -4679091624035232488L
软件包 javax.security.auth.x500 类 javax.security.auth.x500.X500Principal 继承 Object 实现 Serializable serialVersionUID: -500463348111345721L
序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException, NotActiveException, ClassNotFoundException
- 从流读取此对象（即将其反序列化）。
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 将 X500Principal 对象保存到流中。
- 序列数据：
- 此
X500Principal通过写出它的 DER 编码格式（getEncoded的值被序列化）来获得序列化。 - 抛出：
IOException
软件包 javax.security.cert 类 javax.security.cert.CertificateEncodingException 继承 CertificateException 实现 Serializable 类 javax.security.cert.CertificateException 继承 Exception 实现 Serializable 类 javax.security.cert.CertificateExpiredException 继承 CertificateException 实现 Serializable 类 javax.security.cert.CertificateNotYetValidException 继承 CertificateException 实现 Serializable 类 javax.security.cert.CertificateParsingException 继承 CertificateException 实现 Serializable
软件包 javax.security.sasl 类 javax.security.sasl.AuthenticationException 继承 SaslException 实现 Serializable serialVersionUID: -3579708765071815007L
类 javax.security.sasl.AuthorizeCallback 继承 Object 实现 Serializable serialVersionUID: -2353344186490470805L
序列化字段 authenticationID
String authenticationID
- 要检查的（已验证的）身份验证 id。
-
authorizationID
String authorizationID
- 要检查的授权 id。
-
authorizedID
String authorizedID
- 已授权实体的 id。如果为 null，则已授权实体的 id 是 authorizationID。
-
authorized
boolean authorized
- 一个标志，指示是否允许用身份验证 id 代表授权 id。
-
类 javax.security.sasl.RealmCallback 继承 TextInputCallback 实现 Serializable serialVersionUID: -4342673378785456908L
类 javax.security.sasl.RealmChoiceCallback 继承 ChoiceCallback 实现 Serializable serialVersionUID: -8588141348846281332L
类 javax.security.sasl.SaslException 继承 IOException 实现 Serializable serialVersionUID: 4579784287983423626L
序列化字段 _exception
Throwable _exception
- 根本原因异常，可以为 null。
-
软件包 javax.sound.midi 类 javax.sound.midi.InvalidMidiDataException 继承 Exception 实现 Serializable 类 javax.sound.midi.MidiUnavailableException 继承 Exception 实现 Serializable
软件包 javax.sound.sampled 类 javax.sound.sampled.AudioPermission 继承 BasicPermission 实现 Serializable 类 javax.sound.sampled.LineUnavailableException 继承 Exception 实现 Serializable 类 javax.sound.sampled.UnsupportedAudioFileException 继承 Exception 实现 Serializable
软件包 javax.sql 类 javax.sql.ConnectionEvent 继承 EventObject 实现 Serializable serialVersionUID: -4843217645290030002L
序列化字段 ex
SQLException ex
- 发生错误且入池连接不再可用时驱动程序将向应用程序抛出的
SQLException。 -
类 javax.sql.RowSetEvent 继承 EventObject 实现 Serializable serialVersionUID: -1875450876546332005L
软件包 javax.sql.rowset 类 javax.sql.rowset.BaseRowSet 继承 Object 实现 Serializable serialVersionUID: 4886719666485113312L
序列化字段 binaryStream
InputStream binaryStream
- 将由方法
getBinaryStream返回的InputStream对象，该方法在ResultSet接口中指定。 -
unicodeStream
InputStream unicodeStream
- 将由方法
getUnicodeStream返回的InputStream对象，该方法在ResultSet接口中指定。 -
asciiStream
InputStream asciiStream
- 将由方法
getAsciiStream返回的InputStream对象，该方法在ResultSet接口中指定。 -
charStream
Reader charStream
- 将由方法
getCharacterStream返回的Reader对象，该方法在ResultSet接口中指定。 -
command
String command
- 发送到 DBMS 的查询，调用方法
execute时执行该查询。 -
URL
String URL
- 当使用
DriverManager获得连接时，reader、writer 或二者提供给方法DriverManager.getConnection的 JDBC URL。该 JDBC URL 标识用于建立连接的驱动程序。可在驱动程序供应商提供的文档中找到此 URL。
-
dataSource
String dataSource
- 为了从 Java Directory and Naming Interface (JNDI) 命名服务中检索
DataSource对象，reader/writer 应该使用的数据源逻辑名。 -
rowSetType
int rowSetType
- 指示此 JDBC
RowSet对象类型的常量。它必须是以下ResultSet常量之一：TYPE_FORWARD_ONLY、TYPE_SCROLL_INSENSITIVE或TYPE_SCROLL_SENSITIVE。 -
showDeleted
boolean showDeleted
- 指示已删除行在此 JDBC
RowSet对象中是否可见的boolean值。 -
queryTimeout
int queryTimeout
- 驱动程序等待执行命令的最大秒数。当此 JDBC
RowSet对象连接到其数据源时应用此限制，也就是用数据填充该对象和该对象将数据写回数据源时。 -
maxRows
int maxRows
- reader 应该读取的最大行数。
-
maxFieldSize
int maxFieldSize
- reader 应该读取的最大字段大小。
-
concurrency
int concurrency
- 指示此 JDBC
RowSet对象并发性的常量。它必须是以下ResultSet常量之一：CONCUR_READ_ONLY或CONCUR_UPDATABLE。 -
readOnly
boolean readOnly
- 指示此 JDBC
RowSet对象是否为只读的boolean值。true指示它是只读的；false指示它是可写入的。 -
escapeProcessing
boolean escapeProcessing
- 指示此 JDBC
RowSet对象的 reader 是否应该执行转义处理的boolean值。true表示开启转义处理；false表示关闭。默认值为true。 -
isolation
int isolation
- 指示此 JDBC
RowSet对象连接的隔离级别的常量。它必须是以下Connection常量之一：TRANSACTION_NONE、TRANSACTION_READ_UNCOMMITTED、TRANSACTION_READ_COMMITTED、TRANSACTION_REPEATABLE_READ或TRANSACTION_SERIALIZABLE。 -
fetchDir
int fetchDir
- 用作驱动程序提示的常量，指示要从此 JDBC
RowSet对象获取数据时所用的方向。可能的ResultSet常量值如下：FETCH_FORWARD、FETCH_REVERSE、FETCH_UNKNOWN。目前未使用。
-
fetchSize
int fetchSize
- 为驱动程序提供的提示，指示此 JDBC
RowSet对象中的预期行数。目前未使用。
-
map
Map<K,V> map
- 一个
java.util.Map对象，其中包含的项提供了 SQL 类型名称到 Java 编程语言中类的映射，以用于用户定义类型的自定义映射。 -
listeners
Vector<E> listeners
- 一个
Vector对象，保存已向此RowSet对象注册的侦听器所组成的列表。 -
params
Hashtable<K,V> params
- 一个
Vector对象，保存此RowSet对象的当前命令的参数集。 -
类 javax.sql.rowset.RowSetMetaDataImpl 继承 Object 实现 Serializable serialVersionUID: 6893806403181801867L
序列化字段 colCount
int colCount
- 创建此
RowSetMetaDataImpl对象的RowSet对象中的列数。 -
colInfo
javax.sql.rowset.RowSetMetaDataImpl.ColInfo[] colInfo
ColInfo对象数组，这些对象用于存储关于RowSet对象（此RowSetMetaDataImpl对象为其创建）中每个列的信息。此数组中的第一个ColInfo对象包含关于RowSet对象中第一个列的信息，第二个元素包含关于第二列的信息，依此类推。-
类 javax.sql.rowset.RowSetWarning 继承 SQLException 实现 Serializable serialVersionUID: 6678332766434564774L
序列化字段 rwarning
RowSetWarning rwarning
- RowSetWarning 对象句柄。
软件包 javax.sql.rowset.serial 类 javax.sql.rowset.serial.SerialArray 继承 Object 实现 Serializable serialVersionUID: -8466174297270688520L
序列化字段 elements
Object[] elements
- 序列化数组，每个数组元素都是一个 Java 编程语言中表示 SQL
ARRAY值的Object。 -
baseType
int baseType
- 此
SerialArray对象中 SQL 类型的元素。该类型表示为java.sql.Types类中的一个常量。 -
baseTypeName
String baseTypeName
- DBMS 将该类型名称用于此
SerialArray对象所表示的 SQLARRAY值中的元素。 -
len
int len
- 此
SerialArray对象中的元素数，同时还是此SerialArray对象所表示的 SQLARRAY值中的元素数。 -
类 javax.sql.rowset.serial.SerialBlob 继承 Object 实现 Serializable serialVersionUID: -8144641928112860441L
序列化字段 buf
byte[] buf
- 表示此
SerialBlob对象值的序列化未解释字节数组。 -
blob
Blob blob
Blob对象的内部表示形式，此SerialBlob对象以该对象为基础。
len
long len
- 此
SerialBlob对象的字节数组中的字节数。 -
origLen
long origLen
- 刚建立时此
SerialBlob对象的字节数组中的原始字节数。 -
类 javax.sql.rowset.serial.SerialClob 继承 Object 实现 Serializable serialVersionUID: -1662519690087375313L
序列化字段 buf
char[] buf
- 一个序列化字符数组，包含此
SerialClob对象所表示的 SQLCLOB值的数据。 -
clob
Clob clob
- 使用 Clob 初始化 SerialClob 时内部 Clob 表示形式
len
long len
- 此
SerialClob对象内部字符数组的长度（以字符为单位）。 -
origLen
long origLen
- 此
SerialClob对象内部字符数组的原始长度（以字符为单位）。 -
类 javax.sql.rowset.serial.SerialDatalink 继承 Object 实现 Serializable serialVersionUID: 2826907821828733626L
序列化字段 url
URL url
- 提取的 URL 字段，该字段是从 DATALINK 字段检索的。
-
baseType
int baseType
- 此
SerialDatalink对象中 SQL 类型的元素。该类型表示为java.sql.Types类中的常量之一。 -
baseTypeName
String baseTypeName
- DBMS 将该类型名称用于此 SerialDatalink 对象所表示的 SQL
DATALINK值中的元素。 -
类 javax.sql.rowset.serial.SerialException 继承 SQLException 实现 Serializable serialVersionUID: -489794565168592690L
类 javax.sql.rowset.serial.SerialJavaObject 继承 Object 实现 Serializable serialVersionUID: -1465795139032831023L
序列化字段 obj
Object obj
- 要序列化的对象的占位符。
chain
Vector<E> chain
- A container for the warnings issued on this
SerialJavaObjectobject. When there are multiple warnings, each warning is chained to the previous warning.
类 javax.sql.rowset.serial.SerialRef 继承 Object 实现 Serializable serialVersionUID: -4727123500609662274L
序列化字段 baseTypeName
String baseTypeName
- 包含基本类型名称的字符串。
-
object
Object object
- 此类将类型
Ref存储为Object。
reference
Ref reference
- Ref 引用的私有副本。
类 javax.sql.rowset.serial.SerialStruct 继承 Object 实现 Serializable serialVersionUID: -8322445504027483372L
序列化字段 SQLTypeName
String SQLTypeName
- 此
SerialStruct对象所表示的结构类型的 SQL 类型名称。此为在 SQL 结构类型的 SQL 定义中使用的名称。 -
attribs
Object[] attribs
Object实例数组，每个数组元素都是此SerialStruct对象所表示的 SQL 结构类型的属性。这些属性按照它们在 SQL 结构类型定义中的顺序排列。-
软件包 javax.sql.rowset.spi 类 javax.sql.rowset.spi.SyncFactoryException 继承 SQLException 实现 Serializable serialVersionUID: -4354595476433200352L
类 javax.sql.rowset.spi.SyncProviderException 继承 SQLException 实现 Serializable serialVersionUID: -939908523620640692L
序列化字段 syncResolver
SyncResolver syncResolver
- 调用
getSyncResolver方法时此SyncProviderException对象将返回的javax.sql.rowset.spi.SyncResolver实例。
软件包 javax.transaction 类 javax.transaction.InvalidTransactionException 继承 RemoteException 实现 Serializable 类 javax.transaction.TransactionRequiredException 继承 RemoteException 实现 Serializable 类 javax.transaction.TransactionRolledbackException 继承 RemoteException 实现 Serializable
软件包 javax.transaction.xa 类 javax.transaction.xa.XAException 继承 Exception 实现 Serializable 序列化字段 errorCode
int errorCode
- 用其创建 SystemException 的错误代码。
- 该异常的错误代码
软件包 javax.xml.datatype 类 javax.xml.datatype.DatatypeConfigurationException 继承 Exception 实现 Serializable
软件包 javax.xml.namespace 类 javax.xml.namespace.QName 继承 Object 实现 Serializable serialVersionUID: 4418622981026545151L
序列化字段 namespaceURI
String namespaceURI
此
QName的名称空间 URI。
localPart
String localPart
此
QName的本地部分。
prefix
String prefix
此
QName的前缀。
软件包 javax.xml.parsers 类 javax.xml.parsers.FactoryConfigurationError 继承 Error 实现 Serializable 序列化字段 exception
Exception exception
- 表示该错误的
Exception。
类 javax.xml.parsers.ParserConfigurationException 继承 Exception 实现 Serializable
软件包 javax.xml.transform 类 javax.xml.transform.TransformerConfigurationException 继承 TransformerException 实现 Serializable 类 javax.xml.transform.TransformerException 继承 Exception 实现 Serializable 序列化字段 locator
SourceLocator locator
- Field locator specifies where the error occured
containedException
Throwable containedException
- Field containedException specifies a wrapped exception. May be null.
类 javax.xml.transform.TransformerFactoryConfigurationError 继承 Error 实现 Serializable 序列化字段 exception
Exception exception
TransformerFactoryConfigurationError的Exception。
软件包 javax.xml.xpath 类 javax.xml.xpath.XPathException 继承 Exception 实现 Serializable serialVersionUID: -1837080260374986980L
序列化字段 cause
Throwable cause
类 javax.xml.xpath.XPathExpressionException 继承 XPathException 实现 Serializable serialVersionUID: -1837080260374986980L
类 javax.xml.xpath.XPathFactoryConfigurationException 继承 XPathException 实现 Serializable serialVersionUID: -1837080260374986980L
类 javax.xml.xpath.XPathFunctionException 继承 XPathExpressionException 实现 Serializable serialVersionUID: -1837080260374986980L
软件包 org.ietf.jgss 类 org.ietf.jgss.GSSException 继承 Exception 实现 Serializable serialVersionUID: -2706218945227726672L
序列化字段 major
int major
- 此异常的主要代码。
-
minor
int minor
- 此异常的次要代码。
-
minorMessage
String minorMessage
- 次要代码的文本字符串
-
majorString
String majorString
- 主要代码的替换文本字符串
-
软件包 org.omg.CosNaming 类 org.omg.CosNaming._BindingIteratorImplBase 继承 DynamicImplementation 实现 Serializable 类 org.omg.CosNaming._BindingIteratorStub 继承 ObjectImpl 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException
- 抛出：
IOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 抛出：
IOException
类 org.omg.CosNaming._NamingContextExtStub 继承 ObjectImpl 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException
- 抛出：
IOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 抛出：
IOException
类 org.omg.CosNaming._NamingContextImplBase 继承 DynamicImplementation 实现 Serializable 类 org.omg.CosNaming._NamingContextStub 继承 ObjectImpl 实现 Serializable 序列化方法 readObject
private void readObject(ObjectInputStream s) throws IOException
- 抛出：
IOException
writeObject
private void writeObject(ObjectOutputStream s) throws IOException
- 抛出：
IOException
类 org.omg.CosNaming.Binding 继承 Object 实现 Serializable 序列化字段 binding_name
NameComponent[] binding_name
binding_type
BindingType binding_type
类 org.omg.CosNaming.BindingType 继承 Object 实现 Serializable 序列化字段 __value
int __value
类 org.omg.CosNaming.NameComponent 继承 Object 实现 Serializable 序列化字段 id
String id
kind
String kind
软件包 org.w3c.dom 类 org.w3c.dom.DOMException 继承 RuntimeException 实现 Serializable serialVersionUID: 6627732366795969916L
序列化字段 code
short code
软件包 org.w3c.dom.events 类 org.w3c.dom.events.EventException 继承 RuntimeException 实现 Serializable 序列化字段 code
short code
软件包 org.w3c.dom.ls 类 org.w3c.dom.ls.LSException 继承 RuntimeException 实现 Serializable 序列化字段 code
short code
软件包 org.xml.sax 类 org.xml.sax.SAXException 继承 Exception 实现 Serializable serialVersionUID: 583241635256073760L
序列化字段 exception
Exception exception
- 使用隧道时的嵌入异常，否则为 null。
类 org.xml.sax.SAXNotRecognizedException 继承 SAXException 实现 Serializable serialVersionUID: 5440506620509557213L
类 org.xml.sax.SAXNotSupportedException 继承 SAXException 实现 Serializable serialVersionUID: -1422818934641823846L
类 org.xml.sax.SAXParseException 继承 SAXException 实现 Serializable serialVersionUID: -5651165872476709336L
序列化字段 publicId
String publicId
- 公共标识符或 null。
systemId
String systemId
- 系统标识符或 null。
lineNumber
int lineNumber
- 行号或 -1。
columnNumber
int columnNumber
- 列号或 -1。
概述 软件包 类 使用 树 已过时 索引 帮助 JavaTM 2 Platform
Standard Ed. 5.0上一个 下一个 框架 无框架
提交错误或意见
有关更多的 API 参考资料和开发人员文档，请参阅 Java 2 SDK SE 开发人员文档。该文档包含更详细的、面向开发人员的描述，以及总体概述、术语定义、使用技巧和工作代码示例。版权所有 2004 Sun Microsystems, Inc. 保留所有权利。 请遵守许可证条款。另请参阅文档重新分发政策。