Overview | Package | Class | Use | Tree | Deprecated | Index
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## javassist
Class CtNewConstructor

    java.lang.Object
      |
      +--javassist.CtNewConstructor

public class CtNewConstructor
extends java.lang.Object

A collection of static methods for creating a `CtConstructor`. An instance of this class does not make any sense.

See Also:
  `CtClass.addConstructor(CtConstructor)`

Field Summary
`static int` | `PASS_ARRAY` Specifies that parameters are converted into an array of `Object` and passed to a super-class' constructor.
`static int` | `PASS_NONE` Specifies that no parameters are passed to a super-class' constructor.
`static int` | `PASS_PARAMS` Specifies that parameters are passed as is to a super-class' constructor.

Constructor Summary
`CtNewConstructor()`

Method Summary
`static CtConstructor` | `copy(CtConstructor c, CtClass declaring, ClassMap map)` Creats a copy of a constructor.
`static CtConstructor` | `defaultConstructor(CtClass declaring)` Creates a default (public) constructor.
`static CtConstructor` | `make(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)` Creates a public constructor that only calls a constructor in the super class.
`static CtConstructor` | `make(CtClass[] parameters, CtClass[] exceptions, int howto, CtMethod body, CtMethod.ConstParameter cparam, CtClass declaring)` Creates a public constructor.
`static CtConstructor` | `make(CtClass[] parameters, CtClass[] exceptions, java.lang.String body, CtClass declaring)` Creates a public constructor.
`static CtConstructor` | `make(java.lang.String src, CtClass declaring)` Compiles the given source code and creates a constructor.
`static CtConstructor` | `skeleton(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)` Creates a public constructor that only calls a constructor in the super class.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### PASS_NONE

    public static final int PASS_NONE

  Specifies that no parameters are passed to a super-class' constructor. That is, the default constructor is invoked.

  See Also:
    Constant Field Values

### PASS_ARRAY

    public static final int PASS_ARRAY

  Specifies that parameters are converted into an array of `Object` and passed to a super-class' constructor.

  See Also:
    Constant Field Values

### PASS_PARAMS

    public static final int PASS_PARAMS

  Specifies that parameters are passed as is to a super-class' constructor. The signature of that constructor must be the same as that of the created constructor.

  See Also:
    Constant Field Values

Constructor Detail

### CtNewConstructor

    public CtNewConstructor()

Method Detail

### make

    public static CtConstructor make(java.lang.String src,
                                     CtClass declaring)
                              throws CannotCompileException

  Compiles the given source code and creates a constructor. The source code must include not only the constructor body but the whole declaration.

  Parameters:
    `src` - the source text.
    `declaring` - the class to which the created constructor is added.
    `CannotCompileException`

### make

    public static CtConstructor make(CtClass[] parameters,
                                     CtClass[] exceptions,
                                     java.lang.String body,
                                     CtClass declaring)
                              throws CannotCompileException

  Creates a public constructor.

  Parameters:
    `parameters` - a list of the parameter types.
    `exceptions` - a list of the exception types.
    `body` - the source text of the constructor body. It must be a block surrounded by `{}`. If it is `null`, the substituted constructor body does nothing except calling `super()`.
    `declaring` - the class to which the created method is added.
    `CannotCompileException`

### copy

    public static CtConstructor copy(CtConstructor c,
                                     CtClass declaring,
                                     ClassMap map)
                              throws CannotCompileException

  Creats a copy of a constructor.

  Parameters:
    `c` - the copied constructor.
    `declaring` - the class to which the created method is added.
    `map` - the hashtable associating original class names with substituted names. It can be `null`.
    `CannotCompileException`
  See Also:
    `CtConstructor.CtConstructor(CtConstructor,CtClass,ClassMap)`

### defaultConstructor

    public static CtConstructor defaultConstructor(CtClass declaring)
                                            throws CannotCompileException

  Creates a default (public) constructor.

  The created constructor takes no parameter. It calls `super()`.

    `CannotCompileException`

