← 返回首页
Java refactoring and Source Actions
Visual Studio Code
Download

Use the Agents window to build in an agent-first way.

Documentation

Topics Overview Overview Linux macOS Windows VS Code for the Web Raspberry Pi Network Additional Components Uninstall VS Code Tutorial Copilot Quickstart User Interface Personalize VS Code Install Extensions Tips and Tricks Intro Videos Overview Setup Quickstart Overview Language Models Context Tools Agents Customization Trust & Safety Overview Agents Tutorial Agents Window Planning Memory Tools Subagents Local Agents Copilot CLI Cloud Agents Third-Party Agents Overview Chat Sessions Add Context Inline Chat Review Edits Checkpoints Artifacts Panel Debug Chat Interactions Prompt Examples Overview Instructions Prompt Files Custom Agents Agent Skills Language Models MCP Hooks Plugins Context Engineering Customize AI Test-Driven Development Edit Notebooks with AI Test with AI Test Web Apps with Browser Tools Debug with AI MCP Dev Guide OpenTelemetry Monitoring Inline Suggestions Smart Actions Best Practices Security Troubleshooting FAQ Cheat Sheet Settings Reference MCP Configuration Workspace Context Display Language Layout Keyboard Shortcuts Settings Settings Sync Extension Marketplace Extension Runtime Security Themes Profiles Overview Voice Interactions Command Line Interface Telemetry Basic Editing IntelliSense Code Navigation Refactoring Snippets Overview Multi-Root Workspaces Workspace Trust Tasks Debugging Debug Configuration Testing Port Forwarding Integrated Browser Overview Quickstart Staging & Committing Branches & Worktrees Repositories & Remotes Merge Conflicts Collaborate on GitHub Troubleshooting FAQ Getting Started Tutorial Terminal Basics Terminal Profiles Shell Integration Appearance Advanced Overview Enterprise Policies AI Settings Extensions Telemetry Updates Overview JavaScript JSON HTML Emmet CSS, SCSS and Less TypeScript Markdown PowerShell C++ Java PHP Python Julia R Ruby Rust Go T-SQL C# .NET Swift Working with JavaScript Node.js Tutorial Node.js Debugging Deploy Node.js Apps Browser Debugging Angular Tutorial React Tutorial Vue Tutorial Debugging Recipes Performance Profiling Extensions Tutorial Transpiling Editing Refactoring Debugging Quick Start Tutorial Run Python Code Editing Linting Formatting Debugging Environments Testing Python Interactive Django Tutorial FastAPI Tutorial Flask Tutorial Create Containers Deploy Python Apps Python in the Web Settings Reference Getting Started Navigate and Edit Refactoring Formatting and Linting Project Management Build Tools Run and Debug Testing Spring Boot Modernizing Java Apps Application Servers Deploy Java Apps GUI Applications Extensions FAQ Intro Videos GCC on Linux GCC on Windows GCC on Windows Subsystem for Linux Clang on macOS Microsoft C++ on Windows Build with CMake CMake Tools on Linux CMake Quick Start C++ Dev Tools for Copilot Editing and Navigating Debugging Configure Debugging Refactoring Settings Reference Configure IntelliSense Configure IntelliSense for Cross-Compiling FAQ Intro Videos Get Started Navigate and Edit IntelliCode Refactoring Formatting and Linting Project Management Build Tools Package Management Run and Debug Testing FAQ Overview Node.js Python ASP.NET Core Debug Docker Compose Registries Deploy to Azure Choose a Dev Environment Customize Develop with Kubernetes Tips and Tricks Overview Jupyter Notebooks Data Science Tutorial Python Interactive Data Wrangler Quick Start Data Wrangler PyTorch Support Azure Machine Learning Manage Jupyter Kernels Jupyter Notebooks on the Web Data Science in Microsoft Fabric Foundry Toolkit Overview Foundry Toolkit Copilot Tools Create Agents Models Playground Agent Builder Agent Inspector Evaluation Tool Catalog Fine-Tuning (Automated Setup) Fine-Tuning (Project Template) Model Conversion Tracing Profiling (Windows ML) FAQ File Structure Manual Model Conversion Manual Model Conversion on GPU Setup Environment Without Foundry Toolkit Template Project Migrating from Visualizer to Agent Inspector Overview Getting Started Resources View Deployment VS Code for the Web - Azure Containers Azure Kubernetes Service Kubernetes MongoDB Remote Debugging for Node.js Overview SSH Dev Containers Windows Subsystem for Linux GitHub Codespaces VS Code Server Tunnels SSH Tutorial WSL Tutorial Tips and Tricks FAQ Overview Tutorial Attach to Container Create Dev Container Advanced Containers devcontainer.json Dev Container CLI Tips and Tricks FAQ Default Keyboard Shortcuts Default Settings Substitution Variables Tasks Schema
Copy as Markdown

