Conteúdo de hoje
if else判断语句
switch选择语句
for循环语句
while循环语句
do while循环语句
跳出语句break，continue
objetivos de ensino
理解if语句的格式和执行流程
理解if...else语句的格式和执行流程
理解if...else if语句的格式和执行流程
了解if语句和三元运算符互换
理解switch选择语句的格式和执行流程
了解switch选择语句接收的数据类型
了解case的穿透性
理解while语句的格式和执行流程
理解for语句的格式和执行流程
理解do...while语句的格式和执行流程
了解do...while循环的特点
了解跳出语句break，continue的意义
理解嵌套for循环的执行流程
Capítulo Um Controle de Processo
1. 1 Visão geral
Durante a execução de um programa, a ordem de execução de cada instrução tem um impacto direto no resultado do programa. Em outras palavras, o fluxo do programa é
Tem um impacto direto. Portanto, devemos ter clareza sobre o fluxo de execução de cada instrução. Além disso, muitas vezes temos que controlar a ordem de execução das instruções para alcançar
A função que desejamos concluir.
1. 2 Estrutura de sequência
Declaração de julgamento do capítulo dois
2. 1 Declaração de julgamento 1 - se
if语句第一种格式： if
Processo de implementação
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体
如果是false就不执行语句体
public static void main(String[] args){
//顺序执行，根据编写的顺序，从上到下运行
System.out.println( 1 );
System.out.println( 2 );
System.out.println( 3 );
}
if(关系表达式)｛
语句体;
｝
public static void main(String[] args){
System.out.println("开始");
// 定义两个变量
2. 2 Declaração de julgamento 2 - se ... mais
if语句第二种格式： if...else
Processo de implementação
首先判断关系表达式看其结果是true还是false
如果是true就执行语句体 1
如果是false就执行语句体 2
int a = 10 ;
int b = 20 ;
//变量使用if判断
if (a == b){
System.out.println("a等于b");
}
int c = 10 ;
if(a == c){
System.out.println("a等于c");
}
System.out.println("结束");
｝
if(关系表达式) {
语句体 1 ;
}else {
语句体 2 ;
}
2. 3 Declaração de julgamento 3 - if ... else if ... else
if语句第三种格式： if...else if ...else
Processo de implementação
首先判断关系表达式 1 看其结果是true还是false
如果是true就执行语句体 1
如果是false就继续判断关系表达式 2 看其结果是true还是false
如果是true就执行语句体 2
如果是false就继续判断关系表达式...看其结果是true还是false
...
如果没有任何关系表达式为true，就执行语句体n+ 1 。
public static void main(String[] args){
// 判断给定的数据是奇数还是偶数
// 定义变量
int a = 1 ;
if(a % 2 == 0 ) {
System.out.println("a是偶数");
} else{
System.out.println("a是奇数");
}
System.out.println("结束");
}
if (判断条件 1 ) {
执行语句 1 ;
} else if (判断条件 2 ) {
执行语句 2 ;
}
...
}else if (判断条件n) {
执行语句n;
} else {
执行语句n+ 1 ;
}
2. prática de 4 frases
public static void main(String[] args) {
// x和y的关系满足如下：
// x>= 3 y = 2 x + 1 ;
//‐ 1 <=x< 3 y = 2 x;
// x<=‐ 1 y = 2 x – 1 ;
// 根据给定的x的值，计算出y的值并输出。
// 定义变量
int x = 5 ;
int y;
if (x>= 3 ) {
y = 2 * x + 1 ;
} else if (x >= ‐ 1 && x < 3 ) {
y = 2 * x;
} else {
y = 2 * x ‐ 1 ;
}
System.out.println("y的值是："+y);
}
Especifique as pontuações dos testes para determinar o nível do aluno
90-100 excelente
80-89 bom
70-79 bom
60-69 passe
Falha abaixo de 60
2. 5 intercâmbio de instrução if e operador ternário
Em alguns aplicativos simples, a instrução if pode ser usada alternadamente com o operador ternário.
Capítulo 3 Selecione a declaração
3. 1 chave de instrução de seleção
switch语句格式：
public static void main(String[] args) {
int score = 100 ;
if(score< 0 || score> 100 ){
System.out.println("你的成绩是错误的");
}else if(score>= 90 && score<= 100 ){
System.out.println("你的成绩属于优秀");
}else if(score>= 80 && score< 90 ){
System.out.println("你的成绩属于好");
}else if(score>= 70 && score< 80 ){
System.out.println("你的成绩属于良");
}else if(score>= 60 && score< 70 ){
System.out.println("你的成绩属于及格");
}else {
System.out.println("你的成绩属于不及格");
}
}}
public static void main(String[] args) {
int a = 10 ;
int b = 20 ;
//定义变量，保存a和b的较大值
int c;
if(a > b) {
c = a;
} else {
c = b;
}
//可以上述功能改写为三元运算符形式
c = a > b? a:b;
}
Processo de implementação
Primeiro calcule o valor da expressão
其次，和case依次比较，一旦有对应的值，就会执行相应的语句，在执行的过程中，遇到break就会结
束。
最后，如果所有的case都和表达式的值不匹配，就会执行default语句体部分，然后程序结束掉。
switch (expressão) { valor constante do caso 1: corpo da instrução 1; quebra; valor constante do caso 2: corpo da instrução 2; quebra; ... padrão: corpo da instrução n + 1; quebra; }
public static void main (String [] args) { // Definir a variável e determinar o dia da semana int weekday = 6; // switch switch de seleção de implementação de instrução (dia da semana) { case 1: System.out.println ("Monday") ; break; case 2: System.out.println ("Tuesday"); break; case 3:
Na instrução switch, o tipo de dados da expressão pode ser byte, short, int, char, enum (enumeração). As strings podem ser recebidas após o JDK 7.
3. 2 penetração da caixa
Na instrução switch, se a quebra não for escrita após o caso, ocorrerá um fenômeno de penetração, ou seja, o valor do próximo caso não será julgado e será executado para trás
até encontrar uma quebra ou o switch geral terminar.
No programa acima, após a execução do caso 5, por não haver
o comando break, o programa sempre voltará para trás, não julgará o caso nem prestará atenção no break e executará a chave completa diretamente .
Por causa da natureza penetrante do caso, os iniciantes devem escrever uma pausa ao escrever declarações switch.
Capítulo 4 Declaração de Loop
4. 1 Visão geral do ciclo
System.out.println("星期三");
break;
case 4 :
System.out.println("星期四");
break;
case 5 :
System.out.println("星期五");
break;
case 6 :
System.out.println("星期六");
break;
case 7 :
System.out.println("星期日");
break;
default:
System.out.println("你输入的数字有误");
break;
}
}
public static void main(String[] args) {
int i = 5 ;
switch (i){
case 0 :
System.out.println("执行case 0 ");
break;
case 5 :
System.out.println("执行case 5 ");
case 10 :
System.out.println("执行case 10 ");
default:
System.out.println("执行default");
}
}
Uma instrução de loop pode executar um determinado trecho de código repetidamente quando as condições de loop são atendidas.O código que é executado repetidamente é chamado de instrução de corpo de loop.
Ao executar o corpo deste loop, é necessário modificar a condição de julgamento do loop para false quando apropriado para encerrar o loop, caso contrário, o loop continuará a ser executado,
formando um loop infinito.
4. 2 declaração de loop 1 - para
for循环语句格式：
Processo de implementação
Sequência de execução: ①②③④> ②③④> ②③④… ②Não satisfeito.
①Responsável por completar a inicialização das variáveis de loop
②Responsável por julgar se as condições do ciclo são atendidas e, se não forem atendidas, eles sairão do ciclo
③ A instrução de execução específica
④ Após o loop, as mudanças das variáveis envolvidas nas condições do loop
for(初始化表达式①; 布尔表达式②; 步进表达式④){
循环体③
}
public static void main(String[] args) {
//控制台输出 10 次HelloWorld，不使用循环
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
Exercício de loop: use loops para calcular a soma de números pares entre 1-100
4. 3 declaração de loop 2 - enquanto
while循环语句格式：
Processo de implementação
Sequência de execução: ①②③④> ②③④> ②③④… ②Não satisfeito.
①Responsável por completar a inicialização das variáveis do laço.
②Responsável por julgar se as condições do ciclo são atendidas e, se não forem atendidas, sairão do ciclo.
③ A instrução de execução específica.
④Após o loop, a alteração das variáveis do loop.
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("HelloWorld");
System.out.println("‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐‐");
//用循环改进，循环 10 次
//定义变量从 0 开始，循环条件为< 10
for(int x = 0 ; x < 10 ; x++) {
System.out.println("HelloWorld"+x);
}
}
public static void main(String[] args) {
// 1 .定义一个初始化变量,记录累加求和,初始值为 0
int sum = 0 ;
// 2 .利用for循环获取 1 ‐ 100 之间的数字
for (int i = 1 ; i <= 100 ; i++) {
// 3 .判断获取的数组是奇数还是偶数
if(i % 2 == 0 ){
// 4 .如果是偶数就累加求和
sum += i;
}
}
// 5 .循环结束之后,打印累加结果
System.out.println("sum:"+sum);
}
Expressão de inicialização①
while(布尔表达式②){
循环体③
步进表达式④
}
O loop while exibe HelloWorld 10 vezes
O loop while calcula a soma entre 1-100
public static void main(String[] args) {
//while循环实现打印 10 次HelloWorld
//定义初始化变量
int i = 1 ;
//循环条件<= 10
while(i<= 10 ){
System.out.println("HelloWorld");
//步进
i++;
}
}
public static void main(String[] args) {
//使用while循环实现
//定义一个变量,记录累加求和
int sum = 0 ;
//定义初始化表达式
int i = 1 ;
//使用while循环让初始化表达式的值变化
while(i<= 100 ){
//累加求和
sum += i ;
//步进表达式改变变量的值
i++;
4. 4 Declaração de loop 3 - faça ... enquanto
do...while循环格式
Processo de implementação
Sequência de execução: ①③④> ②③④> ②③④… ②Não satisfeito.
①Responsável por completar a inicialização das variáveis do laço.
②Responsável por julgar se as condições do ciclo são atendidas e, se não forem atendidas, sairão do ciclo.
③ A instrução de execução específica
④ Após o loop, a mudança das variáveis do loop
}
// Imprime a variável somada
System.out.println(" 1 ‐ 100 的和是："+sum);
}
Expressão de inicialização①
do{
循环体③
步进表达式④
}while(布尔表达式②);
Imprimir HelloWorld 10 vezes
As características do loop do ... while: incondicionalmente executar o corpo do loop uma vez, mesmo se escrevermos a condição do loop diretamente como falsa, ele ainda executará o loop uma vez. Esse tipo de
loop tem um certo risco, portanto, não é recomendado que iniciantes usem o loop do ... while.
4. 5 A diferença entre as instruções de loop
public static void main(String[] args) {
int x= 1 ;
do {
System.out.println("HelloWorld");
x++;
}while(x<= 10 );
}
public static void main(String[] args){
do{
System.out.println("无条件执行一次");
}while(false);
}
4. 5 A diferença entre as instruções de loop
for 和 while 的小区别：
控制条件语句所控制的那个变量，在for循环结束后，就不能再被访问到了，而while循环结束还可以继
续使用，如果你想继续使用，就用while，否则推荐使用for。原因是for循环结束，该变量就从内存中消
失，能够提高内存的使用效率。
在已知循环次数的时候使用推荐使用for，循环次数未知的时推荐使用while。
4. 6 Salte para fora da frase
pausa
使用场景：终止switch或者循环
在选择结构switch语句中
在循环语句中
离开使用场景的存在是没有意义的
continuar
Cenário de uso: terminar este ciclo e continuar para o próximo ciclo
Capítulo 5 Expandindo Pontos de Conhecimento
5. 1 loop infinito
死循环：也就是循环中的条件永远为true，死循环的是永不结束的循环。例如：while(true){}。
public static void main(String[] args) {
for (int i = 1 ; i<= 10 ; i++) {
//需求:打印完两次HelloWorld之后结束循环
if(i == 3 ){
break;
}
System.out.println("HelloWorld"+i);
}
}
public static void main(String[] args) {
for (int i = 1 ; i <= 10 ; i++) {
//需求:不打印第三次HelloWorld
if(i == 3 ){
continue;
}
System.out.println("HelloWorld"+i);
}
}
No desenvolvimento posterior, haverá cenas que usam loops infinitos. Por exemplo, precisamos ler a entrada de entrada do usuário, mas quantos dados o usuário insere, não
Não sei, só posso usar o loop infinito. Quando o usuário não quiser inserir dados, ele pode encerrar o loop. Como encerrar um loop infinito?
É hora de pular fora da frase.
5.2 Loop aninhado
所谓嵌套循环，是指一个循环的循环体是另一个循环。比如for循环里面还有一个for循环，就是嵌套循环。总
共的循环次数=外循环次数*内循环次数
嵌套循环格式：
Processo de execução de loop aninhado:
Sequência de execução: ①②③④⑤⑥> ④⑤⑥> ⑦②③④⑤⑥> ④⑤⑥
O loop externo é uma vez e o loop interno muitas vezes.
Por exemplo, pular corda: existem 5 grupos de saltos, 10 saltos em cada grupo. Cinco grupos são loops externos e 10 são loops internos.
Exercício: Use loops aninhados para imprimir um retângulo 5 * 8
for(初始化表达式①; 循环条件②; 步进表达式⑦) {
for(初始化表达式③; 循环条件④; 步进表达式⑥) {
执行语句⑤;
}
}
public static void main(String[] args) {
// 5 * 8 的矩形，打印 5 行*号，每行 8 个
//外循环 5 次，内循环 8 次
for(int i = 0 ; i < 5 ; i++){
for(int j = 0 ; j < 8 ; j++){
//不换行打印星号
System.out.print("*");
}
//内循环打印 8 个星号后，需要一次换行
System.out.println();
}
｝