07 方法

方法(函数)

• 为什么要有方法
  假设有一个游戏程序，程序在运行过程中，要不断地发射炮弹(植物大战僵尸)。
  发射炮弹的动作需要编写100行的代码，在每次实现发射炮弹的地方都需要重复地编写这100行代码，这样程序会变得很臃肿，可读性也非常差。
  为了解决代码重复编写的问题，可以将发射炮弹的代码提取出来放在一个{}中，并为这段代码起个名字，
  这样在每次发射炮弹的地方通过这个名字来调用发射炮弹的代码就可以了。上述过程中，所提取出来的代码可以被看作是程序中定义的一个方法，
  程序在需要发射炮弹时调用该方法即可。
• 什么是方法
  方法就是完成特定功能的代码块
  在很多语言中都有函数的定义，但是在咱们JAVA语言中，我们将其称之为方法。
• 方法的格式

修饰符 返回值类型 方法名(参数类型 参数名1，参数类型 参数名2 ....){
		方法体;
		return 返回值;
	}

• 方法的格式详细说明
  (1): 修饰符 比较多,后面会详细介绍。目前使用 public static
  (2): 返回值类型 用于限定返回值的数据类型
  (3): 方法名 就是一个名称，它的存在是为了方便我们调用方法
  (4): 参数类型 限定调用方法时传入参数的数据类型
  (5): 参数名 是一个变量，接收调用方法时传入的参数
  这个参数其实有一个专业的名词,被称之为形式参数,它的作用是用来接收实际参数的.
  (6): 方法体 完成功能的代码
  (7): return 结束方法以及返回方法指定类型的值
  (8): 返回值 就是功能的结果，由return带回，带回给调用者
• 如何写一个方法
  两个明确
  (1):返回值类型 明确功能结果的数据类型
  (2):参数列表 你要传递几个参数，以及每一个参数的数据类型
• 方法调用(有明确返回值的调用) 可以用方法调用图解来理解
  a:单独调用,一般来说没有意义，所以不推荐。
  b:赋值调用,推荐方案。
  c:输出调用,但是不够好。因为我们可能需要针对结果进行进一步的操作
• 方法的注意事项
  A: 方法不调用不执行
  B: 方法与方法是平级关系，不能嵌套定义
  C: 方法定义的时候参数之间用逗号隔开
  D: 方法调用的时候不用在传递数据类型
  E: 如果方法有明确的返回值，一定要由return带回一个值

package org.westos.demo;
public class MyDemo {
    //JVM 来调用主方法 main
    public static void main(String[] args) {
//方法：就是对一段功能逻辑的封装，以实现重复调用
//方法的语法：public static 返回值类型 方法名(参数类型 参数名){方法体}//public static void main(String[] args) 
//1.方法的定义位置：方法定义在类中  //类 public class MyDemo
//2.方法跟方法是平级关系，不能嵌套定义
//3.方法不调用，不执行
        System.out.println("这是主方法");//main主方法//主方法是public static void main(String[] args)
        
        //我在main调用我自己定义的方法 add  // 调用下面自己定义的 public static void add(){...}方法 
        add(); //使用方法名直接调用 
        add();
    }
    //自己定义方法
    public static void add(){
        int num1=1;
        int num2=10;
        System.out.println(num1+num2);
    }
}

//需求：求两个数据之和的案例
package org.westos.demo;
public class MyDemo {
    public static void main(String[] args) {
        add();
       
        add2(10,30); // 带参数方法add2(int a,double b)  形参传入值为 add2(10,30) 是常量
        //调用带有参数的方法:必须给形参传入值，传入的类型和个数要跟形参对应
        //在定义方法时，写在括号里面的参数，叫做形式参数，简称形参
        //在调用方法时，传入的参数，叫做实际参数，简称 实参

        int num1=50;
        double num2=50;
        add2(num1, num2);//形参传入值是变量

        double r= add3(10,50);//add3(10,50)改成double r= add3(10,50) 要返回double类型的返回值
        System.out.println(r);  //拿到了方法的返回值r
        //因为：我想拿到调用完方法后，产生的那个结果
        //所以：这个方法你调用完之后，他有返回值，你可以接收这个返回值，那么方法返回什么类型，你就用什么类型来收
        //那至于这个方法的返回值，你可以接收，你也可以不接收
        //返回值，是谁调用就返回给谁   //return 返回结果并结束方法

        double v = add3(2.6, 6.3);
        System.out.println(v);
        
        //如果这个方法有返回值，就可以直接输出调用
        System.out.println(add3(3,9));
       //System.out.println(add3(3,9));等于把double v = add3(2.6, 6.3);和System.out.println(v);结合成一个语句了
    }
    //定义两个数相加的方法
    public static void add(){
        int num=1;
        int num2=2;
        int sum=num+num2;
        System.out.println(sum);
        return; //因为是void无明确返回值类型 所以return仅仅就结束方法   是void时 return可以省略不写
    }
     
