2020-07-17

7-14笔记整理

逻辑运算符的基本用法

逻辑运算符有哪些

&（并且），|（或者），！（非），^（异或），&&（短路与），| |（短路或）

注意事项

• 逻辑运算符一般用于连接boolean类型的表达式或者值。
• 在Java中我们要表示一个数大于3并且小于6，不可以写成 3<x<6,应该写成x>3 & x<6。
• 表达式：就是用运算符把常量或者变量连接起来的符合java语法的式子：

​ 算术表达式：a+b

​ 关系表达式：a==b

案例演示及结论

public class demo {
    //&的使用
    public static void main(String[] args) {
        System.out.println(true&true);//true
        System.out.println(true&false);//false
        System.out.println(false&true);//false
        System.out.println(false&false);//false
    }
}

结论：有false则false

public class demo {
    //|的使用
    public static void main(String[] args) {
        System.out.println(true|true);//true
        System.out.println(true|false);//true
        System.out.println(false|true);//true
        System.out.println(false|false);//false
    }
}

结论：有true则true

public class demo {
    //^的使用
    public static void main(String[] args) {
        System.out.println(true^true);//false
        System.out.println(true^false);//true
        System.out.println(false^true);//true
        System.out.println(false^false);//false
    }
}

结论：相同为false，不同为true

public class demo {
    //!的使用
    public static void main(String[] args) {
        System.out.println(!true);//false
        System.out.println(!false);//true
    }
}

结论：非false则true，非true则false（注意偶数个不改变本身）

几个小技巧

• 快速生成主方法 psvm
• 快速生成输出语句 sout
• 单行注释快捷键 ctrl+/
• 多行注释快捷键 ctrl+shift+/
• 排版代码 ctrl+alt+l
• 快速输出变量 变量.sout
• 万能纠错键 alt+enter 可以纠错，自动补全
• 自动补全 ctrl+alt+v
• 选择列 按住alt选择

逻辑运算符&&/||和&/|的区别

public class demo {
    //&与&&的区别
    public static void main(String[] args) {
        int a = 2;
        int b = 1;
        boolean f = a < b && (b++) > 0;
        System.out.println(f);  //false
        System.out.println(b); // 1
    }
}

结论：

• &左右两端的表达式都要执行
• &&当左端为false时，右端不执行
• &&当左端为true时，右端要执行

public class demo {
    //|与||的区别
    public static void main(String[] args) {
        int i = 2;
        int j = 3;
        boolean f = i<j || (j++) > 0;
        System.out.println(f); //true
        System.out.println(j);//3
    }
}

结论：

• |左右两端的表达式都要执行
• ||当左端为true时，右端不执行
• ||当左端为false时，右端要执行

位运算符的基本用法

位运算符有哪些

&（与），|（或），^（异或），~（按位取反），<<（左移），>>右移，>>>（无符号右移）

注意事项

位运算符是直接对二进制补码进行运算，运算效率高一些

结论

• &：有0则0
• |：有1则1
• ^：相同则0，不同则1
• ~：按位取反；0变1,1变0，符号位也包含在内取反
• <<：补码左移对应位数（3<<2：把3的补码左移两位），空位补0
• “>>”：被移位的二进制最高位是0，移位后，空缺位补0；最高位是1，高位补1
• “>>>”：无符号右移 被移位二进制最高位无论是0或者是1，空缺位都用0补

正数的按位反：+9
原码：00001001
反码：00001001
补码：00001001
按位取反 1  1110110 补码
再推回原码
      1  1110110 补码
    -          1  
   -----------------------------   
      1  1110101 反码
  取反
   ----------------------   
      1  0001010 原码 
      
最后结果是： -10    
      
      

-9的按位取反：
原码：1 0001001
反码：1 1110110
补码：1 1110111

负数的补码按位取反：0 0001000 的到正数 正数的原反补一样

最后结果是：8

简便计算方法

