java波兰式

A. java B/S模式

在Java B/S开发模式有以下几种：
一、JSP+JDBC
这是最简单的一种开发模式是页面+逻辑处理，映射到技术上反应出来的有Jsp+Jdbc，在基于这类的实现中在View层也就是jsp页面上负责数据的显示、逻辑处理，结合jdbc完成数据的持久化，在小型的项目中，人们确实发现这种方式是最为方便的，但在复杂的项目以及需求不断变化的项目中，人们慢慢的发现这种方式造成了不少的问题，首先是调试的问题，想想在一个jsp页面中进行排错是多么的困难，其次是修改的问题，为了满足用户需求的一个小小的变化，都需要去改不少的页面，而且很多时候由于写的时间长了，自己都需要回忆很久才能想起是怎么回事，更不用说如果人员流动了会怎么样，同时还带来开发效率的问题，由于需要缺少足够的调试的支持，需要较为熟练的开发人员才能快速的完成，对于一般的人员来说需要一定的适应和学习过程，当然伴随而来的还有诸如修改界面的时候一不小心少了点代码什么造成的错，最大的问题可能还是重用的问题，通常会造成N多同样的代码在页面上来去的，总结下来在这种模式下有几个比较重大的问题就是：
1、调试问题。
2、维护问题，显示和逻辑处理在一起导致了修改显示的时候较为困难，至于修改代码则因为之前的调试问题导致了困难，同时由于逻辑均在页面上后期接手人员需要一段时间去理解。
3、代码重用性问题。
但同样它还是存在优点的，那就是可以很快的上手，但由于调试和维护性问题确实太大了，所以在现在也是基本不再采用这种方式了。
二、JSP+JavaBean
在经历了jsp+jdbc阶段后，开始考虑怎么样去解决上面三个问题，这个时候就诞生了诸JSP+JavaBean这样的技术体系，在这个体系中由jsp页面负责显示以及接收页面请求，并调用相应的JavaBean来完成逻辑处理，在获取其返回的处理数据后转到相应的页面进行显示。在这样的技术体系中，由于逻辑是由JavaBean来完成的，可以对其进行调试了，代码的重用性一定程度上也得到了提高。刚开始的时候用这样的技术体系确实发现比以前用jsp+jdbc爽了很多，但随着用多了，慢慢又发现了问题，那就是在页面中需要编写对于页面请求数据的获取，还得根据请求去调用相应的javabean，并根据javabean的处理结果转入相应的页面，这同样造成了修改的麻烦，毕竟是去页面上修改这些逻辑，总结下来在这种Java B/S开发模式下有比较重大的问题就是：
1、代码重用性以及维护性问题。但这里的代码重用性问题和jsp+jdbc的就不同，在逻辑处理部分现在已经可以重用了，但现在在各个页面就不得不重复的写获取页面请求的参数、相应的调用Model、根据Model的处理结果转发页面，这样的话就导致了在改的时候需要到处去找，造成了维护的复杂。
2、系统结构不清晰。毕竟仍然是在页面控制整个响应页面事件的处理流程，这个时候就造成了很多页面中出现完全相同的jsp代码，而且控制代码在页面，仍然是不便操作，例如对于JavaBean的调用等，而且由于获取javabean的数据需要转发的缘故，其实通常就是在最终的显示页面上加上上面的控制事件处理流程的代码，并没有真正的做到显示和处理的分离。
同样，它的优点在于分离了显示和业务逻辑处理，增强了可调试以及维护性，而且也是很容易上手的，对于小型项目来说仍然是可选的方案之一。
三、基于MVC Framework
在经历了上面的Jsp+JavaBean的Java B/S开发模式后，我们发现其实现在最需要的就是在jsp、javabean之间能有个东西自动完成页面请求数据的封装、根据请求调用相应的javabean、同时根据javabean的处理结果返回至相应的View，有了这样的思想后，发现smalltalk中的MVC思想很适合这种场景，于是便在Java B/S开发中引入了MVC思想，在这里也简单的介绍下MVC思想，MVC强调View和Model的分离，View所面对的是Controller，由Controller负责与Model进行交互，View只负责显示页面以及显示逻辑的处理，显示逻辑指的是诸如第一行要显示蓝色、第二行要显示红色这样的显示方面的处理，Controller负责接受页面请求，并将其请求数据进行封装，同时根据请求调用相应的Model进行逻辑处理，在Model处理后返回结果数据到Controller，Controller将根据此数据调用相应的View，并将此数据传递给View，由View负责将数据进行融合并最终展现。MVC带来的优点很明显的体现出来了，基于一个这样的MVC Framework的话开发人员可以按照一种固定的模式进行开发，规范了整个开发过程，提高了质量以及系统结构的清晰性，并由于保证了View/Model的分离，使得一个Model可以对于多种显示形式的View，需要的仅仅是去改变View和Controller。
按照MVC思想，最容易想到的实现方案莫过于jsp+servlet+javabean，在这里面jsp对应着View，servlet对应着Controller，javabean对应着Model，因为采用servlet可使用servlet container已经封装好的页面数据请求对象HttpServletRequest，这样就省去了自己封装页面请求数据的工作，作为Controller同时还需要承担根据请求调用对应的javabean，最简单的做法无非就是在Servlet中直接根据某种逻辑(诸如反射或接口)调用相应的bean进行执行，之后将HttpServletRequest、HttpServletResponse作为参数传入javabean进行处理，javabean从HttpServletRequest中获取请求数据，将返回的结果数据放入HttpServletResponse，整个过程结束后继续由Controller接手进行处理，这个时候作为Controller的servlet将根据处理的结果返回相应的页面，在这个模型使用时人们慢慢的发现了一个问题，那就是随着jsp、javabean的变化造成了controller的不断修改，需要修改其中调用相应javabean以及转发相应页面的部分，为了解决这个问题，首先想到的是应该分离根据请求调用相应javabean的步骤，这个时候采用了设计模式中的front controller+application controller的方法，front controller负责接受页面请求并进行封装，同时将此数据对象传递至application controller，由application controller来负责调用相应的bean，这样的设计其实都是遵循着一个设计原则，就是职责单一，通常实现application controller的模式是Command模式，在这种情况下MVC Framework的结构体系就演变成了view+controller(front+application)+model。
在完成了上述演变后慢慢又发现了一个问题，就是model依赖于了httpservletrequest，这样造成的一个问题就是没法测试，仍然要不断重启服务器来测试，当然与此同时的发展是model层的细化，细化成用于响应页面请求的action Layer+Domain Model Layer+Persistent Layer，在这里不去讨论后面层次的问题，因为作为MVC Framework它并不管你Model层是怎么个处理流程的。
慢慢也发现了另外一个问题，那就是变化经常要影响到controller的修改，于是便引入了采用配置文件的解决方法，编写action的配置文件，在配置文件中控制根据action的返回结果转入相应的View，这样的话在将来需要改变的时候只需要去改变这个配置文件就可以了，保证了Controller的稳定，这是典型的设计中的重点考虑因素，分离变化和不变化的，让变化造成的影响最小。
但在引入了上面的配置文件后，慢慢又发现了问题，那就是手写配置文件总是容易出各种各样的问题，这个时候采用图形化的界面来生成配置文件的想法又有了，这也就造就了page flow的诞生，当然，这只是page flow的一小部分功能。
当然，随着MVC的发展，也带动了其他相关技术的发展，如异步请求/响应模式(ajax、amowa)等。

