Fel是轻量级的高效的表达式计算引擎学习（一）
Fel在源自于企业项目，设计目标是为了满足不断变化的功能需求和性能需求。
Fel是开放的，引擎执行中的多个模块都可以扩展或替换。Fel的执行主要是通过函数实现,运算符(+、-等都是Fel函数），所有这些函数都是可以替换的，扩展函数也非常简单。
Fel有双引擎，同时支持解释执行和编译执行。可以根据性能要求选择执行方式。编译执行就是将表达式编译成字节码（生成java代码和编译模块都是可以扩展和替换的）
Fel有多快？
通常情况下，Fel-0.7每秒可以执行千万次表达式（不包含编译时间）。速度是Jexl-2.0的20倍以上。
目前还没有发现开源的表达式引擎比Fel快。
具体的测试数据请参见http://code.google.com/p/fast-el/wiki/Performance。
为何要使用Fel?
Fel语法和API非常简单，语法与Java基本相同，几乎没有学习成本。
Fel非常快，上面已经做了简单说明。
Fel整个包只有200多KB。
Fel可以非常方便的访问数组、集合、Map的元素和对象的属性。
Fel可以非常方便的调用对象的方法和类方法（如果这些还不够，可以添加自定义函数）。
Fel支持大数值高精度计算
Fel有良好的安全管理功能
如果Fel不能满足你的要求，扩展和修改Fel很简单。
Fel不能做什么？
Fel只支持表达式，不支持脚本。
Fel适用场景：
Fel适合处理海量数据，Fel良好的扩展性可以更好的帮助用户处理数据。
Fel同样适用于其他需要使用表达式引擎的地方（如果工作流、公式计算、数据有效性校验等等）
安装
1：获取Fel
项目主页：http://code.google.com/p/fast-el/ 下载地址：http://code.google.com/p/fast-el/downloads/list
Fel使用例子：
1：算术表达式：
FelEngine fel = new FelEngineImpl(); Object result = fel.eval("5000*12+7500"); System.out.println(result);
输出结果：67500
2：变量
使用变量，其代码如下所示：
FelContext ctx = fel.getContext(); ctx.set("单价", 5000); ctx.set("数量", 12); ctx.set("运费", 7500); Object result = fel.eval("单价*数量+运费"); System.out.println(result);
输出结果：67500
3：访问对象属性
在Fel中，可能非常方便的访问对象属性，示例代码如下所示
FelEngine fel = new FelEngineImpl(); FelContext ctx = fel.getContext(); Foo foo = new Foo(); ctx.set("foo", foo); Map<String,String> m = new HashMap<String,String>(); m.put("ElName", "fel"); ctx.set("m",m); //调用foo.getSize()方法。 Object result = fel.eval("foo.size"); //调用foo.isSample()方法。 result = fel.eval("foo.sample"); //foo没有name、getName、isName方法 //foo.name会调用foo.get("name")方法。 result = fel.eval("foo.name"); //m.ElName会调用m.get("ElName"); result = fel.eval("m.ElName");
4:访问数组、集合、Map
FelEngine fel = new FelEngineImpl(); FelContext ctx = fel.getContext(); //数组 int[] intArray = {1,2,3}; ctx.set("intArray",intArray); //获取intArray[0] String exp = "intArray[0]"; System.out.println(exp+"->"+fel.eval(exp)); //List List<Integer> list = Arrays.asList(1,2,3); ctx.set("list",list); //获取list.get(0) exp = "list[0]"; System.out.println(exp+"->"+fel.eval(exp)); //集合 Collection<String> coll = Arrays.asList("a","b","c"); ctx.set("coll",coll); //获取集合最前面的元素。执行结果为"a" exp = "coll[0]"; System.out.println(exp+"->"+fel.eval(exp)); //迭代器 Iterator<String> iterator = coll.iterator(); ctx.set("iterator", iterator); //获取迭代器最前面的元素。执行结果为"a" exp = "iterator[0]"; System.out.println(exp+"->"+fel.eval(exp)); //Map Map<String,String> m = new HashMap<String, String>(); m.put("name", "HashMap"); ctx.set("map",m); exp = "map.name"; System.out.println(exp+"->"+fel.eval(exp)); //多维数组 int[][] intArrays= {{11,12},{21,22}}; ctx.set("intArrays",intArrays); exp = "intArrays[0][0]"; System.out.println(exp+"->"+fel.eval(exp)); //多维综合体，支持数组、集合的任意组合。 List<int[]> listArray = new ArrayList<int[]>(); listArray.add(new int[]{1,2,3}); listArray.add(new int[]{4,5,6}); ctx.set("listArray",listArray); exp = "listArray[0][0]"; System.out.println(exp+"->"+fel.eval(exp));
5:调用JAVA方法
FelEngine fel = new FelEngineImpl(); FelContext ctx = fel.getContext(); ctx.set("out", System.out); fel.eval("out.println('Hello Everybody'.substring(6))");
输出结果：Everybody
6:自定义上下文环境
//负责提供气象服务的上下文环境 FelContext ctx = new AbstractConetxt() { public Object get(Object name) { if("天气".equals(name)){ return "晴"; } if("温度".equals(name)){ return 25; } return null; } }; FelEngine fel = new FelEngineImpl(ctx); Object eval = fel.eval("'天气:'+天气+';温度:'+温度"); System.out.println(eval);
输出结果：天气:晴;温度:25
7:多层上下文环境（命名空间）
FelEngine fel = new FelEngineImpl(); String costStr = "成本"; String priceStr="价格"; FelContext baseCtx = fel.getContext(); //父级上下文中设置成本和价格 baseCtx.set(costStr, 50); baseCtx.set(priceStr,100); String exp = priceStr+"-"+costStr; Object baseCost = fel.eval(exp); System.out.println("期望利润：" + baseCost); FelContext ctx = new ContextChain(baseCtx, new MapContext()); //通货膨胀导致成本增加（子级上下文 中设置成本，会覆盖父级上下文中的成本） ctx.set(costStr,50+20 ); Object allCost = fel.eval(exp, ctx); System.out.println("实际利润：" + allCost);
输出结果：
期望利润：50
实际利润：30
8:编译执行
FelEngine fel = new FelEngineImpl(); FelContext ctx = fel.getContext(); ctx.set("单价", 5000); ctx.set("数量", 12); ctx.set("运费", 7500); Expression exp = fel.compile("单价*数量+运费",ctx); Object result = exp.eval(ctx); System.out.println(result);
执行结果：67500
备注：适合处理海量数据，编译执行的速度基本与Java字节码执行速度一样快。
9:自定义函数
//定义hello函数 Function fun = new CommonFunction() { public String getName() { return "hello"; } /* * 调用hello("xxx")时执行的代码 */ @Override public Object call(Object[] arguments) { Object msg = null; if(arguments!= null && arguments.length>0){ msg = arguments[0]; } return ObjectUtils.toString(msg); } }; FelEngine e = new FelEngineImpl(); //添加函数到引擎中。 e.addFun(fun); String exp = "hello('fel')"; //解释执行 Object eval = e.eval(exp); System.out.println("hello "+eval); //编译执行 Expression compile = e.compile(exp, null); eval = compile.eval(null); System.out.println("hello "+eval);
执行结果：
hello fel hello fel
10:调用静态方法
如果你觉得上面的自定义函数也麻烦，Fel提供的$函数可以方便的调用工具类的方法 熟悉jQuery的朋友肯定知道"$"函数的威力。Fel东施效颦，也实现了一个"$"函数,其作用是获取class和创建对象。结合点操作符，可以轻易的调用工具类或对象的方法。
//调用Math.min(1,2) FelEngine.instance.eval("$('Math').min(1,2)"); //调用new Foo().toString(); FelEngine.instance.eval("$('com.greenpineyu.test.Foo.new').toString());
通过"$('class').method"形式的语法，就可以调用任何等三方类包（commons lang等）及自定义工具类的方法，也可以创建对象，调用对象的方法。如果有需要，还可以直接注册Java Method到函数管理器中。
11 大数值计算（始于0.9版本）
Fel发布后，有些网友希望提供大数值计算功能，于是，大数值计算功能就有了。例子如下：
FelEngine fel = FelBuilder.bigNumberEngine(); String input = "111111111111111111111111111111+22222222222222222222222222222222"; Object value = fel.eval(input); Object compileValue = fel.compile(input, fel.getContext()).eval(fel.getContext()); System.out.println("大数值计算（解释执行）:" + value); System.out.println("大数值计算（编译执行）:" + compileValue);
由上例子可以看出，大数值计算引擎和常规计算引擎在使用方法是相同的。如果表达式数值比较大，要求精度高，可使用大数值计算引擎。不足之处是效率没有常规计算引擎高。
安全（始于0.8版本）
为了防止出现“${'System'}.exit(1)”这样的表达式导致系统崩溃。Fel加入了安全管理器，主要是对方法访问进行控制。安全管理器中通过允许访问的方法列表（白名单）和禁止访问的方法列表（黑名单）来控制方法访问。将"java.lang.System. * "加入到黑名单，表示System类的所有方法都不能访问。将"java.lang.Math. * "加入白名单，表示只能访问Math类中的方法。如果你不喜欢这个安全管理器，可以自己开发一个，非常简单，只需要实现一个方法就可以了。
附基本Java工程源代码：
Example类：
1 public class Example { 2 3 public static void main(String[] args) { 4 5 System.out.println("-----------1.入门---------"); 6 helloworld(); 7 8 System.out.println("-----------2.使用变量---------"); 9 useVariable(); 10 11 System.out.println("-----------3.获取对象属性---------"); 12 getAttr(); 13 14 System.out.println("---------4.调用对象的方法-----------"); 15 callMethod(); 16 17 System.out.println("--------5.访问数组、集合------------"); 18 visitColl(); 19 20 System.out.println("--------6.自定义上下文环境------------"); 21 context(); 22 23 System.out.println("--------7.多层次上下文环境(变量命名空间)------------"); 24 contexts(); 25 26 System.out.println("---------8.大数值计算-----------"); 27 testBigNumber(); 28 29 System.out.println("----------9.函数----------"); 30 userFunction(); 31 32 System.out.println("---------10.自定义 解释器-----------"); 33 userInterpreter(); 34 35 System.out.println("----------11.操作符重载----------"); 36 operatorOverload(); 37 38 System.out.println("----------12.速度测试----------"); 39 testSpeed(); 40 41 System.out.println("----------13.静态方法----------"); 42 staticMethod(); 43 } 44 45 /** 46 * 入门 47 */ 48 public static void helloworld() { 49 // FelEngine fel = new FelEngineImpl(); 50 Object result = FelEngine.instance.eval("5000*12+7500"); 51 System.out.println(result); 52 } 53 54 /** 55 * 使用变量 56 */ 57 public static void useVariable() { 58 FelEngine fel = getEngine(); 59 FelContext ctx = fel.getContext(); 60 ctx.set("单价", 5000); 61 ctx.set("数量", 12); 62 ctx.set("运费", 7500); 63 Object result = fel.eval("单价*数量+运费"); 64 System.out.println(result); 65 } 66 67 /** 68 * 获取对象属性 69 */ 70 public static void getAttr() { 71 FelEngine fel = getEngine(); 72 FelContext ctx = fel.getContext(); 73 Foo foo = new Foo(); 74 ctx.set("foo", foo); 75 Map<String, String> m = new HashMap<String, String>(); 76 m.put("ElName", "fel"); 77 ctx.set("m", m); 78 79 // 调用foo.getSize()方法。 80 Object result = fel.eval("foo.size"); 81 System.out.println(result); 82 // 调用foo.isSample()方法。 83 result = fel.eval("foo.sample"); 84 System.out.println(result); 85 // foo没有name、getName、isName方法 86 // foo.name会调用foo.get("name")方法。 87 result = fel.eval("foo.name"); 88 System.out.println(result); 89 // m.ElName会调用m.get("ElName"); 90 result = fel.eval("m.ElName"); 91 System.out.println(result); 92 } 93 94 /** 95 * 调用对象的方法 96 */ 97 public static void callMethod() { 98 FelEngine fel = getEngine(); 99 FelContext ctx = fel.getContext(); 100 ctx.set("out", System.out); 101 fel.eval("out.println('Hello Everybody'.substring(6))"); 102 } 103 104 /** 105 * 访问数组、集合 106 */ 107 public static void visitColl() { 108 FelEngine fel = getEngine(); 109 FelContext ctx = fel.getContext(); 110 111 // 数组 112 int[] intArray = { 1, 2, 3 }; 113 ctx.set("intArray", intArray); 114 // 获取intArray[0] 115 String exp = "intArray[0]"; 116 System.out.println(exp + "->" + fel.eval(exp)); 117 118 // List 119 List<Integer> list = Arrays.asList(1, 2, 3); 120 ctx.set("list", list); 121 // 获取list.get(0) 122 exp = "list[0]"; 123 System.out.println(exp + "->" + fel.eval(exp)); 124 125 // 集合 126 Collection<String> coll = Arrays.asList("a", "b", "c"); 127 ctx.set("coll", coll); 128 // 获取集合最前面的元素。执行结果为"a" 129 exp = "coll[0]"; 130 System.out.println(exp + "->" + fel.eval(exp)); 131 132 // 迭代器 133 Iterator<String> iterator = coll.iterator(); 134 ctx.set("iterator", iterator); 135 // 获取迭代器最前面的元素。执行结果为"a" 136 exp = "iterator[0]"; 137 System.out.println(exp + "->" + fel.eval(exp)); 138 139 // Map 140 Map<String, String> m = new HashMap<String, String>(); 141 m.put("name", "Wangxiaoming"); 142 ctx.set("map", m); 143 exp = "map.name"; 144 System.out.println(exp + "->" + fel.eval(exp)); 145 146 // 多维数组 147 int[][] intArrays = { { 11, 12 }, { 21, 22 } }; 148 ctx.set("intArrays", intArrays); 149 exp = "intArrays[0][0]"; 150 System.out.println(exp + "->" + fel.eval(exp)); 151 152 // 多维综合体，支持数组、集合的任意组合。 153 List<int[]> listArray = new ArrayList<int[]>(); 154 listArray.add(new int[] { 1, 2, 3 }); 155 listArray.add(new int[] { 4, 5, 6 }); 156 ctx.set("listArray", listArray); 157 exp = "listArray[0][0]"; 158 System.out.println(exp + "->" + fel.eval(exp)); 159 } 160 161 /** 162 * 自定义上下文环境 163 */ 164 public static void context() { 165 // 负责提供气象服务的上下文环境 166 FelContext ctx = new AbstractContext() { 167 @Override 168 public Object get(String name) { 169 if ("天气".equals(name)) { 170 return "晴"; 171 } 172 if ("温度".equals(name)) { 173 return 25; 174 } 175 return null; 176 } 177 178 }; 179 FelEngine fel = new FelEngineImpl(ctx); 180 String exp = "'天气-----:'+天气+';温度------:'+温度"; 181 Object eval = fel.compile(exp, ctx).eval(ctx); 182 System.out.println(eval); 183 } 184 185 /** 186 * 多层次上下文环境(变量命名空间) 187 */ 188 public static void contexts() { 189 FelEngine fel = getEngine(); 190 String costStr = "成本"; 191 String priceStr = "价格"; 192 FelContext baseCtx = fel.getContext(); 193 // 父级上下文中设置成本和价格 194 baseCtx.set(costStr, 50); 195 baseCtx.set(priceStr, 100); 196 197 String exp = priceStr + "-" + costStr; 198 Object baseCost = fel.eval(exp); 199 System.out.println("期望利润：" + baseCost); 200 201 FelContext ctx = new ContextChain(baseCtx, new MapContext()); 202 // 通货膨胀导致成本增加（子级上下文 中设置成本，会覆盖父级上下文中的成本） 203 ctx.set(costStr, 50 + 20); 204 Object allCost = fel.eval(exp, ctx); 205 System.out.println("实际利润：" + allCost); 206 } 207 208 /** 209 * 大数值计算 210 */ 211 public static void testBigNumber() { 212 // 构建大数值计算引擎 213 FelEngine fel = FelBuilder.bigNumberEngine(); 214 String input = "111111111111111111111111111111+22222222222222222222222222222222"; 215 Object value = fel.eval(input);// 解释执行 216 Object compileValue = fel.compile(input, fel.getContext()).eval( 217 fel.getContext());// 编译执行 218 System.out.println("大数值计算（解释执行）:" + value); 219 System.out.println("大数值计算（编译执行）:" + compileValue); 220 } 221 222 /** 223 * 函数 224 */ 225 public static void userFunction() { 226 // 定义hello函数 227 Function fun = new CommonFunction() { 228 229 @Override 230 public String getName() { 231 return "hello"; 232 } 233 234 /* 235 * 调用hello("xxx")时执行的代码 236 */ 237 @Override 238 public Object call(Object[] arguments) { 239 Object msg = null; 240 if (arguments != null && arguments.length > 0) { 241 msg = arguments[0]; 242 } 243 return ObjectUtils.toString(msg); 244 } 245 246 }; 247 FelEngine e = getEngine(); 248 // 添加函数到引擎中。 249 e.addFun(fun); 250 String exp = "hello('fel')"; 251 // 解释执行 252 Object eval = e.eval(exp); 253 System.out.println("hello " + eval); 254 // 编译执行 255 Expression compile = e.compile(exp, null); 256 eval = compile.eval(null); 257 System.out.println("hello " + eval); 258 } 259 260 /** 261 * 262 */ 263 public static void testCompileX() { 264 FelEngine fel = getEngine(); 265 String exp = "单价*数量"; 266 final MutableInt index = new MutableInt(0); 267 268 // 数据库中单价列的记录 269 final int[] price = new int[] { 2, 3, 4 }; 270 // 数据库中数量列的记录 271 final double[] number = new double[] { 10.99, 20.99, 9.9 }; 272 FelContext context = new AbstractContext() { 273 274 @Override 275 public Object get(String name) { 276 if ("单价".equals(name)) { 277 return price[index.intValue()]; 278 } 279 if ("数量".equals(name)) { 280 return number[index.intValue()]; 281 } 282 return null; 283 } 284 }; 285 Expression compExp = fel.compile(exp, context); 286 for (int i = 0; i < number.length; i++) { 287 index.setValue(i); 288 Object eval = compExp.eval(context); 289 System.out.println("总价[" + price[i] + "*" + number[i] + "=" + eval 290 + "]"); 291 } 292 } 293 294 /** 295 * 自定义 解释器 296 */ 297 public static void userInterpreter() { 298 FelEngine fel = getEngine(); 299 String costStr = "成本"; 300 FelContext rootContext = fel.getContext(); 301 rootContext.set(costStr, "60000"); 302 FelNode node = fel.parse(costStr); 303 // 将变量解析成常量 304 node.setInterpreter(new ConstInterpreter(rootContext, node)); 305 System.out.println(node.eval(rootContext)); 306 } 307 308 /** 309 * 操作符重载，使用自定义解释器实现操作符重载 310 */ 311 public static void operatorOverload() { 312 /* 313 * 扩展Fel的+运算符，使其支持数组+数组 314 */ 315 316 FelEngine fel = getEngine(); 317 // 单价 318 double[] price = new double[] { 2, 3, 4 }; 319 // 费用 320 double[] cost = new double[] { 0.3, 0.3, 0.4 }; 321 FelContext ctx = fel.getContext(); 322 ctx.set("单价", price); 323 ctx.set("费用", cost); 324 String exp = "单价+费用"; 325 Interpreters interpreters = new Interpreters(); 326 // 定义"+"操作符的解释方法。 327 interpreters.add("+", new Interpreter() { 328 @Override 329 public Object interpret(FelContext context, FelNode node) { 330 List<FelNode> args = node.getChildren(); 331 double[] leftArg = (double[]) args.get(0).eval(context); 332 double[] rightArg = (double[]) args.get(1).eval(context); 333 return sum(leftArg) + sum(rightArg); 334 } 335 336 // 对数组进行求和 337 public double sum(double[] array) { 338 double d = 0; 339 for (int i = 0; i < array.length; i++) { 340 d += array[i]; 341 } 342 return d; 343 } 344 }); 345 346 // 使用自定义解释器作为编译选项进行进行编译 347 Expression expObj = fel.compile(exp, null, interpreters); 348 Object eval = expObj.eval(ctx); 349 System.out.println("数组相加:" + eval); 350 } 351 352 /** 353 * 速度测试 354 */ 355 public static void testSpeed() { 356 FelEngine fel = getEngine(); 357 String exp = "40.52334+60*(21.8144+17*32.663)"; 358 FelNode node = fel.parse(exp); 359 int times = 1000; 360 long s1 = System.currentTimeMillis(); 361 for (int i = 0; i < times; i++) { 362 // double j = 40.52334 + 60 * (21.8144 + 17 * 32.663); 363 node.eval(null); 364 } 365 long s2 = System.currentTimeMillis(); 366 System.out.println("花费的时间:" + (s2 - s1)); 367 } 368 369 /** 370 * 大数据量计算（计算1千万次) 371 */ 372 public static void massData() { 373 FelEngine fel = getEngine(); 374 final Interpreters opti = new Interpreters(); 375 final MutableInt index = new MutableInt(0); 376 int count = 10 * 1000 * 1000; 377 final double[] counts = new double[count]; 378 final double[] prices = new double[count]; 379 Arrays.fill(counts, 10d); 380 Arrays.fill(prices, 2.5d); 381 opti.add("单价", new Interpreter() { 382 @Override 383 public Object interpret(FelContext context, FelNode node) { 384 return prices[index.intValue()]; 385 } 386 }); 387 opti.add("数量", new Interpreter() { 388 @Override 389 public Object interpret(FelContext context, FelNode node) { 390 return counts[index.intValue()]; 391 } 392 }); 393 Expression expObj = fel.compile("单价*数量", null, opti); 394 long start = System.currentTimeMillis(); 395 Object result = null; 396 for (int i = 0; i < count; i++) { 397 result = expObj.eval(null); 398 index.increment(); 399 } 400 long end = System.currentTimeMillis(); 401 402 System.out.println("大数据量计算:" + result + ";耗时:" + (end - start)); 403 } 404 405 /** 406 * 静态方法 407 * 408 * 409 * 如果你觉得上面的自定义函数也麻烦，Fel提供的$函数可以方便的调用工具类的方法 熟悉jQuery的朋友肯定知道"$"函数的威力。 410 * Fel东施效颦，也实现了一个"$"函数,其作用是获取class和创建对象。结合点操作符，可以轻易的调用工具类或对象的方法。 411 * 通过"$('class').method"形式的语法，就可以调用任何等三方类包（commons lang等）及自定义工具类的方法， 412 * 也可以创建对象，调用对象的方法。如果有需要，还可以直接注册Java Method到函数管理器中。 413 */ 414 public static void staticMethod() { 415 // 调用Math.min(1,2) 416 System.out.println(FelEngine.instance.eval("$('Math').max(1,3)")); 417 // 调用new Foo().toString(); 418 System.out.println(FelEngine.instance 419 .eval("$('com.ebiz.fel.Foo.new').toString()")); 420 } 421 422 private static FelEngine getEngine() { 423 return FelBuilder.engine(); 424 } 425 426 } 427 428 class ColumnInterpreter implements Interpreter { 429 MutableInt index; 430 431 double[] records; 432 433 ColumnInterpreter(MutableInt index, double[] records) { 434 this.index = index; 435 this.records = records; 436 } 437 438 @Override 439 public Object interpret(FelContext context, FelNode node) { 440 return records[index.intValue()]; 441 } 442 } 443 444 class MutableInt { 445 private int value; 446 447 public MutableInt(int i) { 448 this.value = i; 449 } 450 451 public int intValue() { 452 return value; 453 } 454 455 public void setValue(int i) { 456 this.value = i; 457 } 458 459 public void increment() { 460 value++; 461 } 462 }
Foo类：
1 import java.util.ArrayList; 2 import java.util.Iterator; 3 import java.util.List; 4 5 public class Foo { 6 7 private final String name; 8 9 private Foo foo = null; 10 11 static private Foo[] f = new Foo[] { new Foo("array0"), new Foo("array1") }; 12 13 static private Foo[] fooes = f; 14 15 public Foo[] getFooes() { 16 return fooes; 17 } 18 19 public void setFooes(Foo[] fooes) { 20 this.fooes = fooes; 21 } 22 23 private boolean beenModified = false; 24 private String property1 = "some value"; 25 26 public Foo(String name) { 27 this.name = name; 28 } 29 30 public Foo() { 31 this("anonymity"); 32 } 33 34 public static String sayHello(String str) { 35 return "hello" + str; 36 } 37 38 public class Cheezy { 39 public Iterator<String> iterator() { 40 return getCheeseList().iterator(); 41 } 42 } 43 44 public String get(String arg) { 45 if ("name".equals(arg)) { 46 return name; 47 } 48 return "can't find " + arg; 49 } 50 51 public String convertBoolean(boolean b) { 52 return "Boolean : " + b; 53 } 54 55 public int getCount() { 56 return 5; 57 } 58 59 public String contact(String a, String b, String c, String d) { 60 return a + b + c + c; 61 } 62 63 public List<String> getCheeseList() { 64 ArrayList<String> answer = new ArrayList<String>(); 65 answer.add("cheddar"); 66 answer.add("edam"); 67 answer.add("brie"); 68 return answer; 69 } 70 71 public Cheezy getCheezy() { 72 return new Cheezy(); 73 } 74 75 public boolean isSimple() { 76 return true; 77 } 78 79 public int square(int value) { 80 return value * value; 81 } 82 83 public boolean getTrueAndModify() { 84 beenModified = true; 85 return true; 86 } 87 88 public boolean getModified() { 89 return beenModified; 90 } 91 92 public int getSize() { 93 return 22; 94 } 95 96 public String getProperty1() { 97 return property1; 98 } 99 100 public void setProperty1(String newValue) { 101 property1 = newValue; 102 } 103 104 public Foo getFoo() { 105 return this.foo; 106 } 107 108 public void setFoo(Foo foo) { 109 this.foo = foo; 110 } 111 112 @Override 113 public String toString() { 114 return this.name; 115 } 116 }
运行结果：
1 -----------1.入门--------- 2 67500 3 -----------2.使用变量--------- 4 67500 5 -----------3.获取对象属性--------- 6 22 7 can't find sample 8 anonymity 9 fel 10 ---------4.调用对象的方法----------- 11 Everybody 12 --------5.访问数组、集合------------ 13 intArray[0]->1 14 list[0]->1 15 coll[0]->a 16 iterator[0]->a 17 map.name->Wangxiaoming 18 intArrays[0][0]->11 19 listArray[0][0]->1 20 --------6.自定义上下文环境------------ 21 天气-----:晴;温度------:25 22 --------7.多层次上下文环境(变量命名空间)------------ 23 期望利润：50 24 实际利润：30 25 ---------8.大数值计算----------- 26 大数值计算（解释执行）:22333333333333333333333333333333 27 大数值计算（编译执行）:22333333333333333333333333333333 28 ----------9.函数---------- 29 hello fel 30 hello fel 31 ---------10.自定义 解释器----------- 32 60000 33 ----------11.操作符重载---------- 34 数组相加:10.0 35 ----------12.速度测试---------- 36 花费的时间:91 37 ----------13.静态方法---------- 38 3 39 anonymity
转载：https://blog.csdn.net/chichengjunma/article/details/56012272
