Java教程

Java-day-06

本文主要是介绍Java-day-06,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!
package com.yonyou;

import java.util.Scanner;

/**
 * 编写for循环找出1~100中所有的素数
 * 素数:又被称为质数,能够被1和自身整除,不能被其他数字整除的数字被成为素数
 * 该题目主要掌握的知识点:
 * * for循环的使用
 * * for循环嵌套
 * * 编辑
 * * break;
 * * 统计
 */
@SuppressWarnings("all")
public class ForTest09 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("--------------------------------------");
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
//        /**
//         * 先编写程序,验证?这个数字是否为素数
//         * 构建思路:
//         *      7/1【不需要】
//         *      7/2【7 % 2】
//         *      7/3【7 % 3】
//         *      7/4【7 % 4】
//         *      7/5【7 % 5】
//         *      7/6【7 % 6】
//         *      7/7【不需要】
//         */
//
//        /**
//         * 默认将i看做一个素数【0表示素数,1表示非素数】
//         */
//
//        /**
//         * 默认将i看做一个素数【标记在开发中比较常用】
//         */
//        boolean isSuShu = true;
//        for (int j = 2; j < start; j++) {
//            /**
//             * j是什么:2 3 4 5 6
//             */
//            if (start % j == 0) {
//                /**
//                 * 非素数
//                 */
//                isSuShu = false;
//                /**
//                 * 已经知道i是非素数,跳出循环
//                 */
//                break;
//            }
//        }
//        System.out.println(isSuShu ? start + "是素数" : start + "不是素数");
//        for (int i = start; i <= end; i++) {
//            boolean usSuShu = true;
//            for (int j = start; j < i; j++) {
//                if (i % j == 0) {
//                    usSuShu = false;
//                    break;
//                }
//            }
//            if (usSuShu) {
//                /**
//                 * 素数
//                 */
//                System.out.println(i);
//            }
//            System.out.println();
//        }
//        /**
//         * 升级版:
//         *      编写for循环找出1~10000中所有的素数
//         *      要求每8个换一行输出
//         */
//            for (int j = start; j < i; j++) {
//                if (i % j == 0) {
//                    usSuShu = false;
//                    break;
//                }
//            }
//        }
        /**
         * 升级版【加入统计机制]
         */
        int count = 0;
        for (int i = start; i <= end; i++) {
            /**
             * 判断的这段代码只判断i是否为素数
             */
            boolean isSuShu = true;
            for (int j = start; j < i; j++) {
                if (i % j == 0) {
                    isSuShu = false;
                    break;
                }

            }
            if (isSuShu) {
                count++;
                System.out.println(i + "\t");
                if (count == 8) {
                    System.out.println();
                    /**
                     * 归0
                     */
                    count = 0;
                }
            }
        }
        System.out.println("--------------------------------------");
    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 以下程序不使用”方法“,分析程序存在哪些缺点?
 *      * 一下的代码都是完成两个int类型数据的和,相同的代码写了三遍(只不过每一次参与求和的数据不同)
 *      代码没有得到重复使用
 *      * 应该在Java语言当中有这样的一种机制:
 *          - 某个功能代码只需要写一遍
 *          - 要使用这个功能,只需要给功能传递具体的数据
 *          - 这个功能完成之后返回一个最终的结果
 *          这样代码九可以重复利用了,提高代码复用性【这就是方法】
 *      * 使用这个方法我们成为调用
 */
@SuppressWarnings("all")
public class MethodTest01 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("--------------------------------------");
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * 需要1:请编写程序计算10和20的和,并将结果输出
         */
        int numc = start + end;
        System.out.println(start + "+" + end + "=" + numc);
        /**
         * 需求2:编写程序计算666和888的和,并将结果输出
         */
        int starts = start * 100;
        int ends = end * 100;
        int numcs = starts + ends;
        System.out.println(starts + "+" + ends + "=" + numcs);
        /**
         * 需求:编写程序计算111和222的和,并将结果输出
         */
        int startsh = start * 111;
        int endsh = end * 111;
        int numcsh = starts + ends;
        System.out.println(startsh + "+" + endsh + "=" + numcsh);
        /**
         * 以上的三个需求其实就是一个需求,
         * 这个需求是:计算两个int类喜欢那个的和,功能相同。
         * 只不过每一次参与计算的具体数据不同
         */
        System.out.println("--------------------------------------");

    }
}

 

