方法

/*
    方法（相当于函数）：代码的重复利用，提高代码的复用性
    需要方法的时候就调用(invoke)
    方法是定义在类体当中，方法编写的位置没有先后顺序
*/
public class MethodTest01
{
    public static void main(String[] args){
        
        //计算两个int类型数据的和
        MethodTest01.sumInt(10, 20);

        MethodTest01.sumInt(666, 888);

        MethodTest01.sumInt(111, 222);
    }

    //单独的定义的一个方法
    //该方法完成计算两个int类型数据的和，并且将结果输出
    public static void sumInt(int a, int b){
        int c = a + b;
        System.out.println(a + " + " + b + " = " + c);
    }
}

/*
    关于java语言当中的方法：
        方法的语法结果：
            [修饰符列表] 返回值类型 方法名(形式参数列表){
                方法体:
            }

        对以上的语法进行解释说明
            关于修饰符列表
                可选项，不是必须的
                目前统一写成：public static
                方法的修饰符列表中有static关键字，调用方法的方法：
                    类名.方法(实际参数列表);

            返回值类型
                1、返回值：
                    一个方法完成某个特定的功能后，
                    大多数需要返回一个最终的执行结果，
                    这个具体存在的数据就是返回值

                2、返回值可以返回的类型：
                    java任意的类型都可以，
                    包括基本数据类型和所有的引用数据类型

                3、也可以这个方法执行结束之后不返回任何数据类型，
                    所有在返回值类型位置必须编写：void关键字

                4、返回值类型若不是void，
                    表示这个方法执行结束之后必须返回一个具体的数据

                5、返回值类型是void的时候，
                    在方法体当中不能编写"return 值;"这样的语句。
                    但可以编写"return;"这样的语句

                6、只要带有return关键字的语句执行，
                    return语句所在的方法结束

            方法名：
                要合法标识符、最好见名知意、最好是动词、
                首字母要求小写，后面每个单词首字母大写
            
            形式参数列表（简称形参）：
                形参是局部变量，多个形参之间用“逗号”隔开
                方法在调用时，
                实际给这个方法传递的真实的数据称为实际参数，
                简称实参

            方法体必须由大括号括起来，
            内部的代码遵循自上而下的顺序依次执行

            方法的调用：
                方法只有在调用的时候才会执行
                语法规则（方法的修饰符列表中有static）：
                类名.方法名(实参列表);
*/
//public表示公开的
//class表示定义类
//MethodTest03是一个类名
public class MethodTest02{
    
    //方法出现在类体当中
    //(String[] args)：形式参数列表，
    //String[]是一种引用数据类型，args是局部变量的变量名
    //主方法需这样固定编写，是程序的入口
    public static void main(String[] args){
        
        //这里的程序一定会执行
        //main方法是JVM负责调用的，是一个入口位置
        //可以在此编写java语句来调用其他的方法
        //调用MethodTest02的sum方法，传递两个实参
        MethodTest02.sum(10, 20);

        //一个方法可以被重复调用
        int a =100;
        MethodTest02.sum(a,500);

    }

    //自定义方法，不是程序的入口
    //方法作用：计算两个int类型数据的和，不要求返回结果，但要求将结果直接输出到控制台
    //修饰符列表：public static
    //返回值类型：void
    //方法名：sum
    //形式参数列表：(int x,int y)
    //方法体：主要任务是求和之后输出结果
    public static void sum(int i, int j){
        System.out.println(i + "+" + j + "=" + (i + j));
    }
}

/*
    方法的调用不一定在main方法当中，可以在其他地方
*/
public class MethodTest03
{
    public static void sum(int a,int b){
        
        System.out.println(a + "+" + b + "=" + (a + b));

        //调用dosome方法
        MethodTest03.dosome();
    }

    //主方法
    public static void main(String[] args){
        
        //调用sum方法
        MethodTest03.sum(1,2);

        System.out.println("Hello World");
    }

    public static void dosome(){
        System.out.println("do some!");
    }
}

//类型不同的时候要求进行相应的自动类型转换

public class MethodTest04
{
    public static void main(String[] args){
        
        //编译报错：参数数量不同
        //MethodTest04.sum();

        //编译错误：实参和形参的类型不是对应相同
        //MethodTest04.sum(true,false);

        //可以
        MethodTest04.sum(10L,20L);

        //存在自动类型转换：int --> long
        MethodTest04.sum(10,20);
    }

    public static void sum(long a,long b){
        System.out.println(a + "+" + b + "=" + (a + b);)
    }
}

/*
    方法调用：
        1、方法的修饰符列表当中有static关键字，
            完整的调用方式是：类名.方法名（实参列表）;
        2、但是，有些时候“类名”可以省略，
            m1(){
                m2();
            }
            //m1方法和m2方法在同一个类体当中的时候，
            //“类名.”可以省略不写
        3、建议在一个java源文件中只定义一个class，比较清晰 
*/
public class MethodTest05
{
    public static void main(String[] args){
        
        //调用方法
        MethodTest05.m();

        //对于方法的修饰符列表当中有static关键字的：
        //“类名.”可以省略不写
        m();

        //调用其他类【不是本类中的】中的方法
        A.doOther();

        //编译报错：“类名.”省略之后，
        //默认从当前类中找"doOther"方法，
        //在当前类中该方法不存在
        //doOther();
    }

    public static void m(){
        System.out.println("m method execute!");

        //完整的方式
        MethodTest05.m2();

        //省略的方式
        m2();

        //调用其他类的m2
        A.m2();
    }

    public static void m2(){
        System.out.println("m2 execute!");
    }
}

class A //最好不要这样写，一个文件一个class，这里只是例子
{
    public static void doOther(){
        System.out.println("A's doOther method invoke!");
    }

