Browse Java elements either from a JDeveloper dialog or from a file that is open in the Java Source Editor.

While working in JDeveloper, you can browse Java elements using a JDeveloper dialog or directly from an open file in the Java Source Editor. You also can locate source code or Javadoc for a given type.

Sources are displayed for classes present in the project's source path. They are also displayed for classes present in a project library, if the library has sources included.

In the Java Source Editor, locate the declaration of any identifier. Follow the steps to navigate to the declaration of a code element.

• Right-click on the code element and choose Go to Declaration, or:

• Press the Control key and left-click on the code element.

The source code for that element opens, with the line on which it is declared highlighted.

Figure 8-1 Highlighted Declaration

Description of "Figure 8-1 Highlighted Declaration"

If the declaration is in the same file, the cursor moves to it and highlights it. If the declaration is in a different file, the source file opens in the Java Source Editor. The cursor moves to it and highlights it.

In the Java Source Editor, search for references to a class or interface and its members. Use the procedure to find the usages of a class.

1. Select the class or interface in one of the following ways:

   • In the Java Source Editor, select the name.

   • In the Applications window or the Structure window, select a class or an interface.

2. Invoke the command using one of the following ways:

   • Choose Search > Find Usages.

   • Right-click and choose Find Usages.

   • Press Ctrl+Alt+U.

     The Usages of <Object> dialog displays.

3. In the Find box, select the types of references that the search will return.
4. In the Where box, define the optional additional areas you want to search in.
5. To direct the output of the search, select New Tab to direct the output to a new Usages Log.

   If not selected, the result of the previous search for usages, if any, are discarded.

6. Click OK.

   The results display in the Usages Log window.

In the Java Source Editor, search for references to a method. Use the procedure to find usages of a method to instances of the class or interface for which the method is defined, or usages of its subclasses or subinterfaces that inherit the method.

1. Select the method in one of the following ways:

   • In a Java Source Editor, select the name.

   • In the Structure pane, select the method.

2. Invoke the command in one of the following ways:

   • Choose Search > Find Usages.

   • Right-click and choose Find Usages.

   • Press Ctrl+Alt-U.

     The Usages of <Method> dialog displays. This dialog provides various options that you can specify to search for usages.

   • Specify options in the dialog and click OK to begin the search.

In the Java Source Editor, search for references to a field in instances of the class or interface for which the field is defined, and instances of its subclasses or subinterfaces that inherit the field. Use the procedure to find the usages of a field.

1. Select the field in one of the following ways:

   • In a Java Source Editor, select the name.

   • In the Structure pane, select the field.

2. Invoke the command in one of the following ways:

   • Choose Search > Find Usages.

   • Right-click and choose Find Usages.

   • Press Ctrl+Alt-U.

3. Complete the Usages of <Object> dialog and click OK. You can specify options to extend the search to other areas, define the scope of the search, and optionally specify that the results be displayed in a new tab in the Log window.

   The search will commence, and the results will be displayed in the Usages of <Object> Log window.

In the Java Source Editor, search for references to a local variable or a parameter in a method body. Use the procedure to find the usages of a local variable or parameter.

1. Select the variable or parameter name in the Java Source Editor.
2. Invoke the command in one of the following ways:

   • Choose Search > Find Usages.

   • Right-click and choose Find Usages.

   • Press Ctrl+Alt-U.

     The results are displayed in the Usages Log window.

In the Java Source Editor, methods that override or implement superclass definitions can be identified. Click Overrides or Implements in the margin to view the overridden definition of a method.

In the Java Source Editor, inspect the hierarchy of subtypes and supertypes of a class or interface.

While working in the Java Source Editor, you can inspect the hierarchy of subtypes and supertypes of a class or interface.

What displays in the editor is the entire GUI hierarchy for the node. The method of display depends upon whether this hierarchy consists of menu or non-menu items.

In a Java Source Editor, use keyboard accelerators to move from member to member in a class definition. Use the code-stepping commands listed in the Navigate category of the Shortcut Keys page of the Preferences dialog or the Navigate options to navigate between members.

Create an application, a project, a new class, or an interface that JDeveloper adds to an active project, and displays in the Java Source Editor. Use the procedure to create a new class, and add it to a project.

1. In the Applications window, select the project where you want to add the Java class, for example, client.
2. Right-click and choose New > Java Class.
3. In the Create Java Class dialog, enter the class or interface name, the package name, and the superclass that the new class will extend.
4. Select attributes as needed.
5. Click OK.

In the source editor, add framework code that modifies a target class to implement an interface, or make a target interface extend another interface. Use the procedure to implement an interface.