package com.yonyou;

import java.util.Scanner;

/**
 * 以下直接使用方法这种机制,分析程序的优点?
 * 方法的本质是什么?
 *      * 方法就是一段代码片段,并且这段代码片段可以完成某个特定的功能,并且可以被重复的使用。
 *  方法,对应的英语单词为:method
 *  方法在c语言叫做函数/Function
 *  方法定义子啊类体当中。在一个类当中可以定义多个方法,方法编写的位置没有先后顺序,可以随意。
 *  方法体当中不能再定义
 *  方法体由Java语句构体,方法体当中的代码遵守自上而下的顺序依次执行
 */
@SuppressWarnings("all")
public class MethodTest02 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("--------------------------------------");
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * 单独的定义一个方法
         * 该方法完成计算两个int类型数据的和,并且将结果输出
         */
        MethodTest02.sumInt(start, end);
        System.out.println("--------------------------------------");
    }

    public static void sumInt(int a, int b) {
        int c = a + b;
        System.out.println(a + "+" + b + "=" + c);

    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 关于java语言当中的方法:
 * 1、方法怎么定义,语法结构:
 * 【修饰符列表】返回值类型 方法名(形式参数列表){
 * 方法体;
 * return
 * }
 * 2、对以上的语法结构进行解释说明:
 * 2.1、关于修饰列表
 * * 可选项,不是必须的
 * * 目前统一写成:public static
 * * 方法的修饰符列表当中有static关键字的话,怎么调用这个方法?
 * - 类名的方法名(实际参数列表);
 * 2.2 返回值类型
 * * 什么是返回值?
 * 一个是可以完成某个特定功能的,这个功能结束之后大多数都是需要返回最终执行结果的,执行结果可能是一个具体存在的数据。
 * 而这个具体存在的数据就是返回值
 * * 返回值类型?
 * 返回值是一个具体存在的数据,数据都是由类型的,此处需要使用指定的返回值的具体类型。
 * * 返回值类型都可以指定那些雷丁呢?
 * java任意一种类型都可以,包括基本数据类型和所有的引用数据类型。
 * * 也可能这个方法执行结束之后不反悔任何数据,Java中规定,当一个方法执行结束之后不返回任何数据的话,返回值类型位置必须编写,void关键字
 * * 返回类型可以是:
 * byte,short,int,long,float,double,boolean,char,String,void......
 * * 返回值类型若不是void,表示这个方法执行结束之后必须返回一个具体的数值。
 * 当方法执行结束的时候没有返回任何数据的话编译器报错,
 * 返回值类型是void的时候,在方法体当中不能编写“return”;值:这样的语句,但是要注意
 * * 只要带有return关键字的语句执行,return语句所在的方法结束
 * 2.3、方法名:
 * * 只要是合法的标识符就行
 * * 方法名最好见名知意
 * * 方法名最好是动词
 * * 方法名首字母要求小写,后面每个首字母大写
 * 2.4、形式承诺书列表:简易形参
 * * 形参是局部变量:int a;double e;float c;String s;.....
 * 形参的个数可以是:0-N个
 * 多个形参之间用”逗号“隔开
 * 形参中起决定性作用是形参的数据类型,形参的名字就是局部变量的名字。
 * * 方法在调用的时候,实际给这个传递的真是数据被称为:实际数据,简称
 * 2.5、方法体必须由大括号括起来,方法体当中的代码有顺序,遵循自上而下的顺序的依次执行。
 * 并且方法体由java语句构成,每一个java语句以”;“结尾
 * 3.方法怎么调用?
 * 方法只定义不去调用时是不会执行的,只有在调用的时候才会执行
 * 语法规则:<>方法的修饰符列表当中static</>
 * 类名:方法名(实参列表:这是一条Java语句,表示某个类的某个方法,传播想这样的实参)
 */
@SuppressWarnings("all")
/**
 * public表示公开的
 * class表示定义类
 * MethodTest03表示一个类名
 * public class MethodTest03表示定义一个公开的类起名MethodTest03,由于是公开额类型
 * 所以源文件名必须:MethodTest03.java
 */
public class MethodTest03 {
    /**
     * 类体
     * 类体中不能直接编写java语句,除声明变量之外
     * 方法出现在类体当中
     * <p>
     * 方法
     * public表示公开的
     * static表示静态的
     * void表示方法执行结束之后不返回任何数据
     * main是方法名:主方法
     * String[] args:形式参数列表,其中string【】是一种引用数据类型,atgs是一个局部变量的变量名
     * 所以以下只有args这个局部变量的变量名是随意的
     * 主方法就需要这样编写,这是程序的入口【SUN公司规定的,必须这样写】
     *
     * @param args
     */
    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * 这里的程序是一定会执行的
         * main方法是JVM负责调用的,是一个入口位置
         * 从这里作用起吊开发执行程序
         * 既然是这样,我们就可以在这里编写来调用其他的方法
         * 调用
         */
        MethodTest03.sumInt(start, end);
        /**
         * 一个方法可以被重复使用,重复调用
         * 再次调用方法
         * 注意:方法当中的代码是有顺序的,遵循自上而下的顺序的依次执行
         */
        System.out.println("--------------------------------------");
    }

    /**
     * 自定义
     * 计算两个int类型参数的合,不要求返回结果,但是要求将结果直接输出到控制台
     * 修饰符类型:public static
     * 返回值类型:void
     * 方法名:sumInt
     * 形式参数列表:{int x , int y}
     * 方法体:主要任务是求和之后输出计算结果
     */

    public static void sumInt(int x, int y) {
        /**
         * 自定义初始版本结果:直接输出结果的加法
         */
        System.out.println(x + "+" + y + "=" + (x + y));
    }
}

 