    public static void m2(){
        System.out.println("A's m2 method execute!");
    }
}

/*
    输出结果
    main begin
    m1 begin
    m2 begin
    m3 begin
    m3 over
    m2 over
    m1 over
    main over
    对于当前程序来说，main方法最先被调用，也是最后一个结束
*/
public class MethodTest06
{
    public static void main(String[] args){
        System.out.println("main begin");
        m1();
        System.out.println("main over");
    }

    public static void m1(){
        System.out.println("m1 begin");
        m2();
        System.out.println("m1 over");
    }

    public static void m2(){
        System.out.println("m2 begin");
        m3();
        System.out.println("m2 over");
    }

    public static void m3(){
        System.out.println("m3 begin");
        System.out.println("m3 over");
    }
}

/*
    1、方法的返回值类型不是void的时候，要求方法必须百分百执行
        "return 值;"这样的语句来完成值的返回
    2、一个方法有返回值的时候，对于调用者来说，
        这个返回值可以选择接收也可以选择不接收，但通常都接收
*/
public class MethodTest07
{
    public static void main(String[] args){
        

        //调用方法
        divide(10,3); //这里没有接收这个方法的返回值

        //采用变量接收，
        //变量的数据类型需要和返回值的数据类型相同，
        //或者可以自动类型转换
        int i = divide(10,3);
        System.out.println(i);

        System.out.println(divide(10,3));
    }

    /*
        需求：
            定义并实现一个方法，
            该方法可以计算两个int类型数据的商
            要求将最终结果返回给调用者
    */

    public static int divide(int a, int b){
        return a / b;
    }
}

/*
    深入return语句
        1、带有return关键字的java语句只要执行，所在的方法执行结束
        2、在同一个作用域当中，
            return语句下面不能编写任何代码，
            因为这些代码永远不会执行
*/
public class MethodTest08
{
    public static void main(String[] args){
        System.out.println(m());
    }

    //编译报错：缺少返回语句，
    //以下程序编译器认为无法百分百保证“return 1;”会执行
    /*
    public static int m(){
        int a = 10;
        if(a > 3){
            return 1;
        }
    }
    */
    
    //编译通过：以下程序可以保证“return 1;” 或“return 0;”执行
    public static int m(){
        int a = 10;
        if(a > 3){
            return 1;
            //编译错误，这里的代码无法访问
            //System.out.println("Hello");
        }
        return 0;
    }

    //也可以用三目运算符
    /*
    public static int m(){
        return 10 > 3 ? 1 : 0;
    }
    */
}

/*
    在返回值是void的方法当中使用"return;"语句
    "return;"语句出现在返回值为void的方法中主要是为了结束当前方法
*/

public class MethodTest10
{
    public static void main(String[] args){
        m();
    }

    //编译错误：对于结果类型为空的方法，无法返回值
    /*
    public static void m(){
        return 10;
    }
    */
    public static void m(){
        
        for(int i = 0;i< 10;i++){
            if(i = 5){
                //return //终止了m()方法
                break; //终止的for循环
            }
            System.out.println("i --> " + i);
        }
        System.out.println("Hello World");
}

/*
    方法在执行过程中，在JVM的内存的分配方法
        
        1、方法只定义，不调用，是不会执行的，
            并且在JVM中也不会给该方法分配“运行所属”的内存空间。
            只有在调用这个方法的时候，
            才会动态的给这个方法分配所属的内存空间。
        
        2、在JVM内存划分有三块主要的内存空间
            （除这三块还有其他的）：
            方法区内存
            堆内存
            栈内存
        
        3、关于栈数据结构：
            栈：stack，是一种数据结构
            数据结构反应的是数据的存储形态
            数据结构是独立的学科，
                不属于任何编程语言的范畴，
                只不过大多数编程语言当中要使用数据结构
            常见的数据结构：数组、队列、栈、链表、二叉树...

        4、方法代码片段存在哪里？
        方法执行的时候执行过程的内存在哪里分配？
            方法代码片段属于.c1ass字节码文件的一部分，
            字节码文件在类加载的时候，
            将其放到了方法区当中。
            所以JVM中的三块主要的内存空间中方法区内存，
            最先有数据，存放了代码片段

            代码片段虽然在方法区内存当中只有一份，
            但是可以被重复调用。
            每一次调用这个方法的时候，
            需要给该方法分配独立的活动场所，在栈内存中分配。
            【栈内存中分配方法运行的所属内存空间】

        5、方法在调用的瞬间，会给该方法分配内存空间，
            会在栈中发生压栈动作，方法执行结束之后，
            给该方法分配的内存空间全部释放，
            此时发生弹栈动作。
                压栈：给方法分配内存
                弹栈：释放该方法的内存空间

        6、局部变量在方法体中声明。
            局部变量运行阶段内存在栈中分配

*/

 

//在EditPlus当中，字体颜色为红色的表示一个类的名字，
//并且这个类是javaSE类库中自带的

//我们自定义的类MethodTest11，和自带的类String.class...
//都是标识符，只要是类名就一定是标识符

//重点：方法调用的时候，在参数传递的时候，
//实际上传递的是变量中保存的那个值传过去了

//顺序： 类加载：MethodTest11、String、System ->
//        然后执行main方法 ->开辟a、b两变量空间
public class MethodTest11
{
    public static void main(String[] args){
        int a = 10;
        int b = 20;
        int retValue = sumInt(a,b);
        System.out.println("retValue = " + retValue);
    }

    public static int sumInt (int i,int j){
        int result = i + j;
        int num = 3;
        int retValue = divide(result,num);
        return retValue;
    }

    public static int divide(int x,int y){
        int z = x / y;
        return z;
    }
}