Java jdt 编辑_JDT入门

最新推荐文章于 2022-09-15 13:06:32 发布
最新推荐文章于 2022-09-15 13:06:32 发布
阅读量201 收藏
点赞数
文章标签： Java jdt 编辑
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_39554290/article/details/114873026
版权

1.打开Java类型

要打开一个Java类或Java接口以进行编辑，可以执行以下操作之一：

在编辑器中所显示的源代码里选择所要编辑的Java类或Java接口的名字(或者简单地将插入光标定位到所要编辑的ava类或Java接口的名称中)，然后右击鼠标并在所出现的快捷菜单中选择Open Declaration命令，或者按F3键。

选择 Ctrl + Shift + T 快捷键，然后在所出现的 Open Type 对话框中输入所要编辑的Java类或Java接口的名字。

在打开的编辑器中，按住Ctrl键不放。这时，当你将鼠标移动到编辑器中所显示的那些Java类或接口的名称上时，它们会变成一个超链接，你可以单击该超链接，这样就可以打开该Java类型的定义。

2.查看超类型和子类型

要在Hierarchy视图中查看某一个类或接口的超类型(或子类型)，请执行下列操作之一：

在Java编辑器中选择所要查看的Java类或Java接口的名字(或者简单地将插入光标定位到所要查看的ava类或Java接口的名称中)，然后再在右击鼠标后所出现的快捷菜单中选择 Open Type Hierarchy命令，后者直接按F4。

在按了Ctrl + Shift + H 快捷键后所出现的 Open Type in Hierarchy 对话框中输入需要查看其超类型(或子类型)的类或接口的名称。

现在编辑器中选择需要查看其超类型(或子类型)的Java类型，然后按 Ctrl + T 快捷键。

3.查看方法的调用情况

要查看调用了某一特定方法的全部方法，请执行下列操作之一：

在Java编辑器中选择一个方法(或者简单地将插入光标定位到方法名称中)，然后再在右击鼠标后所出现的快捷菜单中选择 Open Call Hierarchy 命令，后者直接按Ctrl + Alt + H 快捷键。

4.对Java代码进行格式化

进入代码编辑器视图，按快捷键Ctrl + Shift + F，你就可以对整个代码文件进行格式化(如果是选中一段代码，按快捷键Ctrl + Shift + F，那么只会格式化选中的代码)。你也可以先选择一个Java项目、源文件夹或包，然后选择 Source | Format 菜单项，以对所包含的全部Java源文件进行格式化。

5.迅速查看类的相关信息

在选择一个方法、类型或包引用后按快捷键 Ctrl + T ,这样你就会在弹出的窗口中看到 quick type hierarchy 视图。如果前面选择的是一个类型，那么在该快捷视图中所显示的是该类型的层次结构，如果前面所选择的是一个方法，那么在该快捷视图中所显示的是所有实现该方法的类型的层次结构。通过连续按快捷键 Ctrl + T，你就可以在子类型和超类型层次结构快捷视图之间进行切换。

按快捷键 Ctrl + O 后，你会在弹出窗口中看到 quick outline 视图。通过连续按快捷键 Ctrl + O，你可以切换显示被继承的成员元素。

6.注释快捷键

添加行注释/取消行注释：Ctrl + /

添加块注释：Ctrl + Shift + /

取消块注释：Ctrl + Shift + \

7.移动代码内容的快捷键

通过使用快捷键 Alt + Up Arrow 或 Alt + Down Arrow，你可以将当前行内容或所选的多行内容上移或下移。

8.代码生成

JDT提供了一些代码生成功能，这些代码生成功能可在编辑器快捷菜单的 Source 菜单项下获得。通过按快捷键 Alt + Shift + S，你也可以获得这些代码生成功能。下面是对一些代码生成功能的说明。

Source | Organize Imports：添加import语句，并删除无用的相关语句。

Source | Add Import：为选中的引用添加import语句。

Source | Generate Getters and Setters：快速创建getter和setter方法。

Source | Surrounded with try / catch block：如果你在选择了某一个表达式后使用该菜单项，那么代码就会被分析，以查看所选表达式中是否有任何异常被抛出，并对那些抛出异常的代码添加try / catch 语句。通过使用表达式选择快捷键 Alt + Shift + Up 和 Alt + Shift + Down，你可以精确地选择要使用try / catch 块的代码。

