Provides a set of static methods that extend the Java metaobject : Class « Reflection « Java

Java
1. 2D Graphics GUI
2. 3D
3. Advanced Graphics
4. Ant
5. Apache Common
6. Chart
7. Class
8. Collections Data Structure
9. Data Type
10. Database SQL JDBC
11. Design Pattern
12. Development Class
13. EJB3
14. Email
15. Event
16. File Input Output
17. Game
18. Generics
19. GWT
20. Hibernate
21. I18N
22. J2EE
23. J2ME
24. JDK 6
25. JNDI LDAP
26. JPA
27. JSP
28. JSTL
29. Language Basics
30. Network Protocol
31. PDF RTF
32. Reflection
33. Regular Expressions
34. Scripting
35. Security
36. Servlets
37. Spring
38. Swing Components
39. Swing JFC
40. SWT JFace Eclipse
41. Threads
42. Tiny Application
43. Velocity
44. Web Services SOA
45. XML
Java Tutorial
Java Source Code / Java Documentation
Java Open Source
Jar File Download
Java Articles
Java Products
Java by API
Photoshop Tutorials
Maya Tutorials
Flash Tutorials
3ds-Max Tutorials
Illustrator Tutorials
GIMP Tutorials
C# / C Sharp
C# / CSharp Tutorial
C# / CSharp Open Source
ASP.Net
ASP.NET Tutorial
JavaScript DHTML
JavaScript Tutorial
JavaScript Reference
HTML / CSS
HTML CSS Reference
C / ANSI-C
C Tutorial
C++
C++ Tutorial
Ruby
PHP
Python
Python Tutorial
Python Open Source
SQL Server / T-SQL
SQL Server / T-SQL Tutorial
Oracle PL / SQL
Oracle PL/SQL Tutorial
PostgreSQL
SQL / MySQL
MySQL Tutorial
VB.Net
VB.Net Tutorial
Flash / Flex / ActionScript
VBA / Excel / Access / Word
XML
XML Tutorial
Microsoft Office PowerPoint 2007 Tutorial
Microsoft Office Excel 2007 Tutorial
Microsoft Office Word 2007 Tutorial
Java » Reflection » ClassScreenshots 
Provides a set of static methods that extend the Java metaobject
      
/*
Java Reflection in Action
Ira R. Forman and Nate Forman
ISBN 1932394184
Publisher: Manning Publications Co.
*/


/* Copyright 2002 -- Ira R. Forman and Nate Forman */
/**
 * This class provides a set of static methods that extend the Java metaobject
 * protocol.
 
 @author: Ira R. Forman
 */

import java.lang.reflect.*;
import java.util.*;

abstract public class Mopex {