• <<：把<<左边的数据乘2的移动次幂；例如10<<3，结果10*2^3=80
• “>>”：把>>左边的数据除以2的移动次幂；例如40>>3，结果40/2^3=5

位异或运算符的特点

• 一个数据被另一个数据位异或两次，该数本身不变
• 自己位异或自己是0
• 位运算符运算效率高

public class demo {
    //异或运算符的使用
    public static void main(String[] args) {
        int a = 10;
        int b = 20;
        System.out.println(a ^ b ^ b); //10
        System.out.println(a ^ b ^ a);//20
        System.out.println(100 ^ 100);//0
        System.out.println(10 ^ 10);//0
    }
}

值交换

int a=10;
int b=20;
//方式1：找一个中间变量  开发中常用 必须掌握
int t;
t=a;
a=b;
b=t;
//方式2
/*位异或运算符的特点
^的特点：一个数据被另一个数据位异或两次，该数本身不变。*/
a=a^b;
b=a^b;	//a^b^b  b=a
a=a^b;  //a^b^a
//方式3
a=a+b;
b=a-b;
a=a-b;
//方式4 一句话搞定
b=(a+b)-(a=b);

三元运算符的基本用法

三元运算符的格式

（关系表达式）？表达式1：表达式2

int a=(10>20)?30:50；a=50

三元运算符的执行流程

计算关系表达式的值：如果为true，运算后的结果是表达式1；

​ 如果为false，运算后的结果是表达式2；

public class demo {
    //取最大值
    public static void main(String[] args) {
        int a=15;
        int b=20;
        int max=a>b?a:b;
        System.out.println(max);//20
    }
}

public class demo {
    //比较是否相等
    public static void main(String[] args) {
        int a = 15;
        int b = 20;
        boolean i = (a == b) ? true : false;
        System.out.println(i);//false
    }
}

public class demo {
    //三个数取最大值
    public static void main(String[] args) {
        int a = 15;
        int b = 20;
        int c = 13;
        int i = a > b ? a : b;
        int max = i > c ? i : c;
        System.out.println(max);//20
    }
}

键盘录入的基本格式讲解

为什么要使用键盘录入数据

• 为了让程序的数据更符合开发的数据
• 让程序更灵活一下

如何实现键盘录入

• 导包

格式：import java.util.Scanner

位置：在class上面

• 创建键盘录入对象

格式：Scanner sc=new Scanner(System.in);

• 通过对象获取数据

格式：int x=sc.nextInt();

import java.util.Scanner;//导包
public class demo {
    //根据输入数字求和并输出结果
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("输入第一个数");
        int x = sc.nextInt();//通过对象获取第一个数据
        System.out.println("输入第二个数");
        int y = sc.nextInt();//通过对象获取第二个数据
        int i=x+y;
        System.out.println(i);
    }
}

import java.util.Scanner;
public class demo {
    //根据输入数字比较大小并输出结
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("输入第一个数");
        int x = sc.nextInt();//通过对象获取第一个数据
        System.out.println("输入第二个数");
        int y = sc.nextInt();//通过对象获取第二个数据
        int max=x>y?x:y;果
        System.out.println(max);
    }
}

import java.util.Scanner;
public class demo {
    //根据输入数字比较两数是否相等
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("输入第一个数");
        int x = sc.nextInt();//通过对象获取第一个数据
        System.out.println("输入第二个数");
        int y = sc.nextInt();//通过对象获取第二个数据
        boolean i=x==y?true:false;
        System.out.println(i);
    }
}

import java.util.Scanner;
public class demo {
    //根据输入数字比较最大值并输出
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("输入第一个数");
        int x = sc.nextInt();//通过对象获取第一个数据
        System.out.println("输入第二个数");
        int y = sc.nextInt();//通过对象获取第二个数据
        System.out.println("输入第三个数");
        int z = sc.nextInt();//通过对象获取第三个数据
        int i=x>y?x:y;
        int max=i>z?i:z;
        System.out.println(max);
    }
}

顺序结构语句