Source | Generate Constructor Using Fields...：基于字段生成构造函数。

9.重构

若要重构代码，则现在Java视图中选择Java元素，然后再在编辑器中将插入光标置于元素引用中(或在编辑器中选择 Java 元素或表达式)。接着是用快捷键 Alt + Shift + T，这样，你就会看到一个菜单，在该菜单中列出了可能的重构操作。

weixin_39554290
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Eclipse 平台Java开发入门
05-09
Eclipse的标准插件集包含了Java Development Tools (JDT)，使得它能够很好地支持Java开发。此外，Eclipse还包含Plug-in Development Environment (PDE)，允许开发者创建和集成新的插件，进一步扩展Eclipse的功能。这...
Java环境配置及Eclipse入门.doc
01-13
例如，对于Java开发，可能需要安装Java Development Tools (JDT)插件，它提供了完整的Java语言支持。 一旦Eclipse安装和配置完毕，开发者就可以在其中创建项目，编写、编译、运行和调试Java代码，同时享受代码自动...
Eclipse开发工具--使用JDT开发java程序
ll_j_21的博客
03-23 1231
JDT JDT（Java Development Tools）是Eclipse平台所提供的一个Java程序开发组件，该组件依赖于JDK的支持，并且默认情况下会自动选择一个可以使用的JDK或JRE环境，如果开发者要准确的指明JDK，则必须进行手工配置，配置界面路径为：【Window】 ->【Preferences】 ->【Java】 ->【Installed JREs】 配置JD...
jdt 解析java语句,利用JDT 回分析java 源代码
weixin_32596045的博客
03-11 497
项目里需要扫代码的sql，主要是想找出所有用到的sql。 将相关的sql 提交给DBA 来分析，希望在最早的时间发现潜在的查询性能问题。想想eclipse 里面用到的JDT 能分析java 源代码， 如果我们能分析项目里的源代码利用ASTParser 就可以找到相关的SQL 定义了。其实已经有人想到这个 http://www.programcreek.com/2011/01/a-complete-...
Eclipse jdt formatting Java code
杀神lwz的博客
03-26 1128
一、概述 JDT（java development tooling）是Eclipse提供的一组API。 Eclipse官方文档 Eclipse documentation maven引入：org.eclipse.jdt.core>>3.29.0 <!-- https://mvnrepository.com/artifact/org.eclipse.jdt/org.eclipse.jdt.core --> <dependency> <group
使用Eclipse的JDT对Java程序插桩并获取覆盖信息
最新发布
qq_46153642的博客
09-15 643
Java ASTParser 实现对源代码的修改与插桩
Eclipse-Java 开发工具(JDT)
轻轻草原
12-26 771
Eclipse是一个流行的针对Java编程的集成开发环境(IDE)。它还可以用作编写其他语言(比如C++和Ruby)的环境，合并各种种类工具的框架，以及创建桌面或服务器应用程序的富客户端平台。如今，Eclipse开源社区拥有数十个项目，其范围从商务智能到社会网络等各个方面。Eclipse同时也是管理这些项目的非赢利性组织的名称。(而且，尽管我相当肯定它并非地板蜡，还是存在Eclipse汽车、足球队...
Eclipse.rar_Java编程_Java_
08-11
学习Eclipse还涉及到Java开发中的其他知识点，例如JDT（Java Development Tools）提供了一系列用于Java语言开发的工具，PDE（Plug-in Development Environment）则用于开发和管理Eclipse插件。理解这些工具的工作...
Java_Eclipse_16课件
06-16
总之，【Java_Eclipse_16课件】涵盖了从入门到进阶的全方位Java编程和Eclipse使用教程，无论是对新手还是有一定经验的开发者，都能从中受益，提升自己的Java开发技能。通过深入学习并实践课件中的内容，你将具备使用...
Java开发入行真功夫 光盘 源代码
12-10
Java开发入行真功夫 光盘 源代码 ， <name>ch14 <comment></comment> ... <name>org.eclipse.jdt.core.javabuilder <nature>org.eclipse.jdt.core.javanature </projectDescription>
JDT生成代码实例
07-27
package ast.test.demo; import org.eclipse.jdt.core.dom.AST; import org.eclipse.jdt.core.dom.Assignment; import org.eclipse.jdt.core.dom.Block; import org.eclipse.jdt.core.dom.ClassInstanceCreation; import org.eclipse.jdt.core.dom.CompilationUnit; import org.eclipse.jdt.core.dom.ExpressionStatement; import org.eclipse.jdt.core.dom.IfStatement; import org.eclipse.jdt.core.dom.ImportDeclaration; import org.eclipse.jdt.core.dom.InfixExpression; import org.eclipse.jdt.core.dom.MethodDeclaration; import org.eclipse.jdt.core.dom.MethodInvocation; import org.eclipse.jdt.core.dom.Modifier; import org.eclipse.jdt.core.dom.NumberLiteral; import org.eclipse.jdt.core.dom.PackageDeclaration; import org.eclipse.jdt.core.dom.PrimitiveType; import org.eclipse.jdt.core.dom.ReturnStatement; import org.eclipse.jdt.core.dom.SingleVariableDeclaration; import org.eclipse.jdt.core.dom.StringLiteral; import org.eclipse.jdt.core.dom.SuperConstructorInvocation; import org.eclipse.jdt.core.dom.ThrowStatement; import org.eclipse.jdt.core.dom.TypeDeclaration; import org.eclipse.jdt.core.dom.TypeLiteral; import org.eclipse.jdt.core.dom.VariableDeclarationFragment; import org.eclipse.jdt.core.dom.VariableDeclarationStatement; import org.eclipse.jdt.core.dom.Assignment.Operator; import org.eclipse.jdt.core.dom.Modifier.ModifierKeyword; public class Demo { public static void main(String[] args) { AST ast = AST.newAST(AST.JLS3); CompilationUnit compilationUnit = ast.newCompilationUnit(); //创建类 TypeDeclaration programClass = ast.newTypeDeclaration(); programClass.setName(ast.newSimpleName("Program")); //设定类或接口的修饰类型 programClass.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD)); //将创建好的类添加到文件 compilationUnit.types().add(programClass); //创建包 PackageDeclaration packageDeclaration = ast.newPackageDeclaration(); //设定包名 packageDeclaration.setName(ast.newName("com.aptech.lzh")); //将创建好的添加到文件 compilationUnit.setPackage(packageDeclaration); //要导入的包 String[] imports = {"java.util.Date", "java.util.Random"}; for(String imp : imports){ //创建一个新包声名 ImportDeclaration importDeclaration = ast.newImportDeclaration(); //添加包说明 importDeclaration.setName(ast.newName(imp)); //将包声名加入文件中 compilationUnit.imports().add(importDeclaration); } //创建一个main方法 { //创建一个方法声名 MethodDeclaration main = ast.newMethodDeclaration(); main.setName(ast.newSimpleName("main")); main.modifiers().add(ast.newModifier(Modifier.ModifierKeyword.PUBLIC_KEYWORD)); //为方法添加静态声名 main.modifiers().add(ast.newModifier(ModifierKeyword.STATIC_KEYWORD)); //为方法增加返回值类型声明 main.setReturnType2(ast.newPrimitiveType(PrimitiveType.VOID)); //将方法装入类中 programClass.bodyDeclarations().add(main); //为方法增加语句块 Block mainBlock = ast.newBlock(); main.setBody(mainBlock); //给main方法定义String[]参数 SingleVariableDeclaration mainParameter = ast.newSingleVariableDeclaration(); //设置参数名称为arg mainParameter.setName(ast.newSimpleName("arg")); //设置参数类型为String[] mainParameter.setType(ast.newArrayType(ast.newSimpleType(ast.newName("String")))); main.parameters().add(mainParameter); //创建Pragram对象: Program program=new Program(); //创建一个变量声名明（变量的前半部份） VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment(); //（1）设置变量名称 fragment.setName(ast.newSimpleName("program")); //（2）为变量创建表AST节点类型 VariableDeclarationStatement statement = ast.newVariableDeclarationStatement(fragment); //（3）对变量进行修鉓符设置 statement.setType(ast.newSimpleType(ast.newSimpleName("Program"))); //实例化变量 ClassInstanceCreation classInstanceCreation = ast.newClassInstanceCreation(); classInstanceCreation.setType(ast.newSimpleType(ast.newSimpleName("Program"))); //将变量实例化 fragment.setInitializer(classInstanceCreation); //将变量装入主句语块 mainBlock.statements().add(statement); //创建一个方法调用 //调用getString方法:String r = program.getString("中国"); MethodInvocation methodInvocation = ast.newMethodInvocation(); //设置引用方法对像 methodInvocation.set[removed]ast.newSimpleName("program")); //设置引用方法 methodInvocation.setName(ast.newSimpleName("getString")); //String参数（是一个字符串节点）方法参数字面值 StringLiteral stringLiteral = ast.newStringLiteral(); stringLiteral.setLiteralValue("中国"); //将其作为引用方法参数 methodInvocation.arguments().add(stringLiteral); //创建变量 VariableDeclarationFragment fragment2 = ast.newVariableDeclarationFragment(); //设置变量声名名称 fragment2.setName(ast.newSimpleName("r")); //将声名创建为一个AST节点 VariableDeclarationStatement statement3 = ast.newVariableDeclarationStatement(fragment2); //设置节点类型声名 statement3.setType(ast.newSimpleType(ast.newSimpleName("String"))); //调用methodInvocation方法，进行实例化 fragment2.setInitializer(methodInvocation); mainBlock.statements().add(statement3); //输出r的值: System.out.println(r); //(1)创建方法引用实例 MethodInvocation methodInvocation2 = ast.newMethodInvocation(); //(2)设置引用方法对像 methodInvocation2.set[removed]ast.newName("System.out")); //(3)设置方法名称 methodInvocation2.setName(ast.newSimpleName("println")); //设置方法参数 methodInvocation2.arguments().add(ast.newSimpleName("r")); //使用方法实例创建表达类型 ExpressionStatement statement2 = ast.newExpressionStatement(methodInvocation2); //将表达式添加到语句块 mainBlock.statements().add(statement2); } //构造方法 { //创建一个方法声名（构造函数方法） MethodDeclaration constructorMethod = ast.newMethodDeclaration(); //(1)声名为构造方法 constructorMethod.setConstructor(true); //(2)设置方法名称为program constructorMethod.setName(ast.newSimpleName("Program")); //(3)设置方法的修鉓类型为公开 constructorMethod.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD)); { //基本类型的参数 SingleVariableDeclaration p1 = ast.newSingleVariableDeclaration(); //（1）设置参数名称为a p1.setName(ast.newSimpleName("a")); //（2）设置参数类型为INT p1.setType(ast.newPrimitiveType(PrimitiveType.INT)); //int[]类型的参数 SingleVariableDeclaration p2 = ast.newSingleVariableDeclaration(); p2.setName(ast.newSimpleName("b")); p2.setType(ast.newArrayType(ast.newPrimitiveType(PrimitiveType.INT))); //引用类型的参数(创建一个修鉓类型为final的参数 SingleVariableDeclaration p3 = ast.newSingleVariableDeclaration(); p3.setName(ast.newSimpleName("c")); p3.setType(ast.newSimpleType(ast.newName("Integer"))); p3.modifiers().add(ast.newModifier(ModifierKeyword.FINAL_KEYWORD)); //将参数添加到方法声名中 constructorMethod.parameters().add(p1); constructorMethod.parameters().add(p2); constructorMethod.parameters().add(p3); } //创建方法句语块（空） Block constructBlock = ast.newBlock(); //将句语块添加到方法中 constructorMethod.setBody(constructBlock); //将方法添加到类中 programClass.bodyDeclarations().add(constructorMethod); //创建super SuperConstructorInvocation superConstructorInvocation = ast.newSuperConstructorInvocation(); constructBlock.statements().add(superConstructorInvocation); superConstructorInvocation.arguments().add(ast.newNullLiteral()); } /**//*定义一个方法,形如: public String getString(String name){ String newString = name + "你好"; return newString; } */ { //创建getString()方法 MethodDeclaration getString = ast.newMethodDeclaration(); //（1）设置方法名称为getString getString.setName(ast.newSimpleName("getString")); //（2）设置方法public修饰 getString.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD)); //（3）设置方法参数 SingleVariableDeclaration p = ast.newSingleVariableDeclaration(); //（3.1）设置参数名称p p.setName(ast.newSimpleName("p")); //（3.2）设置参数类型String p.setType(ast.newSimpleType(ast.newName("String"))); //将参数添加到方法中 getString.parameters().add(p); //设置return类型 getString.setReturnType2(ast.newSimpleType(ast.newSimpleName("String"))); //创建块 Block block = ast.newBlock(); //将句语块添加到方法中 getString.setBody(block); programClass.bodyDeclarations().add(getString); //方法内容----定义String变量 VariableDeclarationFragment fragment = ast.newVariableDeclarationFragment(); fragment.setName(ast.newSimpleName("newString")); //String newString = "初始值"; /**//*StringLiteral stringLiteral2 = ast.newStringLiteral(); stringLiteral2.setLiteralValue("初始值"); fragment.setInitializer(stringLiteral2);*/ //创建一个类实例引用 ClassInstanceCreation classInstanceCreation = ast.newClassInstanceCreation(); //引用实例名称 classInstanceCreation.setType(ast.newSimpleType(ast.newName("String"))); //创建赋值实例 SingleVariableDeclaration p1 = ast.newSingleVariableDeclaration(); //创建一个字面参数 StringLiteral stringLiteral3 = ast.newStringLiteral(); //设置字面值 stringLiteral3.setLiteralValue("初始值"); //将字面参数作为类引用赋值 classInstanceCreation.arguments().add(stringLiteral3); //将classInstanceCreateion实初始化之后，作为变量实例 fragment.setInitializer(classInstanceCreation); //创建一个变量节点 VariableDeclarationStatement statement = ast.newVariableDeclarationStatement(fragment); //设置变量类型 statement.setType(ast.newSimpleType(ast.newName("String"))); //创建一个新作业 newString = "你好"; Assignment assignment = ast.newAssignment(); //设置左侧 assignment.setLeftHandSide(ast.newSimpleName("newString")); //(1)设置方法传入字面值 StringLiteral stringLiteral = ast.newStringLiteral(); stringLiteral.setLiteralValue("你好"); //(2)将字面值设置在右侧 assignment.setRightHandSide(stringLiteral); //设置表达式的运算符 assignment.setOperator(Operator.ASSIGN); ExpressionStatement statement2 = ast.newExpressionStatement(assignment); block.statements().add(statement); block.statements().add(statement2); //方法调用 MethodInvocation methodInvocation = ast.newMethodInvocation(); //设置引用方法对像 methodInvocation.set[removed]ast.newName("newString")); //设置方法名称 methodInvocation.setName(ast.newSimpleName("index")); //方法名 //设置方法传入字面值 StringLiteral stringLiteral2 = ast.newStringLiteral(); stringLiteral2.setLiteralValue("值"); methodInvocation.arguments().add(stringLiteral2); //声名一个变量 VariableDeclarationFragment fragment2 = ast.newVariableDeclarationFragment(); //将方法声名加入变量 fragment2.setInitializer(methodInvocation); //设置变量名称 fragment2.setName(ast.newSimpleName("result")); //为变量声明一个Statement VariableDeclarationStatement statement3 = ast.newVariableDeclarationStatement(fragment2); //定义类型 statement3.setType(ast.newSimpleType(ast.newName("String"))); //将Statement装入语句块 block.statements().add(statement3); StringLiteral stringLiteral4 = ast.newStringLiteral(); stringLiteral4.setLiteralValue("你好"); //定义一个拼串对像name + "你好"; InfixExpression infixExpression = ast.newInfix[removed]); //(1)定义左侧 infixExpression.setLeftOperand(ast.newName("name")); //（2）设置连接符号 infixExpression.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.PLUS); //（3）定义右侧 infixExpression.setRightOperand(stringLiteral4); //创建一个新作业 newString = name + "你好"; Assignment assignment2 = ast.newAssignment(); assignment2.setLeftHandSide(ast.newSimpleName("newString")); assignment2.setOperator(Operator.ASSIGN); assignment2.setRightHandSide(infixExpression); ExpressionStatement statement4 = ast.newExpressionStatement(assignment2); block.statements().add(statement4); //创建一个return Statement ReturnStatement rs = ast.newReturnStatement(); rs.set[removed]ast.newName("newString")); block.statements().add(rs); } /** *//** * 定义一个方法,形如: * public String isOdd(int a) throws NullPointerException, Exception{ * if(a < 0) throw new Exception("数字不能为负数"); * * if(a % 2 == 0){ * return "偶数"; * }else{ * System.out.println("完"); * return "奇数"; * } */ { MethodDeclaration methodDeclaration = ast.newMethodDeclaration(); methodDeclaration.setName(ast.newSimpleName("isOdd")); methodDeclaration.modifiers().add(ast.newModifier(ModifierKeyword.PUBLIC_KEYWORD)); methodDeclaration.setReturnType2(ast.newSimpleType(ast.newSimpleName("String"))); //设置参数 SingleVariableDeclaration singleVariableDeclaration = ast.newSingleVariableDeclaration(); singleVariableDeclaration.setName(ast.newSimpleName("a")); singleVariableDeclaration.setType(ast.newPrimitiveType(PrimitiveType.INT)); methodDeclaration.parameters().add(singleVariableDeclaration); //抛出异常 methodDeclaration.thrownExceptions().add(ast.newSimpleName("NullPointerException")); methodDeclaration.thrownExceptions().add(ast.newSimpleName("Exception")); //创建块{} Block isOddBlock = ast.newBlock(); methodDeclaration.setBody(isOddBlock); //创建if与异常 IfStatement ifStatement = ast.newIfStatement(); //表达式 a < 0 InfixExpression infixExpression = ast.newInfix[removed]); infixExpression.setLeftOperand(ast.newSimpleName("a")); infixExpression.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.LESS); NumberLiteral numberLiteral = ast.newNumberLiteral("0"); infixExpression.setRightOperand(numberLiteral); ifStatement.set[removed]infixExpression); //设置if中的内容 ThrowStatement throwStatement = ast.newThrowStatement(); ClassInstanceCreation classInstanceCreation = ast.newClassInstanceCreation(); classInstanceCreation.setType(ast.newSimpleType(ast.newSimpleName("Exception"))); StringLiteral stringLiteral = ast.newStringLiteral(); stringLiteral.setLiteralValue("数字不能为负数"); classInstanceCreation.arguments().add(stringLiteral); throwStatement.set[removed]classInstanceCreation); ifStatement.setThenStatement(throwStatement); //if(a % 2 == 0) IfStatement ifStatement2 = ast.newIfStatement(); InfixExpression infixExpression2 = ast.newInfix[removed]); infixExpression2.setLeftOperand(ast.newSimpleName("a")); infixExpression2.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.REMAINDER); NumberLiteral numberLiteral2 = ast.newNumberLiteral("2"); infixExpression2.setRightOperand(numberLiteral2); InfixExpression infixExpression3 = ast.newInfix[removed]); infixExpression3.setLeftOperand(infixExpression2); infixExpression3.setOperator(org.eclipse.jdt.core.dom.InfixExpression.Operator.EQUALS); NumberLiteral numberLiteral3 = ast.newNumberLiteral("0"); infixExpression3.setRightOperand(numberLiteral3); ifStatement2.set[removed]infixExpression3); //return "偶数"; ReturnStatement returnStatement = ast.newReturnStatement(); StringLiteral stringLiteral2 = ast.newStringLiteral(); stringLiteral2.setLiteralValue("偶数"); returnStatement.set[removed]stringLiteral2); ifStatement2.setThenStatement(returnStatement); //else Block elseBlock = ast.newBlock(); MethodInvocation methodInvocation = ast.newMethodInvocation(); methodInvocation.set[removed]ast.newName("System.out")); methodInvocation.setName(ast.newSimpleName("println")); StringLiteral stringLiteral4 = ast.newStringLiteral(); stringLiteral4.setLiteralValue("完"); methodInvocation.arguments().add(stringLiteral4); ExpressionStatement statement = ast.newExpressionStatement(methodInvocation); elseBlock.statements().add(statement); ReturnStatement returnStatement2 = ast.newReturnStatement(); StringLiteral stringLiteral3 = ast.newStringLiteral(); stringLiteral3.setLiteralValue("奇数"); returnStatement2.set[removed]stringLiteral3); elseBlock.statements().add(returnStatement2); ifStatement2.setElseStatement(elseBlock); isOddBlock.statements().add(ifStatement); isOddBlock.statements().add(ifStatement2); programClass.bodyDeclarations().add(methodDeclaration); } System.out.println(compilationUnit.toString()); } }
jdt-compiler-3.1.1.jar
03-08
java开发常用 jdt-compiler-3.1.1.jar
JDT应用开发相关资料
09-23
JDT应用开发相关资料 JDT应用开发相关资料 JDT应用开发相关资料
jdt需要的jar包
01-14
Eclipse ASTView需要的jar包，基本上已经全了，一共12个
Java解析语法树（AST）使用JDT相关库
09-28
包括以下包：jdt-3.2.1-r321_v20060823.jar、 jdt-3.3.0-v20070607-1300.jar、jdt-3.4.2_r894.jar、jdt-compiler.jar、org.eclipse.datatools.enablement.jdt.classpath_1.0.1.v201107221501.jar、org.eclipse.jdt.annotation_1.1.0.v20140129-1625.jar、org.eclipse.jdt.annotation_2.0.0.v20140415-1436.jar、org.eclipse.jdt.apt.core_3.3.600.v20150122-0735.jar、org.eclipse.jdt.apt.pluggable.core_1.0.400.v20131113-0353.jar org.eclipse.jdt.apt.ui_3.3.400.v20140311-1758.jar org.eclipse.jdt.compiler.apt_1.1.0.v20150122-0735.jar org.eclipse.jdt.compiler.tool_1.0.300.v20150114-1827.jar org.eclipse.jdt.core.manipulation_1.5.0.v20130605-1748.jar org.eclipse.jdt.core_3.10.2.v20150120-1634.jar org.eclipse.jdt.core-3.7.1.jar org.eclipse.jdt.debug.ui_3.6.300.v20140512-1926.jar org.eclipse.jdt.doc.user_3.10.1.v20140827-1504.jar org.eclipse.jdt.junit.core_3.7.300.v20140409-1618.jar org.eclipse.jdt.junit.runtime_3.4.500.v20140527-1138.jar org.eclipse.jdt.junit_3.7.300.v20140418-0836.jar org.eclipse.jdt.junit4.runtime_1.1.400.v20140314-0036.jar org.eclipse.jdt.launching_3.7.102.v20141111-0953.jar org.eclipse.jdt.ui_3.10.2.v20141014-1419.jar org.eclipse.jdt_3.10.1.v20150204-1700.jar org.eclipse.m2e.jdt.ui_1.5.1.20150109-1820.jar org.eclipse.m2e.jdt_1.5.1.20150109-1820.jar
Java jdt 编辑_使用JDT 提取Java方法体以及对应注释
weixin_33782854的博客
02-28 489
package app;import java.io.BufferedReader;import java.io.BufferedWriter;import java.io.File;import java.io.FileReader;import java.io.FileWriter;import java.io.IOException;import java.util.List;import ...
精通 Eclipse V3.4，第 3 部分: JDT 文本编辑器提示和技巧
蒋珍波的专栏
03-31 864
 “精通 Eclipse” 系列的这一部分将详细介绍 Eclipse 的 Java 编辑器。开发人员将在这个编辑器上花费大量的时间，因此了解其高级功能可以显著提高您的生产率。Organize Imports 命令Organize Imports 命令将添加缺失的导入并将现有的导入声明组织到 Java 文件中。您可以通过使用 Ctrl+Shift+O 组合键在当前编辑器中运行这条命令。要
使用JDT转java代码为AST
weixin_30820077的博客
11-16 460
maven依赖 <dependency> <groupId>org.eclipse.jdt</groupId> <artifactId>org.eclipse.jdt.core</artifactId> <version>3.13.0</version></dependency>代码...
java jdt_在JDT中使用Java 8 Lambda
最佳 Java 编程
06-12 511
java jdt 旧 Curmudgeon 认识Smalltalk的Dude 在修改Eclipse Java开发工具 （JDT）项目正在开发的Java 8支持时，我一直在使用这种语言。 我承认我对Java 8中的lambda有点不满意。 当然，这来自于知道Smalltalk （和LISP / Scheme）的老兄 。 像其他任何优秀的Smalltalk记号笔一样，当我着手...
Java基础入门教程 含习题 第11章 Eclipse开发工具（共30页）.pptx
12-26
其自带的标准插件集包含了Java开发工具（JDT），这意味着开发者可以直接使用Eclipse进行Java编程，而无需额外安装JDK或配置环境变量。 11.2 Eclipse的安装与启动 安装Eclipse非常简单，只需下载ZIP压缩包并解压到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值