//
// Copyright (c) 2020, 2021 Contributors to the Eclipse Foundation
//

== Java Representation of XML Content

This section defines the basic binding
representation of package, value class, element classes, properties and
enum type within the Java programming language. Each section briefly
states the XML Schema components that could be bound to the Java
representation. A more rigorous and thorough description of possible
bindings and default bindings occurs in
<<Binding XML Schema to Java Representations>> and in
<<Customizing XML Schema to Java Representation Binding>>.

=== Mapping between XML Names and Java Identifiers

XML schema languages use _XML names_, _i.e._,
strings that match the Name production defined in XML 1.0 (Second
Edition) to label schema components. This set of strings is much larger
than the set of valid Java class, method, and constant identifiers.
<<Binding XML Names to Java Identifiers>>,
specifies an algorithm for mapping XML names to Java
identifiers in a way that adheres to standard Java API design
guidelines, generates identifiers that retain obvious connections to the
corresponding schema, and results in as few collisions as possible. It
is necessary to rigorously define a standard way to perform this mapping
so all implementations of this specification perform the mapping in the
same compatible manner.

=== Java Package

Just as the target XML namespace provides a
naming context for the named type definitions, named model groups,
global element declarations and global attribute declarations for a
schema vocabulary, the Java package provides a naming context for Java
interfaces and classes. Therefore, it is natural to map the target
namespace of a schema to be the package that contains the Java value
class representing the structural content model of the document.

A package consists of:

* A _name_ , which is either derived directly
from the XML namespace URI as specified in
<<Generating a Java package name>> or
specified by a binding customization of the XML namespace URI as
described in <<Package>>.
* A set of Java value classes representing the
content models declared within the schema.
* A set of Java element classes representing
element declarations occurring within the schema.
<<Java Element Representation>> describes
this binding in more detail.
* A public class `ObjectFactory` contains:
** An instance factory method signature for
each Java content within the package. +
 +
Given Java value class named Foo, here is the derived factory method:

 public Foo createFoo();

** An element instance factory method
signature for each bound element declaration.

 public JAXBElement<T> createFoo(T elementValue);

** Dynamic instance factory allocator method signature:

 public Object newInstance(Class javaContentInterface);

** Property setter/getter +
Provide the ability to associate implementation specific property/value
pairs with the instance creation process.

 java.lang.Object getProperty(String name);
 void setProperty(String name, Object value);

* A set of enum types.
* Package javadoc.

*_Example:_* +
Purchase Order Schema fragment with `targetNamespace`:

[source,xml]
----
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
            xmlns:po="http://www.example.com/PO1"
            targetNamespace="http://www.example.com/PO1">
  <xs:element name="purchaseOrder" type="po:PurchaseOrderType"/>
  <xs:element name="comment"       type="xs:string"/>
  <xs:complexType name="PurchaseOrderType"/>
  ...
</xs:schema>
----

Default derived Java code:

[source,java]
----
package com.example.PO1;
import jakarta.xml.bind.JAXBElement;
public class PurchaseOrderType {...};
public Comment { String getValue() {...} void setValue(String) {...} }
...
public class ObjectFactory {
    PurchaseOrderType createPurchaseOrderType();
    JAXBElement<PurchaseOrderType> createPurchaseOrder(PurchaseOrderType elementValue);
    Comment createComment(String value);
    ...
}
----

=== Enum Type

A simple type definition whose value space is
constrained by enumeration facets can be bound to a Java enum type. Enum
type was introduced in J2SE 5.0 and is described in Section 8.9 of
[JLS]. Enum type is a significant enhancement over the typesafe enum
design pattern that it was designed to replace. If an application wishes
to refer to the values of a class by descriptive constants and
manipulate those constants in a type safe manner, it should consider
binding the XML component containing enumeration facets to an enum type.

An enum type consists of:

* A _name_ , which is either computed
directly from an XML name or specified by a binding customization for
the schema component.
* A _package name_, which is either computed
from the target namespace of the schema component or specified within a
binding declaration as a customization of the target namespace or a
specified package name for components that are scoped to no target
namespace.
* Outer Class Names is “_._” separated list of outer class names. +
 +
