方法

何谓方法？

比如，System.out.println()

​ 类 对象 方法

• Java方法是语句的集合，他们在一起执行一个功能。

  1. 方法是解决一类问题的步骤的有序组合
  2. 方法包含于类或对象中
  3. 方法在程序中被创建，在其他地方被引用

• 设计方法的原则：保持方法的原子性，即一个方法只完成一个功能

方法定义

Java方法相当于其他语言的函数，是一段用来 完成特定功能的代码片段。

修饰符  返回值类型  方法名（参数类型  参数名）{
   ....
   方法体
   ....
   return 返回值;      
}

方法包含一个方法头和一个方法体。

1. 修饰符：可选

2. 返回值类型：没有返回值时，用关键字void

3. 方法名：注意规范，见名知意

4. 参数类型：参数像是一个占位符。当方法被调用时，传递值给参数。这个值称为实参或变量。

   参数列表是指方法的参数类型、顺序和参数个数。参数是可选的，方法可以不包含任何参数。

   **形式参数：**在方法被调用时用于接受外界输入的数据。

   ​ 被调用时才创建，被临时分配内存，在调用结束后，立即释放所分配的内存单元。也就是说，当方法调用返回时，不能在使用这些形式参数。

   **实参：**调用方法时实际传给方法的数据。

5. 方法体：方法体包含具体的语句，定义该方法的功能。

6. break :跳出switch,结束循环

​ return:结束方法，返回一个结果

方法调用

1. 调用方法：对象名.方法名（实参列表）

2. Java支持两种调用方法，根据方法是否返回值来选择。

   • 当方法返回一个值时，方法调用通常被当作一个值。
   • 如果方法返回值是void，方法调用一定是一条语句。

   扩充：

   • 值传递（Java）：

   ​ 在方法的调用过程中，实参把它的实际值传递给形参，此传递过程就是将实参的值复制一份传递到函数中，这样如果在函数中对该值（形参的值）进行了操作将不会影响实参的值。因为是直接复制，所以这种方式在传递大量数据时，运行效率会特别低下。

   //值传递
   public class Demo3 {
       public static void main(String[] args) {
           int a=1;
           System.out.println(a);//a为1
   
           Demo3.change(a);
           System.out.println(a);//a为1
       }
       //返回值为空
       public static  void  change(int a){
           a=10;
       }
   }
   

   ​ 引用传递：

   ​ 引用传递弥补了值传递的不足，如果传递的数据量很大，直接复过去的话，会占用大量的内存空间，而引用传递就是将对象的地址值传递过去，函数接收的是原始值的首地址值。在方法的执行过程中，形参和实参的内容相同，指向同一块内存地址，也就是说操作的其实都是源数据，所以方法的执行将会影响到实际对象。

   • 静态方法

   static 可以直接调用

• 非静态方法 需要实例化对象才能被调用

方法的重载

​ 假设要设计一系列方法，他们功能相似；如果他们都统一叫相同的名称，那对用户来说就非常方便。但是对编译器来说这就很难区分。 比如：一个班有8个人重名，都叫“张三”。老师无法从姓名上区分这8个人，需要用到这些同学的其他信息（脸部特征、声音特征等）

​ 因此，编译器为了区分这些函数，除了会用到方法名这个特征，还会用方法的参数列表（参数类型+参数个数）来区分不同方法。**方法的名称及参数列表构成方法的签名。（方法的返回值不属于签名）**所以不能用方法的返回值来区分不同方法。

eg: int add(int,int) 与 void add(int,int) 对编译器，这两个方法相同，无法重载

​ 这种方法名相同，参数列表不同的方法签名机制，就是方法的重载

规则

1. 方法名称相同
2. 参数列表不同（参数个数、参数类型、参数顺序至少有一项不同）
3. 方法的返回值类型和修饰符不做要求，可同也可不同。

方法名称相同时，编译器会根据调用方法的参数个数、参数类型等逐一配对，以选择对应的方法；如果匹配失败，则编译器报错。

重载方法valueOf()的使用演示

public class OverLoadValueOf {
    public static void main(String[] args) {
        byte num_byte=12;
        short num_short=34;
        int num_int =12345;
        float num_float=12.34f;
        boolean b_value=false;
                            //使用了String类下的静态重载方法valueOf()
        System.out.println("num_byte is"+String.valueOf(num_byte));
        //虽然方法同名，但参数列表不同，他们所调用的形参类型依次是 byte/short等
        System.out.println("num_short is"+String.valueOf(num_short));
        System.out.println("num_int is"+String.valueOf(num_int));
        System.out.println("num_float is"+String.valueOf(num_float));
        System.out.println("b_value is"+String.valueOf(b_value));

    }
}

重载方法printlin的使用演示

System.out.println();可以输出不同的数据类型；相同的方法名+不同的参数列表=方法重载

/*
    System.out.println();的含义
 System是在java.lang包中定义了一个内置类，在该类中定义了一个内置对象out;
由于静态成员是属于类成员的，所以访问方式是：类名.成员名（System.out）;
 out本质上是PrintStream类的实例对象;
 println()是PrintStream类中定义的方法  ;
 */

加法方法的重载

public class AddMethodOverLoad {

        //计算两个整数之和
        public int add(int a,int b)//第一个方法add，参数列表类型（int,int）
        {
            return  a+b;
        }

        //计算两个单精度浮点数之和
        public float add ( float a, float b)//第二个方法add，参数列表类型（float,float）
        {
            return a + b;
        }

        //计算三个整数之和
        public int add ( int a, int b, int c)//第三个方法add，参数列表类型（int,int,int）
        {
            return a + b + c;
        }
        //上面三个add方法，由于参数列表不同构成方法重载

    public static void main(String[] args) {
        int result;
        float result_f;
        //实例化一个本类对象
         AddMethodOverLoad test=new AddMethodOverLoad();

         //调用第一个add方法
        result=test.add(1,2);
        System.out.println("add计算1+2的和："+result);
        //调用第二个add方法
        result_f=test.add(1.2f,2.3f);
        System.out.println("add计算1.2+2.3的和："+result_f);
        //调用第三个add方法
        result=test.add(1,2,3);
        System.out.println("add计算1+2+3的和："+result);
    }

构造方法

可变参数

从JDK 1.5开始，Java支持传递同类型的可变参数给一个方法

• 在方法声明中，在指定参数类型后加一个省略号…
• 一个方法中只能指定一个可变参数，它必须是方法的最后一个参数。任何普通的参数必须在它之前声明。

public class Demo3 {
    public static void main(String[] args) {
        Demo3 demo3=new Demo3();
        demo3.test(1,3,6);
    }
    public void test(int... i){//（int... i,int j）这是错的
        System.out.println(i[0]);
        System.out.println(i[1]);
    }
}

递归

学的是递归思想

5！ 下面从左到右在从右到左

​ main —f(5)----f(4)—f(3)—f(2)—f(1)=1

main里面调用到，输出—f(5) <-----f(4)—f(3)----f(2)-------1