Package javassist

# Class ClassPool

java.lang.Object
javassist.ClassPool

public class ClassPool extends Object
A container of `CtClass` objects. A `CtClass` object must be obtained from this object. If `get()` is called on this object, it searches various sources represented by `ClassPath` to find a class file and then it creates a `CtClass` object representing that class file. The created object is returned to the caller.

Memory consumption memo:

`ClassPool` objects hold all the `CtClass`es that have been created so that the consistency among modified classes can be guaranteed. Thus if a large number of `CtClass`es are processed, the `ClassPool` will consume a huge amount of memory. To avoid this, a `ClassPool` object should be recreated, for example, every hundred classes processed. Note that `getDefault()` is a singleton factory. Otherwise, `detach()` in `CtClass` should be used to avoid huge memory consumption.

`ClassPool` hierarchy:

`ClassPool`s can make a parent-child hierarchy as `java.lang.ClassLoader`s. If a `ClassPool` has a parent pool, `get()` first asks the parent pool to find a class file. Only if the parent could not find the class file, `get()` searches the `ClassPath`s of the child `ClassPool`. This search order is reversed if `ClassPath.childFirstLookup` is `true`.

See Also:
  - `CtClass`
  - `ClassPath`

## Field Summary

Fields
Modifier and Type
Field
Description
`static boolean`
`cacheOpenedJarFile`
If true, the contents of a jar file are cached after the jar file is opened.
`boolean`
`childFirstLookup`
Determines the search order.
`static boolean`
`doPruning`
Turning the automatic pruning on/off.
`static boolean`
`releaseUnmodifiedClassFile`
If true, unmodified and not-recently-used class files are periodically released for saving memory.

## Constructor Summary

Constructors
Constructor
Description
`ClassPool()`
Creates a root class pool.
`ClassPool(boolean useDefaultPath)`
Creates a root class pool.
`ClassPool(ClassPool parent)`
Creates a class pool.

## Method Summary

Modifier and Type
Method
Description
`ClassPath`
`appendClassPath(String pathname)`
Appends a directory or a jar (or zip) file to the end of the search path.
`ClassPath`
`appendClassPath(ClassPath cp)`
Appends a `ClassPath` object to the end of the search path.
`void`
`appendPathList(String pathlist)`
Appends directories and jar files for search.
`ClassPath`
`appendSystemPath()`
Appends the system search path to the end of the search path.
`void`
`clearImportedPackages()`
Clear all the package names recorded by `importPackage()`.
`URL`
`find(String classname)`
Searches the class path to obtain the URL of the class file specified by classname.
`CtClass`
`get(String classname)`
Reads a class file from the source and returns a reference to the `CtClass` object representing that class file.
`CtClass[]`
`get(String[] classnames)`
Reads class files from the source and returns an array of `CtClass` objects representing those class files.
`CtClass`
`getAndRename(String orgName, String newName)`
Reads a class file and constructs a `CtClass` object with a new name.
`ClassLoader`
`getClassLoader()`
Get the classloader for `toClass()`, `getAnnotations()` in `CtClass`, etc.
`CtClass`
`getCtClass(String classname)`
Returns a `CtClass` object with the given name.
`static ClassPool`
`getDefault()`
Returns the default class pool.
`Iterator<String>`
`getImportedPackages()`
Returns all the package names recorded by `importPackage()`.
`CtMethod`
`getMethod(String classname, String methodname)`
Reads a class file and obtains a compile-time method.
`CtClass`
`getOrNull(String classname)`
Reads a class file from the source and returns a reference to the `CtClass` object representing that class file.
`void`
`importPackage(String packageName)`
Record a package name so that the Javassist compiler searches the package to resolve a class name.
`ClassPath`
`insertClassPath(String pathname)`
Inserts a directory or a jar (or zip) file at the head of the search path.
`ClassPath`
`insertClassPath(ClassPath cp)`
Insert a `ClassPath` object at the head of the search path.
`Object[]`
`lookupCflow(String name)`
Undocumented method.
`CtClass`
`makeAnnotation(String name)`
Creates a new annotation.
`CtClass`
`makeClass(InputStream classfile)`
Creates a new class (or interface) from the given class file.
`CtClass`
`makeClass(InputStream classfile, boolean ifNotFrozen)`
Creates a new class (or interface) from the given class file.
`CtClass`
`makeClass(String classname)`
Creates a new public class.
`CtClass`
`makeClass(String classname, CtClass superclass)`
Creates a new public class.
`CtClass`
`makeClass(ClassFile classfile)`
Creates a new class (or interface) from the given class file.
`CtClass`
`makeClass(ClassFile classfile, boolean ifNotFrozen)`
Creates a new class (or interface) from the given class file.
`CtClass`
`makeClassIfNew(InputStream classfile)`
Creates a new class (or interface) from the given class file.
`CtClass`
`makeInterface(String name)`
Creates a new public interface.
`CtClass`
`makeInterface(String name, CtClass superclass)`
Creates a new public interface.
`void`
`makePackage(ClassLoader loader, String name)`
Deprecated.
`void`
`recordInvalidClassName(String name)`
Deprecated.
`void`
`removeClassPath(ClassPath cp)`
Detatches the `ClassPath` object from the search path.
`Class`
`toClass(CtClass clazz)`
Converts the given class to a `java.lang.Class` object.
`Class<?>`
`toClass(CtClass ct, Class<?> neighbor)`
Converts the class to a `java.lang.Class` object.
`Class`
`toClass(CtClass ct, Class<?> neighbor, ClassLoader loader, ProtectionDomain domain)`
Converts the class to a `java.lang.Class` object.
`Class`
`toClass(CtClass ct, ClassLoader loader)`
Deprecated.
Replaced by `toClass(CtClass,Class,ClassLoader,ProtectionDomain)`.
`Class`
`toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain)`
Deprecated.
Replaced by `toClass(CtClass,Class,ClassLoader,ProtectionDomain)`.
`Class<?>`
`toClass(CtClass ct, MethodHandles.Lookup lookup)`
Converts the class to a `java.lang.Class` object.
`String`
`toString()`
Returns the class search path.

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