1. Open a Java source file.
2. From the main menu, choose Source > Implement Interface.
3. On the Search or Hierarchy tab, locate the class that will implement the interface and select the names of the interfaces that are to be implemented.
4. If you want documentation comments from the overridden methods to be included, select Copy Javadoc.
5. Click OK.

In the source editor, add stub definitions to a class to override methods inherited from superclasses. Use the procedure to override methods.

1. Open a Java source file.
2. From the main menu, choose Source > Override Methods.
3. In the Methods list, select the methods that are to be overridden.

   The list displays methods inherited from all superclasses. Abstract methods are shown in bold type. These must be implemented by non-abstract types.

4. If you want documentation comments from the overridden methods to be included, select Copy Javadoc.
5. Click OK.

   The stub method definitions are added to the class.

6. Edit the stub definitions.

Lambda expressions provide a mechanism to express instances of anonymous inner classes that contain only a single method. Use the procedures to convert an inner class to a lambda expression, and to turn off the feature.

1. Go to Tools > Preferences and click the Audit node.
2. Click Edit Profiles on the Audit page.
3. Click the Code Assists tab.
4. Expand the following Code Assists category nodes: Java SE > Java > Code Assists.
5. Uncheck the Eligible Lambda Expression to make the feature unavailable.

   Select to make the feature available through code assist.

Use the predefined code templates in JDeveloper to insert text for commonly used statements. Use the procedure to evoke a defined code template.

for (Object object : Object) {
            ;
       }

1. In the file open in the editor, put the cursor at the point where the template is to be inserted.
2. Enter the shortcut associated with the template and then press Ctrl+Enter.

   The code as defined in the template is inserted in the source file. Import statements needed for the template, if any, are inserted at the top of the file.

Use the predefined JDeveloper code templates in the list to insert code for commonly used statements.

ai
for (int $i$ = 0; $i$ < $array$.length; $i$++)
{
    $type$ $var$ = $array$[$i$];
    $end$
}

daev
public void on$end$(PageLifecycleContext ctx)
{
}

for
for ($end$ ; ; ) 
{
}

if
if ($end$) 
{
}

ife
if ($end$) 
{

} else
{

}

fori
for (int $i$ = 0; $i$ < $lim$; $i$++) 
{
   $end$
}

forn

int $n$ = $lim$;
for (int $i$ = 0; $i$ < $n$; $i$++) 
{
   $end$
}

iofc
if ($var$ instanceof $type$)
{
     $type$ $casted$ = ($type$) $var$;
     $end$
}

String amDef = "test.TestModule";
String config = "TestModuleLocal";
ApplicationModule am =
Configuration.createRootApplicationModule(amDef,config);
ViewObject vo = am.findViewObject("TestView");
$end$// Work with your appmodule and view object here
Configuration.releaseRootApplicationModule(am,true); 

itar

for (int $i$ = 0; $i$ < $array$.length; $i$++)
{
     $type$ $var$ = $array$[$i$]; 
     $end$
}

itco

for(Iterator $iter$ = $col$.iterator();$iter$.hasNext();)

{
     $type$ $var$ = ($type$) $iter$.next();
     $end$ }

itli
for (int $i$ = 0; $i$ < $list$.size(); $i$++)
{
     $type$ $var$ = ($type$) $list$.get($i$);
     $end$
}

itmk

Iterator $iter$ = $map$.keySet().iterator();
while ($iter$.hasNext())
{
     $type$ $var$ = ($type$) $iter$.next();
     $end$
}

itmv

Iterator $iter$ = $map$.values().iterator();
while ($iter$.hasNext())
{
     $type$ $var$ = ($type$) $iter$.next();
     $end$
}

conn

public static Connection getConnection() throws SQLException
{
     String username = "$end$scott";
     String password = "tiger";
     String thinConn = "jdbc:oracle:thin:@localhost:1521:ORCL";
     Driver d = new OracleDriver();
     Connection conn = 
DriverManager.getConnection(thinConn,username,password);
     conn.setAutoCommit(false);
     return conn;
}

ltoar

$type$ $var$ = new $typeelem$[$list$.size()];
$var$ = ($type$) $list$.toArray($var$);
$end$ 

main

public static void main(String[] args)
{
     $end$
}

outp

out.println($end$); 

pral

private ArrayList _$end$ = new ArrayList(); 

prb

private boolean _$end$; 

prhm

private HashMap _$end$ = new HashMap(); 

pri

private int _$end$; 

prs

private String _$end$; 

pusf

public static final $end$; 

pusfb

