(java@oneshot)logo/  logo/  logo/  logo/


 

Java Tutorial » Reflection » Class  
7.1.16.Class comparator: compare and sort classes and their superclasses.Previous/Next
/* 
 * JCommon : a free general purpose class library for the Java(tm) platform
 
 *
 * (C) Copyright 2000-2005, by Object Refinery Limited and Contributors.
 
 * Project Info:  http://www.jfree.org/jcommon/index.html
 *
 * This library is free software; you can redistribute it and/or modify it 
 * under the terms of the GNU Lesser General Public License as published by 
 * the Free Software Foundation; either version 2.1 of the License, or 
 * (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but 
 * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 
 * or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public 
 * License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, 
 * USA.  
 *
 * [Java is a trademark or registered trademark of Sun Microsystems, Inc. 
 * in the United States and other countries.]
 *
 * --------------------
 * ClassComparator.java
 * --------------------
 * (C)opyright 2003-2005, by Thomas Morgner and Contributors.
 *
 * Original Author:  Thomas Morgner (taquera@sherito.org);
 * Contributor(s):   David Gilbert (for Object Refinery Limited);
 *
 * $Id: ClassComparator.java,v 1.3 2005/10/18 13:24:19 mungady Exp $
 *
 * Changes
 * -------
 * 02-May-2003 : Initial version
 
 */

import java.io.Serializable;
import java.util.Comparator;

/**
 * The class comparator can be used to compare and sort classes and their
 * superclasses. The comparator is not able to compare classes which have no
 * relation...
 
 @author Thomas Morgner
 */
public class ClassComparator implements Comparator, Serializable {

  /** For serialization. */
  private static final long serialVersionUID = -5225335361837391120L;

  /**
   * Defaultconstructor.
   */
  public ClassComparator() {
    super();
  }

  /**
   * Compares its two arguments for order. Returns a negative integer, zero, or
   * a positive integer as the first argument is less than, equal to, or greater
   * than the second.
   
   
   * Note: throws ClassCastException if the arguments' types prevent them from
   * being compared by this Comparator. And IllegalArgumentException if the
   * classes share no relation.
   
   * The implementor must ensure that <tt>sgn(compare(x, y)) ==
   * -sgn(compare(y, x))</tt>
   * for all <tt>x</tt> and <tt>y</tt>. (This implies that
   * <tt>compare(x, y)</tt> must throw an exception if and only if
   * <tt>compare(y, x)</tt> throws an exception.)
   
   
   * The implementor must also ensure that the relation is transitive:
   * <tt>((compare(x, y)&gt;0) &amp;&amp; (compare(y, z)&gt;0))</tt> implies
   * <tt>compare(x, z)&gt;0</tt>.
   
   
   * Finally, the implementer must ensure that <tt>compare(x, y)==0</tt>
   * implies that <tt>sgn(compare(x, z))==sgn(compare(y, z))</tt> for all
   * <tt>z</tt>.
   
   
   * It is generally the case, but <i>not</i> strictly required that
   * <tt>(compare(x, y)==0) == (x.equals(y))</tt>. Generally speaking, any
   * comparator that violates this condition should clearly indicate this fact.
   * The recommended language is "Note: this comparator imposes orderings that
   * are inconsistent with equals."
   
   @param o1
   *          the first object to be compared.
   @param o2
   *          the second object to be compared.
   @return a negative integer, zero, or a positive integer as the first
   *         argument is less than, equal to, or greater than the second.
   */
  public int compare(final Object o1, final Object o2) {
    final Class c1 = (Classo1;
    final Class c2 = (Classo2;
    if (c1.equals(o2)) {
      return 0;
    }
    if (c1.isAssignableFrom(c2)) {
      return -1;
    else {
      if (!c2.isAssignableFrom(c2)) {
        throw new IllegalArgumentException("The classes share no relation");
      }
      return 1;
    }
  }

  /**
   * Checks, whether the given classes are comparable. This method will return
   * true, if one of the classes is assignable from the other class.
   
   @param c1
   *          the first class to compare
   @param c2
   *          the second class to compare
   @return true, if the classes share a direct relation, false otherwise.
   */
  public boolean isComparable(final Class c1, final Class c2) {
    return (c1.isAssignableFrom(c2|| c2.isAssignableFrom(c1));
  }
}
7.1.Class
7.1.1. Get class name for various object
7.1.2. Create new instance
7.1.3. Get Canonical Name for a class
7.1.4. Demonstrates the use of getDeclaringClass()
7.1.5. Demonstrates the use of instance comparisons
7.1.6. Demonstrates usage of various class information methods
7.1.7. Demonstrates how to get declaration information on a Class
7.1.8. Demonstrates Dynamic class type checking
7.1.9. Demonstrates how to set public field objects
7.1.10. Demonstrates fetching nested class info from a Class object
7.1.11. Demonstration of how to obtain instances of java.lang.Class
7.1.12. Demonstrates getting immediate superclass info
7.1.13. Get declared method by name and parameter type
7.1.14. get class from an object
7.1.15. Returns the name of a class without the package name
7.1.16. Class comparator: compare and sort classes and their superclasses.
7.1.17. Is Type Compatible
7.1.18. Is the Same Signature
7.1.19. Determine whether the supplied string represents a well-formed fully-qualified Java classname.