By default, if the XML component containing a
typesafe enum class to be generated is scoped within a complex type as
opposed to a global scope, the typesafe enum class should occur as a
nested class within the Java value class representing the complex type
scope. +
Absolute class name is PackageName.[OuterClassNames.]Name. +
Note: Outer Class Name is null if class is a top-level class. +
 +
The schema customization <jaxb:globalBindings localScoping=”toplevel”/>,
specified in Section <<Usage>>, disables
the generation of schema-derived nested classes and can be used to
override the default binding of a nested schema component binding to
nested Java class.

* A set of _enum constants_.
* Class javadoc is a combination of a documentation annotation
from the schema component and/or javadoc specified by customization.

An _enum constant_ consists of:

* A _name_, which is either computed from the
enumeration facet value or specified by customization.
* A _value_ for the constant. Optimally, the
_name_ is the same as the _value_. This optimization is not possible
when the enumeration facet value is not a valid Java identifier.
* A datatype for the constant’s value.
* _Javadoc for the constant field_ is a
combination of a documentation annotation for an enumeration value facet
and/or javadoc specified by customization.

=== Content Representation

A complex type definition is bound to either
a Java value class or a content interface, depending on the value of the
global binding customization *[jaxb:globalBinding]*
`@generateValueClass`, specified in <<Usage>>.
Value classes are generated by default. The attributes and
children element content of a complex type definition are represented as
properties of the Java content representation. Property representations
are introduced in <<Properties>>.

==== Value Class

A value class consists of:

* A _name_ , which is either computed
directly from an XML name or specified by a binding customization for
the schema component.
* A package name, which is either computed
from the target namespace of the schema component or specified by a
binding customization of the target namespace or a specified package
name for components that are scoped to no target namespace.
* The _outer class name_ context, a dot-separated list of Java class names. +
 +
By default, if the XML schema component for
which a Java value class is to be generated is scoped within a complex
type as opposed to globally, the complex class should occur as a nested
class within the Java value class representing the complex type scope.
The schema customization <jaxb:globalBindings localScoping=”toplevel”/>,
specified in Section <<Usage>>, disables
the generation of schema-derived nested classes and all classes are
generated as toplevel classes. +
 +
The absolute class name is PackageName.[OuterClassNames.]Name. +
Note: The OuterClassNames is null if the class is a top-level class.

* A base class that this class extends. See
<<Complex Type Definition>> for further
details.
* A set of Java properties providing access
and modification to the complex type definition’s attributes and content
model represented by the value class.
* Class-level javadoc is a combination of a
documentation annotation from the schema component and/or javadoc
specified within customization.
* Creation
  ** A value class supports creation via a
public constructor, either an explicit one or the default no-arg
constructor.
  ** A factory method in the package’s
`ObjectFactory` class (introduced in <<Java Package>>).
The factory method returns the type of the Java value
class. The name of the factory method is generated by concatenating the
following components:
+
--
    *** The string constant `create`.
    *** If the Java value class is nested within another value class,
then the concatenation of all outer Java class names.
    *** The _name_ of the Java value class.
--
+
For example, a Java value class named `Foo`
that is nested within Java value class `Bar` would have the following
factory method signature generated in the containing Java package’s
`ObjectFactory` class:

 Bar.Foo createBarFoo() {...}

==== Java Content Interface

This binding is similar to the value class binding
with the following differences.

* A content interface is a public interface
while a value class is a public class.
* A content interface can only be created
with an ObjectFactory method whereas a value class can be created using
a public constructor. The factory method signature is the same for both
value class and content interface binding to ease switching between the
two binding styles.
* A content interface contains the method
signatures for the set of properties it contains, while a value class
contains method implementations.

=== Properties

The schema compiler binds local schema
components to _properties_ within a Java value class.

A property is defined by:

* A _name_, which is either computed from the XML name
or specified by a binding customization for the schema component.
* A _base type_, which may be a Java
primitive type (_e.g._, `int`) or a reference type.
* An optional _predicate_ , which is a
mechanism that tests values of the base type for validity and throws a
`TypeConstraintException` if a type constraint expressed in the source
schema is violated.footnote:constraint[Note that it is optional for a JAXB
implementation to support type constraint checks
when setting a property in this version of the specification.]
* An optional _collection type_ , which is
used for properties whose values may be composed of more than one value.
* A _default value_ . Schema component has a
schema specified default value which is used when property’s value is
not set and not nil.
* Is _nillable_ . A property is nillable when
it represents a nillable element declaration.