On this page there are 3 sections

Java refactoring and Source Actions

Visual Studio Code provides many options to refactor your source code as well as Source Actions to generate code and fix issues while you're coding. To access them, click on the light bulb 💡 whenever you see it. Or right-click the editor view and pick Source Action....

List of Supported Code Actions

Refactoring

The goal of the Java program refactoring is to make system-wide code changes without affecting behavior of the program. The Java Language Support for VS Code provides many easily accessible refactoring options.

Invoke refactoring

Refactoring commands are available from the context menu of the editor. Select the element you want to refactor, right-click to open the context menu, and choose Refactor...:

Then you will see all the available refactoring options.

Assign to variable

Assigns an expression to a local variable or a field.

Example

Before List<String> fruits = Arrays.asList("apple", "lemon", "banana");

It can also be used to assign a parameter to a new field for unused parameter(s) in a constructor.

Convert anonymous to nested class

Converts an anonymous inner class to a member class.

Example

Let's convert the anonymous class Interface(){...} to a member of the class Clazz.

Before public class Clazz { private final class MyInterface extends Interface { private final boolean isValid; private MyInterface(boolean isValid) { this.isValid = isValid; } public boolean isValid() { return isValid; } } public Interface method() { final boolean isValid = true; return new MyInterface(isValid); } }

Convert to anonymous class creation

Converts lambda expression to anonymous class creation.

Example

The variable runnable is assigned with a lambda expression. Let's convert it to an anonymous class creation.