B. java如何计算比较复杂的数学计算，比如有括号同时有+-*/，顺序不一定，就是一个运算公式

可以用编译原理的思想来理解，主要用到数据结构里面的栈和队列。
利用栈的后进先出以及运算符号(+-*/(){} )优先级，对运算符号进行匹配。
分两个栈，一个是符号栈，一个是数字栈。
栈的每一次pop出一个字符，要进行校验，如果匹配（符合运算规则）则计算，并保存结果到数据栈。

C. java 中|| 和 && 这类的符号都表示什么

&&和||是一种逻辑运算符，&&是逻辑与，当两个数都为真，则结果为真。||是逻辑或，两个数任意一个为真，则结果为真。

举个例子：

1、a && b

当a、b都为真时，结果为真。有一个为假或者都为假时结果为假。

2、a || b

当a、b有一个为真时，结果为真。a、b都为假时结果为假。

(3)java波兰式扩展阅读：

在java中还有其他的逻辑符号，比如：！、|、 &

“！”是非运算符号，比如a为真，则！a则为假。a如果为假，则！a为真。

而“|”也是逻辑或，“&”也是逻辑与，但是他们与“||”和“&&”有些区别，区别如下：

“&”与“|”无论第一个判断条件是否成立，逻辑运算符前后两个条件都会进行判断。

