javax.el

## Class Expression

- java.lang.Object
- - javax.el.Expression

- All Implemented Interfaces:
    Serializable
  Direct Known Subclasses:
    MethodExpression, ValueExpression

      public abstract class Expression
      extends Object
      implements Serializable

  Base class for the expression subclasses `ValueExpression` and `MethodExpression`, implementing characteristics common to both.

  All expressions must implement the `equals()` and `hashCode()` methods so that two expressions can be compared for equality. They are redefined abstract in this class to force their implementation in subclasses.

  All expressions must also be `Serializable` so that they can be saved and restored.

  `Expression`s are also designed to be immutable so that only one instance needs to be created for any given expression String / `FunctionMapper`. This allows a container to pre-create expressions and not have to re-parse them each time they are evaluated.

  Since:
    JSP 2.1
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `Expression()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `abstract boolean` | `equals(Object obj)` Determines whether the specified object is equal to this `Expression`.
    `abstract String` | `getExpressionString()` Returns the original String used to create this `Expression`, unmodified.
    `abstract int` | `hashCode()` Returns the hash code for this `Expression`.
    `abstract boolean` | `isLiteralText()` Returns whether this expression was created from only literal text.

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, toString, wait, wait, wait`

- - ### Constructor Detail

    - #### Expression

          public Expression()

  - ### Method Detail

    - #### getExpressionString

          public abstract String getExpressionString()

      Returns the original String used to create this `Expression`, unmodified.

      This is used for debugging purposes but also for the purposes of comparison (e.g. to ensure the expression in a configuration file has not changed).

      This method does not provide sufficient information to re-create an expression. Two different expressions can have exactly the same expression string but different function mappings. Serialization should be used to save and restore the state of an `Expression`.

      Returns:
        The original expression String.

    - #### equals

          public abstract boolean equals(Object obj)

      Determines whether the specified object is equal to this `Expression`.

      The result is `true` if and only if the argument is not `null`, is an `Expression` object that is the of the same type (`ValueExpression` or `MethodExpression`), and has an identical parsed representation.

      Note that two expressions can be equal if their expression Strings are different. For example, `${fn1:foo()}` and `${fn2:foo()}` are equal if their corresponding `FunctionMapper`s mapped `fn1:foo` and `fn2:foo` to the same method.

      Overrides:
        `equals` in class `Object`
      Parameters:
        `obj` - the `Object` to test for equality.
      Returns:
        `true` if `obj` equals this `Expression`; `false` otherwise.
      See Also:
        `Hashtable`, `Object.equals(java.lang.Object)`

    - #### hashCode

          public abstract int hashCode()

      Returns the hash code for this `Expression`.

      See the note in the `equals(java.lang.Object)` method on how two expressions can be equal if their expression Strings are different. Recall that if two objects are equal according to the `equals(Object)` method, then calling the `hashCode` method on each of the two objects must produce the same integer result. Implementations must take special note and implement `hashCode` correctly.

      Overrides:
        `hashCode` in class `Object`
      Returns:
        The hash code for this `Expression`.
      See Also:
        `equals(java.lang.Object)`, `Hashtable`, `Object.hashCode()`

    - #### isLiteralText

          public abstract boolean isLiteralText()

      Returns whether this expression was created from only literal text.

      This method must return `true` if and only if the expression string this expression was created from contained no unescaped EL delimeters (`${...}` or `#{...}`).

      Returns:
        `true` if this expression was created from only literal text; `false` otherwise.

Copyright © 1996-2013, Oracle and/or its affiliates. All Rights Reserved. Use is subject to license terms.