什么是流程控制语句

• 在一个程序执行的过程中，各条语句的执行顺序对程序的结果是有直接影响的
• 也就是说程序的流程对运行结果有直接的影响。所以，我们必须清楚每条语句的执行流程
• 而且，很多时候我们要通过控制语句的执行顺序来实现我们要完成的功能

流程控制语句的分类

• 顺序结构
• 选择结构
• 循环结构

顺序结构

• 是程序中最简单最基本的流程控制，没有特定的语法结构，按照代码的先后顺序，依次执行，程序中大多数的代码都是这样执行的
• 总的来说：写在前面先执行，写在后面的后执行

执行流程

从上往下，依次执行

选择结构if语句格式及其使用

什么是选择结构

• 也被称为分支结构
• 选择结构有特定的语法规则，代码要执行具体的逻辑运算要进行判断
• 逻辑运算的结果有两个，所以产生选择，按照不同的选择执行不同的代码

选择结构的分类

• if语句
• switch语句

if语句的格式1

if（比较表达式或者是boolean类型的值）{

​ 语句体

}

执行流程

• 先计算比较表达式的值，看其返回值是true还是false
• 如果是true，就执行语句体
• 如果是false，就不执行语句体

public class demo {
    public static void main(String[] args) {
        int a = 10;
        int b = 11;
        if (a == b) {
            System.out.println("a与b相等");//返回值false，不执行
        }
    }
}

注意事项

• 比较表达式无论简单还是复杂，结果必须是boolean类型
• if语句控制的语句体如果是一条语句，大括号可以省略；如果是多条语句，就不能省略。建议永远不要省略
• 一般来说：有左大括号就没有分号，有分号就没有左大括号

if语句的格式2

if（比较表达式）{

​ 语句体1；

}else{

​ 语句体2；

}

**注意事项：**else后面是没有比较表达式的，只有if后面有

执行流程

• 首先计算比较表达式的值，看其返回值是true还是false
• 如果是true，就执行语句体1
• 如果是false，就执行语句体2

public class demo {
    //获取两个数据中的较大值
    public static void main(String[] args) {
        int a = 10;
        int b = 11;
        if (a > b) {
            System.out.println(a);//返回值true，则执行
        }else{
            System.out.println(b);//返回值false，则不执行
        }
    }
}

public class demo {
    //判断一个数据是奇数还是偶数
    public static void main(String[] args) {
        int a = 10;
        if (a % 2 == 0) {
            System.out.println("是偶数");//返回值true，则执行
        }else{
            System.out.println("是奇数");//返回值false，则不执行
        }
    }
}

if语句的格式2和三元的相互转换问题

• 三元运算符实现的，都可以采用if语句实现。反之不成立

• 什么时候if语句能实现不能用三元改进呢？

  当if语句控制的操作是一个输出语句的时候就不能

  为什么呢？因为三元运算符是一个运算符，运算符操作完毕就应该有一个结果，而不是一个输出

if语句的格式3

if（比较表达式1）{

​ 语句体1；

}else if（比较表达式2）{

​ 语句体2；

}else if（比较表达式3）{

​ 语句体3；

}

……

else{

​ 语句体n+1；

}

执行流程

• 首先计算比较表达式1看其返回值是true还是false

  如果是true，就执行语句体1，if语句结束

  如果是false，接着计算比较表达式2看其返回值是true还是false

• 如果是true，就执行语句体2，if语句结束

  如果是false，接着计算比较表达式3看其返回值是true还是false

  ……

• 如果都是false，就执行语句体n+1

**注意事项：**当只要有一个条件满足时，if语句结束，else是可以省略，但是不建议省略

