Package javassist

# Class CtMethod

java.lang.Object
javassist.CtMember
javassist.CtBehavior
javassist.CtMethod

public final class CtMethod extends CtBehavior
An instance of `CtMethod` represents a method.

See the super class `CtBehavior` since a number of useful methods are in `CtBehavior`. A number of useful factory methods are in `CtNewMethod`.

See Also:
  - `CtClass.getDeclaredMethods()`
  - `CtNewMethod`

## Nested Class Summary

Nested Classes
Modifier and Type
Class
Description
`static class`
`CtMethod.ConstParameter`
Instances of this class represent a constant parameter.

## Constructor Summary

Constructors
Constructor
Description
`CtMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass declaring)`
Creates a public abstract method.
`CtMethod(CtMethod src, CtClass declaring, ClassMap map)`
Creates a copy of a `CtMethod` object.

## Method Summary

Modifier and Type
Method
Description
`boolean`
`equals(Object obj)`
Indicates whether `obj` has the same name and the same signature as this method.
`String`
`getLongName()`
Returns the method name followed by parameter types such as `javassist.CtMethod.setBody(String)`.
`String`
`getName()`
Obtains the name of this method.
`CtClass`
`getReturnType()`
Obtains the type of the returned value.
`int`
`hashCode()`
Returns a hash code value for the method.
`boolean`
`isEmpty()`
Returns true if the method body is empty, that is, `{}`.
`static CtMethod`
`make(String src, CtClass declaring)`
Compiles the given source code and creates a method.
`static CtMethod`
`make(MethodInfo minfo, CtClass declaring)`
Creates a method from a `MethodInfo` object.
`void`
`setBody(CtMethod src, ClassMap map)`
Copies a method body from another method.
`void`
`setName(String newname)`
Changes the name of this method.
`void`
`setWrappedBody(CtMethod mbody, CtMethod.ConstParameter constParam)`
Replace a method body with a new method body wrapping the given method.

### Methods inherited from class javassist.CtBehavior

`addCatch, addCatch, addLocalVariable, addParameter, getAnnotation, getAnnotations, getAttribute, getAvailableAnnotations, getAvailableParameterAnnotations, getExceptionTypes, getGenericSignature, getMethodInfo, getMethodInfo2, getModifiers, getParameterAnnotations, getParameterTypes, getSignature, hasAnnotation, insertAfter, insertAfter, insertAfter, insertAt, insertAt, insertBefore, insertParameter, instrument, instrument, setAttribute, setBody, setBody, setExceptionTypes, setGenericSignature, setModifiers, useCflow`

### Methods inherited from class javassist.CtMember

`getDeclaringClass, hasAnnotation, toString, visibleFrom`

### Methods inherited from class java.lang.Object

`getClass, notify, notifyAll, wait, wait, wait`

## Constructor Details

### CtMethod

public CtMethod(CtClass returnType, String mname, CtClass[] parameters, CtClass declaring)
Creates a public abstract method. The created method must be added to a class with `CtClass.addMethod()`.

Parameters:
  `returnType` - the type of the returned value
  `mname` - the method name
  `parameters` - a list of the parameter types
  `declaring` - the class to which the created method is added.
See Also:
  - `CtClass.addMethod(CtMethod)`

### CtMethod

public CtMethod(CtMethod src, CtClass declaring, ClassMap map) throws CannotCompileException
Creates a copy of a `CtMethod` object. The created method must be added to a class with `CtClass.addMethod()`.

All occurrences of class names in the created method are replaced with names specified by `map` if `map` is not `null`.

For example, suppose that a method `at()` is as follows:

     public X at(int i) {
         return (X)super.elementAt(i);
     }

(`X` is a class name.) If `map` substitutes `String` for `X`, then the created method is:

     public String at(int i) {
         return (String)super.elementAt(i);
     }

By default, all the occurrences of the names of the class declaring `at()` and the superclass are replaced with the name of the class and the superclass that the created method is added to. This is done whichever `map` is null or not. To prevent this replacement, call `ClassMap.fix()` or `put()` to explicitly specify replacement.

Note: if the `.class` notation (for example, `String.class`) is included in an expression, the Javac compiler may produce a helper method. Since this constructor never copies this helper method, the programmers have the responsiblity of copying it. Otherwise, use `Class.forName()` in the expression.

Parameters:
  `src` - the source method.
  `declaring` - the class to which the created method is added.
  `map` - the hashtable associating original class names with substituted names. It can be `null`.
Throws:
  `CannotCompileException`
See Also:
  - `CtClass.addMethod(CtMethod)`
  - `ClassMap.fix(String)`

## Method Details

### make

public static CtMethod make(String src, CtClass declaring) throws CannotCompileException
Compiles the given source code and creates a method. This method simply delegates to `make()` in `CtNewMethod`. See it for more details. `CtNewMethod` has a number of useful factory methods.

Parameters:
  `src` - the source text.
  `declaring` - the class to which the created method is added.
Throws:
  `CannotCompileException`
See Also:
  - `CtNewMethod.make(String, CtClass)`

### make

public static CtMethod make(MethodInfo minfo, CtClass declaring) throws CannotCompileException
Creates a method from a `MethodInfo` object.

Parameters:
  `declaring` - the class declaring the method.
Throws:
  `CannotCompileException` - if the the `MethodInfo` object and the declaring class have different `ConstPool` objects
Since:
  3.6

### hashCode

public int hashCode()
Returns a hash code value for the method. If two methods have the same name and signature, then the hash codes for the two methods are equal.

Overrides:
  `hashCode` in class `Object`

### equals

public boolean equals(Object obj)
Indicates whether `obj` has the same name and the same signature as this method.

Overrides:
  `equals` in class `Object`

### getLongName

public String getLongName()
Returns the method name followed by parameter types such as `javassist.CtMethod.setBody(String)`.

Specified by:
  `getLongName` in class `CtBehavior`
Since:
  3.5

### getName

public String getName()
Obtains the name of this method.

Specified by:
  `getName` in class `CtMember`
See Also:
  - `CtConstructor.getName()`

### setName

public void setName(String newname)
Changes the name of this method.

### getReturnType

public CtClass getReturnType() throws NotFoundException
Obtains the type of the returned value.

Throws:
  `NotFoundException`

### isEmpty

public boolean isEmpty()
Returns true if the method body is empty, that is, `{}`. It also returns true if the method is an abstract method.

Specified by:
  `isEmpty` in class `CtBehavior`

### setBody

public void setBody(CtMethod src, ClassMap map) throws CannotCompileException
Copies a method body from another method. If this method is abstract, the abstract modifier is removed after the method body is copied.

All occurrences of the class names in the copied method body are replaced with the names specified by `map` if `map` is not `null`.

Parameters:
  `src` - the method that the body is copied from.
  `map` - the hashtable associating original class names with substituted names. It can be `null`.
Throws:
  `CannotCompileException`

### setWrappedBody

public void setWrappedBody(CtMethod mbody, CtMethod.ConstParameter constParam) throws CannotCompileException
Replace a method body with a new method body wrapping the given method.

Parameters:
  `mbody` - the wrapped method
  `constParam` - the constant parameter given to the wrapped method (maybe `null`).
Throws:
  `CannotCompileException`
See Also:
  - `CtNewMethod.wrapped(CtClass,String,CtClass[],CtClass[],CtMethod,CtMethod.ConstParameter,CtClass)`