Class Constructor

  • All Implemented Interfaces:, java.lang.Cloneable, java.lang.Comparable<Constructor>

    public class Constructor
    extends Callable
    implements, java.lang.Comparable<Constructor>, java.lang.Cloneable
    Similar to java.lang.reflect
    This class is heavily used internally, and can be used (if needed) to modify Java Doc Web-Pages, programmatically.

    HTML Processors that sort the Web-Page "Summary-Tables" will provide instances of this class to your Summary-Sorter Handler methods. Summary-Sorter handlers usually implement the SummarySorterHelper interface; please review that class for more about sorting Java-Doc Page Summary Tables.

    The HTML Processors that upgrade Web-Page "Detail Elements" also rely heavily on this class. Please review the class: ReflHTML for more information about Java-Doc Web-Page Detail Sections.
    Reflection Class: Holds all information extracted from '.java' Source-Files about Constructor's identified in that file.

    Instances of this Class are Obtained From: ReflHTML & SummaryTableHTML

    Use of the Reflection-HTML API is *NOT REQUIRED* to perform a standard Java Doc HTML File Upgrade. This "extra API" allows for programmatic modification of Java Doc HTML. This class contains quite a bit of reflected information, and furthermore, here there is a hook to the Native Java Parser Reflection Class.
    Class class Constructor allows for storing the name, definition, modifiers list, etc... of a constructor.

    Reflection-Classes Inheritance-Diagram

    Class Declaration
    Class Callable
    Class Method
    Class Constructor
    Also Inherits Class Callable
    No Additional Fields
    Reflection Class
    Inheritance Diagram

    Class Field
    Class EnumConstant
    Class AnnotationElem
    Class NestedType

    Native JDK API Hook:
    All reflection classes above, also contain an additional (transient, non-Serializable) field that hooks into the native Java Tree-Parser Tools available in JDK Package com.sun.source.tree.*

    If a more in-depth Code-Analysis is needed, the JDK's AST's have full and complete Parses of your Source-Code that can facilitate almost any analysis.
    See Also:
    Serialized Form

    • Field Detail

      • serialVersionUID

        🡇     🗕  🗗  🗖
        public static final long serialVersionUID
        This fulfils the SerialVersion UID requirement for all classes that implement Java's interface Using the Serializable Implementation offered by java is very easy, and can make saving program state when debugging a lot easier. It can also be used in place of more complicated systems like "hibernate" to store data as well.
        See Also:
        Constant Field Values
        Exact Field Declaration Expression:
         public static final long serialVersionUID = 1;
      • methodTree

        🡅  🡇     🗕  🗗  🗖
        public final transient com.sun.source.tree.MethodTree methodTree

        Hook Reference to Sun/Oracle Parser-Refletion Class

        Though this class offers a streamlined set of reflection features, the Native Oracle Library Reflection-Classes offer a detailed AST interface into the standard Java Compiler. If you would like to use these Tree's to provide further code analysis on your Java-Doc Pages, this field is provided as a convenience for such purposes.
        If a user decides to make use of the native Sun/Oracle MethodTree instance that was used to build this Constructor instance, it may be retrieved from this transient field.

        NOTE: The package com.sun.source.tree "reuses" or "overloads" the MethodTree object such that it may represent either a Method, or a Constructor. When a MethodTree instance is actually representing a constructor, the name that is used for the instance will be '<init>', rather than a method that abides by the standard Java naming conventions.
    • Method Detail

      • toString

        🡅  🡇     🗕  🗗  🗖
        public java.lang.String toString()
        Generates a string of this constructor, with most information included.

        NOTE: This will not return every piece of information contained by this class. For example, both the constructor body, and any possible JavaDoc Comments are not included. For a more enhanced toString() version, call the one that accepts flags.
        toString in class Callable
        A printable string of this field.
        See Also:
        PF, toString(int), StrCSV.toCSV(String[], boolean, boolean, Integer)
        Exact Method Body:
             "Name:            [" + name + "]\n" +
             "Signature:       [" + StrPrint.abbrevEndRDSF(signature, MAX_STR_LEN, true) + "]\n" +
             "Modifiers:       [" + StrCSV.toCSV(modifiers, true, true, null) + "]\n" +
             printedParameterNamesTS() +
             printedParameterTypesTS() +
             printedExceptionsTS() +
             // This will **NEVER** be null - unless 'this' instance was built from an HTML File,
             // rather than a source-code file.  Instances like that are only used temporarily, and
             // are garbage collected instantly.  Do this check anyway (just in case).
             "Location:        " + ((this.location == null)
                 ? "null" 
                 : ('[' + this.location.quickSummary() + ']'));
      • toString

        🡅  🡇     🗕  🗗  🗖
        public java.lang.String toString​(int flags)
        This class expects a flags that has been masked using the constant (public, static, final int) fields of class PF. Please view this class for more information about the flags available for modifying the return-value of this toString() method.
        toString in class Callable
        flags - These are the toString flags from class PF ("Print Flags"). View available flags listed in class PF.
        A printable String of this Constructor, with comment information included as well.
        See Also:
        toString(), StrCSV.toCSV(String[], boolean, boolean, Integer), PF
        Exact Method Body:
         boolean color = (flags & UNIX_COLORS) > 0;
             printedName("Constructor", 20, color) + 
             printedSignature(20, color) +
             printedModifiers(20) +
             printedParamNames() + 
             printedParamTypes(jowFlags(flags)) +
             printedExceptions() +
             printedLocation(20, color, (flags & BRIEF_LOCATION) > 0) +
             // The previous method does not add a '\n' end to the end of the returned string
             // These are both optional, they add a '\n' AT THE BEGINNING if one of them is included
             printedComments(20, color, (flags & JAVADOC_COMMENTS) > 0) +
      • compareTo

        🡅  🡇     🗕  🗗  🗖
        public int compareTo​(Constructor c)
        Java's interface Comparable<T> requirements. This looks at the number of parameters, and parameter types in making a sort-decision.
        Specified by:
        compareTo in interface java.lang.Comparable<Constructor>
        c - Any other Constructor to be compared to 'this' Constructor
        An integer that fulfils Java's interface Comparable<Constructor> public boolean compareTo(Constructor c) method requirements.
        Exact Method Body:
         if (this == c) return 0;
         int ret = this.numParameters() - c.numParameters();
         if (ret != 0) return ret;
         if (this.parameterTypesJOW != null)
             for (int i=0; i < this.parameterTypesJOW.size(); i++)
                 ret = this.parameterTypesJOW.get(i).compareTo(c.parameterTypesJOW.get(i));
                 if (ret != 0) return ret;
         return 0;
      • equals

        🡅     🗕  🗗  🗖
        public boolean equals​(Constructor other)
        This should be called an "atypical version" of the usual equals(Object other) constructor. This version of equals merely compares the name and parameters-list of the constructor. The presumption here is that the definition of a 'constructor' only has meaning - at all - inside the context of a class or enumerated-type where that constructor is defined. Since inside any '.java' source-code file, there may only be one constructor with a given parameter-list, this shall return TRUE whenever the constructor being compared has the same parameter types as 'this' does.
        other - This may be any other constructor. It is strongly suggested that this be a constructor defined in the same '.java' source-code file as 'this' constructor.
        This method returns TRUE when 'this' instance of Constructor has the same parameter-list as 'other'.
        Exact Method Body:
         // If the number of parameters in the 'other' instance of Constructor differ from the
         // number of parameters in 'this' Constructor, then return FALSE immediately.  It cannot be
         // a match
         if (this.numParameters() != other.numParameters()) return false;
         // If there are no parameters (for either of them), then return true immediately
         if (this.numParameters() == 0) return true;
         // If any of the parameter-names are different, break immediately and return false;
         for (int i=0; i < this.parameterNames.size(); i++)
             if (! this.parameterNames.get(i).equals(other.parameterNames.get(i)))
                 return false;
         // If the parameter-types listed by the javadoc '.html' file differ from parameter-types
         // listed in the original '.java' source-code file, then break immediately.
         // NOTE: The "package-information" for the FULL CLASS OR INTERFACE NAME is not always
         // available.
         for (int i=0; i < this.parameterTypes.size(); i++)
             if (! this.parameterTypesJOW.get(i).equals(other.parameterTypesJOW.get(i)))
                 return false;
         // ALL TESTS PASSED
         return true;