In order to support fields of the same name in subclasses we are now prefixing them with name of the class that defines them. To provide convenient way to access them from generated bytecode and also directly from JavaScript, there is a getter/setter function for each field. It starts with _ followed by the field name. If called with a parameter, it sets the field, with a parameter it just returns it.
2 * Copyright (c) 1997, 2007, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
29 * This interface imposes a total ordering on the objects of each class that
30 * implements it. This ordering is referred to as the class's <i>natural
31 * ordering</i>, and the class's <tt>compareTo</tt> method is referred to as
32 * its <i>natural comparison method</i>.<p>
34 * Lists (and arrays) of objects that implement this interface can be sorted
35 * automatically by {@link Collections#sort(List) Collections.sort} (and
36 * {@link Arrays#sort(Object[]) Arrays.sort}). Objects that implement this
37 * interface can be used as keys in a {@linkplain SortedMap sorted map} or as
38 * elements in a {@linkplain SortedSet sorted set}, without the need to
39 * specify a {@linkplain Comparator comparator}.<p>
41 * The natural ordering for a class <tt>C</tt> is said to be <i>consistent
42 * with equals</i> if and only if <tt>e1.compareTo(e2) == 0</tt> has
43 * the same boolean value as <tt>e1.equals(e2)</tt> for every
44 * <tt>e1</tt> and <tt>e2</tt> of class <tt>C</tt>. Note that <tt>null</tt>
45 * is not an instance of any class, and <tt>e.compareTo(null)</tt> should
46 * throw a <tt>NullPointerException</tt> even though <tt>e.equals(null)</tt>
47 * returns <tt>false</tt>.<p>
49 * It is strongly recommended (though not required) that natural orderings be
50 * consistent with equals. This is so because sorted sets (and sorted maps)
51 * without explicit comparators behave "strangely" when they are used with
52 * elements (or keys) whose natural ordering is inconsistent with equals. In
53 * particular, such a sorted set (or sorted map) violates the general contract
54 * for set (or map), which is defined in terms of the <tt>equals</tt>
57 * For example, if one adds two keys <tt>a</tt> and <tt>b</tt> such that
58 * <tt>(!a.equals(b) && a.compareTo(b) == 0)</tt> to a sorted
59 * set that does not use an explicit comparator, the second <tt>add</tt>
60 * operation returns false (and the size of the sorted set does not increase)
61 * because <tt>a</tt> and <tt>b</tt> are equivalent from the sorted set's
64 * Virtually all Java core classes that implement <tt>Comparable</tt> have natural
65 * orderings that are consistent with equals. One exception is
66 * <tt>java.math.BigDecimal</tt>, whose natural ordering equates
67 * <tt>BigDecimal</tt> objects with equal values and different precisions
68 * (such as 4.0 and 4.00).<p>
70 * For the mathematically inclined, the <i>relation</i> that defines
71 * the natural ordering on a given class C is:<pre>
72 * {(x, y) such that x.compareTo(y) <= 0}.
73 * </pre> The <i>quotient</i> for this total order is: <pre>
74 * {(x, y) such that x.compareTo(y) == 0}.
77 * It follows immediately from the contract for <tt>compareTo</tt> that the
78 * quotient is an <i>equivalence relation</i> on <tt>C</tt>, and that the
79 * natural ordering is a <i>total order</i> on <tt>C</tt>. When we say that a
80 * class's natural ordering is <i>consistent with equals</i>, we mean that the
81 * quotient for the natural ordering is the equivalence relation defined by
82 * the class's {@link Object#equals(Object) equals(Object)} method:<pre>
83 * {(x, y) such that x.equals(y)}. </pre><p>
85 * This interface is a member of the
86 * <a href="{@docRoot}/../technotes/guides/collections/index.html">
87 * Java Collections Framework</a>.
89 * @param <T> the type of objects that this object may be compared to
92 * @see java.util.Comparator
96 public interface Comparable<T> {
98 * Compares this object with the specified object for order. Returns a
99 * negative integer, zero, or a positive integer as this object is less
100 * than, equal to, or greater than the specified object.
102 * <p>The implementor must ensure <tt>sgn(x.compareTo(y)) ==
103 * -sgn(y.compareTo(x))</tt> for all <tt>x</tt> and <tt>y</tt>. (This
104 * implies that <tt>x.compareTo(y)</tt> must throw an exception iff
105 * <tt>y.compareTo(x)</tt> throws an exception.)
107 * <p>The implementor must also ensure that the relation is transitive:
108 * <tt>(x.compareTo(y)>0 && y.compareTo(z)>0)</tt> implies
109 * <tt>x.compareTo(z)>0</tt>.
111 * <p>Finally, the implementor must ensure that <tt>x.compareTo(y)==0</tt>
112 * implies that <tt>sgn(x.compareTo(z)) == sgn(y.compareTo(z))</tt>, for
115 * <p>It is strongly recommended, but <i>not</i> strictly required that
116 * <tt>(x.compareTo(y)==0) == (x.equals(y))</tt>. Generally speaking, any
117 * class that implements the <tt>Comparable</tt> interface and violates
118 * this condition should clearly indicate this fact. The recommended
119 * language is "Note: this class has a natural ordering that is
120 * inconsistent with equals."
122 * <p>In the foregoing description, the notation
123 * <tt>sgn(</tt><i>expression</i><tt>)</tt> designates the mathematical
124 * <i>signum</i> function, which is defined to return one of <tt>-1</tt>,
125 * <tt>0</tt>, or <tt>1</tt> according to whether the value of
126 * <i>expression</i> is negative, zero or positive.
128 * @param o the object to be compared.
129 * @return a negative integer, zero, or a positive integer as this object
130 * is less than, equal to, or greater than the specified object.
132 * @throws NullPointerException if the specified object is null
133 * @throws ClassCastException if the specified object's type prevents it
134 * from being compared to this object.
136 public int compareTo(T o);