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());
}
}
