JavaSE——程序的逻辑控制和方法的定义及使用

1.Java程序结构与逻辑控制

在Java中，程序一共有三种结构：

• 分支结构
• 循环结构
• 顺序结构

1.1.Java分支结构

分支结构：进行逻辑判断，当满足某些条件时才会执行某些语句

1.1.1.if语句

if语句有如下两种形式：

if(布尔表达式){
    //条件满足时执行代码
        }else{
    条件不满足时执行代码
        }
        
if(布尔表达式1){
    //条件1满足时执行代码
        }else if(布尔表达式2){
    //条件2满足时执行代码
        }....
         else{
             //以上条件均不满足时执行代码
        }

1.1.2.switch语句

switch语句格式如下：

switch(数字|枚举|字符|字符串){
    case 内容1:{
        内容1满足时执行代码;
        break;
        }
    case 内容2:{
        内容2满足时执行代码;
        break;
        }
    case 内容3:{
        内容3满足时执行代码;
        break;
        }
    .....
    default:{
         以上内容均不满足时执行语句;
         break;
         }
}

!!!!注意switch开关语句，若case之后没有break，则会把满足case之后所有语句一直执行到有break的地方或全部结束，如下：

public class Test{
    public static void main(String[] args) throws IOException {
        System.out.println("请输入字符：");
        char x = (char) System.in.read();
        switch(x){
            case 'a':{
                System.out.println("邹大炮是猪");
            }
            case 'b':{
                System.out.println("邹大炮不是猪");
            }
            default:{
                System.out.println("邹大炮原来是瓜娃子");
            }
        }
    }
}
//请输入字符：
//b
//邹大炮不是猪
//邹大炮原来是瓜娃子

正确写法如下：

public class Test{
    public static void main(String[] args) throws IOException {
        System.out.println("请输入字符：");
        char x = (char) System.in.read();
        switch(x){
            case 'a':{
                System.out.println("邹大炮是猪");
                break;
            }
            case 'b':{
                System.out.println("邹大炮不是猪");
                break;
            }
            default:{
                System.out.println("邹大炮原来是瓜娃子");
                break;
            }
        }
    }
}
//请输入字符：
//a
//邹大炮是猪

1.2.循环结构

循环结构：某几行代码被重复执行

1.2.1.while循环

while循环语法：

while(循环结束的条件判断){
    循环语句;
    修改条件内容;
        }

1.2.2.do-while循环

do-while循环语法：

do{
   循环语句;
   修改条件内容;
        }while(循环结束的条件判断);

比较：使用while循环，如果条件不成立一次也不执行，使用do-while循环至少要执行一次。

1.2.3.for循环

for循环语法如下：

for(循环初始化;循环结束的条件判断;修改条件内容){
    循环体;
        }

使用for循环打印九九乘法口诀表：

public class Test{
    public static void main(String[] args) {
        for (int i = 1; i <= 9; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j + "*" + i + "=" + i*j + "\t");
            }
            System.out.println();
        }
    }
}
//输出
//1*1=1	
//1*2=2	2*2=4	
//1*3=3	2*3=6	3*3=9	
//1*4=4	2*4=8	3*4=12	4*4=16	
//1*5=5	2*5=10	3*5=15	4*5=20	5*5=25	
//1*6=6	2*6=12	3*6=18	4*6=24	5*6=30	6*6=36	
//1*7=7	2*7=14	3*7=21	4*7=28	5*7=35	6*7=42	7*7=49	
//1*8=8	2*8=16	3*8=24	4*8=32	5*8=40	6*8=48	7*8=56	8*8=64	
//1*9=9	2*9=18	3*9=27	4*9=36	5*9=45	6*9=54	7*9=63	8*9=72	9*9=81	

---

---

综上，循环使用规则：

• 对于不知道循环执行次数但知道循环结束条件的使用while循环
• 明确知道循环次数的使用for循环

1.3.循环控制（continue、break）

• continue：执行到此语句时会跳过当前循环的剩余部分，返回循环判断。
• break：退出整个循环

2.Java方法的定义和使用

2.1.方法的定义

方法是一段可以被重复调用的代码块，方法的声明如下：

public static 方法返回值类型 方法名称(参数类型 参数1，参数类型 参数2....参数类型 参数n){
    方法体代码;
    return 返回值;
}

当方法以void关键字声明，那么表示此方法没有返回值，若该方法有返回值，返回值可以为基本类型和引用类型，示例如下：

public class Test{
    public static void main(String[] args) {
        System.out.println(add(5,5));
    }
    public static int add(int x,int y){
        return x + y;
    }
}
//10

!!!!注意：如果方法以void声明，那么可以使用return来结束调用（常常与if语句配合使用）,示例如下：

public class Test{
    public static void main(String[] args) {
        myPrint(1);
        myPrint(2);
        myPrint(3);
        myPrint(4);
    }
    public static void myPrint(int x){
        if(x == 2){
            return;//若执行此语句，则此语句后面的代码不能被执行，方法调用结束
        }else{
            System.out.println(x);
        }
    }
    //输出
    //1
    //3
    //4

2.2.方法重载

• 方法重载定义：方法名称相同，参数的类型或个数不同
• 方法的标签：指的是方法名与参数，返回类型不是标签的一部分
• !!!!注意：不能有两个名字相同、参数类型也相同却返回不同类型值的方法

方法重载示例：

public class Test{
    public static void main(String[] args) {
        System.out.println(add(5,5));
        System.out.println(add(5,5,555));
    }
    public static int add(int x,int y){
        return x + y;
    }
    public static int add(int x,int y,int z){
        return x + y + z;
    }
}
//10
//565

开发原则：在进行方法的重载时，要求方法的返回值一定相同

2.3.方法递归

• 方法递归定义：指的是一个方法调用自己的方式
• 递归方法的特点：
  方法必须有递归的结束条件
  方法在每次递归处理的时候一定要做出一些变更

示例：

//递归实现1到100的叠加
public class Test{
    public static void main(String[] args) {
        System.out.println(sum(100));
    }
    public static int sum(int num){
        if(num == 1){
            return 1;
        }else{
            return num + sum(num - 1);
        }
    }
}
//5050