public static final boolean $end$; 

pusfi
public static final int $end$; 

pusfs

public static final String $end$; 

ritar

for (int $i$ = $array$.length; --$i$ >= 0 ;)
{
    $type$ $var$ = $array$[$i$];
    $end$
}

ritli

for (int $i$ = $list$.size(); --$i$ >= 0 ; )
{
     $type$ $var$ = ($type$) $list$.get($i$);
     $end$
}

sep
System.err.println($end$); 

sop

System.out.println($end$); 

sw

switch ($end$) 
{
    case XXX:
       {
       }
    break;
    default;
      {
      }
    break;
}

try

try
{
   $end$
} catch (Exception ex) 
{
  ex.printStackTrace();
} finally 
{
}

tag

<$tag$>
  $end$
</$tag$>

wh

while ($end$) 
{

}

Use the Expand or Narrow Selection option to expand or narrow a selected block of code. Use the procedure to expand selected code.

1. With the file open in the editor, ensure that the editor has focus.
2. Put the cursor at the point where you want to expand the selection, or select a portion of the code.
3. From the main menu, choose Source > Expand Selection, or press Ctrl+Shift+Equals.

   The selection expands to include the smallest logical unit containing the element previously selected or within which the cursor previously resided.

In the Java Source Editor, use coding constructs to surround Java statements and blocks. Use the procedure to surround a block of code with a construct.

1. With the file open in the editor, right-click within a statement, or select a block of code, and choose Surround. This options is available by right-clicking in the Visual Editor and choosing Surround from the context menu. Alternatively, you can click the Surround ({}) icon on the Source Editor toolbar.

   Note:

   This icon is only enabled when the selected code is a valid code block to which the Surround With feature can be applied.

2. In the Surround With dialog, select the coding construct.

In a file open in the Java Source Editor, code folding collapses selected blocks of code so that other areas of code can be viewed better. Follow the steps to use code folding.

public void main(String[] args) throws SQLException, IOException {
 
	//... some code ...
 
	{
	  Run.dbgPrnt("Extractor main() querying => BSN");
	  // make the basin file
	  query = "select * from BSN";
	  rset = OracleAccess.makeResultSet(query, stmt);
	  rset.next();
	  l = Basin.extract(rset, Version);
	  Format.writeFile(outPath, "groupings.txt", l);
	}
 
//	... some more code ...
 
  Run.dbgPrnt("Extractor main() has ended");
}

Any unresolved reference to an unavailable class in the Source Editor causes JDeveloper to import the class, or display possible matches for selection so that an import statement can be added. Set Import Statement Options in the Java Source Editor to configure or disable Import assistance.

You can add needed import statements while working in the Java Source Editor. If, as you are typing in the Source Editor, you introduce a reference to a class that has not yet been imported, a ragged line will appear below it. A popup will open showing that an import is needed, giving the fully-qualified name of the class.

Figure 8-2 Import Statement Needed

Description of "Figure 8-2 Import Statement Needed"

JDeveloper automatically adds an import if it can find only one exact match for an unresolved reference to a class. If the import assistance matches more than one possible match, then a popup list displays all possible matches from the class path. You can then choose the appropriate import and the import statement is automatically added.

The import assistance popup can be triggered at any time by pressing Alt+Enter.

The gutter-based code assistance can be used to add an import statement. If the editor does not recognize a class, a light bulb appears in the gutter when the line is highlighted and various import options are displayed.

To configure or disable Import assistance, you can set Import Statement Options in the Java Source Editor.

Organize import statements in the Java Source Editor by setting the options for organizing imports in the Preferences dialog. Follow the step to organize import statements in a source file.

Use the ojformat command line tool that is located in <JDeveloper_Home>/jdev/bin to reformat workspaces or projects.

The Java Visual Editor displays the visual components of a user interface in Design so that you can view and edit source code as you design the UI. Use Source in Source Editor to access the source code.

The Java Visual Editor displays the visual components of a user interface in the Design tab, as shown in Figure 8-3.

Figure 8-3 Java Visual Editor Design View

Description of "Figure 8-3 Java Visual Editor Design View"

You see the Java source view of the visual classes by clicking the Source tab as shown in Figure 8-4.

Figure 8-4 Java Visual Editor Source View

Description of "Figure 8-4 Java Visual Editor Source View"

When the Java Visual Editor is open, its corresponding elements are displayed hierarchically in the Structure window, as shown in Figure 8-5.

Figure 8-5 Structure Window for Java File

Description of "Figure 8-5 Structure Window for Java File"

