Java 函数练习

1.封装一个函数，返回两个整数里的较大那个

 1 class Practice1{
 2     public static void main(String[] args) {
 3         int num = maxOfNumber(10, 20);
 4         System.out.println("num = " + num);
 5     }
 6     
 7     //封装一个函数，返回两整数里的较大那个
 8     public static int maxOfNumber(int num1, int num2) {
 9         int max = num1;
10         if (num1 < num2) {
11             max = num2;
12         }
13         return max;
14     }
15 }

2.封装一个函数，返回两个浮点数里的较小那个

 1 class Practice2 {
 2     public static void main(String[] args) {
 3         double num = minOfNumber(5.164, 6.45);
 4         System.out.println("num = " + num);
 5     }
 6     
 7     //封装一个函数，返回两浮点数里的较小那个
 8     public static double minOfNumber(double num1, double num2) {
 9         double min = num1;
10         if (num1 > num2) {
11             min = num2;
12         }
13         return min;
14     }
15 }

3.封装一个函数，来判断一个字符是否是大写字母，如果是，返回true,否则返回false

 1 class Practice3 {
 2     public static void main(String[] args) {
 3         boolean flag = isMyUpper('A');
 4         System.out.println("flag = " + flag);
 5     }
 6     
 7     //封装一个函数，来判断一个字符是否是大写字母
 8     //如果是，返回true,否则返回false
 9     public static boolean isMyUpper(char c) {
10         boolean ret = false;
11         if (c >= 'A' && c <= 'Z') {
12             ret = true;
13         }
14         return ret;
15     }
16 }

4.封装一个函数，来判断一个字符是否是数字字符，如果是，返回true，否则返回false

 1 class Practice4 {
 2     public static void main(String[] args) {
 3         boolean flag = isMyNumber('a');
 4         System.out.println("flag = " + flag);
 5     }
 6     
 7     //封装一个函数，来判断一个字符是否是英文字母
 8     //如果是，返回true，否则返回false!
 9     public static boolean isMyNumber(char c) {
10         boolean ret = true;
11         if ((c >= 'A' && c <= 'Z') || (c >= 'a' && c <= 'z')) {
12             ret = false;
13         }
14         return ret;
15     }
16 }

5.封装一个函数，传入一个字符，如果是大写那么转化小写然后返回，否则保持不变返回

 1 class Practice5 {
 2     public static void main(String[] args) {
 3         char ch = toMyLower('A');
 4         System.out.println("ch = " + ch);
 5     }
 6     
 7     //封装一个函数，传入一个字符，如果是大写那么转化小写然后返回，
 8     //否则保持不变返回
 9     public static char toMyLower(char c) {
10         if (c >='A' && c <= 'Z') {
11             c += ('a' - 'A');
12         }
13         
14         return c;
15     }
16 }

6.封装一个函数，实现将一个正整数，倒序打印输出! 如：1234 4321

 1 class Practice6 {
 2     public static void main(String[] args) {
 3         reverse(1234653);
 4     }
 5     
 6     //封装一个函数，实现将一个正整数，倒序打印输出! 1234 4321 
 7     public static void reverse(int number) {
 8         while (number > 0) {
 9         System.out.print(number % 10);
10         number /= 10;
11         }
12     }
13 }

7.流程控制（闰年问题）输入一个年份，判断该年份是平年还是闰年，如果是返回true，否则返false

注: 闰年就是第二个月有29天的那一年, 能被4整除但是不能被100整除的是闰年, 或者能被400整除的也是闰年

 1 class Practice7 {
 2     public static void main(String[] args) {
 3         boolean flag = isLeap(2000);
 4         System.out.println("flag = " + flag);
 5     }
 6     
 7     //流程控制（闰年问题）    输入一个年份，判断该年份是平年还是闰年：
 8     //注: 闰年就是第二个月有29天的那一年, 能被4整除但是不能被100整除的是闰年, 或者能被400整除的也是闰年
 9     //如果是返回 true  不是返回false
10     public static boolean isLeap(int year) {
11         boolean flag = false;
12         if (year % 4 == 0 && year % 100 != 0 || year %400 == 0) {
13             flag = true;
14         }
15         
16         return flag;
17     }
18 }

猜你喜欢