“&&”与“||”，前者第一个条件不成立，后面的条件均不进行判断，返回false；后者第一个条件成立，后面的条件均不进行判断,返回true。

D. 怎样用JAVA写出逆波兰表达式求值部分的源代码（提供代码框架）

下面的代码是用来计算表达式的，看看是不是你要的
public class OPNode {
char op;// 运算符号
int level;// 优先级
//设置优先级
public OPNode(String op) {
this.op = op.charAt(0);
if (op.equals("+") || op.equals("-")) {
this.level = 1;
} else if (op.equals("*") || op.equals("/")) {
this.level = 2;
} else if (op.equals("(")) {
this.level = -3;

} else {
this.level = -1;
}
}
}
//主类
import java.util.Deque;
import java.util.LinkedList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class OPText {
public static void main(String[] args) {
String expression = "2+2+(8-2)/3";// 要计算的表达式
List list = new LinkedList();
//正则式
Pattern entryOfExpression = Pattern
.compile("[0-9]+(\\.[0-9]+)?|\\(|\\)|\\+|-|\\*|/");
Deque stack = new LinkedList();//栈
Matcher m = entryOfExpression.matcher(expression);
while (m.find()) {
//提取语素
String nodeString = expression.substring(m.start(), m.end());
if (nodeString.matches("[0-9].*")) {
list.add(Double.valueOf(nodeString));//如果是数字直接送入列表
} else {
OPNode opn = new OPNode(nodeString);//如果是运算符
int peekLevel = (stack.peek() == null) ? 0 : ((OPNode) stack
.peek()).level;
if (opn.level >=peekLevel) {
stack.push(opn);//新的运算符比旧的优先级别高则入栈
} else {
if (opn.level == -1) {
OPNode temp = (OPNode) stack.pop();
while (temp.level != -3) {//如果为"("则一直出栈一直到")"
list.add(temp);
System.out.println(nodeString);
temp = (OPNode) stack.pop();
}
} else if (opn.level == -3) {
stack.push(opn);
} else {//如果新运算符比栈顶运算符底则一直出栈
OPNode temp = (OPNode) stack.pop();
while (temp.level > opn.level) {
list.add(temp);
if (stack.isEmpty()) {
break;
}
temp = (OPNode) stack.pop();
}
stack.push(opn);
}
}
}

}
OPNode temp = null;
while (!stack.isEmpty()) {
temp = (OPNode) stack.pop();
list.add(temp);
}//后续表达式计算
stack.clear();
for (Object o : list) {
if (o instanceof Double) {
stack.push(o);//为数字入栈
} else {
double op2 = ((Double) stack.pop()).doubleValue();
double op1 = ((Double) stack.pop()).doubleValue();
switch (((OPNode) o).op) {
case '+':
stack.push(op1 + op2);
break;
case '-':
stack.push(op1 - op2);
break;

case '*':
stack.push(op1 * op2);
break;

case '/':
stack.push(op1 / op2);
break;
}

}
}
System.out.println("结果为:" + stack.pop());
}

}
呃，太晚了，没心思去改了
明天再说