import java.util.Scanner;
public class demo {
    //键盘录入成绩判断并输出等级
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("请输入你的成绩");
        int i = sc.nextInt();//通过对象获取一个数据
        if (i >= 90 & i <= 100) {
            System.out.println("优秀");
        } else if (i >= 80 & i <= 89) {
            System.out.println("良");
        } else if (i >= 70 & i <= 79) {
            System.out.println("中");
        } else if (i >= 60 & i <= 69) {
            System.out.println("及格");
        } else if (i >= 0 & i <= 59) {
            System.out.println("差");
        } else {
            System.out.println("成绩输入有误");
        }
    }
}

import java.util.Scanner;
public class demo {
    //键盘录入一个值，计算并输出结果
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);//创建键盘录入对象
        System.out.println("请输入一个数");
        int i = sc.nextInt();//通过对象获取一个数据
        if (i >= 3) {
            System.out.println(2 * i + 1);
        } else if (i >= -1 & i < 3) {
            System.out.println(2 * i);
        } else if (i < -1) {
            System.out.println(2 * i - 1);
        }
    }
}

public class demo {
    //通过if语句获取最大值
    public static void main(String[] args) {
        int a=10;
        int b=15;
        int c=12;
        if(a>b){
            System.out.println("最大值是"+a);
        }else if(c>b){
            System.out.println("最大值是"+c);
        }else{
            System.out.println("最大值是"+b);
        }
    }
}

public class demo {
    //通过三元获取最大值
    public static void main(String[] args) {
        int a=10;
        int b=15;
        int c=12;
        int t=a>b?a:b;
        int max=t>c?t:c;
        System.out.println("最大值是"+max);
    }
}

switch语句结构及其解释

switch语句的格式

switch（表达式）{

​ case 值1：

​ 语句体1；

​ break；

​ case 值2：

​ 语句体2；

​ break；

……

​ default：

​ 语句体n+1；

​ break；

}

switch语句的格式解释

• switch表示这是switch语句

  表达式的取值：byte，short，int，char

  JDK5以后可以是枚举

  JDK7以后可以是String

• case后面跟的是要和表达式进行比较的值

• 语句体部分可以是一条或多条语句

• break表示中断，结束的意思，可以结束switch语句

• default语句表示所有情况都不匹配的时候，就执行该处的内容，和if语句的else相似

执行流程

• 先计算表达式的值
• 然后和case后面的匹配，如果匹配成功就执行对应的语句，遇到break就会结束，否则执行default控制的语句

switch语句的基本使用

定义固定值

import java.util.Scanner;
public class demo {
    //根据输入值输出对应的星期
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个数1-7");
        int i = sc.nextInt();
        switch(i){
            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("输入数字不在范围内");

        }
    }
}

注意事项

• case后面只能是常量，不能是变量，多个case后面的值不能出现相同的值

• default可以省略，但是不建议，因为它的作用是对不正确的情况给出提示

• break可以省略，但是结果可能不是我们想要的

  会出现一个现象：case穿透，最终建议不要省略

• default不一定要在最后，可以在任意位置，但是建议在最后

• switch语句的结束条件

  遇到break就结束了

  执行到末尾就结束了

选择结构if语句和switch语句的区别

import java.util.Scanner;
public class demo {
    //用switch键入月份，输出对应季节
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个数1-12");
        int i = sc.nextInt();
        switch(i){
            case 3:
            case 4:
            case 5:
                System.out.println("是春天啊");
                break;
            case 6:
            case 7:
            case 8:
                System.out.println("是夏天啊");
                break;
            case 9:
            case 10:
            case 11:
                System.out.println("是秋天啊");
                break;
            case 12:
            case 1:
            case 2:
                System.out.println("是冬天啊");
                break;
            default:
                System.out.println("乱讲");

        }
    }
}

import java.util.Scanner;
public class demo {
    //用if键入月份，输出对应季节
    public static void main(String[] args) {
        Scanner sc= new Scanner(System.in);
        System.out.println("请输入一个数1-12");
        int i = sc.nextInt();
        if(i==3||i==4||i==5){
            System.out.println("是春天啊");
        }else if(i==6||i==7||i==8){
            System.out.println("是夏天啊");
        }else if (i==9||i==10||i==11){
            System.out.println("是秋天啊");
        }else if(i==12||i==1||i==2){
            System.out.println("是冬天啊");
        }else{
            System.out.println("乱讲");
        }
    }
}

