Java-方法

1.方法的简介

方法(method)，就是一段具有特定功能的代码。可以通过调用名字在任意的位置上进行重复使用,从而达到代码简化的目的。

特点以及优点：

1. java程序中最小的执行单元
2. 提高了代码的重用性和可维护性

2.方法的定义

方法是类体中的一个成员，所以方法要定义在类体中。

访问权限修饰符    其他的修饰符  返回值类型  方法名(参数列表) { 
   // 方法体
   return;
}

1.在访问权限修饰符  和  其他的修饰符 的位置上需要的时候要写上，不需要的时候可以不用写

2.方法名用小驼峰命名法（即首单词的字符小写，从第二个单词开始的单词，每个单词的首字母要大写）

3.方法之间是平级的，不允许出现方法嵌套方法。

3.方法的修饰词

 （1)访问权限修饰词

方法并不是在任何位置上都可以被调用，它能否调用与权限修饰词有关。

权限修饰词	本类中	同包下	子类中	其他位置
public	√	√	√	√
protected	√	√	√
默认的	√	√
private	√

 （2）其他修饰词

 static:   静态的方法，    调用的时候使用类名直接调用。 也可以在本类中的其他方法（静态方法和非静态方法）中直接写方法名表示调用（非静态方法中可以直接调用静态静态方法  ）

public class A {
    static void alpha() {
       
    }
    void beta() {
        alpha();
    }
}

 final:    最终，最后。    final修饰的方法在子类中不能被修改了。因为是最终的了。

 （3）方法的返回值

  方法的返回值：

1. 方法在定义时，必须规则方法的返回值类型是什么

2. 方法的返回值类型位置可以书写两大类型

         第一种类型：void, 无类型， 表示方法在执行完毕后，不需要返回任何数据。

         第二种类型：java中的任一类型，包括程序员自定义的类型。

3. return关键字：

         -- 返回，归还的含义。

        -- 在方法中表示结束方法，因此return后不能有其他代码。没有意义，执行不到。

         -- void类型的方法，return 可加可不加 

    //定义一个void形式的方法m1
    public static void m1(){
        int a = 1;
        int b = 2;
        int c = a + b;
        return; //return关键字表示方法结束，可加可不加
    }

         -- 返回值类型是其他类型的方法，return关键字必须添加，并且return 后必须有一个该返回值类型的变量或者表达式。表示方法执行完毕后，最终数据要返回给调用者。

    //定义一个返回值类型为int的方法m2
    public static int m2(){
        int a = 1;
        int b = 2;
        byte c = (byte)(a + b); 
        return c;  //必须加上return  //byte类型自动转成int类型
    }

注意： 谁是调用者： 调用该方法的所在处就是调用者。

（4)方法的参数列表

方法的参数列表：

        1. 参数列表具体指的是定义期间方法名后小括号里的参数的类型列表

                  类型非常重要，列表指的是从左到右的顺序。名字不重要

        2. 参数列表的语法： 是0个以上的变量的声明语法。没有初始化操作。

        3. 参数列表里的参数名，称为形式参数，简称形参。

        4. 形式参数用于规定，方法在调用的时候，告诉调用者应该传入什么样的类型的数据。

扩展知识点：

         方法签名：方法名+参数的类型列表

                         比如：m1(int a, long b,String c)的方法签名：m1(int,long,String)

         在同一个类体中，不能存在方法签名相同的方法                                  

方法的重载：  同一个类中，方法名相同，参数类型列表不同(方法签名不同)。

                            m1(String x, long y,int z) 的方法签名是m1(String,long,int)  m1重载。

方法的重载和访问修饰符以及返回值类型无关

如：

public int A(int i);

public double A(int i); 

这2个方法不能构成重载，会有编译错误。   他们的方法签名相同。

 4.方法的调用

 方法的调用： 没有学习面向对象前，方法都使用static修饰。

        (1). 没有参数的方法调用语法

    1. void修饰的方法，调用的形式是直接写   方法名() ;

     2.其他返回值类型的方法，需要声明一个变量来接收方法中返回的值，特别注意的是该变量的类型要和返回值类型形同;当然也可以用输出语句直接输出。

一般都是如下形式 ：

                        返回值类型 变量 = 方法名();

都没有参数的两种类型的调用演示如下：

public class _04MethodDemo {
    public static void main(String[] args) {
        /* 先演示没有形参列表的方法调用*/
        //void形式的方法调用
        System.out.println("--开始前--");
        myMethod1();
        System.out.println("--后续代码--");
        //返回值是java类型的方法调用
        int s = myMethod2();
        System.out.println("s="+s);
        System.out.println(myMethod2()+1);
    }
    public static void myMethod1(){
        int a = 10;
        int b = 20;
        int c = a + b;
        System.out.println(c);
    }
    // 需求：计算1~100的和。
    public static int myMethod2(){
        int sum = 0;
        for (int i = 1; i < 101; i++) {
            sum+=i;
        }
        return sum;
    }
}

 (2)有参数的方法的调用

                 - 实际参数，简称实参。在调用时，传入到方法小括号里的变量，或者是具体值。

                 - 实参的作用：就是用于给形参赋值(传值),这个过程,称之为传参.

1. void形式的方法调用：  方法名(有几个形参就传入几个实参)  

2. 有具体返回值的方法调用 ： 返回值类型 变量 = 方法名(有几个形参就传入几个实参)

实列参考：

public class _01MethodDemo {
    public static void main(String[] args) {
        //需求:  计算两个int类型的数据之和
        int m = 5;
        int n = 6;
        /* 调用sum(int,int):
         *  调用的时候，m和n都是实际参数，要传入到方法的小括号里。
         *  m给形参a赋值，n给形参b赋值。
         */
        sum(m,n);  // sum int int


        //需求2： 获取三个int类型的随机整数中的最大值。
        int x = (int)(Math.random()*100);
        int y = (int)(Math.random()*100);
        int z = (int)(Math.random()*100);
        System.out.println("x="+x+",y="+y+",z="+z);
        //调用getMax(int,int,int)方法，将实际参数x,y,z传给方法的形参。
        int max = getMax(x, y, z);//该方法是有返回值的方法，需要声明一个变量来接收值。
        System.out.println("max = " + max);
    }

    /**
     *  用于计算两个int类型的数据的和
     * @param a   int类型的a
     * @param b   int类型的b
     */
    public static void sum(int a, int b) {
        a = 2*a;
        b = b+5;
        int c = a+b;
        System.out.println("c=" + c);
    }

    public static int getMax(int a, int b,int c) {
        int max = Integer.MIN_VALUE;
        if(a > b && a > c){
            max =  a;
        }else if(b > a && b > c){
            max = b;
        }else{
            max = c;
        }
        return max;
    }

}