E. java :转变为逆波兰表示式的代码报错：堆栈溢出，怎么解决

while(Character.isDigit(chars[i])||chars[i]=='.') {
s.append(chars[i]);
}
这一段是死循环。。stack一直追加参数，所以溢出了

F. JAVA包含哪三个版本,每个版本有什么功能,各个版本的应用领域

JAVA的三个版本及其功能应用领域介绍如下：

1、JavaSE(Java Standard Edition)

也称为J2SE，标准版本。用于服务器、桌面、嵌入式环境和实时环境中使用的 Java 应用程序。Java SE 包含了支持 Java Web 服务开发的类，并为 Java Platform，Enterprise Edition（Java EE）提供基础。

2、JavaEE(Java Enterprise Editon)

也称为J2EE，是企业版本帮助开发和部署可移植、健壮、可伸缩且安全的服务器端Java 应用程序。Java EE 是在 Java SE 的基础上构建的，它提供Web服务、组件模型、管理和通信 API，可以用来实现企业级的面向服务体系结构（service-oriented architecture，SOA）和 Web 2.0 应用程序。

3、JavaME(Java Micro edition)

也称为J2ME，是网络这一块的，Java ME 为在移动设备和嵌入式设备（比如手机、PDA、电视机顶盒和打印机）上运行的应用程序提供一个健壮且灵活的环境。

Java ME 包括灵活的用户界面、健壮的安全模型、许多内置的网络协议以及对可以动态下载的连网和离线应用程序的丰富支持。基于 Java ME 规范的应用程序只需编写一次，就可以用于许多设备，而且可以利用每个设备的本机功能。

(6)java波兰式扩展阅读

Java本来就是为了嵌入式系统而生，1990年12月，Sun公司内部 由James Gosling、Patrick Naughton以及Mike Sheridan成立了一个叫做Green Team的小组。

Green Team小组的主要目标，是要发展一种新架构，而这种架构必须能够在消费性电子产品作业平台上运行，现在我们普遍认识的PDA、手机或是信息家电 （IA），都是属于这种架构的目标平台。虽然在1999年，Java被分割成J2ME、J2SE、J2EE，所以有了J2ME这个名词的出现。

但是 Java并非1999年才开始发展嵌入式系统上的应用。其实，Java本来就是为了嵌入式系统而发展的一种架构。即使目前大家多半将Java的应用聚焦于 企业上的J2EE应用。但是严格来说，J2ME才是Java真正“回归本心”的领域。

J2EE组件和“标准的” Java类 的不同点在于：它被装配在一个J2EE应用中，具有固定的格式并遵守J2EE规范，由J2EE服务器对其进行管理。

J2EE规范是这样定义J2EE组件 的：客户端应用程序和applet是运行在客户端的组件；Java Servlet和Java Server Pages (JSP) 是运行在服务器端的Web组件；Enterprise Java Bean (EJB )组件是运行在服务器端的业务组件。

G. 什么是逆波兰式

逆波兰式
开放分类： c程序

逆波兰式也叫后缀表达式(将运算符写在操作数之后)
如：我们平时写a+b，这是中缀表达式，写成后缀表达式就是：ab+
(a+b)*c-(a+b)/e的后缀表达式为：
(a+b)*c-(a+b)/e
→((a+b)*c)((a+b)/e)-
→((a+b)c*)((a+b)e/)-
→(ab+c*)(ab+e/)-
→ab+c*ab+e/-
将一个普通的中序表达式转换为逆裂桐波兰表达式的一缺衡般算法是：
1)首先构造一个运算符栈，此运算符在栈内遵循越往栈顶优先级越高的原则。
(2)读入一个用中缀表示的简单算术表达式，为方便起见,设该简单算术表达式的右端多加上了优先级最低的特殊符号“#”。
(3)从左至右扫描该算术表达式，从第一个字符开始判断，如果该字符是数字，则分析到该数字串的结束并将该数字串直接输出。
(4)如果不是数字，该字符则是运算符，此时需比较优先关系。
做法如下：将该字符与运算符栈顶的运算符的优先关系相比较。如果，该字符优先关系高于此运算符栈顶的运算符，则将该运算符入栈。倘若不是的话，则将栈顶的运算符从栈中弹出，直到栈顶运算符的优先级低于当前运算符，将该字符入栈。
(5)重复上述操作(1)-(2)直至扫描完整个简单算术表达式，确定所有字符都得到正确处理，我们便可以将中缀式表示的简单算术表达式转化为逆波兰表示的简单算术表达式。

