Scanner 控制语句 方法 递归

1.键盘输入Scanner
从键盘输入信息并保存需要如下几步:
 
第一步:在程序开头输
“import java.util.Scanner;”,
表示导入键盘输入功能,系统已经写好了,只需要拿到程序中使用就可以了;
 
第二步:在程序执行体中输入:

“Scanner input =new Scanner(System.in);”;
第三步:
表示输入功能初始化,
如果要接受一个整型的数据就要定义一个整型的变量来接收,
如:
“int num1=input.nextInt();”,
如果是其他类型的变量,则“=input.next***();”中的***也要改成相应的类型,如
“double num3=input.nextDouble);”等。
其中nextString()不用,直接用next()代表接受String类型
即
“String num4=input.next();”


 
 
2.控制语句
程序分三种逻辑:顺序,分支,循环
clipboard.png
选择结构:
1.if分支结构
语法:
*.if(判断句)
      { 语句a;}
 
*.if(判断句)
      { 语句a;}
else
       {语句b;}
 
*.if(判断句)
       {语句a;}
else if(判断句)
       {语句b;}
......
else(判断句)
       {语句c;}
 
2.switch分支语句
利用if...else可以实现多条件的验证,而switch只能进行多数值的判  断,而且switch支持的判断数据类型(一直在发展):
*最初:  int
*JDK1.5:枚举
*JDK1.7:String
 
