Comment utiliser le contrôle logique Java

1. Portée du bloc

Tout d'abord, avant d'apprendre la structure de contrôle en profondeur, vous devez comprendre le concept de bloc (bloc).

Bloc : l'instruction composée fait référence à plusieurs instructions Java simples entourées d'une paire d'accolades. Les blocs déterminent la portée des variables. Un bloc peut être imbriqué dans un autre bloc.

public class TestDemo220425 {
    public static void main(String[] args) {
        int n = 10;
        {
            int k = 20;
            int n = 20;
        }
    }
}

Dans ce code, la partie entre parenthèses dans notre fonction principale est le bloc. Un bloc peut être imbriqué dans un autre bloc, mais notez qu'en Java, les variables portant le même nom ne peuvent pas être déclarées dans des blocs imbriqués. Par exemple, int n = 20 dans le bloc interne du code ci-dessus est faux. Ici, nous devons faire la distinction entre les variables globales en C/C++. Lorsque nous rencontrons des variables locales portant le même nom, les variables locales seront utilisées en premier et les variables globales seront protégées. Cela n'est pas autorisé en Java (Java n'a pas de concept de variables globales). c'est juste une analogie).

Deuxième structure séquentielle

La structure séquentielle est relativement simple et est exécutée ligne par ligne dans l'ordre dans lequel le code est écrit.

Illustration :

Trois, structure de branches

Illustration :

Remarque : si /else si est une relation parallèle, contrairement à si else est une relation soit/ou, cela s'appelle une relation multi-branches structure.

Quelques points à noter sur la structure des branches :

1. L'expression entre parenthèses if ne peut être qu'une expression booléenne. Rien d'autre que 0 n'est vrai, et 0 signifie faux.

2. Pour le style de codage en Java, nous recommandons le style de fin de ligne.

3. Le problème du reste suspendu, c'est-à-dire qu'il est préférable d'ajouter des parenthèses à l'instruction if/else, afin que le code soit plus lisible. Sinon, lorsqu'il y a plusieurs instructions if/else, l'instruction else doit être utilisée. être le même que Faire correspondre l'autre le plus proche

public class TeseDemo220424 {
    public static void main(String[] args) {
        int x = 10;
        int y = 10;
        if (x == 10)
            if (y == 10)
                System.out.println("aaa");
        else //这个else其实匹配的是if(y == 10)
            System.out.println("bbb");
    }
}

problème d'instruction de commutation (point clé)

public class TeseDemo220424 {
    public static void main(String[] args) {
        int a = 3;
        switch(a){
            default:
                System.out.println("输入错误!");
                break;
            case 1:
                System.out.println(1);
                break;
            case 2:
                System.out.println(2);
                break;
        }
    }
}

Remarque :

1. Peu importe où se trouve la valeur par défaut, tant qu'aucun cas ne correspond, la valeur par défaut sera utilisée directement.

2. Chaque instruction case et l'instruction break après l'instruction par défaut ne peuvent pas être omises, sinon elles seront exécutées. Sauf dans une situation spécifique, l'instruction break ne peut pas être omise.

3. Les seuls mots-clés dans la structure switch sont case, break et continue, qui sont utilisés dans les boucles. Il s'agit d'une structure de branche, alors ne vous y trompez pas.

