零基础自学Java--第三弹

原创已于 2025-06-25 22:14:05 修改 · 1.6k 阅读

33 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

于 2025-06-25 22:12:12 首次发布

前言

日期：2025年6月25日

种一棵树最好的时间是十年前，其次就是现在。现在就开始学习，坚持。

提示：以下内容仅自己的学习记录，学习视频：B站：狂神说Java

一、用户交互Scanner

java.util.Scanner 是Java5 的新特征，我们可以通过Scanner 类来获取用户的输入。

Scanner s=new Scanner(System.in);

◆通过 Scanner 类的 next()与 nextLine() 方法获取输入的字符串，在读取前我们一般需要使用 hasNext()与 hasNextLine()判断是否还有输入的数据。

next():

1、一定要读取到有效字符后才可以结束输入。
2、对输入有效字符之前遇到的空白，next()方法会自动将其去掉。
3、只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
4、next()不能得到带有空格的字符串。

package com.xiong.scanner;
//使用next方式接收，等待用户输入完毕（以空格为结束符），无法获取空格。
import java.util.Scanner;

public class Demo01 {
    public static void main(String[] args) {
        //创建一个扫描器对象，用于接受键盘数据
        Scanner scanner = new Scanner(System.in);

        System.out.println("使用next方式接收");

        //判断用户有没有输入字符串
        if (scanner.hasNext()) {
            //使用next方式接收
            String str = scanner.next();    //等待用户输入完毕（以空格为结束符）
            System.out.println("输出的内容为："+ str);
        }

        scanner.close();//凡是属于IO流的类用完不关闭会占用内存，需要养成用完就关掉的良好习惯
    }
}

注意：凡是属于IO流的类用完不关闭会占用内存，需要养成用完就关掉的良好习惯。

nextLine():

1、以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
2、可以获得空白。

package com.xiong.scanner;
//使用nextline方式接收

import java.util.Scanner;
public class Demo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("使用nextline方式接收：");

        if (sc.hasNextLine()) {
            String line = sc.nextLine();//等待用户输入，直到按回车结束
            System.out.println("输出的内容为："+line);
        }
        sc.close();
    }
}

hasNextInt()、hasNextFloat()：

package com.xiong.scanner;
//判断输入的是整数还是浮点数
import java.util.Scanner;
public class Demo04 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        int a = 0;
        float b = 0.0f;
        System.out.println("请输入一个整数：");
        if (sc.hasNextInt()) {

            a = sc.nextInt();
            System.out.println("您输入的整数为："+a);
        }
        else {
            System.out.println("您输入的不是一个整数！");
        }

        System.out.println("请输入一个小数：");
        if (sc.hasNextFloat()) {
            b = sc.nextFloat();
            System.out.println("您输入的小数为："+b);
        }
        else {
            System.out.println("您输入的不是一个小数！");
        }
        sc.close();
    }
}

hasNextDouble()

package com.xiong.scanner;

//可以输入多个数字，并求其总和与平均值，每输入一个数字用回车确认，通过输入非数字来结束输入并输出执行结果

import java.util.Scanner;
public class Demo05 {
    public static void main(String[] args) {

        Scanner sc = new Scanner(System.in);

        //和
        double sum = 0;
        //统计输入了几个数
        int m = 0;
        System.out.print("请输入一个数据: ");
        //通过循环语句判断是否还有输入，并在里面对每一次输入进行求和和统计
        while(sc.hasNextDouble()) {
            System.out.print("请继续输入数据: ");
            double x = sc.nextDouble();
            m += 1; //m++
            sum += x;
            System.out.println("您当前输入的数据个数为：" + m + "，这些数据的和为：" + sum);
        }
        System.out.println("一共输入的数据个数为："+m);
        System.out.println("这些数据的和为：" + sum);
        System.out.println("这些数据的平均值为："+sum/m);

        sc.close();
    }
}

二、顺序结构

◆ JAVA的基本结构就是顺序结构除非特别指明，否则就按照顺序一句一句执行。
◆ 顺序结构是最简单的算法结构。
◆ 语句与语句之间，框与框之间是按从上到下的顺序进行的，它是由若干个依次执行的处理步骤组成的，它是任何一个算法都离不开的一种基本算法结构。
在这里插入图片描述

三、选择结构

1.if单选择结构

在这里插入图片描述

结构如下：

if(布尔表达式){
//如果布尔表达式的值为true}
}

package com.xiong.struct;

import java.util.Scanner;
public class Xuanzejiegou {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);

        System.out.println("请输入内容：");
        String s = sc.nextLine();

        //equals:判断字符串是否相等
        if (s.equals("Hello")) {
            System.out.println(s);
        }
        System.out.println("End");

        sc.close();

    }
}

