JavaDay07

最新推荐文章于 2022-08-04 18:12:55 发布

faith1996

最新推荐文章于 2022-08-04 18:12:55 发布

阅读量184

点赞数

文章标签： Java

本文链接：https://blog.csdn.net/faith1996/article/details/81950144

版权

打印10000以内的所有完全数。如果一个正整数等于除了它本身之外所有除数之和，这个数就是完全数。如6==1+2+3 28==1+2+4+7+14。

package com.bjpowernode.day07.demo01.exercise;
/*
 *打印10000以内的所有完全数。如果一个正整数等于除了它本身之外所有除数之和，这个数就是完全数。
 *如6==1+2+3 28==1+2+4+7+14
 */
public class Demo01 {

    public static void main(String[] args) {
        //遍历10000以内的所有整数，如果这个整数是完全数就打印
        for( int num=1 ; num<=10000 ; num++ ) {
            //求num所有除数之和
            int sum=0;              //保存num所有除数之和

            //求num所有除数之和
            for( int x=1 ; x<num ; x++ ) {
                if ( num % x == 0 ) {
                    sum += x;
                }
            }
            //判断num是否是完全数
            if( num == sum ) {
                System.out.println(num);
            }
        }

    }

}

输入两个数n和a，如n==4，a==3，求 3 + 33 + 333 + 3333的和

package com.bjpowernode.day07.demo01.exercise;

import java.util.Scanner;

/*
 * 输入两个数n和a，如n==4，a==3，求 3 + 33 + 333 + 3333的和
*/
public class Demo02 {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个数n和a");
        int n = sc.nextInt();
        int a = sc.nextInt();

        int sum = 0;        //保存累加和
        int num = 0;        //保存每次需要累加的数

        for( int x=0 ; x<n ; x++ ) {
            //先构建需要累加的数
            num = num*10 + a;   
            sum += num;
        }
        System.out.println("sum=="+sum);
    }
}

打印九九乘法表

package com.bjpowernode.day07.demo01.exercise;
/*
 * 打印九九乘法表
 * 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
 */
public class Demo03 {

    public static void main(String[] args) {
        for( int i=1 ; i<=9 ; i++ ) {
            //每一行，先打印乘法表，不换行
            //第i行，打印i个表达式
            for( int j=1 ; j<=i ; j++ ) {
                System.out.print( j + "*" + i + "=" + (i*j) + "\t");
            }

            System.out.println();
        }
    }

}

换零钱，把一元钱换成5毛，2毛，1毛，有多少种换法，打印

package com.bjpowernode.day07.demo01.exercise;
/*
 *  换零钱，把一元钱换成5毛，2毛，1毛，有多少种换法，打印
 */
public class Demo04 {

    public static void main(String[] args) {

        for( int wumao=0 ; wumao<=2 ; wumao++ ) {
            for( int ermao=0 ; ermao<=5 ; ermao++ ) {
                for( int yimao=0 ; yimao<=10 ; yimao++ ) {
                    if ( wumao*5 + ermao*2 + yimao*1 == 10 ) {
                        System.out.println( "五毛有" + wumao + "个，两毛有" + ermao + "个，一毛有" + yimao + "个");
                    }
                }
            }
        }
    }

}

1 断点调试

1.1 什么是断点调试

是调试程序的一种方法。
可以在某条语句上加上断点，在调试程序时，运行到断点处就会中断，可以查看变量的当前值，可以查看程序的运行过程。

1.2 如何添加断点

1）在某行语句的前面进行双击
2）选择run->Toggle breakpoint
3）Ctrl + shift + B快捷键

1.3 如何调试

1）启动调试
选择Run->Debug
F11快捷键
单击常用工具栏的调试按钮
2）如何调试
Step into–F5–转到方法内部去执行
Step over–F6–执行下一条语句
Step return–F7–从方法中返回
Resume–F8–执行到下一个断点或程序结束
Terminate–Ctrl+F2–终止调试

