【Java方法的声明和使用 03】

一、方法，Method，函数，function

public class MethodTest01 {

    //定义一个方法，该方法完成两个int类型数据的求和
    public static void sum(int a,int b){
        int c = a+b;
        System.out.println(a+"+"+b+"="+c);
    }

    public static void main(String[] args){

        //调用方法：类名.方法名
        MethodTest01.sum(66,88);
        MethodTest01.sum(13,14);
    }

}

二、

方法如何定义，语法：
    [修饰符列表] 返回类型类型  方法名(形式参数列表){
        方法体;//由加吧语句构成}


1、目前阶段所有方法的修饰符列表统一写成：public static
2、返回值类型可以是java中任何一种数据类型
3、如果该方法执行结束之后没有任何返回值，那么返回值数据类型必须写成void
4、如果方法的返回值类型不是void，而是其他的数据类型，那么在方法体中必须保证有rerurn值
5、注意：如果return语句一旦执行，则标识该方法结束，所以return语句下面不能再编写其他的java语句
6、方法名只要是合法的标识符即可
7、方法的形式参数列表参数的个数可以是0个，也可以是1个，还可以是多个，如果是多个的话必须使用逗号隔开
8、方法的形式参数列表中起决定性作用的是参数的类型，而不是变量名
9、所有带有static关键字的方法被调用时，都采用类名称.方法名(实际参数列标配)

package com.company.Mothod;

/**
 * @Created by IntelliJ IDEA.
 * @Author tk
 * @Date 2019/7/29
 * @Time 17:11
 */
public class MethodTest01 {

    //返回值类型为int类型
    public static int sumInt(int a ,int b){
        return a+b;
    }

    //形式参数定义的是布尔类型，返回值内没有false，程序会报错
    public static int method1(boolean flag){
        if(flag){
            return 1;
        }
    }

    //形式参数为布尔类型，返回值的True和false都必须有返回，否则会报错
    public static int method2(boolean flag){
        if(flag){
            return 1;
        }else{
            return 0;
        }
    }

    //return返回以后不能运行Java语句
    public static int method3(boolean flag){
        if(flag){
            return 1;
            System.out.println("hello");
        }else{
            return 0;
        }
        System.out.println("hello world！");
    }

    public static void main(String[] args){

        MethodTest01.sum(13,14);
        //一般情况下有返回值就应该接收
        int retValue =MethodTest01.sumInt(1,2);
        System.out.println(retValue);

        int retMethod = MethodTest01.method2(true);
        System.out.println(retMethod);
    }

}

/*
    单独使用return;
        return;语句只能出现在方法的返回值类型时void的方法中，用来终止该方法的执行
     */
    public static void  method4(){
        for(int i=1;i<=10;i++){
            if (i==5){
                //break;
                return;//返回类型void时，一旦遇到return，就会终止后面其他语句的执行
            }
            System.out.println(i);
        }
        System.out.println("hello Word！");
    }
=====执行结果=====
使用break时，会打印1，2，3，4，5，hello Word！
使用return时，会打印1，2，3，4，5  不会打印hello Word
对比后发现执行return后，后面的语句会被截断，也就是不会在被执行

1）方法中，实际参数的值会按照顺序赋值给形式参数

public class Method002 {

    //实际参数会按照顺序赋值给形式参数,并且是一一对应的
    public static void method1(int x,int y){
        int z = x+y;
        System.out.println("z："+z);
    }

    public static void main(String[] args){

        int i=6;
        int j=7;
        method1(i,j); //i赋值给x,j赋值给y
    }
}

三、类

1、一个.java源文件中可以有多个class的声明

2、并且一个class声明会对应一个class文件

3、public class类名，必须和源文件名保持一致（包括大小写）

4、public类可以没有，要是有的话只能有一个

public class Lei {
    public static void main(String[] args){
        System.out.println("public类！");
    }
}

class A{
    public static void main(String[] args){
        System.out.println("A类！");
    }
}

class B{
    public static void main(String[] args){
        System.out.println("B类！");
    }
}

三、同一个类中的方法被调用，直接用方法名()；不同类中的方法被调用，用类名.方法名()

package com.company.Mothod;

/**
 * @Created by IntelliJ IDEA.
 * @Author tk
 * @Date 2019/7/31
 * @Time 14:57
 */
public class MethodTest02 {

    /*
    同一个类，方法调用可以直接用方法名
    不同的类调用，必须用类名.方法名()
     */
    public static void m1(){
        System.out.println("MethodTest02类中的m1方法被调用");
    }

    public static void main(String[] args){
        m1();
        A.m2();

    }
}

class A{
    public static void m2(){
        System.out.println("A类的m2方法被调用");
    }
}

四、

如果方法只是定义，没有被调用，不会给该方法分分配内存

方法被调用的时候，会在JVM中为该方法分配内存（此时发生的是压栈动作）

当方法结束后，该方法分配的内存就会释放（此时发生的是弹栈动作）

public class MethodTest03 {
    public static void main(String[] args){
        MethodTest03.m1(100);
    }
    public static void m1(int i){
        MethodTest03.m2(i);
    }
    public static void m2(int k){
        MethodTest03.m3(k);
    }
    public static void m3(int m){
        System.out.println(m);
    }
}

五、局部变量

变量的四种属性：数据类型，变量名，变量值，空间大小

定义在方法外的变量叫：成员变量

定义在方法内的形式参数和方法语句内的变量叫：局部变量

-----局部变量脱离了大括号以后不起作用-------

public class MethodTest04 {
    public static void main(String[] args){
        int i =10;
        add(i);
        System.out.println("main -----> "+ i);

    }
    public static void add(int i){
        i++;
        System.out.println("add -----> "+ i);
    }
}

程序执行到add(i)时，先进行压栈，待add方法执行完以后进行弹栈，即：jvm分配的内存释放
main方法在继续执行，执行到 System.out.println("main -----> "+ i);打印的就是int=10；

所以得出：局部变量脱离了大括号以后，作用范围也就失效了

六、方法重载

使用前提：几个方法实现的功能是类似的

方法重载发生的条件

1、方法在同一个类里面

2、方法名相同，参数列表不同（个数，顺序，类型）

3、方法重载和方法的修饰符列表无关

4、方法重载和方法的返回值类型无关

/*
1、功能相同
2、方法名相同但是形式参数个数，类型，顺序不同
3、和修饰符没有关系，和返回的数据类型没有关系
 */
public class MethodTest05 {
    public static void main(String[] args){
        int sum1 = m1(2,3);
        System.out.println("sum1---> "+sum1);
        float sum2 = m1(1.1f,1.2f,1.3f);
        System.out.println("sum2---> "+sum2);
        long sum3 = m1(3,4);
        System.out.println("sum3---> "+sum3);

    }
    public static int m1(int v1,int v2 ){
        return v1+v2;
    }
    public static float m1(float v1,float v2,float v3){
        return v1+v2+v3;
    }
    public static long m1(long v1,long v2){
        return v1+v2;
    }
}

/*
方法重载：
1、各个方法的功能是相同的，可以用方法重载
2、方法重载的方法名是相同的，取决于形式参数的个数、顺序、类型(也就是说，在调用方法的时候，是根据传入的实际参数的顺序，类型和数量来判断调用哪个方法)
3、方法重载和修饰符，返回类型没有关系
 */
public class Method003 {

    //需求：完成不同类型的运算
    public static void main(String[] args){
        sun(2,3);
        sun(1.2,1.3);
        sun(3.6,3.7);
    }

    public static int sun(int a,int b){
        int c = a+b;
        System.out.println("c= "+c);
        return c;

    }

    public static int sun(float a,float b){
        float c = a+b;
        System.out.println("c= "+c);
        return 0;//方法是什么类型就返回什么类型


    }

    public static double sun(double a,double b){
        double c = a+b;
        System.out.println("c= "+c);
        return c;

    }
}