Java Day3

丨陈墨瞳丨

已于 2023-08-08 21:16:44 修改

阅读量40

点赞数 2

分类专栏： Java 文章标签： java python 开发语言

于 2023-08-07 23:28:14 首次发布

本文链接：https://blog.csdn.net/qq_51944132/article/details/132152032

版权

Java 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

Java

day3——2023.8.7

流程控制

顺序结构(代码顺序执行)

在没有其他结构干扰的情况下，任何代码，都是从上到下依次执行

分支结构

在代码中，有的时候，执行某些代码，需要满足一定的条件，就需要使用到分支结构
常用的分支语句，就是 if(){} – else{} 结构

语法1

如果表达式的结果是true，那么就执行它的代码块的内容

if(表达式){
           代码块;
}

语法2

如果表达式结果为true，那么执行代码块1的内容，如果是false，执行代码块2(这种结构的分支，都可以转为三元表达式)

if(表达式){
          代码块1；
}else{
          代码块2;
}

语法3

如果表达式1的结果是true，执行代码块1，表达式2的结果为true，执行代码块2，…表达式都不为true，则执行代码块4

if(表达式1){
           代码块1;
}else if(表达式2){
           代码块2;
}else if(表达式3){
           代码块3；
}else{
           代码块4;
}

public class Demo01 {
public static void main(String[] args) {
        //演示 if 语句
        //让用户输入自己考试的分数，获取对应的奖励，如果考试90分以上，可以奖励1000块钱

        Scanner scanner = new Scanner(System.in);

        System.out.println("请输入你的考试成绩:");
        //接收输入的成绩
        int score = scanner.nextInt();

        //if (score > 90){
        //    System.out.println("考试成绩超过90分,奖励1000块钱！");
        //}

        //如果成绩超过90分奖励1000块钱，否则就提示没有奖励
        //if (score > 90){
        //    System.out.println("考试成绩超过90分,奖励1000块钱！");
        //}else {
        //    System.out.println("没有任何奖励！");
        //}

        //String str = score > 90 ? "考试成绩超过90分,奖励1000块钱！" : "没有任何奖励！";
        //System.out.println(str);


        //输入考试分数，超过90分奖励1000块钱，超过80分奖励500块钱 ，
        // 超过70 分 奖励200块钱，其他情况没有奖励

        if (score > 90){
            System.out.println("考试成绩超过90分,奖励1000块钱！");
        }else if (score > 80){
            System.out.println("考试成绩超过80分,少于90,奖励500块钱！");
        }else if (score > 70){
            System.out.println("考试成绩超过70分,少于80,奖励200块钱！");
        }else {
            System.out.println("没有奖励！");
        }
    }
}

练习

输入语文和数学成绩，如果两门课都超过90分，奖励1000r；如果只有一门课超过90分，另一门课超过80分，可以得到500r
其他情况没有奖励

package com.iweb.airui369.day03.structure;

import java.util.Scanner;

public class Exercise1 {
    public static void main(String[] args) {
        //输入语文和数学成绩
        //如果两门课都超过90分，奖励1000r
        //如果只有一门课超过90分，另一门课超过80分，可以得到500r
        //其他情况没有奖励
            Scanner scanner = new Scanner(System.in);

            System.out.print("请输入语文成绩：");
            int chineseGrade = scanner.nextInt();

            System.out.print("请输入数学成绩：");
            int mathGrade = scanner.nextInt();

            if (chineseGrade > 90 && mathGrade > 90) {
                System.out.println("奖励1000r");
            } else if (chineseGrade > 90 || mathGrade > 90) {
                if (chineseGrade > 80 && mathGrade > 80) {
                    System.out.println("可以得到500r");
                } else {
                    System.out.println("没有奖励");
                }
            } else {
                System.out.println("没有奖励");
            }
        }
}

开关语句

语法

判断switch后面的变量的值，如果变量的值等于值1，执行代码块1，等于值2，执行代码块2，等于值3，执行代码块3…

都不满足，执行default后的默认代码块

