Java方法

方法

• 1. System.out.println();//是什么吗?
  2. //系统类+对象+方法

  复制代码
• Java方法是一对语句的集合,他们一起负责执行一个功能
  

  
  

  
  
  • 方法是解决一类问题的步骤的有序组合
    
  • 方法包含于类或对象中
    
  • 方法在程序中被创建,在其他地方被引用
    

  
  
• 设计原则: 方法本意是功能块(类似C语言的函数), 就是实现某个功能的语句块集合,设计方法最好保持方法的原子性,就是一个方法只完成1个功能,这样有利于后期的扩展
  
• 命名规范: 首字母小写+驼峰规则
  
• 方法都是写在main外面的
  
• 1. package Method;
  3. public class Demo_0 {
  4.     public static void main(String[] args) {
  5.         //调用了add方法
  6.                                 //实参
  7.         int sum = add(1, 2);//int sum = add(1, 2);
  8.         System.out.println(sum);
  9.         //System.out.println(add(1, 2));
  10.         System.out.println("======================================");
  12.         //调用test
  13.         test();
  14.     }
  16.     //加法                                        形式参数
  17.     public static int add(int a, int b) {//有返回值需要int等类型
  18.         return a + b;//返回值
  19.     }
  21.     //方法2
  22.     public static void test() {//返回值为空void
  23.         //while循环输出1~1000之间被5整除的数,并且3个每行
  24.         int i_1 = 0;
  25.         while (i_1 <= 1000) {
  26.             ++i_1;
  27.             if (i_1 % 5 == 0) {
  28.                 System.out.print(i_1 + "\t\t");//不要加ln
  29.             }    //println输出后会自动换行
  30.             if (i_1 % (5 * 3) == 0) {
  31.                 System.out.println();
  32.             }
  33.         }
  35.     }
  37. }
  38. //此段代码不显示图片, 自身去试试代码

  复制代码

方法重载

• 重载就是在一个类中,有相同函数名称, 但形参不同的函数
  
• 重载规则
  
  
  
  • 方法名必须相同
    
  • 参数列表必须不同(个数, 类型, 参数排列顺序不同等)
    
  • 方法返回的类型可相同也可不通
    
  • 仅仅返回类型不同不足以成为方法重载
    
  
  
• 实现理论: 方法名称相同时,编译器会根据调用方法的参数个数,参数类型等逐个匹配, 以选择对应的方法,如果匹配失败,则编译器报错
  
• 重载与返回值无关(返回类型可相同也可不同)
  

1. 修饰符 返回值类型 方法名(参数类型 参数名){
2.     //修饰符包含了static或者void
3.         ...
4.         方法体
5.         ...
6.         return 返回值;
7. }

复制代码

• 注释了的代码可全部解开, 试试输入的double类型和int类型的,最后输出若有.0就是double类型;注意更改我代码中Scanner等变量
  

命令行传参(可以简单了解)

• 以下代码是需要在java文件的路径下用cmd进行编译,参考Hello.java
  
• 以下代码需要用更改编码格式才可编译
  
• 1. //对象名.方法名(实参列表)

  复制代码

1.     int larger = Max(30, 40);

复制代码

• cmd窗口解析
  

  
  

  
  
  • 在java文件的所在路径下编译java文件
    
  • cd ../回退上一级文件夹(可以体会下在其他文件下引用自己写的java文件)
    
  • 运行编译好的java文件(为何没有输出, 因为我们的java代码是需要将参数输出, 我并没有参数输入)
    
  • 再一次运行java文件, 在java Method.CmdTran输入四个参数I am your Father
    
  • 输出了四个刚刚输入的参数(数组下标由0开始)
    

  
  

可变参数(不定项参数)

• 在JDK 1.5开始, Java支持传递同类型的可变参数给一个方法
  
• 方法声明中, 在指定参数类型后加一个省略号(...)
  
• 一个方法中只能指定一个可变参数, 它必须是方法的最后一个参数; 任何普通的参数必须在它之前声明
  
• 在一开始写方法时,会有很多不确定变量, 我们需要写多种方法(方法重载), 而每种方法都是只实现一个功能,依次针对不同情况
  

1. package Method;
3. import java.util.Scanner;
5. public class Demo_1 {
6.     public static void main(String[] args) {
7.         System.out.println("比谁大");
8.         System.out.print("Input Number_1: ");
9.         Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
10.         int Number_1 = Input.nextInt();//用next方法接收
11.         //nextInt()接收int类型的数值
12.         //
13.         System.out.print("Input Number_2: ");
14.         Scanner Input2 = new Scanner(System.in);//创建一个名字"Input"的扫描器
15.         int Number_2 = Input2.nextInt();
16.         System.out.println("\t两个数中这个最小: " + Max(Number_1, Number_2));
17.         System.out.println("============================================");
18.         System.out.println("比谁小");
19.         System.out.print("Input Number_3: ");
20.         Scanner Input_Num3 = new Scanner(System.in);//创建一个名字"Input"的扫描器
21.         int Number_3 = Input.nextInt();//用next方法接收
22.         //nextInt()接收int类型的数值
23.         
24.         System.out.print("Input Number_4: ");
25.         Scanner Input_Num4 = new Scanner(System.in);//创建一个名字"Input"的扫描器
26.         int Number_4 = Input2.nextInt();
27.         System.out.println("\t两个数中这个最小: " + Min(Number_3, Number_4));
28.     }
30.     //两个数比大小,输出大的
31.     public static int Max(int a, int b) {
32.         if (a == b) {
33.             System.out.println("\tNumber_1 == Number_2");
34.             //return 0; //终止方法
35.             return a;
36.         } else if (a > b) {
37.             System.out.println("\t两个数中Number_1最大");
38.             return a;
39.         } else {
40.             System.out.println("\t两个数中Number_2最大");
41.             return b;
42.         }
43.     }
44.     //
46.     //两个数比大小,输出小的
47.     public static int Min(int x, int y) {
48.         if (x == y) {
49.             System.out.println("\tNumber_3 == Number_4");
50.             return x;
51.         } else if (x < y) {
52.             System.out.println("\t两个数中Number_3最小");
53.             return x;
54.         } else {
55.             System.out.println("\t两个数中Number_4最小");
56.             return y;
57.         }
58.     }
59.     //
60. }