package com.yonyou;

import java.util.Scanner;

@SuppressWarnings("all")
/**
 * 方法的调用不一定在main方法当中,可以在其他方法当中。
 * 只要是程序可以执行到额位置,都可以去调用其他方法
 */
public class MethodTest04 {
    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        MethodTest04.sumInt(start, end);
        System.out.println("你好,世界");
        System.out.println("--------------------------------------");
    }

    public static void sumInt(int x, int y) {
        /**
         * 自定义初始版本结果:直接输出结果的加法
         */
        System.out.println(x + "+" + y + "=" + (x + y));
    }

    public static void doSome() {
        System.out.println("do some!");
    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 方法调用的时候和形参要求个数进行格式的自动类型转换,数据类型相同
 */
@SuppressWarnings("all")
public class MethodTest05 {

    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * 编译错误:参数数量不同
         * MethodTest05.sum;
         * 更改签名类型的错误问题:MethodTest05.sum(true,false);
         */
        MethodTest05.sum(10L, 20L);
        MethodTest05.sum(10, 20);
        /**
         * 编译错误:参数类型不是对应相同的
         * MethodTest05.sum(3.0,20);
         */
        MethodTest05.sum((long) 3.0, 20);
        System.out.println("--------------------------------------");
    }

    public static void sum(long x, long y) {
        System.out.println(x + "+" + y + "=" + (x + y));

    }

}
package com.yonyou;

import java.util.Scanner;

/**
 * 方法调用:
 * 1、方法的修饰列表当中有static关键字,完整的调用方式是:类名.方法名(实参列表);
 * 2、但是,有的时候“类名”.“可以省略,什么情况下㐓省略呢?‘
 * m1(){
 * m2();
 * }
 * 吗1方法和m2方法在同一个类当中的时候,”类名.“”可以省略不写“
 */
@SuppressWarnings("all")
public class MethodTest06 {

    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * 调用方法
         */
        MethodTest06.m();
        /**
         * 对于方法的修饰符列表当中有static关键字的:“类名:”可以省略不写吗
         */
        m();
        /**
         * 调用其他类【不是本类中的】中的方法
         */
        A.doOther();
        /**
         * 省略“类名.”试试
         * 编译报错,“类名。”省略之后,默认从当前中找“doOther”方法,在当前类中该方法不存在
         * doOther();
         */
        System.out.println("--------------------------------------");
    }

    public static void m() {
        System.out.println("m method excute!");
        /**
         * 完整的方法
         */
        MethodTest06.m2();
        /**
         * 省略的方法
         */
        m2();
        /**
         * 不想调用当前本类的m2方法,这个时候必须要添加“类名”
         */
        A.m2();
    }

    public static void m2() {
        System.out.println("m2!");
    }
}

