设计模式-解释器模式
1、概念
给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。2、优点
1、可扩展性比较好，灵活。 2、增加了新的解释表达式的方式。 3、易于实现简单文法。3、缺点
1、可利用场景比较少。 2、对于复杂的文法比较难维护。 3、解释器模式会引起类膨胀。 4、解释器模式采用递归调用方法。4、角色
1.AbstractExpression抽象解释器：具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和NonterminalExpression
2.TerminalExpression终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结
表达式，但有多个实例，对应不同的终结符。
3.NonterminalExpression非终结符表达式：文法中的每条规则对应于一个非终结表达式，非终结符表达式根据逻辑的
复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式
4.Context环境角色
5、使用场景
1、可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。 2、一些重复出现的问题可以用一种简单的语言来进行表达。 3、一个简单语法需要解释的场景。6、案例描述
将类似C#代码转换为Java代码7、UML类图
8、代码解析UML类图
AbstractExpression：/**
* Created by laizhiyuan on 2017/8/1.
*
* <p>
* 设计模式-解释器模式-抽象解释器（语法装换器）
* </p>
*/
public abstract class AbstractConversionExpression {
public abstract String conversion(Context content);
}
TerminalExpression：
/**
* Created by laizhiyuan on 2017/8/1.
*
* <p>
* 设计模式-解释器模式-终结符（字符串）
* </p>
*/
public class StringTerminaExpression extends AbstractConversionExpression{
private String str;
public StringTerminaExpression(String str) {
this.str = str;
}
public String getStr() {
return str;
}
@Override
public String conversion(Context content) {
return str;
}
}
NonterminalExpression：
/**
* Created by laizhiyuan on 2017/8/1.
*/
public class TypeConversionNonterminalExpression extends AbstractConversionExpression {
private AbstractConversionExpression mainExpression;
private AbstractConversionExpression constantExpression;
public TypeConversionNonterminalExpression(AbstractConversionExpression mainExpression,
AbstractConversionExpression constantExpression) {
this.mainExpression = mainExpression;
this.constantExpression = constantExpression;
}
@Override
public String conversion(Context context) {
if (mainExpression.conversion(context).indexOf(constantExpression.conversion(context)) != -1){
int index = mainExpression.conversion(context).indexOf(constantExpression.conversion(context));
StringBuilder stringBuilder = new StringBuilder(mainExpression.conversion(context).substring(0, index))
.append(context.get(constantExpression).conversion(context))
.append(" ")
.append(mainExpression.conversion(context).substring(index + 7, mainExpression.conversion(context).length()));
return stringBuilder.toString();
}
return mainExpression.conversion(context);
}
}
/**
* Created by laizhiyuan on 2017/8/1.
*
* <p>
* 设计模式-解释器模式-非终结符（继承字符串装换）
* </p>
*/
public class ExtendsConversionNonterminalExpression extends AbstractConversionExpression {
private AbstractConversionExpression mainExpression;
private AbstractConversionExpression constantExpression;
public ExtendsConversionNonterminalExpression(AbstractConversionExpression mainExpression,
AbstractConversionExpression constantExpression) {
this.mainExpression = mainExpression;
this.constantExpression = constantExpression;
}
@Override
public String conversion(Context context) {
if (mainExpression.conversion(context).indexOf(constantExpression.conversion(context)) != -1){
int index = mainExpression.conversion(context).indexOf(constantExpression.conversion(context));
StringBuilder stringBuilder = new StringBuilder(mainExpression.conversion(context).substring(0, index))
.append(context.get(constantExpression).conversion(context))
.append(mainExpression.conversion(context).substring(index + 1, mainExpression.conversion(context).length()));
return stringBuilder.toString();
}
return mainExpression.conversion(context);
}
}
Context：
/**
* Created by laizhiyuan on 2017/8/1.
*
* <p>
* 设计模式-解释器模式-上下文
* </p>
*/
public class Context {
private Map<AbstractConversionExpression, AbstractConversionExpression>
context = new HashMap<AbstractConversionExpression, AbstractConversionExpression>();
public void put(AbstractConversionExpression key, AbstractConversionExpression value){
context.put(key, value);
}
public AbstractConversionExpression get(AbstractConversionExpression key){
AbstractConversionExpression expression = context.get(key);
if (expression == null){
for (AbstractConversionExpression nKey : context.keySet()){
if (key.conversion(this).indexOf(nKey.conversion(this)) != -1){
return context.get(nKey);
}
}
}
return expression;
}
}
工具类：
/**
* Created by laizhiyuan on 2017/08/01
*/
public class HandleTextFileUtil extends ArrayList<String>{
public static String read(String fileName){
if ("".equals(fileName)){
return "";
}
StringBuilder sb = new StringBuilder();
try {
BufferedReader br = new BufferedReader(new FileReader(new File(fileName).getAbsoluteFile()));
String s ;
try {
while ((s = br.readLine()) != null ){
sb.append(s).append("\n");
}
return sb.toString();
} catch (IOException e) {
throw new RuntimeException(e);
}finally{
if (br != null){
try {
System.out.print("close buffered reader");
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return "";
}
public static void write(String fileName, String text){
if ("".equals(fileName) || "".equals(text)){
return;
}
try {
PrintWriter pw = new PrintWriter(new File(fileName).getAbsoluteFile());
try{
pw.println(text);
}finally {
if (pw != null){
pw.close();
}
}
} catch (FileNotFoundException e) {
throw new RuntimeException(e);
}
}
public void write(String fileName){
if ("".equals(fileName)){
return;
}
try {
PrintWriter pw = new PrintWriter(new File(fileName).getAbsoluteFile());
try{
for (String item : this){
pw.println(item);
}
pw.flush();
}finally {
System.out.print("close write");
pw.close();
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
}
public HandleTextFileUtil(String fileName, String split){
super(Arrays.asList(read(fileName).split(split)));
if (get(0).equals(""))
remove(0);
}
public HandleTextFileUtil(String fileNamee){
this(fileNamee,"\n");
}
}
9、测试
/**
* Created by laizhiyuan on 2017/8/1.
*/
public class Main {
public static void main(String[] args) {
String path = "D:\\Hello.cs";
File file = new File("D:\\Hello.java");
try {
file.delete();
file.createNewFile();
} catch (IOException e) {
e.printStackTrace();
}
HandleTextFileUtil handleTextFileUtil = new HandleTextFileUtil(path);
Context context = new Context();
AbstractConversionExpression cExtendsStr = new StringTerminaExpression(":");
AbstractConversionExpression javaExtendsStr = new StringTerminaExpression("extends");
AbstractConversionExpression cStringTypeStr = new StringTerminaExpression("string");
AbstractConversionExpression javaStringTypeStr = new StringTerminaExpression("String");
context.put(cExtendsStr, javaExtendsStr);
context.put(cStringTypeStr, javaStringTypeStr);
AbstractConversionExpression expression = null;
AbstractConversionExpression mainExpression = null;
for (int i = 0; i < handleTextFileUtil.size(); i++){
mainExpression = new StringTerminaExpression(handleTextFileUtil.get(i));
if (mainExpression.conversion(context).indexOf(cExtendsStr.conversion(context)) != -1){
expression = new ExtendsConversionNonterminalExpression(mainExpression, cExtendsStr);
handleTextFileUtil.set(i, expression.conversion(context));
}else if (mainExpression.conversion(context).indexOf(cStringTypeStr.conversion(context)) != -1){
expression = new TypeConversionNonterminalExpression(mainExpression, cStringTypeStr);
expression.conversion(context);
handleTextFileUtil.set(i, expression.conversion(context));
}
}
handleTextFileUtil.write("D:\\Hello.java");
}
}
测试源文件：
class Hello : World{
private string name;
public void setName(string name){
this.name = name;
}
public string getName(){
return this.name;
}
}
解释后的文件
class Hello extends World{
private String name;
public void setName(String name){
this.name = name;
}
public String getName(){
return this.name;
}
}