typedef int SElemType;

typedef struct SqStack

{ char *base;

char *top;

char stacksize;

}SqStack;

程序

void InitStack (SqStack &S)

{

S.base=(char *) malloc (STACK_INIT_SIZE *sizeof(char));

if (!S.base)

exit (OVERFLOW); //为栈S分配存储空间失败

S.top=S.base;

S.stacksize=STACK_INIT_SIZE;

}

int Push(SqStack &S,char ch)

// 将元素e插入到栈S中，成为新的栈顶元素

{

if (S.top-S.base>S.stacksize) //Stack==full?

{ S.base=(char *)realloc(S.base,(S.stacksize+STACKINCREMENT *sizeof(char)));

if (!S.base)

{ printf(“Failure to reallocate the Memory units!:\n”);

exit(OVERFLOW);

}

S.top=S.base+S.stacksize; //To Modify pointer of Satck top

S.stacksize+=STACKINCREMENT; //To modify the size of stack

} // end of if

*S.top++=ch; //先将e送入栈顶指针所指向的单元，再将栈顶指针加1

return(OK);

} //end of Push() subfunction

int Pop(SqStack &S,char &ch)

{

if (S.top==S.base)

{

printf(“下溢！”)；

return (ERROR);

}

ch=*--S.top;

return (OK);

}

void Translation()

{//将算术表达式转化伏源做为逆波兰表达式，num为算术表达式的字符总个数

int i,j;

char str[100],exp[100],ch;

SqStack S;

InitStack(S);

i=1;

printf(“ 请输入算术表达式字符串，求其逆波兰表达式，以＃为结束标志，如a-b*c/(3+6)#:\n”);

do

{

scanf(“%c”,&str);

i++;

}while(str[i-1]!=’#’);

str[0]=’(‘; //将表达式放在（）内

str[i-1]=’)’;

str=’#’;

i=0;

j=0;

while(str!=’#’)

{ if((str>=’0’ &&str<=’9’)||(str>=’a’ &&str<=’z’))

{

exp[j]=str;

j++;

} //end of if

else if(str==”(”)

Push(S.str);

else if(str==’)’)

{ while(*(S.top-1)!=’(’)

//将S中左括号“（”以前的所有字符依次弹出并存入数组exp中

{ Pop(S,ch); exp[j]=ch; j++; }

S.top--;

} //end of elseif

else if(str==’+’||str==’-’) //如果判定为“＋”号或“-”号，则做如下操作

{ while((s.top!=S.base)&&(*(S.top-1)!=’(’))

//将S中左括号“（”以前字符依次弹出并存入数组exp 中

{ Pop(S,ch); exp[j]=ch; j++; }

Push(S,str);

} //end of else if

else if (str==’*’||str==’/’)

{

while((*(S.top-1)==’*’)||(*(S.top-1)==’/’))

{ Pop(S,ch); exp[j]=ch; j++; }

Push(S,str);

} //end of else if

i++;

} //end of while

exp[j]=’#’;

printf(“\n\n输入的算术表达式”);

i=1;

while(str[i+1]!=’#’)

{ printf(“%c”,str);

i++;

} //end of while

printf(“ 逆波兰表达式为：\n”);

i=0;

while(exp!=’#’)

{ printf(“%c”,exp); i++; }
}
void main()
{
Translation();
printf(“\n”);
printf(“…OK…!”)
getch();
}