So verwenden Sie die Java-Logiksteuerung

1. Blockumfang

Bevor Sie die Kontrollstruktur eingehend erlernen, müssen Sie zunächst das Konzept verstehen von Block (Block) .

Block: Zusammengesetzte Anweisung bezieht sich auf mehrere einfache Java-Anweisungen, die in geschweifte Klammern eingeschlossen sind. Blöcke bestimmen den Umfang von Variablen. Ein Block kann in einem anderen Block verschachtelt sein.

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

In diesem Code ist der in Klammern eingeschlossene Teil unserer Hauptfunktion der Block. Ein Block kann in einem anderen Block verschachtelt sein. Beachten Sie jedoch, dass in Java Variablen mit demselben Namen nicht in verschachtelten Blöcken deklariert werden können. Beispielsweise ist int n = 20 im inneren Block des obigen Codes falsch. Hier müssen wir zwischen globalen Variablen in C/C++ unterscheiden. Wenn wir auf lokale Variablen mit demselben Namen stoßen, werden zuerst lokale Variablen verwendet und globale Variablen abgeschirmt. Dies ist in Java nicht zulässig (Java hat kein Konzept für globale Variablen). das ist nur eine Analogie).

2. Sequentielle Struktur

Die sequentielle Struktur ist relativ einfach und wird Zeile für Zeile in der Reihenfolge ausgeführt, in der der Code geschrieben wird.

Bild:

Drittens, Zweigstruktur

Bild:

#🎜 🎜#

Hinweis: Wenn /else if eine parallele Beziehung ist, wird dies im Gegensatz zu else eine Entweder-Oder-Beziehung als mehrfach verzweigte Struktur bezeichnet.

Ein paar Punkte, die Sie zur Zweigstruktur beachten sollten:

1 Der Ausdruck in den if-Klammern kann nur ein boolescher Ausdruck sein, außer 0 ist wahr und 0 bedeutet falsch.

2, für den Codestil in Java empfehlen wir den Zeilenendestil.

3, das baumelnde else-Problem, das heißt, es ist am besten, der if/else-Anweisung Klammern hinzuzufügen, damit der Code besser lesbar ist. Wenn nicht, gibt es mehrere if/. else-Anweisungen. Wann, else muss mit der nächstgelegenen else-Anweisung übereinstimmen default Wo auch immer sich die Position befindet, solange keine Groß-/Kleinschreibung übereinstimmt, wird default direkt verwendet.

2. Jede case-Anweisung und die break-Anweisung nach der default-Anweisung können nicht weggelassen werden, da sie sonst ausgeführt werden. Sofern dies nicht der Fall ist, kann die break-Anweisung nicht weggelassen werden.

3. Die einzigen Schlüsselwörter in der Schalterstruktur sind case, break und continue, die in Schleifen verwendet werden, also lassen Sie sich nicht verwirren.

4. Der Datentyp in den Schalterklammern kann nur Byte, Short, Int, Char, String, Enum sein, und die Konstante, nachdem die Groß- und Kleinschreibung mit dem Schalter übereinstimmt. (Beachten Sie, dass es nicht lang sein darf, da die Ganzzahl in int konvertiert wird. Die Konvertierung von long in int führt jedoch zu einem Präzisionsverlust.)

5. Der konstante Wert nach dem Fall kann nicht wiederholt werden. Jeder Fall repräsentiert eine andere Situation.

6. Ausdrücke können in die Klammern von switch eingefügt werden, jedoch nicht wie if-Anweisungen.

7, Switch-Anweisungen können verschachtelt werden, sehen aber nicht gut aus.

Vier, Schleife

Drei Hauptschleifen: while-Schleife, for-Schleife, do while-Schleife (die spezifische Grunddefinition der Schleife wird nicht vorgestellt, hier sind nur einige Punkte auf Punkte achten)

4.1, fehleranfällige Punkte

1, mehrere Teile der Schleife, Definition von Schleifenvariablen, bedingte Beurteilung, Schleifenkörper, Iteration der Schleife Variablen. Achten Sie unbedingt auf die Iteration von Schleifenvariablen. Wenn eine Schleifenvariable nicht iteriert, bis sie sich in die Richtung bewegt, in der sie aus der Schleife herausspringt, kann dies zu einer Endlosschleife führen.

2. Manipulieren Sie keine Schleifenvariablen innerhalb der Schleife. Auch wenn Sie Ihre Schleifenvariable verwenden müssen, verwenden Sie eine temporäre Variable, um ihren Wert zu erhalten, bevor Sie sie verwenden.

3, verwenden Sie Gleitkommazahlen nicht so einfach als Schleifenvariablen.

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");
    }
}

Wie erwartet durchläuft dieser Code eine Endlosschleife, was ich mit der Verwendung von Gleitkommazahlen als Schleifenvariablen meine. Denn wenn 0,1 gespeichert wird, kann der Dezimalteil nicht genau binär ausgedrückt werden, sodass es sich bei jeder Addition um einen ungefähren Wert handelt. Dann kann 10 nach der Addition einfach übersprungen werden, sodass die Schleife fortgesetzt wird.

4.2, break-Anweisung

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;
        }
    }
}

Screenshot des laufenden Programms:

Die Funktion des Die Break-Anweisung ist, aus der Schleife herauszuspringen, in der sie sich befindet. Wenn beispielsweise i == 2 oben ist, springt sie aus der While-Schleife, sodass nur ein Hehe ausgegeben wird.

Erweiterte Verwendung von break:

In Java gibt es keine goto-Anweisung, aber weil der Designer glaubt, dass die Idee der goto-Anweisung unter bestimmten Bedingungen immer noch kein Problem darstellt Bedingungen können in der Tat einen sehr guten Effekt auf das Herausspringen aus der Schleife haben. Daher wurde in Java die beschriftete Break-Anweisung erfunden, die außerhalb der durch die Beschriftung angegebenen Schleife brechen kann. (Solange es sich bei dem Tag um eine gültige Kennung handelt) ​​**

Beispiel:

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

Screenshot des laufenden Programms:

#🎜🎜 ##🎜 🎜#

可以看到，到我们利用标签后，可以指定跳出到哪里。如果这里只是用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之间的小数，左闭右开。当然这个是没有上面那种产生同一个随机数的用法的。

Das obige ist der detaillierte Inhalt vonSo verwenden Sie die Java-Logiksteuerung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!