方法

何为方法

JAVA方法是语句的结合，组合在一起来实现某种功能。（可以理解为Python的函数）

本质是功能块，是实现功能的语句块的有序集合

• 方法包含在类和对象中
• 方法在程序中被创建，在其他地方被调用

方法定义的原则：

保持方法原子性(一个方法实现一个功能)

方法的定义和调用

• 修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。

• 返回值类型 ：方法可能会返回值。returnValueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字void。
• 方法名：是方法的实际名称。方法名和参数表共同构成方法签名。
• 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
• 方法体：方法体包含具体的语句，定义该方法的功能。

例1

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


public class Demo {
    public static void main(String[] args) {  //main
       int  add =  add (1,  2) ;  //给方法的参数赋值

        System.out.println(add);  //调用方法使用
    }

    public static int add (int a, int b){ 
 /*
修饰符public static
返回类型 int
方法名 add 
数据类型是 int
数据名是 a , b
*/
        int c = a + b ;
   
        return c ; //返回c 值
    }
}

例2

public class Demo {
    public static void main(String[] args) {
       int  add =  add (1,  2) ;

        System.out.println( "add方法: " + add);
        N(0);
    }

    public static int add (int a, int b){  //整数加法方法
        int c = a + b ;
        return c ;
    }

    public static int N (int a){  //循环输出数字方法，这里的a是形参
    for (int  b = 0 ; b <= 5 ; b++){ // 这里的b为实参
        System.out.println(b);

        a = b ; //将实参的值赋给形参
    }

    return a ;  //返回a值
    }

}

方法调用

对象名.方法名(实参列表)

如果返回是个值，方法调用一般是一个值。

int larger = max(30, 40);

如果是viod，返回值是个语句

System.out.println("Hello,World！");

例如下

public class Demo {
    public static void main(String[] args) {
       int  add =  add (1,  2) ;

        System.out.println( "add方法: " + add);
        System.out.println( "N方法: " + N(0));
        Text( 2) ;

//      Text() ;

    }

    public static int add (int a, int b){  ///add方法，返回值int
        int c = a + b ;
        return c ;
    }

    public static int N (int a){
    for (int  b = 0 ; b <= 2 ; b++){  //N方法，返回值int
        a = b ;
    }
    return a ;
    }

    public static void Text(int a ){ //Text方法,返回值void，不用加return
        if (a == 2){
            System.out.println("Text:" + a);
        }
    }

//  public static void Text(){
//          System.out.println("Text");
//  }

}

方法的重载

在一个类中方法名相同，但参数不一致的方法

重载规则

• 方法名相同
• 方法的参数类型，参数个不一样
• 方法的返回类型可以不相同
• 方法的修饰符可以不相同
• main 方法也可以被重载

实例

public class Demo {
    public static void main(String[] args) {
        double a = N(1) ;
        int b = N(2) ;
        System.out.println(a);
        System.out.println(b);

    }
    //int
    public static int N (int a){  //方法N,返回值 int
    return a ;
    }


    //double
    public static double N (double c){  //方法N,返回值 double 
        return c ;
    }

}

可变参数

可以接受多个值的形参

• 在方法声明中，指定参数类型要加省略号( … )
• 可变参数只能作为函数的最后一个参数，但其前面可以有也可以没有任何其他参数

public class Demo1 {
    public static void main(String[] args) {
        Demo1 Demo1 = new Demo1() ; //定义一个demo1
        Demo1.Text(1,2,3);  //调用Text方法
    }


    public static void Text (int ...i){
        System.out.println(i[0]);
        System.out.println(i[1]);
        System.out.println(i[2]);
    }

}

递归

方法A调用方法A,自己调用自己

public class Demo1 {  
    int b = 0 ;
    public static void main(String[] args) {
        Text(1,0) ;
    }

    public static int Text (int i ,int b ){
        if (b < 100){
            System.out.println(i);
            b ++ ;
        }
        return Text(i,b) ;
    }

}

运行结果如下

对象之间相互引用，最终会导致栈溢出

所以就需要加入边界条件了。

递归结构包括两个部分：

递归头：什么时候不调用自身方法，没有递归头，会陷入死循环

递归体：什么时候需要调用自身方法

所以之前的代码是没有递归头，有递归体。

public class Demo {
    public static void main(String[] args) {
//            Text(0) ;
            Text(9999);
    }

    public static int Text (int b ){
        if (b <= 10){ //递归体
            System.out.println(b);
            return 10 ;
        }else {
            return Text(b-1) ;//递归头
        }

}

修饰符 Static

static 修饰的变量

没加 static

public class MI{
    int P = 10;  //普通变量 P
    public void BB (){
        System.out.println(P);
    }
}

调用输出

public class iiuiu {
    public static void main(String[] args){
    MI M1 = new MI();
    M1.P = 100; //给实例 M1的变量 P 赋值
    M1.BB();

    MI M2 = new MI();
    M2.BB();
    }
}

输出的结果：

加入 static （在同一个类里面创建的所有对象共享一个值）

public class MI{
    static int P = 10; //静态变量 P
    public void BB (){
        System.out.println(P);
    }
}

调用输出

public class iiuiu {
    public static void main(String[] args){
    MI M1 = new MI();
    M1.P = 100;
    M1.BB();

    MI M2 = new MI();
    M2.BB();
    }
}

输出结果:

static 修饰的方法

用 static 修饰的方法，不属于某一个对象，属于某一个类。

public class House {
    static int A ; //静态变量A
    public static void DDD(){ //静态方法DDD
        A = 10;
    }
}