Java条件执行语句

ikun_文
15 阅读7分钟

Java核心基础之循环break退出和跳过

  • 循环退出

    • break 关键字
    • 跳出当前层的循环体，执行循环体下面的语句
    • 例： 
      for (int i = 0; i < 10; i++) {
    if (i == 5) {
        System.out.println("break：" + i);
        break;
    }
    System.out.println(i);
}

  • 循环跳过

    • continue 关键字
    • 跳过当前循环，执行下一次循环, (忽略当前循环内容，直接执行下一次)
    • 例： 
      for (int i = 0; i < 10; i++) {
    if (i == 5) {
        System.out.println("continue：" + i);
        continue;
    }
    System.out.println(i);
}

  • 注意

    • break和continue都只能用于循环结构（如for、while、do-while）中。
    • break用于完全退出循环，而continue用于跳过当前循环的剩余部分并开始下一次迭代。
    • 如果在嵌套的循环中使用break，它将只退出最内层的循环。
    • continue语句只能在循环体中使用，不能用于跳过循环之前的代码或循环之后的代码。

  • 多种循环的实现方式总结

    • while 循环 
      int i = 0;

while (i < 10) {
    System.out.println(i);
    i++;
}
System.out.println("while循环结束：" + i);
    • do while循环 
      int i = 0;

do {
    System.out.println(i);
    i++;
} while (i < 10);
System.out.println("do while循环结束：" + i);
    • 普通for循环 
      for (int i = 0; i < 10; i++) {
    System.out.println(i);
}
    • 增强for循环 
      int[] arr = {1, 2, 3, 4, 5};
for (int i : arr) {
    System.out.println(i);
}

Java核心基础之If else条件语句

  • If语法

    • if 用于基于某个条件来执行代码块。如果条件为真（即值为 true），则执行 if 语句中的代码块
    • 如果条件为真（即值为 true），则执行 if 语句中的代码块。
    • 语法结构： 
      if (条件) {  
    // 条件为真时执行的代码块  
}

  • if-else 语句

    • if-else 语句用于基于某个条件来执行两个代码块之一。

    • 如果条件为真，执行 if 语句块；如果条件为假，执行 else 语句块。

    • 语法结构：

      if (条件) {  
    // 条件为真时执行的代码块  
} else {  
    // 条件为假时执行的代码块  
}

  • if-else if-else 语句

    • 用于基于多个条件来执行不同的代码块。

    • 会按照条件的顺序进行检查，一旦找到满足的条件，就会执行相应的代码块，并结束整个 if-else 结构。

    • 语法结构：

      if (条件1) {  
    // 条件1为真时执行的代码块  
} else if (条件2) {  
    // 条件1为假且条件2为真时执行的代码块  
} else if (条件3) {  
    // 条件1和条件2都为假且条件3为真时执行的代码块  
    // ... 可以继续添加 else if 语句  
} else {  
    // 所有条件都为假时执行的代码块  
}

  • 注意事项

    • if、else if、else 后面都要跟着大括号 {}，即使只有一行代码也建议加上，增加代码的可读性和维护性。
    • else 语句是可选的，但 if 语句至少要有一个。
    • else if 语句可以有多个，顺序很重要，因为 if-else if-else 结构会按照条件的顺序进行检查。
    • if 语句中的条件必须是一个布尔表达式，即它的值必须是 true 或 false

  • 例：

public class IfDemo {
    public static void main(String[] args) {
        int score = 100;
        if (score == 100) {
            System.out.println("满分");
        } else if (score >= 60) {
            System.out.println("及格");
        } else {
            System.out.println("不及格");
        }
    }
}

Java核心基础之Switch条件分支语句

  • Switch 条件分支语句

    • Switch和if语句都是Java的选择语句，这两种都是允许在程序运行时控制程序的执行过程。
    • 是 Java 中另一种条件分支结构，用于基于一个表达式的值来执行不同的代码块，不同版本JDK差异大
    • switch 语句通常与枚举类型（enum）或基本数据类型（byte、short、char、int）一起使用，也支持字符串（String）类型。
    • 选择问题：如果只是简单的选择语句 if else即可，复杂或者条件超过4个，则用switch语句
    • 旧版语法
      • 每个 case 代码块的末尾通常使用 break 语句来避免执行流继续进入下一个 case。
      • 如果没有 break，即程序会继续执行下一个 case 的代码，直到遇到 break 或 switch 语句结束。
    • 新版语法
      • JDK12，对case增加了另一种写法，使用case C -> { } 代替break语句
      • 使⽤箭头函数，不⽤声明break, 会⾃动终⽌, 如果case语句中只有一条语句，可以省略大括号
      • case 标签-> 与 case 标签：不能混用， 一个 switch 语句块中使用一种语法格式。
      • ⽀持多个值匹配,使⽤逗号分隔
      • JDK13中引入了yield语句，用于返回值
    • 例： 
      public class SwitchDemo {
    public static void main(String[] args) {
        testOldSwitch(4);
        testNewSwitch(4);
    }

    // 旧版语法
    public static void testOldSwitch(int week) {
        switch (week) {
            case 1:
                System.out.println("星期一");
                break;
            case 2:
                System.out.println("星期二");
                break;
            case 3:
                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("错误");
        }
    }

    // 新版语法
    public static void testNewSwitch(int week) {
        String day = switch (week) {
            case 1 -> {
                System.out.println("星期一");
                yield "星期一";
            }
            case 2 -> {
                System.out.println("星期二");
                yield "星期二";
            }
            case 3 -> {
                System.out.println("星期三");
                yield "星期三";
            }
            case 4 -> {
                System.out.println("疯狂星期四");
                yield "疯狂星期四";
            }
            case 5 -> {
                System.out.println("星期五");
                yield "星期五";
            }
            case 6, 7 -> {
                System.out.println("休息");
                yield "休息";
            }
            default -> {
                System.out.println("错误");
                yield "错误";
            }
        };
        System.out.println(day);
    }
}