如何选择使用if or switch语句

if语句的使用场景

• 针对结果是boolean类型的判断
• 针对一个范围的判断
• 针对几个常量值的判断

switch语句的使用场景

• 针对几个常量值的判断

7-15笔记整理

循环结构概述

什么是循环结构

• 循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句
• 反复执行这个循环体时，需要在合适的时候把循环判断条件修改为false，从而结束循环，否则循环将一直执行下去，形成死循环

循环结构的分类

• for循环
• while循环

循环结构for语句的格式

for（初始化表达式语句；判断条件语句；控制条件语句）{

​ 循环体语句；

}

执行流程

• 执行初始化表达语句

• 执行判断条件语句，看其返回值是true还是false

  如果是true，就继续执行

  如果是false，就结束循环

• 执行循环体语句

• 执行控制条件语句

• 回到执行判断条件语句继续

**注意事项：**初始化表达式语句只执行一次

public class demo {
    //使用for循环输出10次
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println("Hello Word!");
        }
    }
}

public class demo {
    //使用for循环输出1--10
    public static void main(String[] args) {
        for(int i = 1;i <= 10;i++){
            System.out.println(i);
        }
    }
}

public class demo {
    //使用for循环输出10--1
    public static void main(String[] args) {
        for(int i = 10;i > 0;i--){
            System.out.println(i);
        }
    }
}

注意事项

• 判断条件语句无论简单还是复杂结果是boolean类型
• 循环体语句如果是一条语句，大括号可以省略；如果是多条语句，大括号不能省略。建议永远不要省略
• 一般来说：有左大括号就没有分号，有分号就没有左大括号

public class demo {
    //使用for循环输出1--10中的奇数
    public static void main(String[] args) {
        for(int i=1;i<=10;i+=2){
            System.out.println(i);
        }
    }
}

public class demo {
    //使用for循环heif语句输出1--10中的偶数
    public static void main(String[] args) {
        for(int i=1;i<=10;i++){
            if(i%2==0){
                System.out.println(i);
            }
        }
    }
}

public class demo {
    //用for循环输出1--10的和
    public static void main(String[] args) {
        int sum = 0;//定义一个变量来保存每次相加的结果
        for (int i = 1; i <= 10; i++) {
            sum += i;
            System.out.println(sum);//放在循环内会输出每次循环的结果
        }
        System.out.println(sum);//放在循环外只输出最终结果
    }
}

public class demo{
    //用for循环输出1--100中奇数/偶数的和
    public static void main(String[] args) {
        int x = 0;//定义一个变量来保存奇数每次相加的结果
        int y=0;//定义一个变量来保存偶数每次相加的结果
        for (int i = 1; i <= 100; i++) {
            if(i%2==1){//判断奇偶数
                x+=i;
            }else{
                y+=i;
            }
        }
        System.out.println("奇数和为" + x);
        System.out.println("偶数和为" + y);
    }
}

public class demo {
    //用for循环输出水仙花数
    public static void main(String[] args) {
        for(int i=100;i<=999;i++){//用for循环输出水仙花数
            int x=i/100;//取百位数字
            int y=i/10%10;//取十位数字
            int z=i%10;//取个位数字
            int FlowerNumber=x*x*x+y*y*y+z*z*z;//水仙花数满足条件：三位数；各个数位上的数字立方和等于该数本身
            if(i==FlowerNumber){
                System.out.println(i);
            }
        }
    }
}

public class demo {
    //用for循环统计水仙花数的数量
    public static void main(String[] args) {
        int t=0;
        for(int i=100;i<=999;i++){
            int x=i/100;
            int y=i/10%10;
            int z=i%10;
            int FlowerNumber=x*x*x+y*y*y+z*z*z;
            if(i==FlowerNumber){
                System.out.println(i);
                t++;//每生成一个水仙花数，就+1
            }
        }
        System.out.println(t);//在for循环外统计水仙花数的数量
    }
}