A property is _realized_ by a set of _access methods_.
Several property models are identified in the following
subsections; each adds additional functionally to the basic set of
access methods.

A property’s access methods are named in the
standard JavaBeans style: the name-mapping algorithm is applied to the
property name and then each method name is constructed by prefixing the
appropriate verb (`get`, `set`, etc.).

[[a552]]A property is
said to have a _set value_ if that value was assigned to it during
unmarshallingfootnote:[An unmarshalling
implementation should distinguish between a value from an XML instance
document and a schema specified defaulted value when possible. A
property should only be considered to have a _set value_ when there exists
a corresponding value in the XML content being unmarshalled.
Unfortunately, unmarshalling implementation paths do exist that can not
identify schema specified default values, this situation is considered a
one-time transformation for the property and the defaulted value will be
treated as a _set value_.] or by invoking its mutation method.
The _value_ of a property is its _set value_, if defined; otherwise, it is
the property’s schema specified _default value_, if any; otherwise, it is
the default initial value for the property’s base type as it would be
assigned for an uninitialized field within a Java
classfootnote:[Namely, a `boolean` field type defaults to `false`,
`integer` field type defaults to `0`, object reference field type
defaults to `null`, floating point field
type defaults to `+0.0f`.]. <<a623>>
illustrates the states of a JAXB property and the invocations that
result in state changes.

==== Simple Property

A non-collection property `prop` with a base
type _Type_ is realized by the two methods

[source,java,indent=8]
----
public Type getId();
public void setId(Type value);
----

where _Id_ is a metavariable that represents
the Java method identifier computed by applying the name mapping
algorithm described in <<The Name to Identifier Mapping Algorithm>>
to prop. There is one exception to this
general rule in order to support the boolean property described in
[BEANS]. When _Type_ is boolean, the `get__Id__` method specified above is
replaced by the method signature, _boolean_ `is__Id__()`.

* The `get` or `is` method returns the
property’s value as specified in the previous subsection. If _null_ is
returned, the property is considered to be absent from the XML content
that it represents.
* The `set` method defines the property’s _set value_
to be the argument `value`. If the argument value is `null`, the
property’s _set value_ is discarded. Prior to setting the property’s value
when TypeConstraint validation is enabledfootnote:[Note that it is
optional for a JAXB implementation to support type constraint checks
when setting a property in this version of the specification.],
a non-`null` value is validated by applying the property’s predicate. If
`TypeConstraintException` is thrown, the property retains the value it
had prior to the `set` method invocation.


When the base type for a property is a
primitive non-reference type and the property’s value is optional, the
corresponding Java wrapper class can be used as the base type to enable
discarding the property’s set value by invoking the set method with a
null parameter. <<isset-property-modifier>> describes an alternative to using a wrapper class for this
purpose. The *[jaxb:globalBinding]* customization `@optionalProperty`
controls the binding of an optional primitive property as described in
<<Usage>>.

*_Example:_* +
In the purchase order schema, the _partNum_
attribute of the _item_ element definition is declared:

[source,xml,indent=4]
----
<xs:attribute name="partNum" type="SKU" use="required"/>
----

This element declaration is bound to a simple
property with the base type `java.lang.String`:

[source,java,indent=4]
----
public String getPartNum();
public void setPartNum(String x);
----

The `setPartNum` method could apply a
predicate to its argument to ensure that the new value is legal, _i.e._,
that it is a string value that complies with the constraints for the
simple type definition, SKU, and that derives by restriction from
`xs:string` and restricts the string value to match the regular
expression pattern `"\d{3}-[A-Z]{2}"`.

It is legal to pass `null` to the
`setPartNum` method even though the `partNum` attribute declaration’s
attribute `use` is specified as required. The determination if `partNum`
content actually has a value is a local structural constraint rather
than a type constraint, so it is checked during validation rather than
during mutation.

==== Collection Property