switch (变量){

                        case 值1 : 

                                         代码块1;

                        break;

                        case 值2 : 

                                         代码块2;

                        break;

                        case 值3 : 

                                         代码块3;

                        break;

                        ....

                        default: 

                                        默认代码块;

}

package com.iweb.airui369.day03.structure;

import java.util.Scanner;

public class Demo02 {
    public static void main(String[] args) {
        //接收用户输入的数字（1-5），返回对应可以做到的事情
        //1，查询所有用户
        //2，增加用户
        //3，删除用户
        //4，修改用户
        //5，查询单个用户
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入数字1-5，选择对应的操作：");
        int num = sc.nextInt();

        //通过switch去判断
        switch (num){
            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;
            default:
                System.out.println("你搜索的内容不符合标准！！！");

        }
    }
}

练习

使用switch完成，让用户输入一个数字（1-7），后台输入对应的内容：比如：输入1，则输出，今天是星期一，

输入超过范围的值则返回输入错误。

package com.iweb.airui369.day03.structure;

import java.util.Scanner;

public class Exercise2 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个数字（1-7）：");

        int a = sc.nextInt();
        switch (a){
            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("输入内容不符合标准！！！");

        }
    }
}

使用switch注意的问题

1.switch后面的括号中，可以用的数据类型： byte、short、int、char、String，以及对应的包装类，不能使用long或者浮点型

2.case后面的break可以省略，但是会发生case穿透现象，一般不建议省略

3.case后面，只能是常量，不能是变量，而且case后面的值不可重复

4.default可以不用写，但是不满足条件的情况就无法执行

循环结构

循环其实就是可以将一些重复性的代码内容，整理起来，利用特殊的语法，完成重复性的操作，从而让代码变的更加简单、简洁

while循环

循环必要条件

1，需要一个循环结束条件

2，需要一个控制条件变化的代码块

语法

如果表达式的结果为true，就会执行代码块的内容

while(表达式){

                         代码块;

}

package com.iweb.airui369.day03.structure;

public class Demo03 {
    public static void main(String[] args) {
     /*   System.out.println(1);
        System.out.println(2);
        System.out.println(3);
        System.out.println(4);
        System.out.println(5);
        System.out.println(6);
        System.out.println(7);
        System.out.println(8);
        System.out.println(9);
        System.out.println(10);
*/
     //使用while循环1-100
        //1,循环需要结束条件
        //2，循环体代码需要改变

        int i = 1;
        while ( ++i <= 100){
            System.out.println(i);
        }
        int b = 1;
        while (true){
            System.out.println(b);
            b++;
            if (b > 10){
                break;
            }
        }
        //使用whlie循环求1-100的和
        //1+2+3+4+5+...+100
        int c = 1;
        int sum = 0;
        while (c <= 100){
            sum = sum + c;   //c=1,sum=1;c=2,sum=1+2;c=3,sum=1+2+3...
            c++;
        }
        System.out.println("1-100的和是："  + sum);
    }
}

练习

1.1-100的偶数和

package com.iweb.airui369.day03.structure;

public class Exercise3 {
    public static void main(String[] args) {
        //求1-100偶数和
        int sum = 0;
        for (int i = 1; i <= 100; i++) {
            if (i % 2 == 0) {
                sum += i;
            }
        }
        System.out.println("1-100偶数和是：" + sum);
    }
}

2，将刚刚的switch语句改成循环语句
用户选择一个功能，执行完成后，可以继续选择，直到选到6，退出循环
接收用户输入的数字（1-6），返回对应可以做的事情
1，查询所有用户 2，增加用户 3，删除用户 4，修改用户 5，查询单个用户 6，退出功能

package com.iweb.airui369.day03.structure;

import java.util.Scanner;

public class Exercise4 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);


        while (true){
            System.out.println("请选择功能：");
            System.out.println("1. 查询所有用户");
            System.out.println("2. 增加用户");
            System.out.println("3. 删除用户");
            System.out.println("4. 修改用户");
            System.out.println("5. 查询单个用户");
            System.out.println("6. 退出功能");
            System.out.println("请输入一个数字（1-6）：");
            int d = sc.nextInt();
            switch (d){
                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;
                default:
                    System.out.println("Error 404！！！！");
                    continue;
            }
        }



    }
}