技巧

• 快速生成循环语句 100.fori
• 反向遍历 10.forr
• 补全 new Scanner（System.in）.var

循环结构while语句的格式

while循环的基本格式

while（判断条件语句）{

​ 循环体语句；

}

完整格式

初始化条件语句；

while（判断条件语句）{

​ 循环体语句；

​ 控制条件语句；

}

执行流程

• 执行初始化条件语句；

• 执行判断条件语句，看其返回值是true还是false

  如果是true，就继续执行

  如果是false，就结束执行

• 执行循环体语句

• 执行控制条件语句

• 回到执行判断条件语句继续

public class demo {
    //用while循环输出10个Hello Word！
    public static void main(String[] args) {
        int i=0;//初始化条件语句
        while(i<10){//判断条件语句
            System.out.println("Hello Word！");//循环体语句
            i++;//控制条件语句
        }
    }
}

public class demo {
    //用while循环输出1--10
    public static void main(String[] args) {
        int i=1;
        while(i<=10){
            System.out.println(i);
            i++;
        }
    }
}

public class demo {
    //用while循环求和1--10并输出
    public static void main(String[] args) {
        int t=0;
        int i=1;
        while(i<=10){
            t+=i;
            i++;
        }
        System.out.println(t);
    }
}

public class demo {
    //用while循环输出水仙花数并输出数量
    public static void main(String[] args) {
        int t = 0;
        int i = 100;
        while (i <= 999) {
            int x = i / 100 % 10;
            int y = i / 10 % 10;
            int z = i / 1 % 10;
            int FlowerNumber = x * x * x + y * y * y + z * z * z;
            if (i == FlowerNumber) {
                t++;
                System.out.println(i);//输出水仙数
            }
            i++;
        }

        System.out.println(t);//输出水仙花数的数量
    }
}

循环结构do…while语句的格式

基本格式

do{

​ 循环体语句；

}while（判断条件语句）；

完整格式

初始化条件语句；

do{

​ 循环体语句；

​ 控制条件语句；

}while（判断条件语句）；

执行流程

• 执行初始化条件语句

• 执行循环体语句

• 执行控制条件语句

• 执行判断条件语句，看其返回值是true还是false

  如果是true，就继续执行

  如果是false，就结束循环

• 回到执行循环体语句继续

public class demo {
    //用do…while循环输出10个HelloWord!
    public static void main(String[] args) {
        int i=1;
        do{
            System.out.println("HelloWord!");
            i++;
        }while(i<=10);
    }
}

public class demo {
    //用do…while循环输出1--10
    public static void main(String[] args) {
        int i=1;
        do{
            System.out.println(i);
            i++;
        }while(i<=10);
    }
}

循环结构三种循环语句的区别

• do…while循环至少执行一次循环体

  而for，while循环必须先判断条件是否成立，然后决定是否执行循环体语句

• 如果想在循环结束后，继续使用控制条件的那个变量，用while循环，否则用for。不知道的时候用for循环

  因为变量及早从内存中消失，可以提高内存的使用效率

  建议优先考虑for循环，然后是while循环，最后是do…while循环

循环结构注意事项之死循环

• 一定要注意控制条件语句控制的那个变量问题，不要弄丢了，否则就容易死循环

• 两种最简单的死循环格式

  while（true）{……}

  for（；；）{……}

循环结构在的循环嵌套

public class demo {
    //通过循环嵌套输出5行4列“*”
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){//外循环控制行数
            for(int j=1;j<=4;j++){//内循环控制列数
                System.out.print("*");//print打印不换行
            }//内循环结束后再进行的外循环
            System.out.println();//只是作为换行操作
        }
    }
}