Before public void method() { Runnable runnable = new Runnable() { @Override public void run() { // do something } }; }

Also see: Convert to lambda expression

Convert to enhanced for loop

Converts the simple for loop to for-each style.

Example

Before public void order(String[] books) { for (String book : books) { // do something } }

Convert to lambda expression

Converts an anonymous class creation to the lambda expression.

Example

Let's convert the anonymous class Runnable(){...} to a lambda expression.

Before public void method() { Runnable runnable = () -> { // do something }; }

Also see: Convert to anonymous class creation

Convert to static import

Converts the field or method to static import.

Example

Let's transform the Assert.assertEquals() invocation to a static import.

Before import static org.junit.Assert.assertEquals; ... public void test() { assertEquals(expected, actual); }

Extract to constant

Creates a static final field from the selected expression and substitutes a field reference, then rewrites other places where the same expression occurs.

Examples

Let's extract the value of π: 3.14 to a constant.

Before private static final double PI = 3.14; public double getArea(double r) { return PI * r * r; }

Also see: Inline constant

Extract to field

Declares a new field and initializes it with the selected expression. The original expression is replaced with the usage of the field.

Examples

Let's extract the variable area to a field of the class Square.

Before class Square { private int area; public void calculateArea() { int height = 1; int width = 2; area = height * width; } }

When selecting a variable declaration, convert the variable to field.

Extract to method

Creates a new method containing the statements or expressions currently selected and replaces the selection with a reference to the new method. This feature is useful for cleaning up lengthy, cluttered, or overly complicated methods.

Examples

Let's extract the expression height * width to a new method.

Before public void method() { int height = 1; int width = 2; int area = getArea(height, width); } private int getArea(int height, int width) { return height * width; }

Also see: Inline method

Extract to local variable

Creates a new variable assigned to the expression currently selected and replaces the selection with a reference to the new variable.

Examples

Let's extract the expression platform.equalsIgnoreCase("MAC") to a new variable.

Before public void method() { boolean isMac = platform.equalsIgnoreCase("MAC"); if (isMac) { // do something } }

After the extraction, you can also perform a rename in the same transaction.

Also see: Inline local variable

Inline constant

Replaces a constant reference with its defined value.

Examples

Let's replace the constant PI to its defined value: 3.14.

Before private static final double PI = 3.14; public double getArea(double r) { return 3.14 * r * r; }

Also see: Extract to constant

Inline local variable

Replaces redundant variable usage with its initializer.

Examples

Let's replace the variable isMac directly to the boolean expression.

Before public void method() { if (platform.equalsIgnoreCase("MAC")) { // do something } }

Also see: Extract to local variable

Inline method

Replaces calls to the method with the method’s body.

Example

Let's replace the method getArea(int height, int width) directly to the expression height * width.

Before public void method() { int height = 1; int width = 2; int area = height * width; }

Also see: Extract to method

Invert conditions

Inverts the boolean expression in the conditions.

Example

Let's invert the boolean expression in the if statement.

Before public void method(int value) { if (value <= 5 || value >= 15) { // do something } }

Invert local variable

Inverts the local boolean variable.

Example

Let's invert the variable valid.

Before public void method(int value) { boolean notValid = value <= 5 || value >= 15; }

Move

Moves the selected elements and corrects all references to the elements (also in other files). Available actions are:

  • Move class to another package
  • Move static or instance method to another class
  • Move inner class to a new file

Example

Let's move the static method print() from class Office to class Printer.

Before public class Office { public static void main(String[] args) { Printer.print(); } static class Printer { public static void print() { System.out.println("This is printer"); } } }

Move refactoring on a static method if it is used more in another class than in its own class.

Move a class to another package. Currently, move refactoring is not supported from the File Explorer.

Move an inner class to a new file.

Rename

Default shortcut: F2

Renames the selected element and corrects all references to the elements (also in other files).

Example

Let's rename the class Foo to Bar

Before public class Bar { // ... } public void myMethod() { Bar myClass = new Bar(); }

The shortcut to invoke the Rename refactoring is F2. When you invoke the shortcut on an identifier in the editor, a small box displays within the editor itself where you can change the identifier name. When you press Enter, all references to that identifier are changed too.

Rename refactoring is also supported from the File Explorer for folders and files. After requesting the change, a preview of impacted files will be provided and you can decide how to apply those changes.

Change resolved type to var type

Uses var to declare local variables.

Example

Before var s = "";

Also see: Change var type to resolved type

Change var type to resolved type

Uses the resolved type to declare local variables.

Example

Before String s = "";

Also see: Change resolved type to var type

Source Actions

Source Actions could be used to generate common code structures and recurring elements. Some of them are Quick Fixes that help you fix code issues on the fly.

Generate constructors

Add a constructor for the class.

Generate delegate methods

Generate delegate methods

Override/implement methods

With this Source Action, all the candidates are presented to you with a checklist. You can then decide what to override or implement.

Organize imports

You can use this Source Action to clean up your imports. It can also deal with ambiguous imports, in that case, a dropdown list will be presented for you to pick the right one. The code line with the unresolved type is also presented to you to help you decide.

Generate getters and setters

You can bulk generate getters and setters for all new member variables. If the class has more than one field, the Source Action will prompt a Quick Pick for you to select the target fields to use to generate the accessor methods.

Generate hashCode() and equals()

hashCode() and equals() can be generated with default implementations. All the non-static member variables are listed, and you can customize the generated code using the check list.

There are two options for you to customize the generated code:

  • If you use Java 7+, you can set java.codeGeneration.hashCodeEquals.useJava7Objects to true to generate shorter code that calls Objects.hash and Objects.equals.
  • You can also set java.codeGeneration.hashCodeEquals.useInstanceof to true to use instanceOf operator to check the object types instead of calling Object.getClass().

Generate toString()

There is a new Source Action to generate the toString() method. Customization is possible with a check list of all the member variables.

Change modifiers to final where possible

Adds final modifier to all the variables and parameters in the current source file.

Example

Before public class Clazz { public void method(final int value) { final boolean notValid = value > 5; if (notValid) { // do something } } }

Fix non-accessible reference

This Quick Fix helps you fix non-accessible reference.

Create non-existing package

When your package name doesn't match the folder name, you have the options to either change the package name in your source code, or move the folder in the file system (even when the destination folder doesn't exist yet).

Other Code Actions supported

The list of Code Actions supported by VS Code keeps growing and only lists the most popular ones above. Other notable supported actions include (but not limited to):

  • Create unresolved types
  • Remove the final modifier
  • Remove unnecessary cast
  • Remove redundant interfaces
  • Add missing case labels in switch statements
  • Jump to definition on break/continue
  • Correct access to static elements
12/9/2021