2.if双选择结构

结构如下：

if(布尔表达式){
//如果布尔表达式的值为true}
else{
//如果布尔表达式的值为false}

在这里插入图片描述

package com.xiong.struct;
import java.util.Scanner;
public class Ifdemo02 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入成绩：");
        int score = sc.nextInt();
        if (score >= 60) {
            System.out.println("恭喜你，及格啦！");

        }else {
            System.out.println("很遗憾，未及格，继续努力！");
        }
        sc.close();

    }
}

3.if多选择结构

语法如下：

if(布尔表达式 1){
//如果布尔表达式 1的值为true执行代码}
else if(布尔表达式 2){
//如果布尔表达式 2的值为true执行代码}
else if(布尔表达式 3){
//如果布尔表达式 3的值为true执行代码}
else {
//如果以上布尔表达式都不为true执行代码

在这里插入图片描述

package com.xiong.struct;
import java.util.Scanner;
public class Ifdemo03 {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入您的成绩：");
        int score = sc.nextInt();
        
        if (score == 100) {
            System.out.println("恭喜你，获得满分！");
        } else if (score <100 && score >= 90) {
            System.out.println("恭喜您，获得A等级!");
        }else if (score < 90 && score >= 80) {
            System.out.println("恭喜您，获得B等级!");
        }else if (score < 80 && score >= 70) {
            System.out.println("恭喜您，获得C等级!");
        }else if (score < 7 && score >= 60) {
            System.out.println("恭喜您，获得D等级!");
        }else{
            System.out.println("抱歉，您的成绩未及格!");
        }
    }
}

四、switch多选择结构

◆ 多选择结构还有一个实现方式就是switch case 语句。
◆ switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。
◆ switch 语句中的变量类型可以是。
◆ byte、short、int 或者 char。
◆ 从 Java SE7 开始，switch 支持字符串 String 类型了。
◆ 同时 case 标签必须为字符串常量或字面量。

switch(expression)
{case value :
//语句
break;//可选
case value :
//语句
break;//可选
//你可以有任意数量的case语句
default ://可选
//语句
}

package com.xiong.struct;
//switch多选择结构
public class Switchdemo01 {
    public static void main(String[] args) {
        //case穿透，（不用break会有穿透现象）

        char grade = 'A';
        switch (grade) {
            case 'A':
                System.out.println("YOU HAVE A GRADE A");
                 //如果不用break会出现穿透现象
            case 'B':
                System.out.println("YOU HAVE A GRADE B");
                break;
            case 'C':
                System.out.println("YOU HAVE A GRADE C");
                break;
        }
    }
}
===============================================
输出结果为：
YOU HAVE A GRADE A
YOU HAVE A GRADE B

case穿透，（不用break会有穿透现象）

package com.xiong.struct;
//switch JDK7后，表达式结果支持String字符串
//字符的本质仍然是数字

public class Switchdemo02 {
    public static void main(String[] args) {
        String name = "小熊";
        switch (name) {
            case "大熊":
                System.out.println("你好，大熊！");
                break;
            case "小熊":
                System.out.println("你好，小熊！");
                break;
        }
    }
}

五、循环结构

1.while循环

while是最基本的循环，它的结构为:

while(布尔表达式){
//循环内容
}

◆ 只要布尔表达式为 true，循环就会一直执行下去。
◆ 我们大多数情况是会让循环停止下来的，我们需要一个让表达式失效的方式来结束循环少部分情况需要循环一直执行，比如服务器的请求响应监听等。
◆ 循环条件一直为true就会造成无限循环【死循环】，我们正常的业务编程中应该尽量避免死循环。会影响程序性能或者造成程序卡死奔溃!思考

输出1~100:

package com.xiong.struct;
//输出1~100,while(true)会一直循环，可能陷入死循环，需要注意使用情形
public class Whliedemo01 {
    public static void main(String[] args) {
        int i = 0;
        while (i < 100) {
            i++;
            System.out.println(i);
        }

    }
}

计算1+2+3+4+…+100=？:

package com.xiong.struct;
//计算1+2+3+4+...+100=？
public class Whliedemo02 {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        while (i < 100) {
            i++;
            sum = i + sum;
        }
        System.out.println(sum); //sum = 5050
    }
}

2.do while 循环

◆ while 循环如果不满足条件，则不能进入循环。但有时候我们需要即使不满足条件对也至少执行一次。.
◆ do…while 循环和While 循环相似，不同的是do…while 循环至少会执行一次。

do…while 循环和While 循环对比代码如下：

package com.xiong.struct;
//do whlil至少执行一次循环体
public class Dowhiledemo {
    public static void main(String[] args) {
        int i = 0;
        int sum = 0;
        while (i < 0) {
            i++;
            sum += i;
        }
        System.out.println(sum);//whlie时不满足条件，不进入循环
        
        do {
            i++;
            sum += i;
        }while (i < 0);
        System.out.println(sum);//do while先进入循环体，至少执行一次循环
    }
}

六、For循环

◆ 虽然所有循环结构都可以用 while 或者 do…whie表示，但 Java 提供了另一种语句 – for循环，使一些循环结构变得更加简单。
◆ for循环语句是支持迭代的一种通用结构，是最有效、最灵活的循环结构。
◆ for循环执行的次数是在执行前就确定的。

语法格式如下:

for(初始化;布尔表达式;更新)
{//代码语句}

练习1-分别用whlie循环和for循环打印1~100：

package com.xiong.struct;
//分别用whlie循环和for循环打印1~100
public class Fordemo01 {
    public static void main(String[] args) {
        //用while循环打印1~100
        int i =0;
        while(i<100){
            i++;
            System.out.println(i);
        }
        System.out.println("while循环打印结束");
        //用for循环打印1~100
        for (int i1 = 0; i1 <= 100; i1++) {  //注意！！for循环是执行完循环体里面的内容后再更新i1的值
            System.out.println(i1);
        }
        System.out.println("for循环打印结束");
    }
}

练习2-用for循环计算0到100之间的奇数和与偶数和：

package com.xiong.struct;
//用for循环计算0到100之间的奇数和与偶数和

public class Fordemo02 {
    public static void main(String[] args) {
        int oddsum = 0;
        int evensum = 0;
        for (int i = 0; i <= 100; i++) {
            if (i % 2 == 0) {
                oddsum += i;
            }else {
                evensum += i;
            }

        }
        System.out.println("0~100之间的奇数和为："+oddsum);
        System.out.println("1~100之间的偶数和为："+evensum);
    }
}

练习3-用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个：

package com.xiong.struct;
//用while或for循环输出1~1000之间能被5整除的数，并且每行输出3个
public class Fordemo03 {
    public static void main(String[] args) {
        for (int i = 1; i <= 1000; i++) {
            if (i % 5 == 0) {
                System.out.print(i+"\t");
                }
            if (i % (5*3) == 0) {   //注意运算符的优先级
                System.out.print("\n");
            }
        }
    }
}
//println输出会自动换行
//print输出不会换行也不会空格

练习4-打印九九乘法表：

package com.xiong.struct;
//打印九九乘法表
/*
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
        */
public class Fordemo04 {
    public static void main(String[] args) {
        for (int i = 1; i < 10; i++) {
            for (int i1 = 1; i1 <= i; i1++) {
                System.out.print(i1+"*"+i+"="+(i*i1)+"\t");
            }
            System.out.print("\n");
        }
    }
}

七、增强for循环：

◆ Java5 引入了一种主要用于数组或集合的增强型 for 循环。

Java 增强 for 循环语法格式如下:

for(声明语句 :表达式){
//代码句子
}

◆ 声明语句:声明新的局部变量，该变量的类型必须和数组元素的类型匹配。其作用域限定在循环语句块，其值与此时数组元素的值相等。
◆ 表达式:表达式是要访问的数组名，或者是返回值为数组的方法。

依次打印数组中的值{1,2,3,4,5,6,7,8,9,10}:

package com.xiong.struct;
//依次打印数组中的值{1,2,3,4,5,6,7,8,9,10}

public class Fordemo05 {
    public static void main(String[] args) {
        int [] numbers = {1,2,3,4,5,6,7,8,9,10};//定义了一个数组,1是处于数组中[0]位置

        //方法一：普通for循环
        for (int i = 0; i < 10; i++) {
            System.out.print(numbers[i] + "\t");
        }
        System.out.println("\n"+"===============================================");
        //方法二：增强for循环
            for (int x: numbers) {
                System.out.print(x+"\t");
            }
    }
}

八、break和continue

◆ break在任何循环语句的主体部分，均可用break控制循环的流程。break用于强行退出循环不执行循环中剩余的语句。(break语句也在switch语句中使用)。
◆ continue 语句用在循环语句体中，用于终止某次循环过程，即跳过循环体中尚未执行的语句接着进行下一次是否执行循环的判定。

break：强制跳出当前循环体：

package com.xiong.struct;
//break:强制跳出当前循环体

public class Breakdemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            System.out.println(i);
            if (i == 5) {
                break;
            }
        }
    }
}
====================================================
输出结果为：
0
1
2
3
4
5

continue：退出此次循环，不是跳出循环体，只是此次循环：

public class Continuedemo {
    public static void main(String[] args) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                continue;
            }
            System.out.println(i);
        }
    }
}
=======================================================
输出结果为：
0
1
2
3
4
6
7
8
9