public class demo {
    //通过循环嵌套输出正三角形
    public static void main(String[] args) {
        for(int i=1;i<=5;i++){
            for(int j=1;j<=i;j++){
                System.out.print("*");
            }//内循环的运行条件与外循环中的i相关，因此内外循环依次进行
            System.out.println();
        }
    }
}

public class demo {
    //通过循环嵌套输出九九乘法表
    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+"="+(j*i)+"\t");
            }
            System.out.println();
        }
    }
}

注意

• “\x” x表示任意，这种做法叫转义字符
• “\t” tab键的位置
• “\n” 换行

控制跳转语句

什么是控制跳转语句

• Java中的goto是保留字，目前不能使用，虽然没有goto语句可以增强程序的安全性，但是也带来很多不便
• 比如说，我想在某个循环执行到某一步的时候就结束，现在就做不了这件事情
• 为了弥补这个缺陷，java就提供了break，continue，return来实现控制语句的跳转和中断

控制跳转语句的分类

• break 中断
• continue 继续
• return 返回

控制跳转语句break语句

break使用场景

• 在选择结构switch语句中

• 在循环语句中

  注意：离开使用场景的存在是没有意义的

break的作用

• 退出单层循环

• 退出多层循环（几乎不使用）

  要想实现这个效果，就必须知道一个东西：带标签的语句；

  格式：标签名：语句

控制跳转语句continue语句

continue使用场景

• 在循环语句中
• 离开使用场景的存在是没有意义的

continue的作用

• 跳出一次循环，执行下一步操作

控制跳转语句return语句

return的作用

• return 就是退出一个方法
• 跳转到上层调用的方法

控制跳转语句案例展示

public class demo {
    //原定循环十次，现在要在第五次结束后停下——for
    public static void main(String[] args) {
        for(int i=0;i<=10;i++){
            if(i==6){//限定停下的条件
                break;
            }
            System.out.println(i);
        }
    }
}

public class demo {
    //原定循环十次，现在要在第五次结束后停下——while
    public static void main(String[] args) {
        int i=1;
        while(true){
            System.out.println(i);
            i++;
            if(i>5){
                break;
            }
        }
    }
}

public class demo {
    //循环十次，跳过第五次
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if(i==5){
                continue;
            }
            System.out.println(i);
        }
    }
}

public class demo {
    //打印偶数，跳过其中奇数的循环
    public static void main(String[] args) {
        for (int i = 1; i <= 10; i++) {
            if(i%2==1){
                continue;
            }
            System.out.println(i);
        }
    }
}

public class demo {
    //输出两次HelloWord!
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {
                break;//当x%3==0时，停下
            }
            System.out.println("HelloWord!");
        }
    }
}

public class demo {
    //输出七次HelloWord!
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {
                continue;//当x%3==0时，跳过
            }
            System.out.println("HelloWord!");
        }
    }
}

public class demo {
    //输出十三次次HelloWord!
    public static void main(String[] args) {
        for (int x = 1; x <= 10; x++) {
            if (x % 3 == 0) {//当x%3==0时，输出HelloWord!
                System.out.println("HelloWord!");
            }
            System.out.println("HelloWord!");
        }
    }
}

方法概述和格式说明

为什么要有方法

• 为了实现一个功能我们需要编写100行代码，在程序的运行过程中我们不断的要使用这个功能
• 如果每次都重复编写这100行代码，程序会变得很臃肿，可读性也会非常差
• 为了解决代码重复编写的问题，我们可以把这个功能提取出来放在一个{}中，并为这个代码起个名字
• 这样在每次使用这个功能室我们通过这个代码的名字来调用这段代码就可以了，在上述过程中，所提取出来的代码可以被看做是程序中定义的一个方法
• 程序在需要实现该功能时调用方法即可

什么是方法

• 方法就是完成特定功能的代码块
• 在很多语言中都有函数的定义，但是在java语言中，我们将其称之为方法

方法的格式

修饰符 返回值类型 方法名（参数类型 参数名1，参数类型 参数名2……）{

​ 方法体；

​ return 返回值；

}