package com.bjpowernode.day07.demo02.breakpoint;

import java.util.Scanner;

/*
 * 测试断点调试
 */
public class Demo {

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入一个整数");
        int num = sc.nextInt();

        if ( num>0 ) {
            System.out.println("正整数");
        }else if ( num<0 ) {
            System.out.println("负整数");
        }

        int sum = 0;
        while ( num>=0 ) {
            sum += num;
            num--;
        }
        System.out.println( "sum==" + sum );
    }

}

2 方法

2.1 什么是方法？为什么使用方法？

1）方法就是为了完成某个功能而编写的一段代码，如果以后想使用这功能时就直接调用这个方法即可。
如：System.out.println();语句中println()就是一个方法，它的作用是在屏幕上打印信息并换行。
Math.random();语句中random()就是一个方法，它的作用是生成[0,1]之间的随机小数。
sc.nextInt();语句中nextInt();就是一个方法，它的作用是从键盘上读取一个整数并返回。
以上这些方法，是SUN公司之前就为我们定义好了，我们直接使用即可。

2）为什么使用方法？
方法可以使代码更简洁
可以实现代码的复用
方法方便程序的维护

package com.bjpowernode.day07.demo03.method1;

/*
 * 模拟汽车驾驶
 */
public class Demo {

    public static void main(String[] args) {
        // 起步
        System.out.println("++++++++++++++++++++++");
        System.out.println("踩刹车");
        System.out.println("松手刹");
        System.out.println("踩离合");
        System.out.println("挂档");
        System.out.println("松离合");
        System.out.println("踩油门");

        // 停车
        System.out.println("------------------------");
        System.out.println("踩刹车");
        System.out.println("踩离合");
        System.out.println("摘档");
        System.out.println("松离合");
        System.out.println("拉手刹");
        System.out.println("松刹车");

        // 起步
        System.out.println("++++++++++++++++++++++");
        System.out.println("踩刹车");
        System.out.println("松手刹");
        System.out.println("踩离合");
        System.out.println("挂档");
        System.out.println("松离合");
        System.out.println("踩油门");

        // 停车
        System.out.println("------------------------");
        System.out.println("踩刹车");
        System.out.println("踩离合");
        System.out.println("摘档");
        System.out.println("松离合");
        System.out.println("拉手刹");
        System.out.println("松刹车");

        // 起步
        System.out.println("++++++++++++++++++++++");
        System.out.println("踩刹车");
        System.out.println("松手刹");
        System.out.println("踩离合");
        System.out.println("挂档");
        System.out.println("松离合");
        System.out.println("踩油门");

        // 停车
        System.out.println("------------------------");
        System.out.println("踩刹车");
        System.out.println("踩离合");
        System.out.println("摘档");
        System.out.println("松离合");
        System.out.println("拉手刹");
        System.out.println("松刹车");

        // 起步
        System.out.println("++++++++++++++++++++++");
        System.out.println("踩刹车");
        System.out.println("松手刹");
        System.out.println("踩离合");
        System.out.println("挂档");
        System.out.println("松离合");
        System.out.println("踩油门");

        // 停车
        System.out.println("------------------------");
        System.out.println("踩刹车");
        System.out.println("踩离合");
        System.out.println("摘档");
        System.out.println("松离合");
        System.out.println("拉手刹");
        System.out.println("松刹车");

    }

}

package com.bjpowernode.day07.demo03.method1;
/*
 * 方法可以使代码更简洁
可以实现代码的复用
方法方便程序的维护
 */
public class Demo02 {

    public static void main(String[] args) {
        start();
        stop();

        start();
        stop();

        start();
        stop();

        start();
        stop();
    }

    // 起步
    public static void start() {
        // 起步
        System.out.println("++++++++++++++++++++++");
        System.out.println("踩刹车");
        System.out.println("松手刹");
        System.out.println("踩离合");
        System.out.println("挂档");
        System.out.println("松离合");
        System.out.println("踩油门");
    }