If the Properties window is open, selecting elements in either the Structure window or the Java Visual Editor changes the selection in the Properties window as well.

Right-click anywhere within the Java Visual Editor to bring up a context-sensitive menu of commands. The context menus differ, depending upon whether you are editing non-menu or menu items, and the commands available within the context menu depend on the selected object.

To open the Java Visual Editor:

In the Java Source Editor, record changes that are made to elements by adding or removing tags from documentation comments, and adding tag descriptions. Use the procedure to update documentation comments in a source file.

1. In the Structure window, place the cursor on the element for which comments are to be updated.
2. Right-click and choose Add Javadoc Comments.

JDeveloper provides project defaults that you can modify for individual projects or for all projects across workspaces. Use the procedure to set Javadoc properties for an individual project.

1. In the Applications window, select the project.
2. From the main menu, choose Application > Project Properties, or right-click and choose Project Properties.
3. Choose Javadoc.
4. Set attributes.
5. When finished, click OK to close the Project Properties dialog.

Customize usage of documentation comment tags in the Java code editor by creating custom tags, associating the tag with code elements, defining it for inclusion in a project, assigning it a default value, and giving it an order in the tag list. Use the procedure to define a custom tag.

1. From the main menu, choose Tools > Preferences.
2. In the Preferences dialog, choose the Code Editor > Java > Javadoc page.
3. Click the Plus (+) icon.

   A tag with the default name new will be added to the list.

4. In the Tag Properties box, change the name of the tag and set its other properties.
5. When finished, click OK.

In the Java Source Editor, when the selected source code satisfies certain criteria, the Quick Javadoc feature becomes available so that you can use Javadoc comments for classes, interfaces, or individual members. Use the procedure to display Javadoc for a code element.

When working in the Java Source Editor, you can quickly access Javadoc-generated documentation for the following code elements: a class, interface, or an individual member, using the Quick Javadoc feature.

As shown in Figure 8-8, the Quick Javadoc feature looks up the selected entity on the source path and displays the Javadoc comment entered in a popup window.

Figure 8-8 Quick Javadoc Window

Description of "Figure 8-8 Quick Javadoc Window"

If no Javadoc comment exists for that element, an empty Javadoc comment is displayed.

The Quick Javadoc feature is available when the selected source code meets the following criteria. It is:

1. Select the code element.
2. From the main menu, choose Source > Quick Javadoc, or from within the editor, right-click and choose Quick Javadoc.

   A popup window displaying the documentation for the element appears. Click outside the window to close it.

The Quick Javadoc feature allows you to preview documentation comments in source files. Use the procedure to display documentation comments for a given class, member, or method call.

1. Select the name of the code element.
2. Right-click and choose Quick Javadoc.

   A popup window showing the Javadoc for just that element now appears. From this window, you can link to other Javadoc as you would in a browser.

Use the Audit Profile and Audit filename options for Javadoc Comments to validate documentation comments in source files. Use the procedure to check documentation comments in a source file.

1. In the Applications window, select the file to be checked.
2. From the main menu, choose Build > Audit filename.
3. In the Audit dialog, select Javadoc Rules from the Profile dropdown list.
4. If you want to configure the audit to choose which types of errors to search for or to ignore, click Edit.

   The Audit Profile dialog opens with the Rules tab selected.

5. Expand JavaSE > Java > Javadoc Comments nodes and select one or more Javadoc rules. Select an item to see a description of the validation check. For each item, you can set the property values for each rule.
6. Click OK in the Audit Profile dialog.
7. Click Run in the Audit filename dialog.

   The results of the audit appear in the Log window.

Set properties for a project on the Javadoc page of the Preferences dialog to generate API references and other documentation from the Applications window. Use the procedure to build Javadoc on a package, file, or project.

1. Select the appropriate node in the Applications window.
2. From the main menu choose Build, then Javadoc.

   The Javadoc is generated in the background. Information and results appear in the Log window. A link in the Log window allows you to add the index.html file to the project.

When auditing unresolved Java annotations in the Java Source Code editor, create references to missing annotation elements. Use the procedure to create a reference to a missing annotation.

1. Open the Java class in the Java Source Code editor.
2. Enter the annotation in the Java class source code, for example, @stateless.
3. Hover your cursor over the annotation.

   A dialog displays indicating that the type, for example, @stateless, cannot be found.

4. Click the More link.
5. Click the Create Annotation Type <type> link.
6. In the Create Annotation Type dialog, enter the name of the package where you want to locate the annotation class, for example, project1.
7. Click OK.