方法格式的详细说明

• 修饰符 比较多，目前使用public static

• 返回值类型 用于限定返回值的数据类型

• 方法名 就是一个名称，它的存在是为了方便我们调用方法

• 参数类型 限定调用方法时传入参数的数据类型

• 参数名 是一个变量，接收调用方法时传入的参数

  这个参数其实有一个专业的名词，被称之为形式参数，它的作用是用来接收实际参数的

• 方法体 完成功能的代码

• return 结束方法以及返回方法指定类型的值

• 返回值 就是功能的结果，由return待会，带回给调用者

方法的案例展示

如何写一个方法

两个明确：

• 返回值类型 明确功能结果的数据类型
• 表 要传递几个参数，以及每个参数的数据类型

方法调用（有明确返回值的调用）

• 单独调用，一般来说没有意义，所以不推荐
• 赋值调用，推荐方案
• 输出调用，但是不够好，因为我们可能需要针对结果进行进一步的操作

案例展示

public class demo {
    //使用方法计算
    public static void main(String[] args) {
        int x=send(1, 1);//使用send方法并赋给x
        System.out.println(x);
    }
    public static int send(int i,int j){
        int x=i*2+j*3;
        return x;//返回值是x
    }
}

public class demo {
    //使用方法获取最大值
    public static void main(String[] args) {
        int x=send(10, 15);//使用send方法
        System.out.println("较大值是"+x);
    }
    public static int send(int i,int j){
        int x=0;
        if(i>j){
            x=i;
        }else{
            x=j;
        }
        return x;//获取较大值并返回
    }
}

public class demo {
    //使用方法判断是否相等
    public static void main(String[] args) {
        String x=send(10, 15);
        System.out.println(x);
    }
    public static String send(int i,int j){//字符串返回String
        String x;
        if(i==j){
            x="相等";
        }else{
            x="不相等";
        }
        return x;
    }
}

import java.util.Scanner;
public class demo {
    //使用键入改进以方法取最大值
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入第一个数");
        int i = sc.nextInt();
        System.out.println("输入第二个数");
        int j = sc.nextInt();
        int x=send(i, j);
        System.out.println("较大值是"+x);
    }
    public static int send(int i,int j){
        int x=0;
        if(i>j){
            x=i;
        }else{
            x=j;
        }
        return x;
    }
}

注意事项

• 方法不调用不执行
• 方法与方法是平级关系，不能嵌套定义
• 方法定义的时候参数之间用逗号隔开
• 方法调用的时候不用再传递数据类型
• 如果方法有明确的返回值，一定要由return带回一个值

import java.util.Scanner;
public class demo {
    //键入数据输出*
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("输入第一个数");
        int i = sc.nextInt();
        System.out.println("输入第二个数");
        int j = sc.nextInt();
        send(i, j);
    }
    public static void send(int i,int j){
        for(int x=1;x<=i;x++){
            for(int y=1;y<=j;y++){
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

import java.util.Scanner;
public class demo {
    //键入数据用方法输出乘法表
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数");
        int i=sc.nextInt();
        send(i);
    }
    public static void send(int i){
        for(int x=1;x<=i;x++){
            for(int y=1;y<=x;y++){
                System.out.print(y+"*"+x+"="+x*y+"\t");
            }
            System.out.println("");
        }
    }
}

public class demo {
    //使用方法求和
    public static void main(String[] args) {
        int x=10;
        int y=20;
        int z=25;
        int a=sum(x,y);//重载时会自动调用最合适的方法
        int b=sum(x,y,z);
        System.out.println(a);
        System.out.println(b);
    }
    public static int sum(int x,int y){
        int t=x+y;
        return t;
    }
    public static int sum(int x,int y,int z){
        int t=x+y+z;
        return t;
    }
}

方法重载概述

在同一个类中，允许存在一个以上同名方法，只要它们参数列表不同，与返回值无关

• 参数列表不同：

  参数个数不同

  参数类型不同

完