    // 停车
    public static void stop() {
        // 停车
        System.out.println("------------------------");
        System.out.println("踩刹车");
        System.out.println("踩离合");
        System.out.println("摘档");
        System.out.println("松离合");
        System.out.println("拉手刹");
        System.out.println("松刹车");
    }
}

2.2 方法的定义

语法格式：
[修饰符] 返回值类型方法名( 参数类型参数名 , 参数类型参数名 , ……){
方法体
}

1）方法的修饰符有：public/protected/private/static/abstract/final/synchronized等
2）方法返回值类型是指调用方法时返回的值的类型，如：Math.random()中random()方法返回一个[0,1]之间的小数，random()方法的返回值类型就是double型。如sc,nextInt()中nextInt()方法从键盘上读取一个整数并返回，nextInt()方法的返回值类型就是int类型。如System.out.println()中的println()方法在屏幕上打印信息，没有返回值，如果方法没有返回值，它的返回值类型使用void来表示。
3）方法名是程序员起的名字，方法名一般是一个动词，第一个单词小写，其它每个单词的首字母大写
4）方法在完成某个功能时，可能需要一些数据，在定义方法时指定方法参数来接收这些数据。如在屏幕上打印信息，需要把要打印的信息传递给println()方法。在定义参数时，需要指定参数的类型和参数名，如果有多个参数，参数之间使用逗号分隔。方法也可以没有参数，如random()方法，但是小括弧不能省略。
5）方法体使用一对大括弧括起来。如果在定义方法时指定了方法的返回值类型不是void，表示方法有一个返回值，在方法体中需要通过return语句返回一个对应类型的值。

定义一个没有参数没有返回值的方法

package com.bjpowernode.day07.demo04.methoddefination;
/*
 * 定义一个没有参数，没有返回值的方法
 */
public class Demo01 {

    public static void main(String[] args) {
        /*
         * 程序从main方法开始执行，可以在main方法中调用printRose()方法
         * 没有参数，没有返回值的方法，调用方法的语句作为单独的一条语句
         * 通过方法名来调用方法
         * 调用方法时，程序会转到方法内部去执行，在方法体执行完毕后再返回到调用的位置
         */
        printRose();            //调用无参数，无返回值的方法
    }
    /*
     *定义方法，在屏幕上打印一朵玫瑰
     * 1)方法定义的位置，在类中，在其它方法的外面，方法之间是并列的，不能再一个方法内部再定义另外的方法
     * 2)在屏幕上打印内容，不需要返回值，方法的返回值类型用void表示
     * 3)打印一朵玫瑰，也不需要传递数据，没有参数
     * 4)方法名：printRose是程序员自己定义的
     * 
     * 特别注意：
     *  定义了方法之后，仅仅是在类中添加了一组指令，这一组指令不会自动执行，需要进行方法的调用
     */

    public static void printRose() {
        System.out.println("{@}");
        System.out.println("\\|/");
        System.out.println(" | ");
    }
}

定义一个有多个参数，没有返回值的方法

package com.bjpowernode.day07.demo04.methoddefination;

import java.util.Scanner;

/*
 * 定义一个有多个参数，没有返回值的方法
 */
public class Demo03 {

    public static void main(String[] args) {
        /*
         * 在调用方法时，传递的数据要与定义时指定的参数个数一致
         */
        max(18, 25);                                    //把18传递给num1,把25传递给num2

        Scanner sc = new Scanner(System.in);
        System.out.println("请输入两个整数");
        int m = sc.nextInt();
        int n = sc.nextInt();
        max(m, n);                                      //把变量m的值传递给num1,把变量n的值传递给num2
    }

