Java第4课_①方法②分支语句③循环语句

最新推荐文章于 2024-08-04 11:07:52 发布

小杜小杜~

最新推荐文章于 2024-08-04 11:07:52 发布

阅读量129

点赞数

文章标签： java jvm 开发语言

本文链接：https://blog.csdn.net/qq_43749204/article/details/127176790

版权

一、方法

方法的分类

方法的分类：

①无参无返回方法

②无参有返回方法

③有参无返回方法

public static void sum(int a,int b){
 int result = a + b;
 System.out.println(result);
}

④有参有返回方法

public static int sum(int a, int b){
 int result = a + b;
 return result;
}

方法参数的两个概念

1、形参：形式参数，指的是定义方法时创建的参数，我们称之为形参。
    例如：public static void sum(int a , int b)
    方法名后面的小括号()中的内容就是参数列表，其中形参为a，b
2、实参：实际参数，指的是在调用方法时传入的具体数据，我们称之为实参。
    例如： sum(10,20)
    	其中的数据10，20就是在调用方法实际传入的参数，在方法的执行过程中，会把实参赋值给形参

方法的重载：overload

在同一个类中，出现了多个同名的方法，但是这些方法的参数列表不一样，我们称之为这些方法出现了方法的重载

重点：（两同一不同）
    1、同一个类中（类）
    2、多个同名方法（方法名）
    3、参数列表不一样：①参数类型②参数个数③参数顺序

注意事项：
    方法的重载跟返回值类型无关，以及参数的名字也无关，还和访问权限修饰符无关。
    public：公共的，访问权限是最大的，在同一个项目中都能够访问到这个public修饰的方法。
    private：私有的，访问权限是最小的，只能在本类中访问这个private修饰的方法。

补充：Scanner键盘输入

对于不同的数据类型，需要调用不同的方法来获取

    byte
    short
    int	
    long
    float
    double
    boolean
    String

除了char类型之外，其他的集中类型都有直接的方法来获取到，那么想要通过键盘输入获取char类型的数据时，
    则需要先获取String类型的数据，然后通过String类型的数据调用charAt()方法来获取char类型的数据
    获取步骤：
    	1.获取String类型的数据
    	2.String类型数据调用charAt()就能得到char类型数据

//2.创建扫描器对象
Scanner input = new Scanner(System.in);
//3.通过扫描器对象调用方法
/*
            ①先获取String类型的数据
            ②通过String数据调用charAt()方法
         */
String s = input.next();//字符串
System.out.println("s = " + s);
//调用String中的charAt方法
//按住Ctrl 键，使用鼠标左键点击进入这个方法的源代码中
//charAt方法需要传入一个int类型的参数，一般想要获取String数据中的第一个字符，
// 我们都会传入一个数字0,若想要获取String数据中的第二个字符，则需要传入一个数字1
// 0 代表第一个字符，   1 代表第二个字符  ，依此类推
char c = s.charAt(0);
System.out.println("c = " + c);

二、分支语句

流程控制语句：

在一个程序的执行过程中，各条件语句的执行顺序对程序的结果有直接影响的，也就是说，程序的流程对运行的结果有直接的影响，我们很多时候要通过流程控制语句的执行顺序来实现要完成的功能

执行顺序：
按照书写的顺序，从上到下执行代码

分支语句：

①if语句

②if-else语句

③if-else if语句

④switch语句

①if 语句

if(逻辑表达式){
    代码(语句体)
}
注意：
    1、逻辑表达式的结果一定是一个boolean类型，要么true要么false
    2、特殊情况：没有{}默认if语句

②if-else 语句

if(逻辑表达式){
    语句1;
}else{
    语句2;
}

执行流程：

首先判断逻辑表达式的结果是true还是false

若结果为true，则执行语句1（if大括号里面的代码）

若结果为false，则执行语句2（else大括号里面的代码）

③if-else if 语句

if(逻辑表达式1){
    语句体1;
}else if(逻辑表达式2){
    语句体2;
}else if(逻辑表达式3){
    语句体3;
}
......
 else if(逻辑表达式n){
     语句体n;
 }else{
     语句体n+1;
 }

/*
            根据成绩划分等级
         */
        //创建扫描器对象
        Scanner input = new Scanner(System.in);
        System.out.println("请输入一个成绩：");
        //调用扫描器对象中的方法，用来接收一个成绩
        double score = input.nextDouble();
        //进行变量score的值进行判断
        /*
            不断的对if后面的逻辑表达式进行结果的判断，若第一个逻辑表达式不成立，就去继续判断
                第二个逻辑表达式的结果，若第二个逻辑表达式不成立，继续在向下判断其他的逻辑表达式
                直到所有的逻辑表达式都不成立，最后就会执行else后面的代码
            多个逻辑表达式中只能选取对应的某一个，不能说是能同时选取两个
         */
        if(score >= 90 && score <= 100){//90 <= score <= 100
            System.out.println("优秀");
        }else if(score >= 80 && score < 90){//80 <= score < 90
            System.out.println("较好");
        }else if(score >= 70 && score < 80){//70 <= score < 80
            System.out.println("一般");
        }else if(score >= 60 && score < 70){//60 <= score < 70
            System.out.println("及格");
        }else if(score >= 0 && score < 60){// 0 <= score < 60
            System.out.println("不及格");
        }else{
            //当上面所有的if逻辑表达式都不成立的时候，最后就去执行else大括号中的代码
            System.out.println("输入的不是一个合法的成绩！");
        }


