javassist
public class CtNewConstructor extends Object
CtConstructor
.
An instance of this class does not make any sense.
A class initializer (static constructor) cannot be created by the
methods in this class. Call makeClassInitializer()
in
CtClass
and append code snippet to the body of the class
initializer obtained by makeClassInitializer()
.
See Also: addConstructor makeClassInitializer
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. |
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(String src, CtClass declaring)
Compiles the given source code and creates a constructor.
|
static CtConstructor | make(CtClass[] parameters, CtClass[] exceptions, String body, CtClass declaring)
Creates a 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 | skeleton(CtClass[] parameters, CtClass[] exceptions, CtClass declaring)
Creates a public constructor that only calls a constructor
in the super class. |
Object
and passed to a super-class'
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
.
See Also: CtConstructor
The created constructor takes no parameter. It calls
super()
.
Parameters: src the source text. declaring the class to which the created constructor is added.
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.
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.
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.
See Also: (CtClass,String,CtClass[],CtClass[],CtMethod,CtMethod.ConstParameter,CtClass)
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.
See Also: Initializer