    /*
     * 定义一个方法,把两个整数的较大者打印到屏幕上
     * 不需要返回值,返回值类型就用void来表示
     * 求两个整数的较大者,需要通过两个参数来接收数据，参数之间使用逗号分隔
     */
    public static void max(int num1,int num2) {
        if ( num1>num2 ) {
            System.out.println(num1 + "和" + num2 + "中较大者是" + num1);
        }else {
            System.out.println(num1 + "和" + num2 + "中较大者是" + num2);
        }
    }
}

定义一个方法,没有参数,有返回值

package com.bjpowernode.day07.demo04.methoddefination;
/*
 * 定义一个方法,没有参数,有返回值
 */
public class Demo04 {

    public static void main(String[] args) {
        /*
         * 1)通过方法名来调用方法
         * 2)如果方法有返回值，需要对这个返回值进行处理
         *      (1)可以把返回值打印到屏幕上
         *      (2)可以把返回值保存到一个变量中
         *      (3)可以把方法的返回值作为其它表达式的一部分
         */
        System.out.println( getRndInt() );
        int num = getRndInt();

        if ( getRndInt()%2==0) {
            System.out.println("随机生成了一个偶数");
        }else {
            System.out.println("随机生成了一个奇数");
        }

        System.out.println( num );

    }

    /*
     * 定义方法，返回[0,100]之间的随机整数
     * 返回值类型为int类型,指定了返回值类型之后，在方法体重必须通过return语句返回一个整数
     */
    public static int getRndInt() {
        return (int)(Math.random() * 10);
    }
}

定义方法，有一个参数，有返回值

package com.bjpowernode.day07.demo04.methoddefination;
/*
 * 定义方法，有一个参数，有返回值
 */
public class Demo05 {

    public static void main(String[] args) {

        /*
         * 1)方法有返回值，需要对方法的返回值进行处理
         */
        System.out.println( isPrime(123) );

        //把1~100之间所有的素数打印到屏幕上
        for(int i=1; i<=100; i++) {
            if ( isPrime(i) ) {
                System.out.println( i );
            }
        }
    }
    /**
     * 判断一个数是否为素数，如果是素数返回true，不是素数返回false
     * @param num       接收一个整数
     * @return          返回num是否为素数
     */
    public static boolean isPrime(int num) {
        //对参数接收的数据进行验证
        if ( num<2 ) {
            return false;
        }
        //从2到num-1之间如果有一个数能把num整除，不是素数，返回false
        for (int x = 2; x < num; x++) {
            if ( num%x==0 ) {
                return false;
            }
        }

        return true;
    }
}

定义方法，有多个参数，有返回值

package com.bjpowernode.day07.demo04.methoddefination;
/*
 * 1)定义方法，有多个参数，有返回值
 * 2)一个类中可以定义多个方法，方法之间可以相互调用
 */
public class Demo06 {

    public static void main(String[] args) {
        for( int m=1; m<=12; m++ ) {
            System.out.println( "2017年" + m + "月有" + getDaysOfMonth(2017,m) + "天" );
        }
    }

    /**
     * 定义方法，返回指定年、月的天数
     * @param year      接收年份
     * @param month     接收月份
     * @return          返回指定日期的天数
     */
    public static int getDaysOfMonth(int year,int month) {
        switch ( month ) {
        case 1:
        case 3:
        case 5:
        case 7:
        case 8:
        case 10:
        case 12:
            return 31;
        case 4:
        case 6:
        case 9:
        case 11:
            return 30;
        case 2:
            if ( isLeapYear(year) ) {
                return 29;
            }else {
                return 28;
            }
        }
        return 0;
    }

    /*
     * 当方法定时时指定了返回值类型不是void，在方法体中必须保证return一个值
     */
    public static boolean isLeapYear(int year) {
        if ( year%4==0 && year%100!=0 || year%400==0 ) {
            return true;
        }

        return false;
    }
}

2.4 方法参数传递