do-while循环

语法

跟while循环的用法类似，相比来说，需要先执行一次代码块，然后再去做循环判断，最少会执行一次代码块内容

do{

       代码块;

       }while(循环条件表达式);

package com.iweb.airui369.day03.structure;

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

         */

        //使用do-while完成1-100之间的偶数的求和
        int number = 1;
        int sum = 0;

        do {
            if (number % 2 == 0) {
                sum += number;
            }
            number++;
        } while (number <= 100);

        System.out.println("1到100之间的偶数的求和结果为：" + sum);
    }
    
}

for循环

语法

for(初始化语句a;判断条件语句b;控制条件语句c){

                                              代码块；

}

执行流程

1，先执行初始化语句a

2，执行判断条件b，

如果b的结果为true，执行代码块内容

如果b的结果为false，循环结束

3，执行控制条件c

4，再执行b，依次循环

package com.iweb.airui369.day03.structure;

public class Demo05 {
    public static void main(String[] args) {
        //for循环的使用
        for(int i = 1;i <=10;i++){
            System.out.println(i);
        }
        //使用for循环求1-100的和
        int sum = 0;
        for (int number = 0;number <= 100;number++){
            sum += number;
        }
        System.out.println(sum);

        //求1-100偶数和
        int b = 0;
        for (int c = 1; c <= 100; c++){
            if (c % 2 == 0) {
                b += c;
            }

        }
        System.out.println(b);

        //输出所有水仙花数

        for(int i = 100; i < 1000; i++){
            //个位的三次方+十位的三次方+百位的三次方的和
            int ge = i % 10;
            int shi = i / 10 % 10;
            int bai = i / 100;
            if (i == ge*ge*ge+shi*shi*shi+bai*bai*bai){
                System.out.println("水仙花数：" + i);
            }

                }
            }


        }

for循环的嵌套使用

package com.iweb.airui369.day03.structure;

public class Demo06 {
    public static void main(String[] args) {
        /*
        ******
        ******
        ******
        ******
         */
     for (int j = 0; j < 4;j++){         //外层循环，控制行
         for (int i = 0; i < 6; i++){    //内存循环，控制列
             System.out.print("*");
         }
         System.out.println();
     }


    }
}

练习

使用for循环嵌套，完成99乘法口诀表

package com.iweb.airui369.day03.structure;