A collection property may take the form of an
_indexed property_ or a _list property_. The base type of an indexed
property may be either a primitive type or a reference type, while that
of a list property must be a reference type.

A collection consists of a group of
collection items. If one of the collection items can represent a
nillable element declaration, setting a collection item to `null` is
semantically equivalent to inserting a nil element, `xsi:nil="true"` ,
into the collection property. If none of the collection items can ever
represent a nillable element declaration, setting a collection item to
`null` is the semantic equivalent of removing an optional element from
the collection property.

===== Indexed Property

This property follows the indexed property
design pattern for a multi-valued property from the JavaBean
specification. An indexed property `prop` with base type _Type_ is
realized by the five methods

[source,java,indent=8]
----
public Type[] getId();
public void setId(Type[] value);
public void setId(int index, Type value);
public Type getId(int index);
public int getIdLength();
----

regardless of whether _Type_ is a primitive
type or a reference type. _Id_ is computed from `prop` as it was defined
in simple property. An array item is a specialization of the collection
item abstraction introduced in the collection property overview.

* `get__Id__()` +
The array `getter` method returns an array containing the property’s
value. If the property’s value has not set, then `null` is returned.
* `set__Id__(_Type_ [])` +
The `array setter` method defines the property’s set value. If the
argument itself is `null` then the property’s set value, if any, is
discarded. If the argument is not `null` and `TypeConstraint` validation
is enabledfootnote:constraint[] then the sequence of values in the
array are first validated by applying the property’s predicate, which
may throw a `TypeConstraintException`. If the `TypeConstraintException`
is thrown, the property retains the value it had prior to the `set`
method invocation. The property’s value is only modified after the
`TypeConstraint` validation step.
* `set__Id__(int, _Type_)` +
The indexed `setter` method allows one to set a value within the array.
The runtime exception `java.lang.ArrayIndexOutOfBoundsException` may be
thrown if the index is used outside the current array bounds. If the
value argument is non-null and TypeConstraint validation is enabledfootnote:constraint[],
the value is validated against the property’s predicate, which may throw
an unchecked `TypeConstraintException`. If `TypeConstraintException` is
thrown, the array index remains set to the same value it had before the
invocation of the indexed `setter` method. When the array item
represents a nillable element declaration and the indexed setter value
parameter is null, it is semantically equivalent to inserting a nil
element into the array.
* `get__Id__(int)` +
The indexed `getter` method returns a single element from the array.
The runtime exception `java.lang.ArrayIndexOutOfBoundsException` may be
thrown if the index is used outside the current array bounds. In order
to change the size of the array, you must use the array set method to
set a new (or updated) array.
* `get__Id__Length()` +
The indexed length method returns the length of the array. This method
enables you to iterate over all the items within the indexed property
using the indexed mutators exclusively. Exclusive use of indexed
mutators and this method enable you to avoid the allocation overhead
associated with array `getter` and `setter` methods.

The arrays returned and taken by these
methods are not part of the content object’s state. When an array
`getter` method is invoked, it creates a new array to hold the returned
values. Similarly, when the corresponding array `setter` method is
invoked, it copies the values from the argument array.

To test whether an indexed property has a set
value, invoke its `array getter` method and check that the result is not
`null`. To discard an indexed property’s set value, invoke its array
`setter` method with an argument of `null`.

See the customization attribute
`collectionType` in <<globalbindings-declaration>>
and <<property-declaration>> on how to enable the generation of indexed property
methods for a collection property.

*_Example:_* +
In the purchase order schema, we have the
following repeating element occurrence of element _item_ within
`complexType` _Items_.

[source,xml,indent=4]
----
<xs:complexType name="Items">
  <xs:sequence>
    <xs:element name="item" minOccurs="1" maxOccurs="unbounded">
      <xs:complexType>...</xs:complexType>
  </xs:element>
</xs:complexType>
----

The content specification of this element
type could be bound to an array property realized by these five methods:

[source,java,indent=4]
----
public Items.ItemType[] getItem();
public void setItem(Items.ItemType[] value);
public void setItem(int index, Items.ItemType value);
public Items.ItemType getItem(int index);
public int getItemLength();
----

===== List Property