4. Le type de données entre parenthèses de commutateur ne peut être que de type octet, short, int, char, String, enum, puis la constante après la casse correspond au commutateur. (Notez qu'il ne peut pas être long, car les entiers seront convertis en int, mais la conversion de long en int entraînera une perte de précision).

5. La valeur constante après le cas ne peut pas être répétée. Chaque cas représente une situation différente.

6. Les expressions peuvent être placées entre parenthèses de switch, mais pas comme les instructions if. Certaines expressions plus complexes peuvent être placées.

7. Les instructions Switch peuvent être imbriquées, mais elles ne semblent pas bonnes.

Quatre boucles

Trois boucles principales : boucle while, boucle for, boucle do while (la définition de base spécifique de la boucle ne sera pas présentée, voici juste quelques points auxquels il faut prêter attention)

4.1, facile de faire des erreurs

1. Plusieurs parties de la boucle, la définition des variables de boucle, le jugement conditionnel, le corps de la boucle et l'itération des variables de boucle. Assurez-vous de faire attention à l'itération des variables de boucle. Si une variable de boucle n'itère pas jusqu'à ce qu'elle se déplace dans le sens de sortir de la boucle, cela peut provoquer une boucle infinie.

2. Ne manipulez pas les variables de boucle à l'intérieur de la boucle. Même si vous devez utiliser votre variable de boucle, utilisez une variable temporaire pour recevoir sa valeur, puis utilisez-la.

3. N'utilisez pas facilement des nombres à virgule flottante comme variables de boucle.

public class TestDemo220425 {
    public static void main(String[] args) {
        for(double x = 0;x != 10;x += 0.1){
            System.out.println("haha");
        }
    }
}

Comme prévu, ce code est dans une boucle infinie, c'est ce que j'entends par utiliser des nombres à virgule flottante comme variables de boucle. Parce que lorsque 0,1 est stocké, la partie décimale ne peut pas être exprimée avec précision en binaire, donc chaque fois que nous l'ajoutons, c'est une valeur approximative. Ensuite, 10 peut simplement être ignoré après l'ajout, donc la boucle continue.

4.2, instruction break

public class TeseDemo220424 {
    public static void main(String[] args) {
        int i = 1;
        while(i <= 10){
            if(i == 2){
                break;
            }
            System.out.println("hehe");
            i++;
        }
    }
}

Capture d'écran du programme en cours d'exécution :

La fonction de l'instruction break est de sortir de la boucle dans laquelle elle se trouve. Par exemple, lorsque i == 2 ci-dessus, elle sortira de la boucle while, donc une seule sera sortie Hehe.

Utilisation étendue de break :

En Java, il n'y a pas d'instruction goto, mais comme le concepteur estime que l'idée de l'instruction goto n'est pas problématique, elle peut en effet avoir un bon effet de sortir de la boucle sous certains conditions spécifiques. , donc l'instruction labeled break a été inventée en Java, qui peut sortir de la boucle spécifiée par l'étiquette. (Tant que le tag est un identifiant légal)**

Exemple :

public class TestDemo220425 {
    public static void main(String[] args) {
        label1:
        while(true){
            for(int i = 0;i < 10;i++){
                if(i == 3){
                    break label1;
                }
                System.out.println(i);
            }
        }
        System.out.println("已跳出循环!");
    }
}

Capture d'écran du programme en cours d'exécution :

可以看到，到我们利用标签后，可以指定跳出到哪里。如果这里只是用break，不用标签的话，那么break就只会跳出里层的for循环，外面的while还是一个死循环，用了标签之后，当i== 3，就可以直接跳出到while循环的外部。

4.3，continue语句

public class TeseDemo220424 {
    public static void main(String[] args) {
        int i = 1;
        while(i <= 10){
            if(i == 2){
                continue;
            }
            System.out.println("hehe");
            i++;
        }
    }
}

程序运行截图：

continue语句的作用是结束本轮循环而开始下一次的循环，如上题，当i == 2,所以就会直接跳过后面的语句，也就是i++不会执行了，导致i一直等于2，所以陷入了死循环。当然如果你这里用for循环就不会这样了，因为i++的执行顺序在前面，continue影响不到

continue扩展用法：

同样的，在continue里面，也是可以使用标签的，可以指定跳到与标签匹配的循环的首部。

示例：

public class TestDemo220425 {
    public static void main(String[] args) {
        label1:
        for(int i = 0;i < 10;i++){
            if(i == 3){
                continue label1;
            }
            System.out.println(i);
        }
}

程序运行截图：

五，输入输出

5.1，输出到控制台

利用%结合上面的转换符就可以进行格式化的输出，当然在进行格式化输出的时候，也可以运用一些标志，比如输出的时候带前缀，带正负号等等…

5.2，从键盘输入

public class TeseDemo220424 {
    public static void main(String[] args) {
        Scanner myscanner = new Scanner(System.in);
        System.out.println("请输入年龄");
        int num = myscanner.nextInt();
        System.out.println(num);
        System.out.println("请输入名字");
        String str = myscanner.nextLine();//读入一行
        System.out.println(str);
        System.out.println("请输入专业");
        String str1 = myscanner.next();
        System.out.println(str1);//读入一个字符串，遇到空格停止
    }
}

这里就是要注意你的输入与你接收的方法要对应，另外就是当你用了nextLine()来接收一行的时候，要注意它前面有不有用输入的方法，因为你的换行会被当成一行读入到nextLine()里面，这里就类似于C语言里面吃掉缓冲区里面的回车是一个道理。

程序运行截图：

扩展，在用键盘进行输入的时候，我们是能够看到我们自己的输入的，但是在某些情况下，比如输入密码，我们一般是不想让人看到的，所以这里可以运用到Console类。(这里只做简要介绍)

Console类：访问与当前Java虚拟机关联的基于字符的控制台设备（如果有的话）的方法，也即使从控制台接收输入的方法。

使用示例：

import java.io.Console;
public class TestDemo220425 {
    public static void main(String[] args) {
        Console cons = System.console();
        String username = cons.readLine("User name: ");
        char[] passwd = cons.readPassword("Password:");
    }
}

在IDEA下的运行截图：

❌？？？怎么直接报空指针异常了，寻思着这里也没用到指针吧，感到十分的不解…????????

后来，度娘告诉我是这样的：在使用IDEA等集成开发环境中，使用Console将全为null，表示Java程序无法获得Console实例，是因为JVM不是在命令行中被调用的，或者输入输出被重定向了。以至于我们只能去控制台下或者linux环境下去运行程序，如下图在控制台下运行：

可以看到在控制台下运行正常，并且我们输入的密码是看不到的(这里真的输入了的哦，只是看不到，中国人不骗中国人的！????)

5.3，循环输入

public class TeseDemo220424 {
    public static void main(String[] args) {
        Scanner myscanner1 = new Scanner(System.in);
        while(myscanner1.hasNextInt()){
            int age = myscanner1.nextInt();
        }
    }
}

hasNextInt()：如果此扫描器输入中的下一个标记可以使用nextInt()方法将其解释为默认基数中的int值，则返回true。也即是说只有你下一个输入的是int类型的值才能够进入循环。

程序运行截图：

循环输入的时候可以ctrl + D 进行正常退出

六，猜数字游戏

这里主要是介绍Java里面的生成随机数的方法

所在包：Java.util.random

import java.util.Random;
public class TeseDemo220424 {
    public static void main(String[] args) {
//        生成随机数
        Random random = new Random();
        int rannum = random.nextInt(100);//生成[0,100) 的随机数 其他范围可以通过在后面加上数来进行范围改变，默认左边都是从0开始
        
    }
}

对于int rannum = random.nextInt();如果你后面nextInt()中不给值，那么它产生的就是所有有效的整数，包括正数，负数，0

注意：Random random = new Random(2022); 这里在定义随机数对象的时候是可以传参的，因为生成随机数是以时间戳为参考的，所以当你传入一个数后，他就只会以这个数为标准进行时间戳的计算，进而产生的随机数每次都是一样的。

其他方法：

其他方法主要就是Math.random(),这个产生的是0~1之间的小数，左闭右开。当然这个是没有上面那种产生同一个随机数的用法的。

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!