复制代码

• 变长参数是 Java 的一个语法糖，本质上还是基于数组的实现：
  

1. package Method;
3. import java.util.Scanner;
5. public class Demo_1 {
6.     public static void main(String[] args) {
7.         //System.out.println("比谁大");
8.         //System.out.print("Input Number_1: ");
9.         //Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
10.         //int Number_1 = Input.nextInt();//用next方法接收
11.         ////nextInt()接收int类型的数值
12.         //
13.         //System.out.print("Input Number_2: ");
14.         //int Number_2 = Input.nextInt();
15.         //System.out.println("\t两个数中这个最小: " + Max(Number_1, Number_2));
16.         //Input2.close();
17.         //Input.close();
18.         //System.out.println("==============================================");
19.         //System.out.println("比谁小");
20.         //System.out.print("Input Number_3: ");
21.         //Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
22.         //int Number_3 = Input.nextInt();//用next方法接收
23.         ////nextInt()接收int类型的数值
24.         //
25.         //System.out.print("Input Number_4: ");
26.         //int Number_4 = Input.nextInt();
27.         //System.out.println("\t两个数中这个最小: " + Min(Number_3, Number_4));
28.         //Input_Num3.close();
29.         //Input_Num4.close();
30.         ///////////////////
31.         System.out.println("比谁大");
32.         System.out.print("Input Number_1: ");
33.         Scanner Input = new Scanner(System.in);//创建一个名字"Input"的扫描器
34.         double Number_1 = Input.nextDouble();//用next方法接收
35.         //nextInt()接收int类型的数值
37.         System.out.print("Input Number_2: ");
38.         double Number_2 = Input.nextDouble();//若nextDouble变为nextInt不会出崔,但最后结果会跟随最开头的Double
39.         System.out.println("\t两个数中这个最小: " + Max(Number_1, Number_2));
40.         Input.close();
41.         Input2.close();
42.     }
45.     //两个数比大小,输出大的
46.     public static int Max(int a, int b) {
47.         if (a == b) {
48.             System.out.println("\tNumber_1 == Number_2");
49.             //return 0; //终止方法
50.             return a;
51.         } else if (a > b) {
52.             System.out.println("\t两个数中Number_1最大");
53.             return a;
54.         } else {
55.             System.out.println("\t两个数中Number_2最大");
56.             return b;
57.         }
58.     }
60.     public static double Max(double a, double b) {//针对Max()方法的重载;返回double类型
61.         if (a == b) {
62.             System.out.println("\tNumber_1 == Number_2");
63.             //return 0; //终止方法
64.             return a;
65.         } else if (a > b) {
66.             System.out.println("\t两个数中Number_1最大");
67.             return a;
68.         } else {
69.             System.out.println("\t两个数中Number_2最大");
70.             return b;
71.         }
72.     }
73.     //
76.     //两个数比大小,输出大的
77.     public static int Min(int x, int y) {
78.         if (x == y) {
79.             System.out.println("\tNumber_3 == Number_4");
80.             return x;
81.         } else if (x < y) {
82.             System.out.println("\t两个数中Number_3最小");
83.             return x;
84.         } else {
85.             System.out.println("\t两个数中Number_4最小");
86.             return y;
87.         }
88.     }
89.     //
90. }

复制代码

递归

• A方法调用A方法! 自己调用自己
  
• 思想: 简单程序解决复杂问题; 把大型复杂的问题层层转化为一个与原问题相似的规模较小问题来求解
  
• 递归结构: 递归头就是啥时候不调用自己,如果没有就陷入死循环
  
• 递归结构: 递归体就是啥时候调用自身方法
  
• 虽然代码量简单且少,但会占用很多空间
  

1. javac -encoding utf8 CmdTran.java
2.      //编码格式

复制代码

• 递归: 本质就是当我调用时, 只要我调用方法时没用到递归头的条件我就必须使用递归体语句从而不断缩小了问题的本质, 当进行递归体语句时,就可以将递归体语句的结果不断返回上去
  

计算器实现

• 计算器,实现加减乘除,并能循环接收新数据,通过交互实现
  

1. package Method;//注意自己的包名
3. public class CmdTran {//注意自己的文件名
4.     public static void main(String[] args) {
5.         //命令行传参
6.         for (int i = 0; i < args.length; i++) {
7.             System.out.println("args[" + i + "] = " + args[i]);
8.         }
9.     }
10. }

复制代码

• 计算器可以对其数据类型更改为double类型, 让其除法运算有更高的精度;
  
• 思路:
  
  
  • 对加减乘除方法进行编写
    
  • 思考利用什么条件来对switch条件进行判断运算选择(利用运算符)
    
  • 由于条件需要循环不断接收数值, 所以利用while语句的判定, 并且在一次循环结尾重新定义while语句的判定,判断是否再一次进行二元运算
    
  
  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！