public class Exercise3 {
    public static void main(String[] args) {
        //使用for循环嵌套，完成99乘法口诀表

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

break,continue,return的区别

1.break只用在switch和循环中

/*
break在多重循环中的使用
 */
public class BreakDemo {
    public static void main(String[] args) {
        wc:for (int i = 0; i < 5; i++) {
            nc:for (int j = 0; j < 4; j++) {
                if (j == 2){
                   // break; //默认状态下，跳出内部循环
                   // break wc;
                    break nc;
                }
                System.out.print("*");
            }
            System.out.println();
        }
    }
}

2.continue一般用在循环中，表示跳出当此循环，继续下次循环

/*
continue的用法
 */
public class ContinueDemo {
    public static void main(String[] args) {
        //有10个学生，循环录入学生的成绩，录完之后，统计
        //80分以上的学生的占比情况

        //1，创建需要的变量，输入对象
        double count = 0.0;
        Scanner scanner = new Scanner(System.in);
        //2，写一个循环，循环10次，每次循环录入一个学生成绩
        for (int i = 1; i <= 10; i++) {
            //3，录入成绩后，可以判断这个学生的成绩是否超过80
            System.out.println("请输入" + i +"号学生的成绩:");
            int score = scanner.nextInt();
            //4，如果超过80，记录到一个变量，不超过 continue
            if (score < 80){
                continue;
            }
            count++;
        }
        double total = count / 10;
        //5，计算占比
        System.out.println("超过80分的学生占比为:" + total * 100 +"%");
    }
}

3.return用在方法中的，一般用来结束方法

package com.iweb.airui369.day03.structure;

public class Exercise6 {
    public static void main(String[] args) {
        for (int i = 1; i < 10;i++){
            if (i == 5){
                System.out.println("退出");
                //break;
                //continue;
                return;
            }
            System.out.println(i);
        }
        System.out.println("运行结束");
    }
    //1 2 3 4 退出   运行结束
    //1 2 3 4 退出 6 7 8 9 运行结束
    //1 2 3 4 退出
}

增强for循环

语法

一般用来遍历数组或者集合中的内容

for（数据类型 变量： 数据集合）{

}

引用数据类型：String，数组，类

创建方式

数据类型变量名 = new 数据类型（）；

比如： Scanner sc = new Scanner(System.in);

为什么叫引用类型？

因为，引用类型在创建的时候，都是创建在堆空间中，然后将堆空间中的区域的地址赋值给栈中的变量

这种地址赋值方式，就是一种引用的方式，所以，称为引用类型

String类型

String类型，是字符串类型，在Java中，用双引号引起来的内容就是字符串，它是一个比较特殊的引用类型

声明的时候，可以像基本类型一样，使用字面量的方式赋值，也可以通过new关键字来声明

package com.iweb.airui369.day03.Stringtest;

public class StringDemo {
    public static void main(String[] args) {
        //String类型的声明方式
        //方式1：类似于基本类型的赋值方式
        String s1 = "Hello!";

        //方式2：和引用类型赋值方式一样
        String s2 = new String("Hello!");

        System.out.println(s1);
        System.out.println(s2);

        System.out.println(s1 == s2);   //false

        String s3 = "Hello!";
        System.out.println(s1 == s3);   //true
    }
}

Java内存划分初识别

Java程序执行的时候，会将内存分为栈空间、堆空间

栈空间特点

1，自动分配，不需要程序员申请

2，栈空间存取数据的效率较高

3，栈空间的数据按照先进后出的方式管理

4，栈空间存储空间较小，不能存放太多的数据

5，JVM将基本类型的数据存放在栈空间

堆空间特点

1，需要程序员申请，通过new关键字申请

2，堆中存取效率相对较低

3，堆空间中存放数据是随机分配位置，所以在申请了空间后，会得到一个地址值，指向变量

4，堆空间存放数据的空间比较到，能存放大量的数据

5，引用类型的数据一般都存放在堆空间中

方法

Java是面向对象的语言，对象都会有一些方法，方法其实就是这些类可以做的事情，也称为函数

方法中，一般都会写一些执行了某些功能的代码

将来可以调用这个方法，从而去完成某些想要的功能

语法

修饰符  返回值类型  方法名 (参数列表){

            代码块;

             return 返回值;

}

修饰符：暂时的写法 public static

返回值类型：可以是void ，表示没有返回值，也可以是数据类型(基本类型和引用类型)

方法名 : 自己取的名字，遵循标识符命名规范

参数列表：将来调用这个方法时候，是否需要传入值进行运算，如果不需要，可以不写

参数的定义方式：数据类型变量名

代码块：将来方法中执行的功能

return ：跟返回值类型挂钩

如果有返回值类型，那么就需要return 对应类型的值，

如果没有返回值类型，return可以省略

package com.iweb.airui369.day03.method;

public class MethodDemo {

    //写一个方法，调用之后，可以传入两个整数，并完成两个整数的计算求和后返回
    public static int add(int a ,int b){
        int sum = a + b;   //拿到存入的参数，并计算和
        return sum;        //把求和的结果返回
    }

    public static void main(String[] args) {
        //调用方法
        //也可以将整个方法的表达式参与运算
        System.out.println(add(10,20));
        //可以声明一个变量，接收返回的值
        int result = add(10,20);
        System.out.println(result);
    }
}

形参

定义在方法体的括号中的参数

实参

调用方法的时候，传入的实际的内容

//方法的其他用法
public class MethodDemo02 {
    public static void main(String[] args) {
        //修饰符  返回值  方法名 (参数列表){
        // 代码块;
        // return;
        // }

        add();
        //调用方法，传入参数的类型不能有错
        add("hello","world");
        //调用有返回值的方法
        //1，要么将方法结果返回给一个变量
        //2，要么将返回值结果，拿过来做运算
        String s = addString();
        System.out.println(addString());

        //调用有参数有返回值的方法

        String s3 = addString("你好", "世界");
        String s1 = "你好";
        String s2 = "世界";
        String s4 = addString(s1, s2);
        System.out.println(s3);
        System.out.println(s4);

    }
    // 没有返回值的方法，一般在方法中，会把要做的事情处理完
    //1,没有返回值，没有参数 ,某些固定的功能，不需要改变的时候使用这种
    public static void add(){
        String s1 = "hello";
        String s2 = "world";
        System.out.println(s1 + s2);
    }
    //2,没有返回值，有参数的情况，一般会根据用户传入的内容，执行对应的功能
    public static void add(String s1,String s2){
        System.out.println(s1 + s2);
    }

    //3，有返回值，没有参数的情况
    public static String addString(){
        //只要有返回值，必须对应有return
        String s1 = "hello";
        String s2 = "world";
        //返回字符串的拼接
        return s1+s2;
    }
    //4,有返回值，有参数的情况
    public static String addString(String s1,String s2){
        return  s1 + s2;
    }

    //形参  ：定义在方法体的括号中的参数
    // 实参 ：调用方法的时候，传入的实际的内容
}

定义一个方法，调用的时候传入两个整数，传入之后，让两个参数的值做交换后打印输出

输出内容：传入的参数为 a = ? b = ? , 交换之后的a = ? b = ?

public static void swap(int a , int  b){
        System.out.println("传入的参数为 a = " + a + " ,b = " + b);
        int c  = a;
        a = b;
        b = c;
        System.out.println("交换之后的 a = " + a + " ,b = " + b);
    }

方法递归

方法递归其实就是方法在自己的方法体中调用自身

递归在调用的时候，可能会产生栈溢出的错误，使用的时候要注意控制递归的次数，而且将来要去指定递归结束的条件

//方法递归的使用
public class MethodDemo03 {
    public static void main(String[] args) {
        //方法递归
        //method01();
        int sum = sum01(100);
        System.out.println(sum);
        int sum02 = sum02(100);
        System.out.println(sum02);
    }

    //public static void method01(){
    //    int i = 1;
    //    System.out.println(++i);
    //    method01();
    //}

    //定义一个方法，传入参数n，可以返回1-n之间数值的和
    //普通循环求法
    public static int sum01(int n){
        int sum = 0;
        for (int i = 0; i <= n; i++) {
            sum += i;
        }
        return sum;
    }
    //递归的写法 1+2+3+4+5+...+n
    public static int sum02(int n){
        if (n == 1){
            return 1;
        }
        return n + sum02(n-1);
    }
    // n = 1    sum = 1
    // n = 2     2 + sum02(1)  ==> 2 + 1
    // n = 3     3 + sum02(2)  =>  3 + 2 + 1
    //..
}

一只青蛙一次可以跳上1级台阶，也可以跳2级台阶
//求该青蛙跳上一个n级台阶总共有几种跳法

package com.iweb.airui369.day04;

public class Exercise03 {
    //一只青蛙一次可以跳上1级台阶，也可以跳2级台阶
    //求该青蛙跳上一个n级台阶总共有几种跳法
    //1级台阶   1                                           1
    //2级台阶   11   2                                      2
    //3级台阶   111 12 21                                   3
    //4级台阶   1111 121 112 211 22                         5
    //5级台阶   11111 122 211 212 1112 1211 2111 1121       8
    public static int jumpmethod(int n){
        if (n <= 2){
            return n;
        }else{
            return jumpmethod(n-1) + jumpmethod(n-2);
        }
    }

    public static void main(String[] args) {
        int n =3;
        int result = jumpmethod(n);
        System.out.println( +result);
    }
}