class A {
    public static void doOther() {
        System.out.println("A's doOther method invoke!'");
    }

    public static void m2() {
        System.out.println("A 'm2'");
    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 分析以下程序的输出结果
 * main begin
 * m1 begin
 * m2 begin
 * m3 begin
 * m3 over
 * m2 over
 * m1 ov er
 * main over
 * 对,当前的程序来说,main方法最先被调用,main方法也是最后一个结束
 * 最先调用的方法是m3,该方法最先结束
 * main方法结束之后,整个程序结束了
 * 自上而下的顺序依次执行
 * 当前行的程序在没有结束的时候,下一行的代码是无法执行
 */
@SuppressWarnings("all")
public class MethodTest07 {

    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        System.out.println("begin");
        m1();//暂停
        System.out.println("end");
        System.out.println("--------------------------------------");
    }

    /**
     * m1一旦over,整个进程就会结束
     */
    public static void m1() {
        System.out.println("m1 begin");
        m2();//暂停
        System.out.println("m2 over");
    }

    public static void m2() {
        System.out.println("m2 begin");
        m3();//活跃
        System.out.println("m2 over");
    }

    public static void m3() {
        System.out.println("m3 begin");
        System.out.println("m3 over");
    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 方法的返回值类型不是void的时候
 * 1、返回值类型不是void的时候:要求方法必须保证百分百的执行“return”值:这样的语句来完成值的返回
 * 没有这个语句编译器会报错
 * 2、一个方法有返回值的时候,当我们调用这个方法的时候,方法返回了一个值,对于调用者来说,这个返回值可以选择接收,也可以选择不接收。
 * 但是大部分情况下我们都是选择接收的
 */
@SuppressWarnings("all")
public class MethodTest08 {

    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * 调用方法
         * 接受新的
         */
        int i = divide(10, 3);
        System.out.println(i);

        long y = divide(10, 3);
        System.out.println(y);

        System.out.println(divide(10, 3));
        /**
         * 这里接收一下方法执行结束之后的返回值
         * 采用变量接收
         * 变量的数据类型需要和返回值的数据类型相同,或者可以自动类型的转换
         */
        System.out.println("--------------------------------------");
    }
    /**
     * 定义一个方法,该方法可以计算两个int类型额商
     * 要求将最终的计算结果返回给调用者
     */
    /**
     //     * 编译报错:缺少返回值
     //     * @param a
     //     * @param b
     //     * @return
     //     */
//    public static int divide(int a,int b){
//
//    }

//    /**
//     * 编译错误:缺少返回值
//     * @param a
//     * @param b
//     * @return
//     */
//    public static int divide(int a,int b){
//        return ;
//    }

//    /**
//     * 编译错误:不兼容的类型
//     *
//     * @param a
//     * @param b
//     * @return
//     */
//    public static int divide(int a, int b) {
//        return true;
//    }

//    /**
//     * @param a
//     * @param b 可以:但是具体的方法体中编写的代码无法满足的当前的需求
//     * @return
//     */
//    public static int divide(int a, int b) {
//        return 1;
//    }

    /**
     * @param a
     * @param b 可以:但是具体的方法体中编写的代码无法满足的当前的需求
     * @return
     */
    public static int divide(int a, int b) {
        int c = a / b;

        return c;
    }
}

package com.yonyou;

import java.util.Scanner;

/**
 * 深入return语句
 * * 带有return关键字的java语句只要执行,所在的方法执行结束
 * * 在同一个作用域当中,return语句下面不能编写任何代码。应为这些代码永远都执行不到,所以编译报错
 */
@SuppressWarnings("all")
public class MethodTest09 {
    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        /**
         * int retValue = 0;
         * System.out.println(retValue);
         */

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

    //    /**
//     * 编译器不会自主判断是否成立,它只会 a > 3 是一个布尔值
//     * 编译报错:缺少返回语句,以下程序编译器认为
//     * 无法百分百保证“return 1;”会执行。
//     * @return
//     */
//    public static int m() {
//        int a = 10;
//        if (a > 3) {
//            return 1;
//        }
//    }

    /**
     * 以下程序可以保证“return 1;或 return 0 ; ”执行,编译通过
     * 可以,和以上方法完全想相同
     *
     * @return
     */
//    public static int m() {
//        int a = 10;
//        if (a > 3) {
//            return 0;
//        } else {
//            return 0;
//        }
//    }
    public static int m() {
        return 10 > 3 ? 1 : 0;
    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 在返回值类型是void的方法党章使用“return;”语句
 * “return;”语句出现在返回值为void的方法当中主要是为了用来结束当前方法。
 */
@SuppressWarnings("all")
public class MethodTest010 {
    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");
        m();
        for (int i = start; i < end; i--) {
            if (i == 2) {
                return;//结束的是main方法
            }
            System.out.println("data: -->" + i);
        }
        System.out.println("Excute Here!");
        /**
         * return 100;
         * 编译错误:返回值类型是void,不能返回值
         */
        System.out.println("--------------------------------------");
    }

    //    /**
//     * 编译报错:对于结果类型为空的方法,无法返回值
//     */
//    public static void m(){
//        return 10;
//    }
//    public static void m(){
//        return;
//    }
    public static void m() {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
//              return;//不是终止for循环,终止的是m()方法。
                break;//终止的for循环
            }
            System.out.println("i --> " + i);
        }
        System.out.println("httpls");
    }
}
package com.yonyou;

import java.util.Scanner;

/**
 * 方法子啊执行过程当中,在JVM中的内存是如何分配的呢,内存是如何变化的?
 * 1、方法只定义,不调用,是不会执行的,并且在JVM中也不会给该方法分配“运行所属”的内存空间
 * 只要在调用这个方法的时候,才会动态的给这个方法分配所属的内存空间。
 * 2、在JVM内存划分上有三块主要的内存空间(当然除了这三块之外还有其他的内存空间):
 * * 方法区
 * * 堆内存
 * * 栈内存
 * 3、关于栈数据结构:
 * * 栈:stack,是一种数据结构
 * * 数据结构是独立的学科,不属于任何编程语言的范畴,只不过在大多数变成语言当中要使用数据结构
 * * Java有一套庞大的类库文件
 * * 常见的数据结构:
 * - 数组
 * - 队列
 * - 栈
 * - 链表
 * - 二叉树
 * - 哈希表/散列表
 * 栈:
 * 1、栈帧永远指向栈顶元素
 * 2、栈顶元素处于活跃状态,其他元素静止
 * 3、术语:
 * 压栈/入栈/push
 * 弹栈/出线/pop
 * 4、栈数据结构存储数据的特点是:
 * 先进后出
 * 后进先出
 * 4、方法追星的时候代码片段存在在哪里?方法执行的时候执行过程的内存在哪里分配?
 * * 方法代码片段术语.class文件的一部分,字节码文件在类加载的时候,
 * 将其放到方法区当中,所以JVM的三块主要的内存空间中方法区内存最先有数据,存放了代码片段
 * * 代码片段虽然在方法去内存当中是由一份,但是可以被重复调用。
 * * 每一次调用这个方法额时候,需要给该方法分配独立的活动场所,在内存中分配【栈内存中分配方法运行的所属内存空间】
 * 5、方法在调用的时候,会给该方法分配独立的内存空间,会在栈中发生压栈动作,方法执行结束之后,给该方法结束之后,会给方法分配的内存空间全部释放,此时发生弹栈动作,
 * * 压栈:给方法分配内存
 * * 弹栈:释放该方法的内存空间
 * 6、局部变量在“方法体”中声明。局部变量运行截端截端内存在栈中分配。
 */
@SuppressWarnings("all")
public class MethodTest011 {
    public static void main(String[] args) {
        /**
         * 获取键盘输入值
         */
        System.out.println("--------------------------------------");
        Scanner scanner = new Scanner(System.in);
        System.out.println("获取键盘输入值:");
        System.out.println("请输入起始值:");
        int start = scanner.nextInt();
        System.out.println("请输入结束值:");
        int end = scanner.nextInt();
        System.out.println("--------------------------------------");

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

    public static void m() {

    }
}
这篇关于Java-day-06的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!