A list property `prop` with base type _Type_
is realized by the method where `List`
[source,java,indent=8]
----
public List<Type> getId();
----
is the interface `java.util.List`,
_Id_ is defined as above. If base type is a primitive type, the
appropriate wrapper class is used in its place.

* The `get` method returns an object that
implements the `List<Type>` interface, is mutable, and contains the
values of type _Type_ that constitute the property’s value. If the
property does not have a set value or a schema default value, a zero
length `java.util.List` instance is returned.

The `List` returned by the `get` method is a
component of the content object’s state. Modifications made to this list
will, in effect, be modifications to the content object. If
`TypeConstraint` validation is enabled, the list’s mutation methods
apply the property’s predicate to any non-`null` value before adding
that value to the list or replacing an existing element’s value with
that value; the predicate may throw a `TypeConstraintException`. The
collection property overview discussion on setting a collection item to
null specifies the meaning of inserting a null into a List.

The `unset` method introduced in
<<isset-property-modifier>> enables one to
discard the set value for a List property.

[NOTE]
.Design Note
====
There is no setter method for a List property. The getter returns
the List by reference. An item can be added to the List returned by
the getter method using an appropriate method defined on `java.util.List`.
Rationale for this design in JAXB 1.0 was to enable the implementation
to wrapper the list and be able to perform checks as content was added
or removed from the List.

====

*_Example:_* +
The content specification of the _item_
element type could alternatively be bound to a list property realized by
one method:

[source,java,indent=4]
----
public List<Item> getItem();
----

The list returned by the `getItem` method
would be guaranteed only to contain instances of the `Item` class. As
before, its length would be checked only during validation, since the
requirement that there be at least one `item` in an element instance of
complex type definition `Items` is a structural constraint rather than a
type constraint.

==== Constant Property

An attribute use named _prop_ with a schema
specified fixed value can be bound to a Java constant value. _Id_ is
computed from _prop_ as it was defined in simple property. The value of
the fixed attribute of the attribute use provides the `_<fixedValue>_`
constant value.

[source,java,indent=8]
----
public static final Type ID = <fixedValue>;
----

The binding customization attribute
`fixedAttributeToConstantProperty` enables this binding style.
<<globalbindings-declaration>> and <<property-declaration>>
describe how to use this attribute.

==== `isSet` Property Modifier

This optional modifier augments a modifiable
property to enable the manipulation of the property’s value as
a _set value_ or a _defaulted value_. Since this functionality
is above and beyond the typical JavaBean pattern for a property,
the method(s) associated with this modifier are not generated by default.
<<Customizing XML Schema to Java Representation Binding>>
describes how to enable this customization
using the `generateIsSetMethod` attribute.

The method signatures for the `isSet`
property modifier are the following:

[source,java,indent=8]
----
public boolean isSetId();
----

where `_Id_` is defined as it was for simple and collection property.

* The `isSet` method returns `true` if the
property has been set during unmarshalling or by invocation of the
mutation method `setId` with a non-`null` value.footnote:[A Java application
usually does not need to distinguish between the absence of a element
from the infoset and when the element occurred with nil content. Thus,
in the interest of simplifying the generated API, methods were not
provided to distinguish between the two. Two annotation elements
@XmlElement.required and @XmlElement.nillable allow a null value to be
marshalled as an empty or nillable element.] +
To aid the understanding of what `isSet` method implies,
note that the unmarshalling process only unmarshals _set values_
into XML content.

A list property and a simple property with a
non-reference base type require an additional method to enable you to
discard the _set value_ for a property:

[source,java,indent=8]
----
public void unsetId();
----

* The `unset` method marks the property as
having no _set value_. A subsequent call to `getId` method returns the
schema-specified default if it existed; otherwise, it returns the Java
default initial value for `Type`.

All other property kinds rely on the
invocation of their set method with a value of null to discard the set
value of its property. Since this is not possible for primitive types or
a List property, the additional method is generated for these
cases illustrate the
method invocations that result in transitions between the possible
states of a JAXB property
value.

.States of a Property Value
[[a623]]
image::images/xmlb-8.png[image]

*_Example:_* +
In the purchase order schema, the `partNum`
attribute of the element `item`’s anonymous complex type is declared:

[source,xml,indent=4]
----
<xs:attribute name="partNum" type = "SKU" use="required"/>
----

This attribute could be bound to a `isSet`
simple property realized by these four methods:

[source,java,indent=8]
----
public String getPartNum();
public void setPartNum(String skuValue);
public boolean isSetPartNum();
public void unsetPartNum();
----

It is legal to invoke the `unsetPartNum`
method even though the attribute’s `use` is `"required"` in the XML
Schema. That the attribute actually has a value is a local structural
constraint rather than a type constraint, so it is checked during
validation rather than during mutation.

==== Element Property

This property pattern enables the dynamic
association of an element name for a JAXB property. Typically, the
element name is statically associated with a JAXB property based on the
schema’s element name. Element substitution groups and wildcard content
allow an XML document author to use Element names that were not
statically specified in the content model of the schema. To support
these extensibility features, an application uses element property
setters/getters to dynamically introduce element names at runtime.

The method signatures for the `Element`
property pattern are the following:

[source,java,indent=8]
----
public void setId(JAXBElement<? extends Type> value);
public JAXBElement<? extends Type> getId();
----

where `_Id_` and `_Type_` are defined as they
were for simple and collection property. The fully qualified Java name
for `_JAXBElement<T>_` is `_jakarta.xml.bind.JAXBElement<T>_`. The generic
types in the method signatures are expressed as a bounded wildcard to
support element substitution group, see details in
<<Element Declaration>>.

==== Property Summary

The following core properties have been defined:

* Simple property - JavaBean design pattern for single value property
* Indexed property - JavaBean design pattern for multi-valued property
* List property - Leverages java.util.Collection
* Constant property

The methods generated for these four core
property kinds are sufficient for most applications. Configuration-level
binding schema declarations enable an application to request finer
control than provided by the core properties. For example, the `isSet`
property modifier enables an application to determine if a property’s
value is set or not.

=== Java Element Representation

Based on rationale and criteria described in
<<Element Declaration>>, the schema
compiler binds an element declaration to a Java instance that implements
`jakarta.xml.bind.JAXBElement<T>`. `JAXBElement<T>` class provides access
to the basic properties of an XML element: its name, the value of the
element’s datatype, and whether the element’s content model is set to
nil, i.e. `xsi:nil="true"`. Optional properties for an Xml element that
corresponds to an element declaration from a known schema include the
element declaration’s declared type and scope.

The enhanced, default binding for an element
declaration only generates a element instance factory method and is
described in <<Named Java Element instance>>.footnote:[The exception case is
that an element declaration with an anonymous type definition is bound
to a schema-derived value class by default as described in
<<Binding of an anonymous complex type definition>>.]
The customized binding that generates
a schema-dervied Element class for an element declaration is described
in <<Java Element Class>>.

==== Named Java Element instance

Based on the normative binding details
described in <<bind-to-jaxbelementt-instance>>,
the schema compiler binds an element declaration to an
element instance factory method.

The following is a generic element factory signature.

[source,java,indent=8]
----
package elementDeclarationTargetNamespace;
class ObjectFactory {
    jakarta.xml.bind.JAXBElement<ElementType>
                                createElementName(ElementType value);
}
----

The element factory method enables an
application to work with elements without having to directly know the
precise `javax.xml.namespace.QName`. The element factory method
abstraction sets the Xml element name with the Java representation of
the element, thus shielding the JAXB user from the complexities of
manipulating namespaces and QNames.

.Binding of global element declaration to element factory
[source,xml+java,indent=4]
----
<xs:schema targetNamespace=”a” xmlns:a=”a”/>
<xs:element name=”Foo” type=”xsd:int”/>

class ObjectFactory {
    // returns JAXBElement with its name set to QName(“a”, “Foo”).
    JAXBElement<Integer> createFoo(Integer value);
}
----

==== Java Element Class

Based on criteria to be identified in
<<Bind to Element Class>>, the schema
compiler binds an element declaration to a Java element class. An
element class is defined in terms of the properties of the
<<Element Declaration Schema Component>>
as follows:

* An element class name is generated from the
element declaration’s name using the XML Name to Java identifier name
mapping algorithm specified in <<The Name to Identifier Mapping Algorithm>>.
* Scope of element class
** Global element declarations are declared in
package scope.
** By default, local element declarations
occur in the scope of the first ancestor complex type definition that
contains the declaration. The schema customization <jaxb:globalBindings
localScoping=”toplevel”/>, specified in <<Usage>>, disables the generation of
schema-derived nested classes and all classes are generated as toplevel
classes.
* Each generated Element class must extend
the Java class `jakarta.xml.bind.JAXBElement<T>`. The type T of the
`JAXBElement<T>` is derived from the element declaration’s type.
Anonymous type definition binding is a special case that is specified in
<<Binding of an anonymous complex type definition>>.
* A factory method is generated in the
package’s `ObjectFactory` class introduced in
<<Java Package>>. The factory method
returns `JAXBElement<T>`. The factory method has one parameter that is
of type `T`. The name of the factory method is generated by
concatenating the following components:
+
--
** The string constant `create`.
** If the Java element class is nested within
a value class, then the concatenation of all outer Java class names.
** The _name_ of the Java value class.
--
+
The returned instance has the Xml Element
name property set to the QName representing the element declaration’s
name. +
For example, a Java element class named `Foo`
that is nested within Java value class `Bar` would have the following
factory method generated in the containing Java package’s
`ObjectFactory` class:

 JAXBElement<Integer> createBarFoo(Integer value)

* A public no-arg constructor is generated. +
The constructor must set the appropriate Xml element name, just as the
element factory method does.
* The Java element representation extends
`JAXBElement<T>` class, its properties provide the capability to
manipulate
** the value of the element’s content +
Xml Schema’s type substitution capability is enabled by this property.
** whether the element’s content model is `nil`

*_Example:_* +
Given a complex type definition with mixed contentfootnote:[Bind mixed
content describes why <ASimpleElement> element is bound to a Java
Element representation.]footnote:[Assume a
customization that binds this local element declaration to an element
class. By default, this local declaration binds to a element instance
factory returning JAXBElement<Integer>]:

[source,xml,indent=4]
----
<xs:complexType name="AComplexType" mixed="true">
  <xs:sequence>
    <xs:element name="ASimpleElement" type="xs:int"/>
  </xs:sequence>
</xs:complexType>
----

Its Java representation:

[source,java,indent=4]
----
public value class AComplexType {
    public class ASimpleElement extends
                        jakarta.xml.bind.JAXBElement<Integer> {
    }
    ...
};
class ObjectFactory {
    AComplexType createAComplexType();
    JAXBElement<Integer>
            createAComplexTypeASimpleElement(Integer value);
    ...
}
----

==== Java Element Representation Summary

Element declaration binding evolved inJakarta XML Binding
to support XML Schema type substitution. The following diagrams
illustrate the binding changes for the following schema fragment:

[source,xml,indent=8]
----
<xs:element name=”foo” type=”fooType”/>
----

.JAXB 1.0: isA Relationship between generated element interface and its type
image::images/xmlb-9.svg[image]

.Jakarta XML Binding: hasA Relationship between element instance and its type as described in <<Named Java Element instance>>
image::images/xmlb-10.svg[image]

.Jakarta XML Binding: hasA Relationship between generated element class and its type as described in <<Java Element Class>>
image::images/xmlb-11.svg[image]

While a JAXB 1.0 Element interface implemented its type’s interface,
a Jakarta XML Binding Element instance has a
composition relationship to the value of the element declaration’s type,
accessible via the `jakarta.xml.bind.JAXBElement<T>` property `Value` .
This change reflects the relationship that type substitution allows an
element declaration to be associated with many different datatypes, not
just the datatype that was defined statically within the schema.

An added benefit to the default binding
change is to reduce the overhead associated with always generating Java
Element classes for every global element declaration. A value class
is generated for every complex type definition and only a factory
method needs to be generated for each global element declaration.

=== Summary

The composition and relationships between the
Java components introduced in this section are reflected in the
following diagram.

.UML diagram of Java Representationfootnote:[See next figure fordefault binding for anonymous type definition.]
image::images/xmlb-12.png[image]

.UML diagram when xs:element is bound to schema-derived Element class
image::images/xmlb-13.png[image]

See also <<table614>>.