/*
执行流程：
   不断的对if后面的逻辑表达式进行结果的判断，若第一个逻辑表达式不成立，就去继续判断
       第二个逻辑表达式的结果，若第二个逻辑表达式不成立，继续在向下判断其他的逻辑表达式
       直到所有的逻辑表达式都不成立，最后就会执行else后面的代码
       
   多个逻辑表达式中只能选取对应的某一个，不能说是能同时选取两个
*/

if语句和三元运算符的互换

int a = 200;
        int b = 30;
        //用来存a和b中的最大值
        int c = 0;
        //c = a > b ? a: b ;
        /*
            不推荐省略不写大括号
            if语句之间是可以进行嵌套的，允许if语句里面还有另一个if语句
         */
        if(a > b) {
            /*System.out.println(a);
            c = a;*/
            if (a == 1) {

            } else if (a == 2) {

            } else if (a == 3) {

            } else {

            }
        }else
            c = b;

        System.out.println("c = " + c);


        System.out.println("-----------------------------------");

        double score = 70.5;
        //if(score >= 90 && score <= 100){//90 <= score <= 100
        String s = (score >= 90 && score <= 100) ? "满足":"不满足";
        System.out.println("s = " + s);

④switch 语句

switch*(表达式|值|常量){
    case 常量值1:
        语句体1;
        break
    case 常量值2:
        语句体2;
        break
   ......
   default:
        语句体n;
        break;
}

注意事项：

1、case后面常量值的类型一定要和表达式的类型一致，否则会报错

2、default语句是可以省略不写的，没有任何影响

常量值

类型	含义	数据举例
整数常量	所有的整数	0, 1 2 5 10 100 -200
小数常量	所有的小数	0.1 0.5 200.5
字符常量	单引号引起来的内容，只能写一个字符	‘a’ ‘3’ ‘你’
字符串常量	双引号引起来的内容，可以写多个字符	“A” “你好”
布尔常量	只有两个值(只会用来分支结构中)	true ， false
空常量	只有一个值（引用数据类型中）	null

需要注意：switch语句中，表达式的类型数据，可以是byte 、short、int、char、enum（枚举）、String（JDK1.7版本以上才支持）

//表达式为int类型
int number = 1;
//使用switch语句进行判断
switch (number){
    case 1:
        System.out.println("a");
        break;
    case 2:
        System.out.println("b");
        break;
    case 3:
        System.out.println("c");
        break;
    default:
        System.out.println("d");
        break;
}

/*
	执行流程：
		首先先计算表达式的值，其次和case依次比较（把表达式的值与case后面的常量进行判断是否相等），一旦有对应的值，则执行对应case的相应语句，在执行的过程中，若遇到break关键字就会去结束掉switch语句。若到最后，所有的case都和表达式的值不匹配，则执行default语句中的代码，然后结束switch语句。

*/

case 穿透性

在switch语句中，如果case的后面不加break，将出现穿透现象，也就是不会去判断下一个case的值，而是直接去向后运行，直到遇到break或整体switch语句结束。

/*int x = 1;
        int y = 0;
        int a = 0;
        int b = 0;*/
        //switch语句是可以进行嵌套的
        int x = 1,y = 0, a = 0 , b = 0;
        switch (x){//x = 1
            case 1:
                switch (y){
                    case 0:
                        a++;
                        break;
                    case 1:
                        b++;
                        break;
                }
                //break;
            case 2:
                a++;
                break;
            case 3:
                a++;
                b++;
                //break;
        }
        System.out.println("a = " + a);//2
        System.out.println("b = " + b);//0

三、循环语句

循环：重复的，重复某一件事情
    
循环语句可以在满足循环条件的情况下，反复执行某一段代码，这段被重复执行的代码被称为循环体语句。当我们反复的执行这个循环的时候，需要在合适的时候把循环的条件修改为false，从而结束循环，否则循环将会一直执行下去，形成死循环
    
 
循环的四要素：
    1.初始化表达式
    2.boolean条件表达式
    3.修改循环条件语句
    4.循环体语句
    
循环的分类：
    1.for循环
    2.while循环
    3.do-while循环
        
只要是在Java中发现需要重复执行某一段代码的时候，就要想要使用循环解决此问题

1、for循环

for(初始化表达式1;布尔类型表达式2;修改循环条件语句3){
    循环体4
}

说明：
    对于上面for循环语法中 
    	初始化表达式我们一般都是使用的是一个int类型的变量   例如：int i = 0
    	布尔类型表达式结果一定boolean类型，true则表示满足循环条件，重复执行代码。false则表示循环结束
    	修改循环条件语句我们一般都是用 ++ 或 --

执行流程：

执行初始化表达式，并且只能执行1次，然后判断布尔类型表达式是否成立，若不成立（false），则循环结束；若成立（true），则执行循环体中的内容，再去执行修改循环条件语句，继续判断布尔类型表达式是否还成立，若还成立（true），则继续执行循环体中内容…直到布尔类型表达式不成立时，循环就结束了。

顺序：①②④③—>②④③—>②④③---->②不满足为止，循环就结束