### skeleton

    public static CtConstructor skeleton(CtClass[] parameters,
                                         CtClass[] exceptions,
                                         CtClass declaring)
                                  throws CannotCompileException

  Creates a public constructor that only calls a constructor in the super class. The created constructor receives parameters specified by `parameters` but calls the super's constructor without those parameters (that is, it calls the default constructor).

  The parameters passed to the created constructor should be used for field initialization. `CtField.Initializer` objects implicitly insert initialization code in constructor bodies.

  Parameters:
    `parameters` - parameter types
    `exceptions` - exception types
    `declaring` - the class to which the created constructor is added.
    `CannotCompileException`
  See Also:
    `CtField.Initializer.byParameter(int)`

### make

    public static CtConstructor make(CtClass[] parameters,
                                     CtClass[] exceptions,
                                     CtClass declaring)
                              throws CannotCompileException

  Creates a public constructor that only calls a constructor in the super class. The created constructor receives parameters specified by `parameters` and calls the super's constructor with those parameters.

  Parameters:
    `parameters` - parameter types
    `exceptions` - exception types
    `declaring` - the class to which the created constructor is added.
    `CannotCompileException`

### make

    public static CtConstructor make(CtClass[] parameters,
                                     CtClass[] exceptions,
                                     int howto,
                                     CtMethod body,
                                     CtMethod.ConstParameter cparam,
                                     CtClass declaring)
                              throws CannotCompileException

  Creates a public constructor.

  If `howto` is `PASS_PARAMS`, the created constructor calls the super's constructor with the same signature. The superclass must contain a constructor taking the same set of parameters as the created one.

  If `howto` is `PASS_NONE`, the created constructor calls the super's default constructor. The superclass must contain a constructor taking no parameters.

  If `howto` is `PASS_ARRAY`, the created constructor calls the super's constructor with the given parameters in the form of an array of `Object`. The signature of the super's constructor must be:

  `constructor(Object[] params, <type> cvalue)`

  Here, `cvalue` is the constant value specified by `cparam`.

  If `cparam` is `null`, the signature must be:

  `constructor(Object[] params)`

  If `body` is not null, a copy of that method is embedded in the body of the created constructor. The embedded method is executed after the super's constructor is called and the values of fields are initialized. Note that `body` must not be a constructor but a method.

  Since the embedded method is wrapped in parameter-conversion code as in `CtNewMethod.wrapped()`, the constructor parameters are passed in the form of an array of `Object`. The method specified by `body` must have the signature shown below:

  `Object method(Object[] params, <type> cvalue)`

  If `cparam` is `null`, the signature must be:

  `Object method(Object[] params)`

  Although the type of the returned value is `Object`, the value must be always `null`.

  Example:

      ClassPool pool = ... ;
       CtClass xclass = pool.makeClass("X");
       CtMethod method = pool.getMethod("Sample", "m");
       xclass.setSuperclass(pool.get("Y"));
       CtClass[] argTypes = { CtClass.intType };
       ConstParameter cparam = ConstParameter.string("test");
       CtConstructor c = CtNewConstructor.make(argTypes, null,
                                        PASS_PARAMS, method, cparam, xclass);
       xclass.addConstructor(c);

  where the class `Sample` is as follows:

      public class Sample {
           public Object m(Object[] args, String msg) {
               System.out.println(msg);
               return null;
           }
       }

  This program produces the following class:

      public class X extends Y {
           public X(int p0) {
               super(p0);
               String msg = "test";
               Object[] args = new Object[] { p0 };
               // begin of copied body
               System.out.println(msg);
               Object result = null;
               // end
           }
       }

  Parameters:
    `parameters` - a list of the parameter types
    `exceptions` - a list of the exceptions
    `howto` - how to pass parameters to the super-class' constructor (`PASS_NONE`, `PASS_ARRAY`, or `PASS_PARAMS`)
    `body` - appended body (may be `null`). It must be not a constructor but a method.
    `cparam` - constant parameter (may be `null`.)
    `declaring` - the class to which the created constructor is added.
    `CannotCompileException`
  See Also:
    `CtNewMethod.wrapped(CtClass,String,CtClass[],CtClass[],CtMethod,CtMethod.ConstParameter,CtClass)`

Overview | Package | Class | Use | Tree | Deprecated | Index
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Javassist, a Java-bytecode translator toolkit. Copyright (C) 1999-2003 Shigeru Chiba. All Rights Reserved.