## 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 characterstics 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
`Expression()`

Method Summary
`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 © 2008 Mort Bay Consulting. All Rights Reserved.