The Java Object Tree structure window displays the hierarchy of a source element that is selected in the Java Source Editor. Install the Java Object Tree Structure extension using Check for Updates in Help, and get the extension window displayed by selecting JOT Structure Pane from the Window options.

The Java Object Tree (JOT) structure window displays a hierarchical tree of a source element selected in the Java Source Editor. For example, your Java file might contain code similar to the following:

public class Class1 implements Serializable{ 
    @SuppressWarnings("serial:-4347721670334465144") 
        // test 
    private static final long serialVersionUID = -4347721670334465104; 
    public Class2() { 
        super(); 
    } 
    /* Non-javadoc comment */ 
     
    public void a(){} 
    // @SuppressWarnings("serial:23") 
    private class foo{} 
} 

Based on this, the JOT structure window displays at the bottom of JDeveloper, as shown in Figure 8-9. The hierarchy contains all of the child and parent source elements in the code. This could be the class, code blocks, or other elements.

Figure 8-9 JOT Structure Window

Description of "Figure 8-9 JOT Structure Window"

If you select a SourceElement in the Java Source editor, the corresponding SourceElement, including corresponding text, is highlighted in the JOT Structure window.

The Java Object Tree Structure is a JDeveloper extension that you must install to access this feature. Go to Help > Check for Updates to install the extension.

Once installed, display the JOT Structure window by choosing Window > JOT Structure Pane.

1. Select a program element in a source editor window, Applications window, or structure pane.
2. Right-click on the program element and choose Refactor.
3. Choose an operation from the context menu, for example, Rename, Move, or Delete.

You can also choose Refactor from the toolbar and select a refactoring operation from the drop-down list.

As shown in Figure 8-10, refactoring context menus contain different items depending on where in JDeveloper you are right-clicking to display the menu.

Figure 8-10 Refactoring Drop-down List

Description of "Figure 8-10 Refactoring Drop-down List"

For example, you can display different context menus containing different refactoring operations by right-clicking on:

• The structure menu

• The beginning of the line of a method

• The method's return type in the IDE

• The method's name in the IDE

• A parameter in the method's parameter list in the IDE

If the results of the refactoring operation are not what you want, you can undo the refactoring as you would any editing operation, by pressing Ctrl+Z.

A preview provides a view of usages so that they can be inspected and resolved before they are committed. Use the procedure to commit a refactoring operation.

1. If you have made any edits that affect usages, click the Refresh icon in the log toolbar to rerun the usages search.
2. Click the Refactor button in the Preview log window.

In the .java files of an application, unambiguous definitions and all references to code elements such as a package, class, interface, method, field, parameter, or variable can be renamed. Use the procedure to rename a code element.

1. Select the element that is to be renamed in one of the two following ways:

   • In a Java source editor, select the element name.

   • In a window such as the Applications window or Structure window, select the element name.

2. Invoke the command in one of the two following ways:

   • From the Main menu or the context menu, choose Refactor > Rename.

   • Press Ctrl+Alt-R.

     The Rename dialog opens.

3. In the Rename To box, enter the new name. The name must be valid and not already in use.
4. Set the depth of the text substitution.

   • Select Search Javadoc for Textual Usages to extend the operation to comments, the bodies of documentation comments, and to annotations.

   • (Package, type, and members elements only.) Select Search Text Files to extend the operation to other types of text files in the project.

5. Select Preview if you wish to inspect the usages that will be replaced before committing to the renaming operation.
6. Click OK.

   If you selected Preview, to avoid all the usages being modified, finish the renaming operation from the Preview log window.

JDeveloper deletes the definition of a class, interface, method, or field after a deletion is confirmed, leaving undeleted code as undefined references. Use the procedure to delete a code element.

1. Select the element that is to be deleted in one of the following ways:

   • In a Java source editor, select the name.

   • In a window such as the Applications window or Structure window, select the name.

2. Invoke the command in one of the following ways:

   • From the Main menu or the context menu, choose Refactor > Delete.

   • Press Alt+Delete.

     The project files are searched for usages. The Confirm Delete dialog displays how many usages were found.

3. Click the Show Usages button to inspect and resolve the usages in the log window.
4. Select Preview to inspect the usages of the deleted file in the log window.
5. Click OK.

In .java files, primary classes and interfaces can be repurposed, or new ones defined. Use the procedure to move a class or interface.

1. Select the package, class, or interface that is to be moved, in one of the following ways:

   • In a Java Source Editor, select the name.

   • In an Applications window or in the Structure window, select the name.

2. Invoke the command in one of the following ways:

   • From the Main menu or the context menu, choose Refactor > Move.

   • Press Ctrl+Alt-M.

     The Move dialog opens.