    public static void add2(int a,double b){  
    //带有参数方法的定义 
    //我们在定义方法时，写在括号里面的参数，叫做形式参数，简称形参 //(double a,double b)括号里面的参数就是形式参数
    // 格式:数据类型1 参数名1,数据类型2 参数名2
        double sum=a+b;
        System.out.println(sum);
    }
    
//方法的返回值
//void 无明确返回值类型  //上面 public static void add2(int a,double b){} 中的void 就表示 add2无明确返回值类型
//如果你想要让这个方法执行完之后，返回一个结果，那么你就要明确这个方法的返回值类型
// 一旦你明确了方法的返回值类型，那么就必须由 return 带回一个与明确类型相关的值
    public static double add3(double a, double b) {
        double sum = a + b;
        return sum;//add3明确了方法的返回值类型double  就必须由return带回一个与明确类型相关的值
    }
}

//案例演示:	需求：求两个数的最大值，把这个功能逻辑抽取成方法来做
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
    public static void main(String[] args) {
        //定义方法时，要明确的几个方面
        // 1. 这个方法要不要返回值，
        // 2.这个方法方法要不要参数
        // 3.还得明确一下返回值类型和参数类型
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int num1 = scanner.nextInt();      
        System.out.println("请输入第二个整数");
        int num2 = scanner.nextInt();
        //调用方法
        int max = getMax(num1, num2);
        System.out.println("最大值是" + max);
    }
    public static int getMax(int a, int b) {
        int max = a >= b ? a : b;
        return max;
    }
}
--------------------------------------------------------------------------------
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
    public static void main(String[] args) {
    
        int max2 = getMax2();
        System.out.println("最大值是" + max2);
    }
    public static int getMax2() {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个整数");
        int num1 = scanner.nextInt();
        System.out.println("请输入第二个整数");
        int num2 = scanner.nextInt();

        int max = num1 >= num2 ? num1 : num2;
        return max;
    }
}

//案例演示:	需求：比较两个数是否相等
package org.westos.demo;
import java.util.Scanner;
    public class Demo {
        public static void main(String[] args) {
            Scanner sc = new Scanner(System.in);
            System.out.println("请输入第一个数");
            int i = sc.nextInt();
            
            Scanner sc2 = new Scanner(System.in);
            System.out.println("请输入第二个数");
            int j = sc2.nextInt();
            
            String xt=function(i,j);
            System.out.println("这两个数" + xt+"相同的");
        }
        private static String function(int a,int b) {
            return a==b?"是":"不是";
        }
    }

//案例演示:	需求：根据键盘录入的数据输出对应的乘法表
package org.westos.demo;
import java.util.Scanner;
public class MyDemo {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入一个行数");
        int num = scanner.nextInt();
        
        showMultiplicationTable(num);
    }
    
    private static void showMultiplicationTable(int num) {
        for (int i = 1; i <= num; i++) {
            for (int j = 1; j <= i; j++) {
                System.out.print(j+"*"+i+"="+j*i+"\t");
            }
            System.out.println();
        }
       return; //结束方法
    }
}

方法重载概述和基本使用

• 方法重载概述
  在同一个类中，允许存在一个以上的同名方法，只要它们的参数列表不同，与返回值无关。
• 参数列表不同：
  A:参数个数不同
  B:参数类型不同

//案例演示；求和案例  2个整数 3个整数 4个整数
package org.westos.demo3;
public class MyDemo {
    public static void main(String[] args) {
        //几个数相加的操作
        int sum1 = add(1, 2);
        int sum2 = add(1, 2, 3);
        int sum3 = add(1, 2, 3, 4);
        double sum1 = add(1, 2.0);
        System.out.println(sum1);
        System.out.println(sum2);
        System.out.println(sum3);
        System.out.println(sum1);
        //方法重载：允许一个类中可以定义多个同名方法，只要形参的个数或类型不一样就可以
        //不拿返回值来区分
    }
    private static int add(int i, int i1, int i2, int i3) {
        return i + i1 + i2 + i3;
    }
    private static int add(int i, int i1, int i2) {
        return i + i1 + i2;
    }
    private static int add(int i, int i1) {
        System.out.println("两个int类型的调用了");
        return i + i1;
    }
    private static double add(int i, double i1) {
        System.out.println("一个int类型一个double类型的调用了");
        return i + i1;
    }
}