1）在定义方法时，指定的参数称为形式参数，简称为形参；在调用方法时，给方法传递的参数称为实际参数，简称为实参
2）在定义方法时，形参没有分配存储空间，也没有值，相当于一个占位符；在调用方法时，传递的是实际的数据
3）定义了方法，方法不占存储空间，方法的形参和方法的局部变量也不占存储空间；只有在调用方法时，才会在栈区中给方法分配存储空间，然后给形参/局部变量分配存储空间；当方法执行结束，方法所占的栈空间会被释放，方法的形参/局部变量也会被释放
4）在调用方法时，是把实参的值传递给形参，实参与形参是相互独立的，在方法体中对形参进行了重新赋值，不会影响实参。

方法的形参与实参是相互独立的

package com.bjpowernode.day07.demo05.methodargs;
/*
 * 方法的形参与实参是相互独立的
 */
public class Demo {

    public static void main(String[] args) {

        int x = 10;
        int y = 20;

        swap(x, y);                                     //x,y是实参
        System.out.println( "x==" + x + ",y==" + y );
    }
    /**
     * 定义方法，实现两个整数的交换
     * @param m     接收一个整数
     * @param n     接收另外一个整数
     */
    public static void swap(int m,int n) {              //m,n是形参
        int t = m;
        m = n;
        n = t;
    }
}

方法的重载

package com.bjpowernode.day07.demo06.methodoverload;
/*
 * 方法的重载
 * 1)为什么重载？
 *      同一个类中，相同的功能使用相同的方法名
 * 2)如何实现重载？
 *      方法名相同，方法的参数类型或者参数个数不同
 * 在编译时，编译器会找与实参最匹配的方法执行
 */
public class Demo {

    public static void main(String[] args) {

        System.out.println(12);
        System.out.println(1.2);
        System.out.println(true);
        System.out.println('A');
        System.out.println("abc");
        //之所以能够打印不同数据类型的数据，就是因为println()方法已经实现了重载

        //在调用方法时，编译器会找到最匹配的方法执行
        System.out.println( sum(1,2));
        System.out.println( sum(1.5,2));
        System.out.println( sum(1,2.5));
        System.out.println( sum(1.5,2.5));
        System.out.println( sum(1,2,3));
    }

    /*
     * 定义方法，返回两个整数的和
     */
    public static int sum(int x,int y) {
        return x+y;
    }

    /*
     * 定义方法，返回三个整数的和
     */
    public static int sum(int x,int y,int z) {
        return x+y+z;
    }

    /*
     * 定义方法，返回两个小数的和
     */
    public static double sum(double x,double y) {
        return x+y;
    }
}

递归调用

package com.bjpowernode.day07.demo06.methodoverload;
/*
 * 递归调用
 *  在方法体中又调用了它自身
 * 在定义方法时，主要确定两点
 *  1)找规律
 *  2)确定结束条件
 * 
 */
public class Demo01 {

    public static void main(String[] args) {
        long result = getFactorial(5);
        System.out.println( result );
    }

    /*
     * n! = (n-1)! * n
     * 1! = 1
     */
    public static long getFactorial(int n) {
        if ( n==1 ) {
            return 1;
        }
        return getFactorial(n-1)*n;
    }

    /**
     * 求一个数的阶乘
     * @param n     接收一个整数
     * @return      返回n!
     * 
     * 5!=1*2*3*4*5
     * 4!=1*2*3*4
     * n!=(n-1)!*n
     */
    public static long factorial(int n) {
        long res = 1;
        for(int x=1; x<=n; x++) {
            res *= x;
        }
        return res;
    }
}

faith1996

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
JavaDay07

打印10000以内的所有完全数。如果一个正整数等于除了它本身之外所有除数之和，这个数就是完全数。如6==1+2+3 28==1+2+4+7+14。package com.bjpowernode.day07.demo01.exercise;/* *打印10000以内的所有完全数。如果一个正整数等于除了它本身之外所有除数之和，这个数就是完全数。 *如6==1+2+3 28==1...
复制链接

扫一扫