Cara menggunakan kawalan logik Java

1. Skop blok

Pertama sekali, sebelum mempelajari struktur kawalan secara mendalam, anda perlu memahami konsep blok (blok).

blok: pernyataan majmuk, yang merujuk kepada beberapa pernyataan Java ringkas yang disertakan dengan sepasang pendakap. Blok menentukan skop pembolehubah. Satu blok boleh bersarang dalam blok lain.

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

Dalam kod ini, bahagian yang disertakan dengan kurungan dalam fungsi utama kami ialah blok. Blok boleh bersarang dalam blok lain, tetapi ambil perhatian bahawa dalam Java, pembolehubah dengan nama yang sama tidak boleh diisytiharkan dalam blok bersarang Contohnya, int n = 20 dalam blok dalaman kod di atas adalah salah. Di sini kita perlu membezakan antara pembolehubah global dalam C/C++ Apabila menemui pembolehubah tempatan dengan nama yang sama, pembolehubah tempatan akan digunakan terlebih dahulu dan pembolehubah global akan dilindungi Ini tidak dibenarkan di Java (Java tidak mempunyai konsep pembolehubah global. ini hanyalah analogi).

2. Struktur jujukan

Struktur jujukan adalah agak mudah, dan dilaksanakan baris demi baris dalam susunan kod ditulis.

Imej:

3 Struktur cawangan

Imej:

Nota: jika /else if ialah perhubungan selari, tidak seperti if else ialah perhubungan sama ada-atau, ini dipanggil struktur berbilang cawangan.

Beberapa perkara yang perlu diperhatikan tentang struktur cawangan:

1 Ungkapan dalam kurungan if hanya boleh menjadi ungkapan Boolean, dan 0 bermakna palsu.

2. Kami mengesyorkan gaya hujung baris untuk gaya pengekodan dalam Java.

3. Masalah hang else, maksudnya, sebaiknya tambahkan tanda kurung pada pernyataan if/else, supaya kod tersebut lebih mudah dibaca, apabila terdapat banyak pernyataan if/else , else mesti sepadan dengan lain terdekat

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

masalah penyataan suis (titik utama)

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

Nota:

1, tidak kira di mana kedudukan lalainya, selagi ada tiada padanan Dalam apa jua keadaan, lalai akan digunakan secara langsung.

2. Setiap penyataan kes dan penyataan putus selepas penyataan lalai tidak boleh ditinggalkan, jika tidak ia akan dilaksanakan melainkan dalam keadaan tertentu, pemecahan tidak boleh ditinggalkan.

3 Satu-satunya kata kunci dalam struktur suis ialah huruf besar, putus dan teruskan, yang digunakan dalam gelung Ini ialah struktur cawangan, jadi jangan keliru.

4. Jenis data dalam kurungan suis hanya boleh menjadi bait, pendek, int, aksara, String, jenis enum, dan kemudian pemalar selepas kes sepadan dengan suis. (Perhatikan bahawa ia tidak boleh panjang, kerana integer akan ditukar kepada int, tetapi menukar panjang kepada int akan menyebabkan kehilangan ketepatan).

5. Nilai tetap selepas kes tidak boleh diulang.

6. Ungkapan boleh diletakkan dalam kurungan suis, tetapi tidak seperti jika beberapa ungkapan yang lebih kompleks boleh diletakkan.

7. Pernyataan suis boleh bersarang, tetapi ia tidak kelihatan baik.

Empat, Gelung

Tiga gelung utama: gelung sambil, untuk gelung, lakukan gelung sambil (takrif asas khusus gelung tidak akan diperkenalkan, berikut adalah beberapa perkara yang perlu diberi perhatian)

4.1, titik ralat mudah

1, beberapa bahagian gelung, definisi pembolehubah gelung, pertimbangan bersyarat, badan gelung, lelaran pembolehubah gelung. Pastikan anda memberi perhatian kepada lelaran pembolehubah gelung Jika pembolehubah gelung tidak berulang sehingga ia bergerak ke arah melompat keluar dari gelung, ia boleh menyebabkan gelung tak terhingga.

2. Jangan manipulasi pembolehubah gelung di dalam gelung Walaupun anda perlu menggunakan pembolehubah gelung anda, gunakan pembolehubah sementara untuk menerima nilainya dan kemudian gunakannya.

3 Jangan gunakan nombor titik terapung sebagai pembolehubah gelung dengan mudah.

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

Seperti yang dijangkakan, kod ini bergelung tanpa henti, itulah yang saya maksudkan dengan menggunakan nombor titik terapung sebagai pembolehubah gelung. Kerana apabila 0.1 disimpan, bahagian perpuluhan tidak boleh dinyatakan dengan tepat dalam binari, jadi setiap kali kita menambahnya, ia adalah nilai anggaran Kemudian 10 hanya boleh dilangkau selepas menambah, jadi gelung diteruskan.

4.2, pernyataan putus

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

Tangkapan skrin program berjalan:

Fungsi pernyataan putus adalah untuk melompat keluar dari gelung ia berada dalam, seperti apabila ia berada di atas Apabila i == 2, gelung while akan dilonjak keluar, jadi hanya satu hehe akan menjadi output.

Penggunaan rehat lanjutan:

Di Jawa, tidak ada pernyataan goto, tetapi kerana pereka percaya bahawa idea pernyataan goto tidak bermasalah, ia sememangnya boleh berfungsi di bawah spesifik tertentu. keadaan. Ia mempunyai kesan yang sangat baik untuk melompat keluar dari gelung, jadi pernyataan putus berlabel dicipta di Jawa, yang boleh pecah di luar gelung yang ditentukan oleh label. (Asalkan tag adalah pengecam yang sah)**

Contoh:

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("已跳出循环!");
    }
}

Skrin skrin program berjalan:

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

Atas ialah kandungan terperinci Cara menggunakan kawalan logik Java. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!