3. In the Move To field, enter the new package name.

   You can also click the Search icon next to the field to navigate to an existing package.

4. Set the depth of the text substitution.

   • Update References In - In the drop-down list, choose where the references will be updated.

   • Search Javadoc for Textual Usages - Extend the operation to the bodies of documentation.

   • Search Text Files - extend the operation to other types of text files in the project.

5. Select Preview if you want to inspect the usages that will be replaced before committing to the move operation.

   You can also click Show Usages to open a display panel within the Move dialog to see a list of all current usages in the project.

6. Click OK.

   If you selected Preview, to avoid all the usages being modified, finish the renaming operation from the Preview log window.

JDeveloper duplicates selected primary classes and interfaces, and adds them to the same package as the original. Use the procedure to duplicate a class or interface.

1. In a Java Source Editor, select the name of the class or interface that is to be duplicated.

   Note:

   Only primary classes and interfaces - those having the same name as their file - can be selected to be moved.

2. From the Main menu, choose Refactor > Duplicate.

   The Duplicate type dialog opens.

3. In the Class Name box, enter the new name.

   You can also specify a new package with the class, for example, client.frame1.

4. Click OK.

   The new class will be added to the project.

When a new interface is derived from selected methods, and static fields are defined in a class, the modified declaration of the class displays it as an implementation of the new interface. Use the procedure to extract an interface.

1. Select the class from which the interface will be derived in one of the following ways:

   • In a Java Source Editor, select the class name.

   • In an Applications window or in the Structure Window, select the class name.

2. From the Main menu, choose Refactor > Extract Interface.

   The Extract Interface dialog opens.

3. In the Package field, enter the name of the package of the new interface.
4. In the Interface field, enter the name of the new interface.
5. In the Members to Extract table, select the members that will be included in the new interface.
6. Select Replace Usages if you want to convert existing declarations that name the class into declarations naming the interface.
7. Select Preview if you want to inspect the usages of the class before committing to the extract operation.
8. Click OK.

An extracted superclasse based on the selected members of a selected class adds additional levels to the hierarchy of written code. Use the procedure to extract a superclass.

1. In an Applications window, in the Structure window, or in a Java Source Editor window, select the class name.
2. From the main menu, choose Refactor > Extract Superclass.

   The Extract Superclass dialog opens

3. In the Package field, enter the name of the package to which the new superclass will belong.
4. In the Class Name field, enter a name for the new superclass.
5. In the Members to Extract table, select the members that will be included in the new superclass.

   If you want a method to be created as an abstract method in the superclass, check the Abstract box against that method. If you want dependencies of a method to be included in the superclass, check the Dependencies box.

6. Select Replace Usages if you want to convert existing declarations that name the class into declarations naming the superclass.
7. Select Preview to view a list of the usages before committing to their replacement. This option is enabled only if you have selected Replace Usages.
8. Click OK.

Generalize type specifications of declarations in Java code into supertypes by replacing references to a selected class with references to one of its supertypes. Use the procedure to generalize declarations.

1. Select the class or interface whose declarations will be generalized in one of the following ways:

   • In a Java Source Editor, select the name.

   • In an Applications window or in the Structure window, select the name.

2. From the Main menu, choose Refactor > Use Supertype Where Possible.

   The Use Supertype dialog displays.

3. In the Supertypes table, select the supertype that the declarations will be generalized to.
4. Click OK.

Unnamed inner classes or anonymous classes can declare and instantiate a class at the same time, and named inner classes can access everything in their enclosing class. Use the procedure to convert an anonymous class into an inner class.

1. In a Java source editor window, select the declaration of the anonymous class.
2. From the main menu, choose Refactor > Convert Anonymous to Inner Class.

   The Convert Anonymous to Inner Class dialog opens

3. In the Class Name box, enter the name to be given to the inner class.
4. If you want the inner class to be given the static modifier, check the Static box.
5. To convert the anonymous class into an inner class, click OK.

Converting an inner class to a top level class renders code less bulky and more readable. Use the procedure to move an inner class.

1. Select the inner class name in the Structure window or in a Java source editor window.
2. On the main menu select Refactor > Move.

   The Move Inner Class dialog displays.

3. If you do not want the new top level class to be created with the names already shown in the dialog, overwrite them or select new ones.
4. To create a new class at the top level with the details shown in the dialog, click OK.

Refactoring that involves relocating member definitions from one class to another restructures the code to make it simple and readable.

While developing your Java application, you can easily move member definitions from one class to another. For example, you can move a class member (for example, a method) to another class.