`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

## Field Details

### childFirstLookup

public boolean childFirstLookup
Determines the search order.

If this field is true, `get()` first searches the class path associated to this `ClassPool` and then the class path associated with the parent `ClassPool`. Otherwise, the class path associated with the parent is searched first.

The default value is false.

### doPruning

public static boolean doPruning
Turning the automatic pruning on/off.

If this field is true, `CtClass` objects are automatically pruned by default when `toBytecode()` etc. are called. The automatic pruning can be turned on/off individually for each `CtClass` object.

The initial value is false.

See Also:
  - `CtClass.prune()`
  - `CtClass.stopPruning(boolean)`
  - `CtClass.detach()`

### releaseUnmodifiedClassFile

public static boolean releaseUnmodifiedClassFile
If true, unmodified and not-recently-used class files are periodically released for saving memory.

The initial value is true.

### cacheOpenedJarFile

public static boolean cacheOpenedJarFile
If true, the contents of a jar file are cached after the jar file is opened.

The initial value is true.

## Constructor Details

### ClassPool

public ClassPool()
Creates a root class pool. No parent class pool is specified.

### ClassPool

public ClassPool(boolean useDefaultPath)
Creates a root class pool. If `useDefaultPath` is true, `appendSystemPath()` is called. Otherwise, this constructor is equivalent to the constructor taking no parameter.

Parameters:
  `useDefaultPath` - true if the system search path is appended.

### ClassPool

public ClassPool(ClassPool parent)
Creates a class pool.

Parameters:
  `parent` - the parent of this class pool. If this is a root class pool, this parameter must be `null`.
See Also:
  - `getDefault()`

## Method Details

### getDefault

public static ClassPool getDefault()
Returns the default class pool. The returned object is always identical since this method is a singleton factory.

The default class pool searches the system search path, which usually includes the platform library, extension libraries, and the search path specified by the `-classpath` option or the `CLASSPATH` environment variable.

When this method is called for the first time, the default class pool is created with the following code snippet:

    ClassPool cp = new ClassPool();
     cp.appendSystemPath();

If the default class pool cannot find any class files, try `ClassClassPath`, `ModuleClassPath`, or `LoaderClassPath`.

See Also:
  - `ClassClassPath`
  - `LoaderClassPath`

### toString

public String toString()
Returns the class search path.

Overrides:
  `toString` in class `Object`

### importPackage

public void importPackage(String packageName)
Record a package name so that the Javassist compiler searches the package to resolve a class name. Don't record the `java.lang` package, which has been implicitly recorded by default.

Since version 3.14, `packageName` can be a fully-qualified class name.

Note that `get()` in `ClassPool` does not search the recorded package. Only the compiler searches it.

Parameters:
  `packageName` - the package name. It must not include the last '.' (dot). For example, "java.util" is valid but "java.util." is wrong.
Since:
  3.1

### clearImportedPackages

public void clearImportedPackages()
Clear all the package names recorded by `importPackage()`. The `java.lang` package is not removed.

Since:
  3.1
See Also:
  - `importPackage(String)`

### getImportedPackages

public Iterator<String> getImportedPackages()
Returns all the package names recorded by `importPackage()`.

Since:
  3.1
See Also:
  - `importPackage(String)`

### recordInvalidClassName

public void recordInvalidClassName(String name)
Deprecated.
Records a class name that never exists. For example, a package name can be recorded by this method. This would improve execution performance since `get()` quickly throw an exception without searching the class path at all if the given name is an invalid name recorded by this method. Note that searching the class path takes relatively long time.

The current implementation of this method performs nothing.

Parameters:
  `name` - an invalid class name (separeted by dots).

### lookupCflow

public Object[] lookupCflow(String name)
Undocumented method. Do not use; internal-use only.

Parameters:
  `name` - the name of `$cflow` variable

### getAndRename

public CtClass getAndRename(String orgName, String newName) throws NotFoundException
Reads a class file and constructs a `CtClass` object with a new name. This method is useful if you want to generate a new class as a copy of another class (except the class name). For example,

     getAndRename("Point", "Pair")

returns a `CtClass` object representing `Pair` class. The definition of `Pair` is the same as that of `Point` class except the class name since `Pair` is defined by reading `Point.class`.

Parameters:
  `orgName` - the original (fully-qualified) class name
  `newName` - the new class name
Throws:
  `NotFoundException`

### get

public CtClass get(String classname) throws NotFoundException
Reads a class file from the source and returns a reference to the `CtClass` object representing that class file. If that class file has been already read, this method returns a reference to the `CtClass` created when that class file was read at the first time.

If `classname` ends with "[]", then this method returns a `CtClass` object for that array type.

To obtain an inner class, use "$" instead of "." for separating the enclosing class name and the inner class name.

Parameters:
  `classname` - a fully-qualified class name.
Throws:
  `NotFoundException`

### getOrNull

public CtClass getOrNull(String classname)
Reads a class file from the source and returns a reference to the `CtClass` object representing that class file. This method is equivalent to `get` except that it returns `null` when a class file is not found and it never throws an exception.

Parameters:
  `classname` - a fully-qualified class name.
Returns:
  a `CtClass` object or `null`.
Since:
  3.13
See Also:
  - `get(String)`
  - `find(String)`

### getCtClass

public CtClass getCtClass(String classname) throws NotFoundException
Returns a `CtClass` object with the given name. This is almost equivalent to `get(String)` except that classname can be an array-type "descriptor" (an encoded type name) such as `[Ljava/lang/Object;`.

Using this method is not recommended; this method should be used only to obtain the `CtClass` object with a name returned from `getClassInfo` in `javassist.bytecode.ClassPool`. `getClassInfo` returns a fully-qualified class name but, if the class is an array type, it returns a descriptor.

Parameters:
  `classname` - a fully-qualified class name or a descriptor representing an array type.
Throws:
  `NotFoundException`
Since:
  3.8.1
See Also:
  - `get(String)`
  - `ConstPool.getClassInfo(int)`
  - `Descriptor.toCtClass(String, ClassPool)`

### find

public URL find(String classname)
Searches the class path to obtain the URL of the class file specified by classname. It is also used to determine whether the class file exists.

Parameters:
  `classname` - a fully-qualified class name.
Returns:
  null if the class file could not be found.
See Also:
  - `CtClass.getURL()`

### get

public CtClass[] get(String[] classnames) throws NotFoundException
Reads class files from the source and returns an array of `CtClass` objects representing those class files.

If an element of `classnames` ends with "[]", then this method returns a `CtClass` object for that array type.

Parameters:
  `classnames` - an array of fully-qualified class name.
Throws:
  `NotFoundException`

### getMethod

public CtMethod getMethod(String classname, String methodname) throws NotFoundException
Reads a class file and obtains a compile-time method.

Parameters:
  `classname` - the class name
  `methodname` - the method name
Throws:
  `NotFoundException`
See Also:
  - `CtClass.getDeclaredMethod(String)`

### makeClass

public CtClass makeClass(InputStream classfile) throws IOException, RuntimeException
Creates a new class (or interface) from the given class file. If there already exists a class with the same name, the new class overwrites that previous class.

This method is used for creating a `CtClass` object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.

Parameters:
  `classfile` - class file.
Throws:
  `RuntimeException` - if there is a frozen class with the the same name.
  `IOException`
See Also:
  - `makeClassIfNew(InputStream)`
  - `ByteArrayClassPath`

### makeClass

public CtClass makeClass(InputStream classfile, boolean ifNotFrozen) throws IOException, RuntimeException
Creates a new class (or interface) from the given class file. If there already exists a class with the same name, the new class overwrites that previous class.

This method is used for creating a `CtClass` object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.

Parameters:
  `classfile` - class file.
  `ifNotFrozen` - throws a RuntimeException if this parameter is true and there is a frozen class with the same name.
Throws:
  `IOException`
  `RuntimeException`
See Also:
  - `ByteArrayClassPath`

### makeClass

public CtClass makeClass(ClassFile classfile) throws RuntimeException
Creates a new class (or interface) from the given class file. If there already exists a class with the same name, the new class overwrites that previous class.

This method is used for creating a `CtClass` object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.

Parameters:
  `classfile` - class file.
Throws:
  `RuntimeException` - if there is a frozen class with the the same name.
Since:
  3.20

### makeClass

public CtClass makeClass(ClassFile classfile, boolean ifNotFrozen) throws RuntimeException
Creates a new class (or interface) from the given class file. If there already exists a class with the same name, the new class overwrites that previous class.

This method is used for creating a `CtClass` object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.

Parameters:
  `classfile` - class file.
  `ifNotFrozen` - throws a RuntimeException if this parameter is true and there is a frozen class with the same name.
Throws:
  `RuntimeException`
Since:
  3.20

### makeClassIfNew

public CtClass makeClassIfNew(InputStream classfile) throws IOException, RuntimeException
Creates a new class (or interface) from the given class file. If there already exists a class with the same name, this method returns the existing class; a new class is never created from the given class file.

This method is used for creating a `CtClass` object directly from a class file. The qualified class name is obtained from the class file; you do not have to explicitly give the name.

Parameters:
  `classfile` - the class file.
Throws:
  `IOException`
  `RuntimeException`
Since:
  3.9
See Also:
  - `makeClass(InputStream)`
  - `ByteArrayClassPath`

### makeClass

public CtClass makeClass(String classname) throws RuntimeException
Creates a new public class. If there already exists a class with the same name, the new class overwrites that previous class.

If no constructor is explicitly added to the created new class, Javassist generates constructors and adds it when the class file is generated. It generates a new constructor for each constructor of the super class. The new constructor takes the same set of parameters and invokes the corresponding constructor of the super class. All the received parameters are passed to it.

Parameters:
  `classname` - a fully-qualified class name.
Throws:
  `RuntimeException` - if the existing class is frozen.

### makeClass

public CtClass makeClass(String classname, CtClass superclass) throws RuntimeException
Creates a new public class. If there already exists a class/interface with the same name, the new class overwrites that previous class.

If no constructor is explicitly added to the created new class, Javassist generates constructors and adds it when the class file is generated. It generates a new constructor for each constructor of the super class. The new constructor takes the same set of parameters and invokes the corresponding constructor of the super class. All the received parameters are passed to it.

Parameters:
  `classname` - a fully-qualified class name.
  `superclass` - the super class.
Throws:
  `RuntimeException` - if the existing class is frozen.

### makeInterface

public CtClass makeInterface(String name) throws RuntimeException
Creates a new public interface. If there already exists a class/interface with the same name, the new interface overwrites that previous one.

Parameters:
  `name` - a fully-qualified interface name.
Throws:
  `RuntimeException` - if the existing interface is frozen.

### makeInterface

public CtClass makeInterface(String name, CtClass superclass) throws RuntimeException
Creates a new public interface. If there already exists a class/interface with the same name, the new interface overwrites that previous one.

Parameters:
  `name` - a fully-qualified interface name.
  `superclass` - the super interface.
Throws:
  `RuntimeException` - if the existing interface is frozen.

### makeAnnotation

public CtClass makeAnnotation(String name) throws RuntimeException
Creates a new annotation. If there already exists a class/interface with the same name, the new interface overwrites that previous one.

Parameters:
  `name` - a fully-qualified interface name. Or null if the annotation has no super interface.
Throws:
  `RuntimeException` - if the existing interface is frozen.
Since:
  3.19

### appendSystemPath

public ClassPath appendSystemPath()
Appends the system search path to the end of the search path. The system search path usually includes the platform library, extension libraries, and the search path specified by the `-classpath` option or the `CLASSPATH` environment variable.

Returns:
  the appended class path.

### insertClassPath

public ClassPath insertClassPath(ClassPath cp)
Insert a `ClassPath` object at the head of the search path.

Returns:
  the inserted class path.
See Also:
  - `ClassPath`
  - `URLClassPath`
  - `ByteArrayClassPath`

### appendClassPath

public ClassPath appendClassPath(ClassPath cp)
Appends a `ClassPath` object to the end of the search path.

Returns:
  the appended class path.
See Also:
  - `ClassPath`
  - `URLClassPath`
  - `ByteArrayClassPath`

### insertClassPath

public ClassPath insertClassPath(String pathname) throws NotFoundException
Inserts a directory or a jar (or zip) file at the head of the search path.

Parameters:
  `pathname` - the path name of the directory or jar file. It must not end with a path separator ("/"). If the path name ends with "/*", then all the jar files matching the path name are inserted.
Returns:
  the inserted class path.
Throws:
  `NotFoundException` - if the jar file is not found.

### appendClassPath

public ClassPath appendClassPath(String pathname) throws NotFoundException
Appends a directory or a jar (or zip) file to the end of the search path.

Parameters:
  `pathname` - the path name of the directory or jar file. It must not end with a path separator ("/"). If the path name ends with "/*", then all the jar files matching the path name are appended.
Returns:
  the appended class path.
Throws:
  `NotFoundException` - if the jar file is not found.

### removeClassPath

public void removeClassPath(ClassPath cp)
Detatches the `ClassPath` object from the search path. The detached `ClassPath` object cannot be added to the path again.

### appendPathList

public void appendPathList(String pathlist) throws NotFoundException
Appends directories and jar files for search.

The elements of the given path list must be separated by colons in Unix or semi-colons in Windows.

Parameters:
  `pathlist` - a (semi)colon-separated list of the path names of directories and jar files. The directory name must not end with a path separator ("/").
Throws:
  `NotFoundException` - if a jar file is not found.

### toClass

public Class toClass(CtClass clazz) throws CannotCompileException
Converts the given class to a `java.lang.Class` object. Once this method is called, further modifications are not allowed any more. To load the class, this method uses the context class loader of the current thread. It is obtained by calling `getClassLoader()`.

This behavior can be changed by subclassing the pool and changing the `getClassLoader()` method. If the program is running on some application server, the context class loader might be inappropriate to load the class.

This method is provided for convenience. If you need more complex functionality, you should write your own class loader.

Warining: This method should not be used in Java 11 or later. Use `toClass(CtClass,Class)`.

Warining: A Class object returned by this method may not work with a security manager or a signed jar file because a protection domain is not specified.

Throws:
  `CannotCompileException`
See Also:
  - `toClass(CtClass,Class)`
  - `toClass(CtClass,Class,java.lang.ClassLoader,ProtectionDomain)`
  - `getClassLoader()`

### getClassLoader

public ClassLoader getClassLoader()
Get the classloader for `toClass()`, `getAnnotations()` in `CtClass`, etc.

The default is the context class loader.

Returns:
  the classloader for the pool
See Also:
  - `toClass(CtClass)`
  - `CtClass.getAnnotations()`

### toClass

public Class toClass(CtClass ct, ClassLoader loader) throws CannotCompileException
Deprecated.
Replaced by `toClass(CtClass,Class,ClassLoader,ProtectionDomain)`. A subclass of `ClassPool` that has been overriding this method should be modified. It should override `toClass(CtClass,Class,ClassLoader,ProtectionDomain)`.
Converts the class to a `java.lang.Class` object. Do not override this method any more at a subclass because `toClass(CtClass)` will never calls this method.

Warining: A Class object returned by this method may not work with a security manager or a signed jar file because a protection domain is not specified.

Throws:
  `CannotCompileException`

### toClass

public Class toClass(CtClass ct, ClassLoader loader, ProtectionDomain domain) throws CannotCompileException
Deprecated.
Replaced by `toClass(CtClass,Class,ClassLoader,ProtectionDomain)`.
Converts the class to a `java.lang.Class` object. Once this method is called, further modifications are not allowed any more.

The class file represented by the given `CtClass` is loaded by the given class loader to construct a `java.lang.Class` object. Since a private method on the class loader is invoked through the reflection API, the caller must have permissions to do that.

An easy way to obtain `ProtectionDomain` object is to call `getProtectionDomain()` in `java.lang.Class`. It returns the domain that the class belongs to.

This method is provided for convenience. If you need more complex functionality, you should write your own class loader.

Parameters:
  `ct` - the class converted into `java.lang.Class`.
  `loader` - the class loader used to load this class. For example, the loader returned by `getClassLoader()` can be used for this parameter.
  `domain` - the protection domain for the class. If it is null, the default domain created by `java.lang.ClassLoader` is used.
Throws:
  `CannotCompileException`
Since:
  3.3
See Also:
  - `getClassLoader()`

### toClass

public Class<?> toClass(CtClass ct, Class<?> neighbor) throws CannotCompileException
Converts the class to a `java.lang.Class` object. Once this method is called, further modifications are not allowed any more.

This method is available in Java 9 or later. It loads the class by using `java.lang.invoke.MethodHandles` with `neighbor`.

Parameters:
  `ct` - the class converted into `java.lang.Class`.
  `neighbor` - a class belonging to the same package that the converted class belongs to.
Throws:
  `CannotCompileException`
Since:
  3.24

### toClass

public Class<?> toClass(CtClass ct, MethodHandles.Lookup lookup) throws CannotCompileException
Converts the class to a `java.lang.Class` object. Once this method is called, further modifications are not allowed any more.

This method is available in Java 9 or later. It loads the class by using the given `java.lang.invoke.MethodHandles.Lookup`.

Parameters:
  `ct` - the class converted into `java.lang.Class`.
Throws:
  `CannotCompileException`
Since:
  3.24

### toClass

public Class toClass(CtClass ct, Class<?> neighbor, ClassLoader loader, ProtectionDomain domain) throws CannotCompileException
Converts the class to a `java.lang.Class` object. Once this method is called, further modifications are not allowed any more.

When the JVM is Java 11 or later, this method loads the class by using `java.lang.invoke.MethodHandles` with `neighbor`. The other arguments `loader` and `domain` are not used; so they can be null.

Otherwise, or when `neighbor` is null, the class file represented by the given `CtClass` is loaded by the given class loader to construct a `java.lang.Class` object. Since a private method on the class loader is invoked through the reflection API, the caller must have permissions to do that.

An easy way to obtain `ProtectionDomain` object is to call `getProtectionDomain()` in `java.lang.Class`. It returns the domain that the class belongs to.

If your program is for only Java 9 or later, don't use this method. Use `toClass(CtClass,Class)` or `toClass(CtClass,java.lang.invoke.MethodHandles.Lookup)`.

Parameters:
  `ct` - the class converted into `java.lang.Class`.
  `neighbor` - a class belonging to the same package that the converted class belongs to. It can be null.
  `loader` - the class loader used to load this class. For example, the loader returned by `getClassLoader()` can be used for this parameter.
  `domain` - the protection domain for the class. If it is null, the default domain created by `java.lang.ClassLoader` is used.
Throws:
  `CannotCompileException`
Since:
  3.24
See Also:
  - `getClassLoader()`

### makePackage

public void makePackage(ClassLoader loader, String name) throws CannotCompileException
Deprecated.
Defines a new package. If the package is already defined, this method performs nothing.

You do not necessarily need to call this method. If this method is called, then `getPackage()` on the `Class` object returned by `toClass()` will return a non-null object.

The jigsaw module introduced by Java 9 has broken this method.

Parameters:
  `loader` - the class loader passed to `toClass()` or the default one obtained by `getClassLoader()`.
  `name` - the package name.
Throws:
  `CannotCompileException`
Since:
  3.16
See Also:
  - `getClassLoader()`
  - `toClass(CtClass)`
  - `CtClass.toClass()`