  /**
   * Returns a syntactically correct name for a class object. If the class
   * object represents an array, the proper number of square bracket pairs are
   * appended to the component type.
   
   @return java.lang.String
   @param cls
   *            java.lang.Class
   */
  //start extract classNameToString
  public static String getTypeName(Class cls) {
    if (!cls.isArray()) {
      return cls.getName();
    else {
      return getTypeName(cls.getComponentType()) "[]";
    }
  }

  //stop extract classNameToString

  /**
   * Returns an array of the superclasses of cls.
   
   @return java.lang.Class[]
   @param cls
   *            java.lang.Class
   */
  //start extract getSuperclasses
  public static Class[] getSuperclasses(Class cls) {
    int i = 0;
    for (Class x = cls.getSuperclass(); x != null; x = x.getSuperclass())
      i++;
    Class[] result = new Class[i];
    i = 0;
    for (Class x = cls.getSuperclass(); x != null; x = x.getSuperclass())
      result[i++= x;
    return result;
  }

  //stop extract getSuperclasses

  /**
   * Returns an array of the instance variablies of the the specified class.
   * An instance variable is defined to be a non-static field that is declared
   * by the class or inherited.
   
   @return java.lang.Field[]
   @param cls
   *            java.lang.Class
   */
  //start extract getInstanceVariables
  public static Field[] getInstanceVariables(Class cls) {
    List accum = new LinkedList();
    while (cls != null) {
      Field[] fields = cls.getDeclaredFields();
      for (int i = 0; i < fields.length; i++) {
        if (!Modifier.isStatic(fields[i].getModifiers())) {
          accum.add(fields[i]);
        }
      }
      cls = cls.getSuperclass();
    }
    Field[] retvalue = new Field[accum.size()];
    return (Field[]) accum.toArray(retvalue);
  }

  //stop extract getInstanceVariables

  /**
   * Returns an array of fields that are the declared instance variables of
   * cls. An instance variable is a field that is not static.
   
   @return java.lang.reflect.Field[]
   @param cls
   *            java.lang.Class
   */
  //start extract getDeclaredIVS
  public static Field[] getDeclaredIVs(Class cls) {
    Field[] fields = cls.getDeclaredFields();
    // Count the IVs
    int numberOfIVs = 0;
    for (int i = 0; i < fields.length; i++) {
      if (!Modifier.isStatic(fields[i].getModifiers()))
        numberOfIVs++;
    }
    Field[] declaredIVs = new Field[numberOfIVs];
    // Populate declaredIVs
    int j = 0;
    for (int i = 0; i < fields.length; i++) {
      if (!Modifier.isStatic(fields[i].getModifiers()))
        declaredIVs[j++= fields[i];
    }
    return declaredIVs;
  }

  //stop extract getDeclaredIVS

  /**
   * Return an array of the supported instance variables of this class. A
   * supported instance variable is not static and is either declared or
   * inherited from a superclass.
   
   @return java.lang.reflect.Field[]
   @param cls
   *            java.lang.Class
   */
  //start extract getSupportedIVS
  public static Field[] getSupportedIVs(Class cls) {
    if (cls == null) {
      return new Field[0];
    else {
      Field[] inheritedIVs = getSupportedIVs(cls.getSuperclass());
      Field[] declaredIVs = getDeclaredIVs(cls);
      Field[] supportedIVs = new Field[declaredIVs.length
          + inheritedIVs.length];
      for (int i = 0; i < declaredIVs.length; i++) {
        supportedIVs[i= declaredIVs[i];
      }
      for (int i = 0; i < inheritedIVs.length; i++) {
        supportedIVs[i + declaredIVs.length= inheritedIVs[i];
      }
      return supportedIVs;
    }
  }

  //stop extract getSupportedIVS

  /**
   * Returns an array of the methods that are not static.
   
   @return java.lang.reflect.Method[]
   @param cls
   *            java.lang.Class
   */
  //start extract getInstanceMethods
  public static Method[] getInstanceMethods(Class cls) {
    List instanceMethods = new ArrayList();
    for (Class c = cls; c != null; c = c.getSuperclass()) {
      Method[] methods = c.getDeclaredMethods();
      for (int i = 0; i < methods.length; i++)
        if (!Modifier.isStatic(methods[i].getModifiers()))
          instanceMethods.add(methods[i]);
    }
    Method[] ims = new Method[instanceMethods.size()];
    for (int j = 0; j < instanceMethods.size(); j++)
      ims[j(MethodinstanceMethods.get(j);
    return ims;
  }

  //stop extract getInstanceMethods

  /**
   * Returns an array of methods to which instances of this class respond.
   
   @return java.lang.reflect.Method[]
   @param cls
   *            java.lang.Class
   */
  //start extract getSupportedMethods
  public static Method[] getSupportedMethods(Class cls) {
    return getSupportedMethods(cls, null);
  }

  //stop extract getSupportedMethods

  /**
   * This method retrieves the modifiers of a Method without the unwanted
   * modifiers specified in the second parameter. Because this method uses
   * bitwise operations, multiple unwanted modifiers may be specified by
   * bitwise or.
   
   @return int
   @param m
   *            java.lang.Method
   @param unwantedModifiers
   *            int
   */
  //start extract getModifiersWithout
  public static int getModifiersWithout(Method m, int unwantedModifiers) {
    int mods = m.getModifiers();
    return (mods ^ unwantedModifiers& mods;
  }

  //stop extract getModifiersWithout

  /**
   * Returns a Method that has the signature specified by the calling
   * parameters.
   
   @return Method
   @param cls
   *            java.lang.Class
   @param name
   *            String
   @param paramTypes
   *            java.lang.Class[]
   */
  //start extract getSupportedMethod
  public static Method getSupportedMethod(Class cls, String name,
      Class[] paramTypesthrows NoSuchMethodException {
    if (cls == null) {
      throw new NoSuchMethodException();
    }
    try {
      return cls.getDeclaredMethod(name, paramTypes);
    catch (NoSuchMethodException ex) {
      return getSupportedMethod(cls.getSuperclass(), name, paramTypes);
    }
  }

  //stop extract getSupportedMethod
  /**
   * Returns a Method array of the methods to which instances of the specified
   * respond except for those methods defined in the class specifed by limit
   * or any of its superclasses. Note that limit is usually used to eliminate
   * them methods defined by java.lang.Object.
   
   @return Method[]
   @param cls
   *            java.lang.Class
   @param limit
   *            java.lang.Class
   */
  //start extract getSupportedMethods
  public static Method[] getSupportedMethods(Class cls, Class limit) {
    Vector supportedMethods = new Vector();
    for (Class c = cls; c != limit; c = c.getSuperclass()) {
      Method[] methods = c.getDeclaredMethods();
      for (int i = 0; i < methods.length; i++) {
        boolean found = false;
        for (int j = 0; j < supportedMethods.size(); j++)
          if (equalSignatures(methods[i](MethodsupportedMethods
              .elementAt(j))) {
            found = true;
            break;
          }
        if (!found)
          supportedMethods.add(methods[i]);
      }
    }
    Method[] mArray = new Method[supportedMethods.size()];
    for (int k = 0; k < mArray.length; k++)
      mArray[k(MethodsupportedMethods.elementAt(k);
    return mArray;
  }

  //stop extract getSupportedMethods

  /**
   * This field is initialized with a method object for the equalSignatures
   * method. This is an optimization in that selectMethods can use this field
   * instead of calling getMethod each time it is called.
   */

  //start extract equalSignaturesMethod
  static private Method equalSignaturesMethod;

  static {
    Class[] fpl = Method.class, Method.class };
    try {
      equalSignaturesMethod = Mopex.class.getMethod("equalSignatures",
          fpl);
    catch (NoSuchMethodException e) {
      throw new RuntimeException(e);
    }
  }

  //stop extract equalSignaturesMethod
  /**
   * Determines if the signatures of two method objects are equal. In Java, a
   * signature comprises the method name and the array of of formal parameter
   * types. For two signatures to be equal, the method names must be the same
   * and the formal parameters must be of the same type (in the same order).
   
   @return boolean
   @param m1
   *            java.lang.Method
   @param m2
   *            java.lang.Method
   */
  //start extract equalSignatures
  public static boolean equalSignatures(Method m1, Method m2) {
    if (!m1.getName().equals(m2.getName()))
      return false;
    if (!Arrays.equals(m1.getParameterTypes(), m2.getParameterTypes()))
      return false;
    return true;
  }

  //stop extract equalSignatures

  /**
   * Return a string that represents the signature of the specified method.
   
   @return String
   @param m
   *            java.lang.Method
   */
  //start extract signatureToString
  public static String signatureToString(Method m) {
    return m.getName() "("
        + formalParametersToString(m.getParameterTypes()) ")";
  }

  //stop extract signatureToString
  /**
   * Returns a string that can be used as a formal parameter list for a method
   * that has the parameter types of the specified array.
   
   @return String
   @param pts
   *            java.lang.Class[]
   */
  //start extract formalParametersToString
  public static String formalParametersToString(Class[] pts) {
    String result = "";
    for (int i = 0; i < pts.length; i++) {
      result += getTypeName(pts[i]) " p" + i;
      if (i < pts.length - 1)
        result += ",";
    }
    return result;
  }

  //stop extract formalParametersToString
  /**
   * Returns a string that is an actual parameter list that matches the formal
   * parameter list produced by formalParametersToString.
   
   @return String
   @param pts
   *            java.lang.Class[]
   */
  //start extract actualParametersToString
  public static String actualParametersToString(Class[] pts) {
    String result = "";
    for (int i = 0; i < pts.length; i++) {
      result += "p" + i;
      if (i < pts.length - 1)
        result += ",";
    }
    return result;
  }

  //stop extract actualParametersToString

  /**
   * Returns a String that represents the header for a constructor.
   
   @return String
   @param c
   *            java.lang.Constructor
   */
  //start extract constructorHeaderToString
  public static String headerToString(Constructor c) {
    String mods = Modifier.toString(c.getModifiers());
    if (mods.length() == 0)
      return headerSuffixToString(c);
    else
      return mods + " " + headerSuffixToString(c);
  }

  //stop extract constructorHeaderToString
  /**
   * Returns a String that represents the header suffix for a constructor. The
   * term "header suffix" is not a standard Java term. We use it to mean the
   * Java header without the modifiers.
   
   @return String
   @param c
   *            java.lang.Constructor
   */
  //start extract constructorHeaderToString
  public static String headerSuffixToString(Constructor c) {
    String header = signatureToString(c);
    Class[] eTypes = c.getExceptionTypes();
    if (eTypes.length != 0)
      header += " throws " + classArrayToString(eTypes);
    return header;
  }

  //stop extract constructorHeaderToString
  /**
   * Returns a String that represents the signature for a constructor.
   
   @return String
   @param c
   *            java.lang.Constructor
   */
  //start extract constructorHeaderToString
  public static String signatureToString(Constructor c) {
    return c.getName() "("
        + formalParametersToString(c.getParameterTypes()) ")";
  }

  //stop extract constructorHeaderToString

  /**
   * Returns a String that represents the header of a method.
   
   @return String
   @param m
   *            java.lang.Method
   */
  //start extract headerToString
  public static String headerToString(Method m) {
    String mods = Modifier.toString(m.getModifiers());
    if (mods.length() == 0)
      return headerSuffixToString(m);
    else
      return mods + " " + headerSuffixToString(m);
  }

  //stop extract headerToString
  /**
   * Returns a String that represents the suffix of the header of a method.
   * The suffix of a header is not a standard Java term. We use the term to
   * mean the Java header without the method modifiers.
   
   @return String
   @param m
   *            java.lang.Method
   */
  //start extract headerToString
  public static String headerSuffixToString(Method m) {
    String header = getTypeName(m.getReturnType()) " "
        + signatureToString(m);
    Class[] eTypes = m.getExceptionTypes();
    if (eTypes.length != 0) {
      header += " throws " + classArrayToString(eTypes);
    }
    return header;
  }

  //stop extract headerToString
  /**
   * Returns a String that is a comma separated list of the typenames of the
   * classes in the array pts.
   
   @return String
   @param pts
   *            java.lang.Class[]
   */
  //start extract classArrayToString
  public static String classArrayToString(Class[] pts) {
    String result = "";
    for (int i = 0; i < pts.length; i++) {
      result += getTypeName(pts[i]);
      if (i < pts.length - 1)
        result += ",";
    }
    return result;
  }

  //stop extract classArrayToString

  /**
   * Turns true if and only if the header suffixes of the two specified
   * methods are equal. The header suffix is defined to be the signature, the
   * return type, and the exception types.
   
   @return boolean
   @param m1
   *            java.lang.Method
   @param m2
   *            java.lang.Method
   */
  public static boolean equalsHeaderSuffixes(Method m1, Method m2) {
    if (m1.getReturnType() != m2.getReturnType())
      return false;
    if (!Arrays.equals(m1.getExceptionTypes(), m2.getExceptionTypes()))
      return false;
    return equalSignatures(m1, m2);
  }

  /**
   * Creates constructor with the signature of c and a new name. It adds some
   * code after generating a super statement to call c. This method is used
   * when generating a subclass of class that declared c.
   
   @return String
   @param c
   *            java.lang.Constructor
   @param name
   *            String
   @param code
   *            String
   */
  //start extract createRenamedConstructor
  public static String createRenamedConstructor(Constructor c, String name,
      String code) {
    Class[] pta = c.getParameterTypes();
    String fpl = formalParametersToString(pta);
    String apl = actualParametersToString(pta);
    Class[] eTypes = c.getExceptionTypes();
    String result = name + "(" + fpl + ")\n";
    if (eTypes.length != 0)
      result += "    throws " + classArrayToString(eTypes"\n";
    result += "{\n    super(" + apl + ");\n" + code + "}\n";
    return result;
  }

  //stop extract createRenamedConstructor

  /**
   * Returns a String that is formatted as a Java method declaration having
   * the same header as the specified method but with the code parameter
   * substituted for the method body.
   
   @return String
   @param m
   *            java.lang.Method
   @param code
   *            String
   */
  //start extract createReplacementMethod
  public static String createReplacementMethod(Method m, String code) {
    Class[] pta = m.getParameterTypes();
    String fpl = formalParametersToString(pta);
    Class[] eTypes = m.getExceptionTypes();
    String result = m.getName() "(" + fpl + ")\n";
    if (eTypes.length != 0)
      result += "    throws " + classArrayToString(eTypes"\n";
    result += "{\n" + code + "}\n";
    return result;
  }

  //stop extract createReplacementMethod

  /**
   * Returns a string for a cooperative override of the method m. That is, The
   * string has the same return type and signature as m but the body has a
   * super call that is sandwiched between the strings code1 and code2.
   
   @return String
   @param m
   *            java.lang.Method
   @param code1
   *            String
   @param code2
   *            String
   */
  //start extract createCooperativeWrapper
  public static String createCooperativeWrapper(Method m, String code1,
      String code2) {
    Class[] pta = m.getParameterTypes();
    Class retType = m.getReturnType();
    String fpl = formalParametersToString(pta);
    String apl = actualParametersToString(pta);
    Class[] eTypes = m.getExceptionTypes();
    String result = retType.getName() " " + m.getName() "(" + fpl
        ")\n";
    if (eTypes.length != 0)
      result += "    throws " + classArrayToString(eTypes"\n";
    result += "{\n" + code1 + "    ";
    if (retType != void.class)
      result += retType.getName() " cooperativeReturnValue = ";
    result += "super." + m.getName() "(" + apl + ");\n";
    result += code2;
    if (retType != void.class)
      result += "    return cooperativeReturnValue;\n";
    result += "}\n";
    return result;
  }

  /**
   * Returns the method object for the unique method named mName. If no such
   * method exists, a null is returned. If there is more than one such method,
   * a runtime exception is thrown.
   
   @return Method
   @param cls
   *            java.lang.Class
   @param mName
   *            String
   */
  public static Method getUniquelyNamedMethod(Class cls, String mName) {
    Method result = null;
    Method[] mArray = cls.getDeclaredMethods();
    for (int i = 0; i < mArray.length; i++)
      if (mName.equals(mArray[i].getName())) {
        if (result == null)
          result = mArray[i];
        else
          throw new RuntimeException("name is not unique");
      }
    return result;
  }

  /**
   * Finds the first (from the bottom of the inheritance hierarchy) field with
   * the specified name. Note that Class.getField returns only public fields.
   
   @return Field
   @param cls
   *            java.lang.Class
   @param name
   *            String
   */
  //start extract findField
  public static Field findField(Class cls, String name)
      throws NoSuchFieldException {
    if (cls != null) {
      try {
        return cls.getDeclaredField(name);
      catch (NoSuchFieldException e) {
        return findField(cls.getSuperclass(), name);
      }
    else {
      throw new NoSuchFieldException();
    }
  }

}

           
         
    
    
    
    
    
  
Related examples in the same category
1. Class Reflection: class modifierClass Reflection: class modifier
2. Class Reflection: class nameClass Reflection: class name
3. Class Reflection: name for super classClass Reflection: name for super class
4. Object Reflection: create new instance
5. Class reflectionClass reflection
6. This class shows using Reflection to get a field from another classThis class shows using Reflection to get a field from another class
7. Show the class keyword and getClass() method in actionShow the class keyword and getClass() method in action
8. Simple Demonstration of a ClassLoader WILL NOT COMPILE OUT OF THE BOX
9. Demonstrate classFor to create an instance of an object
10. CrossRef prints a cross-reference about all classes named in argv
11. Make up a compilable version of a given Sun or other API
12. Show a couple of things you can do with a Class object
13. Reflect1 shows the information about the class named in argv
14. Show that you can, in fact, take the class of a primitive
15. JavaP prints structural information about classes
16. Object InspectorObject Inspector
17. Demonstration of speed of reflexive versus programmatic invocation
18. Use reflection to get console char set
19. Load the class source location from Class.getResource()
20. Access the enclosing class from an inner class
21. Use reflection to dynamically discover the capabilities of a class.
22. Get the class By way of a string
23. Get the class By way of .class
24. Return a String representation of an object's overall identity
25. Manipulate Java class files in strange and mysterious ways
26. Class file reader for obtaining the parameter names for declared methods in a class
27. Convert a given String into the appropriate Class.
28. Manipulate Java classes
29. Encapsulates a class serialVersionUID and codebase.
30. Dump a class using Reflection
www.java2java.com | Contact Us
Copyright 2009 - 12 Demo Source and Support. All rights reserved.
All other trademarks are property of their respective owners.