语法:
switch (表达式){
case 值1 :
语句1 break;
case 值2 :
 语句2 break;
...
default :
 语句n break;
}  
循环结构:
1. while循环
语法:
while(boolean表达式){
java语句;
 
2.do...while循环
语法:
do{
java语句;
}while(boolean表达式);
  
2.for循环
语法:
for(表达式1;表达式2;表达式3){
java语句;
};
表达式1:初始表达式,表达式2;boolean表达式,表达式3:增量表达式
  
跳转结构:
1.return;
2.continue;
3.break;
 
3.方法(Method)
Java方法是组合在一起来执行操作语句的集合。
方法定义包括方法头和方法体。下面是一个方法的所有部分:
l   修饰符
l   返回类型
l   方法名称
l   参数
l   方法体
 
 
4.递归
递归问题,可以划分为一个或多个子问题,而处理子问题的规则与处理原问题的规则是一样的。
在设计递归算法时,主要需考虑以下 两方面 的问题:
1.确定方法的目的
确定递归公式。 把规模大的、较难解决的问题变成规模较小、易解决的同一问题,需要通过哪些步骤或等式来实现?这是解决递归问题的难点。
确定边界(终了)条件。 在什么情况下可以直接得出问题的解?这就是问题的边界条件及边界值。
  • 1
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
递归下降分析是一种自顶向下的语法分析方法,它可以用来构建 LL(1) 语法分析器。下面是一个简单的 Java 实现,用于分析 PL/0 语法: ```java import java.util.*; public class Parser { private final Scanner scanner; private Token lookahead; public Parser(Scanner scanner) { this.scanner = scanner; lookahead = scanner.nextToken(); } private void match(TokenType expected) { if (lookahead.getType() == expected) { lookahead = scanner.nextToken(); } else { throw new RuntimeException("Syntax error: expected " + expected + ", found " + lookahead.getType()); } } public void parse() { program(); match(TokenType.EOF); } private void program() { block(); } private void block() { match(TokenType.BEGIN); statement(); while (lookahead.getType() == TokenType.SEMICOLON) { match(TokenType.SEMICOLON); statement(); } match(TokenType.END); } private void statement() { if (lookahead.getType() == TokenType.IDENTIFIER) { match(TokenType.IDENTIFIER); match(TokenType.ASSIGN); expression(); } else if (lookahead.getType() == TokenType.IF) { match(TokenType.IF); condition(); match(TokenType.THEN); statement(); if (lookahead.getType() == TokenType.ELSE) { match(TokenType.ELSE); statement(); } } else if (lookahead.getType() == TokenType.WHILE) { match(TokenType.WHILE); condition(); match(TokenType.DO); statement(); } else if (lookahead.getType() == TokenType.CALL) { match(TokenType.CALL); match(TokenType.IDENTIFIER); } else if (lookahead.getType() == TokenType.BEGIN) { block(); } else { throw new RuntimeException("Syntax error: unexpected token " + lookahead.getType()); } } private void condition() { expression(); if (lookahead.getType() == TokenType.EQUAL || lookahead.getType() == TokenType.NOT_EQUAL || lookahead.getType() == TokenType.LESS_THAN || lookahead.getType() == TokenType.LESS_THAN_OR_EQUAL || lookahead.getType() == TokenType.GREATER_THAN || lookahead.getType() == TokenType.GREATER_THAN_OR_EQUAL) { match(lookahead.getType()); expression(); } else { throw new RuntimeException("Syntax error: expected a relational operator, found " + lookahead.getType()); } } private void expression() { term(); while (lookahead.getType() == TokenType.PLUS || lookahead.getType() == TokenType.MINUS) { match(lookahead.getType()); term(); } } private void term() { factor(); while (lookahead.getType() == TokenType.TIMES || lookahead.getType() == TokenType.SLASH) { match(lookahead.getType()); factor(); } } private void factor() { if (lookahead.getType() == TokenType.IDENTIFIER) { match(TokenType.IDENTIFIER); } else if (lookahead.getType() == TokenType.NUMBER) { match(TokenType.NUMBER); } else if (lookahead.getType() == TokenType.LPAREN) { match(TokenType.LPAREN); expression(); match(TokenType.RPAREN); } else { throw new RuntimeException("Syntax error: expected an identifier, number, or left parenthesis, found " + lookahead.getType()); } } } ``` 在这个实现中,我们使用了 `Scanner` 类来读取 PL/0 源代码并生成 `Token` 流。`Token` 类表示 PL/0 中的一个词法单元,它包含一个 `TokenType` 和一个 `value`。`TokenType` 是一个枚举类型,它包含了所有 PL/0 中可能出现的词法单元类型,例如 `IDENTIFIER`、`NUMBER`、`PLUS`、`MINUS` 等等。 `Parser` 类的构造函数接受一个 `Scanner` 对象作为参数,并初始化 `lookahead` 指针,它指向下一个要分析的 `Token`。`match` 方法用于比较 `lookahead` 和 `expected` 是否相等,如果不相等,则抛出一个语法错误异常。`parse` 方法是语法分析器的入口,它调用 `program` 方法来分析整个 PL/0 程序,并期望最后一个 `Token` 是 `EOF`。 `program` 方法实现了 PL/0 中的 `program` 产生式,它只包含一个 `block`。`block` 方法实现了 `block` 产生式,它包含了多个语句,以 `BEGIN` 开始,以 `END` 结束。`statement` 方法实现了 `statement` 产生式,它包含了多种类型的语句,例如赋值语句、条件语句、循环语句、过程调用语句等等。`condition` 方法实现了 PL/0 中的条件表达式,它包含了一个关系运算符和两个表达式。`expression` 方法实现了 PL/0 中的算术表达式,它包含了加减运算符和多个项。`term` 方法实现了 PL/0 中的项,它包含了乘除运算符和多个因子。`factor` 方法实现了 PL/0 中的因子,它可以是一个标识符、一个数字或一个表达式。 这个实现中最重要的部分是 `match` 方法和各个产生式方法中的 `match` 调用。这些调用用于比较 `lookahead` 和期望的 `Token` 是否相等,并将 `lookahead` 指针向前移动。如果 `Token` 不匹配,则抛出一个语法错误异常。这些 `match` 调用的目的是消除左递归,从而使我们的语法分析器成为递归下降分析器。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值