A static method, used for memory management, belongs to the class rather than the object of a class, and can be invoked without creating an instance of a class. Use the procedure to change a method to a static method.

1. Select the method name in the Structure window or in a Java Source Editor.
2. On the main menu select Refactor > Make Static.

   If the class is part of a class hierarchy, the Make Static dialog opens. Otherwise, the static modifier is added immediately.

3. If the Make Static dialog opens:

   • In the Name box, enter or select a name to be used as a reference in the modified method.

     The options listed are derived from local object names.

   • If you want to create a method that cannot be overridden, check the Declare final box.

A method signature comprises the method name and the number and type of its parameters. Use the procedure to change the signature of a method.

1. Select the method name in the Structure window or in a Java Source Editor.
2. On the main menu select Refactor > Change Method.

   The Change Method dialog opens.

3. Make changes to the method name, return type, accessibility and parameters as required.

   If you change the name of the method to one that already exists in the class, you will later see a second dialog. Through this you can opt to replace all usages of the method that you are changing to usages of the existing method.

4. If you want to create tasks based on the changes you have made and add them to the Tasks window, check the Add tasks to the task window box.

Moving definitions of members from a source class to one of its superclasses retains the functionality of the class member while making code simple and readable. Use the procedure to pull a member up into a superclass.

1. Select the class from which the members will be pulled in one of the following ways:

   • In a Java Source Editor, select the name.

   • In an Applications window or the Structure window, select the name.

2. From the main menu, choose Refactor > Pull Members Up.

   The Pull Members Up dialog will open.

3. From the Target drop-down menu, choose the superclass that will be the target class.
4. In the Members to Extract table, select the members you want to pull up.

   The members that are the dependencies of the selected members, if any, will be indicated.

5. In the Abstract column, select the checkbox if you wish the method to abstracted to the target class.

   Note:

   Members that are to be abstracted do not have dependencies.

6. In the Dependencies column select the checkbox if you want to also pull up all of the member's dependencies.

   This selection is transitive. It will cause dependencies of dependencies to also be pulled up.

7. Click OK.

Moving the definitions of members from a class to its immediate subclasses cleans up the class hierarchy. Use the procedure to push a member down into a subrclass.

1. Select the class from which the members will be pulled in one of the following ways:

   • In a Java Source Editor, select the name.

   • In an Applications window or the Structure window, select the name.

2. From the main menu, choose Refactor > Push Members Down.

   The Push Members Down dialog opens.

3. In the Members to Extract table, select the members you want to push down.

   The members that are the dependencies of the selected members, if any, will be indicated.

4. In the Abstract column, select the checkbox if you want an abstract definition of the member to be left in the source class.
5. In the Dependencies column, select a checkbox to cause all the member's dependencies to be pushed down with the member.
6. Click OK.

Covert Java expressions into named elements. Use the procedure to introduce a field.

1. In the source editor, select the expression.
2. From the main menu, choose Refactor > Introduce Field.

   The Introduce Field dialog opens.

3. From the Type drop-down menu choose a type for the field.

   The menu lists all types that are consistent with the expression. This option will display if only a single type is valid.

4. A suggested name displays in the Name text box.

   You can modify or replace it, or choose another suggestion from the drop-down menu.

5. Select an initialization:

   • Select Current Method to put the assignment statement for the field immediately preceding the statement that contains the expression.

   • Select Field Declaration to assign the value to the field in its declaration statement. This option will not be enabled if the expression has a variable or parameter with local scope.

   • Select Constructor to assign the value to the field in the constructor methods of the class. This option will not be enabled if the expression has a variable or parameter with local scope.

6. Click OK.

Code compilation saves overheads by inlining or including the body of a method into the body of its callers. Use the procedure to inline a method call.

1. In a Java Source Editor, select an instance of the method call that you want to be inlined.
2. From the main menu select Refactor > Inline.

   • If there is only one call to the method in this class, the change is made immediately.

   • If there is more than one call to the method in this class, the Inline dialog opens.

3. If the Inline dialog has opened:

   • Choose between inlining only the selected instance of the call or inlining all instances of the call.

   • Click OK.

In the source editor, add a new variable declaration to a method for a selected expression. Use the procedure to introduce a member.

1. In the source editor, select the expression.
2. From the main menu, choose Refactor > Introduce Variable.

   The Introduce Variable dialog opens.

3. If more than one data type is valid for the field, choose the Type from the drop-down list.

   The menu lists all types that are consistent with the expression. The Type field is not shown if only a single type is valid.

4. Modify or replace the suggested name for the variable in the Name field.

   You can choose a suggested name from the drop-down menu.