Java核心基础之static静态代码块和方法

  • static关键字

    • 用于定义类级别的属性和方法，这些属性和方法属于类本身，而不是类的任何特定实例对象
    • static 修饰的方法或变量，优先于对象执行，所以内存有会现有 static修饰的内容，后有对象的内容
    • static关键字有两个主要的应用场景
      • 静态变量（也称为类变量）
      • 静态方法（也称为类方法）
      • 还有一个重要的概念是静态代码块（也称为静态初始化块）
    • 修饰变量就是类变量，修饰方法就是类方法
    • 类变量或者类方法，可以直接通过类名.方法名或者变量名进行调用，不用经过对象 
      public class Student{
  static int age;
  static String name;
  public static void study(){
  }
}

  • 静态变量

    • 是类级别的变量，它们在类的所有实例之间共享，在内存中只有一个副本，无论创建多少个类的实例。
    • 静态变量通常用于存储那些与类本身相关，而与类的任何特定实例无关的信息。
    • 静态变量在类的加载阶段被初始化，并且只能使用类名来访问它们（而不是实例名）。 
      public class MyClass {  
    // 静态变量  
    public static int staticVar = 1;  
}

// 访问静态变量  
int value = MyClass.staticVar;

  • 静态方法

    • 是类级别的方法，它们不需要类的实例就可以被调用。
    • 静态方法不能直接访问类的非静态成员（变量和方法），因为它们属于类的特定实例。
    • 静态方法通常用于执行那些与类本身相关，而与类的任何特定实例无关的操作。
    • 静态方法可以使用类名来调用，而不是通过类的实例。 
      public class MyClass {  
    // 静态方法  
    public static void staticMethod() {  
        System.out.println("This is a static method.");  
    } 
}  

// 调用静态方法  
MyClass.staticMethod();

  • 静态代码块

    • 是一段在类加载时自动执行的代码，通常用于初始化静态变量或执行其他只需要执行一次的类级别的操作。
    • 静态代码块在类的准备阶段（在类的初始化阶段之前）被执行，并且只执行一次，无论创建多少个类的实例。
    • 在类中的位置可以是任意的，但通常放在类的顶部，它们不能包含任何参数，并且没有返回值。 
      public class MyClass {  
    // 静态变量  
    public static int staticVar;  

    // 静态代码块  
    static {  
        staticVar = 1;  
        System.out.println("Static block executed.");  
    }  
}  

// 当类被加载时，静态代码块会被执行  
// 静态变量会被初始化，并且会输出 "Static block executed."

  • 总结

    • 静态变量是类级别的变量，在类的所有实例之间共享。
    • 静态方法是类级别的方法，不需要类的实例就可以被调用。
    • 静态代码块是在类加载时自动执行的代码块，通常用于初始化静态变量或执行其他只需要执行一次的类级别的操作。
    • 静态方法不能直接访问非静态变量，静态方法当中不能使用this
    • 重点：一个类里面 static修饰的不能访问非static修饰的成员或方法，而非static修饰的可以访问static修饰的成员或者方法

  • 例：

public class Cat {
    static String name;
    int age = 2;

    public static void getName() {
        System.out.println("我叫" + name);
    }

    public void getAge() {
        System.out.println("我" + age + "岁了");
    }

    public static void eat() {
        System.out.println("吃饭");
    }

    public void sleep() {
        System.out.println("睡觉");
    }
}

public class StaticDemo {
    public static void main(String[] args) {
        Cat.name = "墩墩";
        System.out.println(Cat.name);
        Cat.getName();
        Cat cat = new Cat();
        cat.getAge();
        Cat.eat();
        cat.sleep();
    }
}
avatar
文章
阅读
粉丝