5. Select Declare final if you want to add the final modifier to the variable's declaration.
6. Click OK.

In the source editor, convert a constant expression in a method body into a new parameter for the method. Use the procedure to introduce a parameter.

1. In the source editor, select the expression.
2. From the main menu, choose Refactor > Introduce Parameter.
3. From the Type drop-down menu, choose a type for the field.

   The menu lists all types that are consistent with the expression. This option is not displayed if only a single type is valid.

4. Modify or replace the suggested name for the variable in the Name field.

   You can choose a suggested name from the drop-down menu.

5. Select Declare final if you want to add the final modifier to the variable's declaration.
6. Click OK.

Convert a constant expression into a constant reference so that the constant declaration that is initialized by the expression is added to the class. Use the procedure to introduce a constant.

1. In the source editor, select the expression.
2. From the main menu, choose Refactor > Introduce Constant.

   The Introduce Constant dialog opens.

3. From the Type drop-down menu choose a type for the field.

   The menu lists all types that are consistent with the expression. This option is not shown if only a single type is valid.

4. Modify or replace the suggested name for the variable in the Name field.

   You can choose a suggested name from the drop-down menu.

5. Click OK.

Create a new private method from the local variables and parameters of a method that conform to certain restrictions. Use the procedure to extract a method.

1. In the source editor, select the expression or the sequence of expressions that you wish to extract.
2. From the main menu, choose Refactor > Extract Method.
3. Enter a name for the new method.
4. In the Parameters list, specify the substitutions that will be made for the local variables and parameters that appear in the selected code:

   • In the Name column replacement names, which are similar or identical to the original names, are proposed. You can select and modify the names.

   • In the Included column, select the proposed parameters that will become the parameters of the new method. Those that you deselect will become uninitialized local variables in the new method.

   • Use the Up and Down buttons to order the parameters

5. Select static if you want to declare the new method to be static.

   This option is disabled if the method is forced to be static because it is called from a static method, or if it is forced to be non-static because it uses a non-static member.

6. Click OK.

   The new method is added to the class, and the code you selected will be replaced by a call to the new method.

7. If you deselected any of the proposed parameters in the Parameters list, edit the new method to initialize its local variables.

To simplify complex classes, extract a new class by replacing the fields and methods of a class. Use the procedure to extract a class.

1. In the source editor, select the class that you wish to extract.
2. From the main menu, choose Refactor > Extract Class.
3. Enter a name for the new class.
4. Select Inner Class to make the new class is an inner class.

   If you do select this option, a top-level class is created.

5. Select whether you want to generate getter and setter methods for the extracted fields in the new class.
6. Select the methods to extract for the new class.
7. Select Replace Usages to replace all usages of the extracted class.

Create a factory method and use it to replace the calls of a constructor to overcome its limitations. Use the procedure to convert a constructor into a factory method.

1. Select the constructor name in the Structure window or in a Java Source Editor.
2. From the main menu, select Refactor > Replace Constructor With Factory Method.
3. In the Method Name box, enter a name for the new method.

   A suggested name based on the current class name already appears in the box.

4. To convert the constructor into a factory method click OK.

Encapsulation makes field data accessible only by public methods, thus hiding the private fields and their implementation for outside classes. Use the procedure to encapsulate a field.

1. Select the field name (or its parent class) in the Structure window or in the Java Source Editor.
2. On the main menu select Refactor > Encapsulate Fields.
3. In the Fields table, check the box next to each field that you want to be encapsulated.

   For each field, you can, you can also specify options for method/field accessibilities and the scope for replacements.

4. In the Replace Accessors box, select how you would like accessors to be replaced as part of the encapsulation.
5. If you want to create tasks based on the changes you have made and add them to the Tasks window, check the Add tasks to the task window box.
6. Click OK.

JDeveloper updates all references to maintain code functionality if a boolean field, parameter or local variable is initialized after its value has been reversed. Use the procedure to invert a boolean method.

1. In the source editor, select the boolean expression.
2. Right-click on the expression and choose Refactor > Invert Boolean.

   Table 8-2 contains an example of an inverted boolean expression.

private double a;...public boolean method() {
 if (enabled){
   a =5;
   return true; }
 false;}

private double a;...public boolean method() {
 if (disabled{
  a =5;
  return false; }
 return true;}

Referring schemas are updated to reflect all changes made to the namespace of a schema target.

When a schema's target namespace changes, all the referring schemas are updated to have the new target namespace.

When you change the base type on a simpletype element that has facets, all facets are not removed. Instead, the facets that are still valid are retained.