Day4: 何为方法 / 方法的定义及调用 / 方法重载 / 命令行传参 / 可变参数 / 递归

1.何为方法

System.out.println() System(类)——out(system下的一个输出对象)——println() (方法)

调用系统中的标准输出对象 out 中的 println()方法
Java方法是语句的集合，它们在一起执行一个功能。
- 方法是解决一类问题的步骤的有序组合
- 方法包含于类或对象中
- 方法在程序中被创建，在其他地方被引用
设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性，就是一个方法只能完成一个功能，这样利于我们后期的扩展。
方法的命名规则：首字母小写和驼峰原则，如run(); runRun();

2.方法的定义及调用

1.方法的定义

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

修饰符：修饰符，这是可选的，告诉编译器如何调用该方法。定义了该方法的访问类型。
返回值类型：方法可能会有返回值。returnVallueType 是方法返回值的数据类型。有些方法执行所需的操作，但没有返回值。在这种情况下，returnValueType 是关键字 void。
方法名：是方法的实际名称。方法名和参数表共同构成方法名。首字母小写和驼峰原则
参数类型：参数像是一个占位符，当方法被调用时，传递值给参数。这个值被称为实参或变量。参数列表是指方法的参数类型、顺序和参数的个数。参数是可选的，方法可以不包含任何参数。
- 形式参数：在方法被调用是用于接收外界输出的数据。
- 实参：调用方法时实际传给方法的数据。
方法体：方法体包含具体的语句，定义该方法的功能。

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

1.修饰符

访问修饰符->访问权限

Java中，可以使用访问控制符来保护对类、变量、方法和构造方法的访问。Java 支持 4 种不同的访问权限。

default (即默认，什么也不写）: 在同一包内可见，不使用任何修饰符。使用对象：类、接口、变量、方法。
private : 在同一类内可见。使用对象：变量、方法。 注意：不能修饰类（外部类）
public : 对所有类可见。使用对象：类、接口、变量、方法
protected : 对同一包内的类和所有子类可见。使用对象：变量、方法。 注意：不能修饰类（外部类）。

修饰符	当前类	同一包内	子孙类(同一包)	子孙类(不同包)	其他包
`public`	Y	Y	Y	Y	Y
`protected`	Y	Y	Y	Y/N（说明）	N
`default`	Y	Y	Y	N	N
`private`	Y	N	N	N	N

非访问修饰符

static 修饰符，用来修饰类方法和类变量。
final 修饰符，用来修饰类、方法和变量，

final 修饰的类不能够被继承，修饰的方法不能被继承类重新定义，修饰的变量为常量，是不可修改的。
abstract 修饰符，用来创建抽象类和抽象方法。
synchronized 和 volatile 修饰符，主要用于线程的编程。

2.返回值类型

void 关键字

本节说明如何声明和调用一个 void 方法。

下面的例子声明了一个名为 print 的方法，并且调用它来打印给定的分数。

public class TestVoidMethod {
  public static void main(String[] args) {
    print();
  }
 
  public static void print() {
       System.out.println("不返回值");
  }
}

这里print方法是一个void类型方法，它不返回值。

一个void方法的调用一定是一个语句。

所以，它被在main方法第三行以语句形式调用。

就像任何以分号结束的语句一样。

3.方法的命名规则

1.方法的名字的第一个单词应以小写字母作为开头，后面的单词则用大写字母开头写，不使用连接符。小驼峰命名法 ，例如：addPerson。

2.下划线可能出现在 JUnit 测试方法名称中用以分隔名称的逻辑组件。一个典型的模式是：test_，例如 testPop_emptyStack。

public class Demo02{
    public static void main(String[] args){
        int max = max(10,20);
        System.out.println(max);
    }

    //比大小
    public static int max(int num1,int num2){
        int result = 0;
        if(num1==num2){
            System.out.println("num1==num2");
            return 0;//终止方法
        }
        if(num1>num2){
            result = num1;
        }else{
            result = num2;
        }
        return result;
    }
}

2.方法调用

调用方法：对象名.方法名(实参列表)
Java支持两种调回方法的方式，根据方法是否返回值来选择。
当方法返回一个值的时候，方法调用通常被当做一个值。例如：
```
int larger = max(30,40);
```
如果方法返回值是void，方法调用一定是一条语句。
```
System.out.println("Hello,uilufz!");
```

如果方法返回值是void，方法调用一定是一条语句。例如，方法println返回void。

静态方法

static 关键字用来声明独立于对象的静态方法。静态方法与类共存，对象还未实例化时就已经存在。

静态方法不能使用类的非静态变量，也不能调用非静态方法（存在的东西不能调用不存在的东西）

静态方法推荐以 类名.方法名 调用。

非静态方法

无static修饰，需要实例化对象，才能调用方法。

public class StaticTest {
    public static void main(String[] args) {
        say();
    }

    public static void say() {
        System.out.println("静态方法类加载时就已经存在，独立于对象");
        //nonStatic();// 调用不存在的方法！报错
        new StaticTest().nonStatic(); // 需要创建对象才产生非静态方法！
    }

    public void nonStatic(){
        System.out.println("这是个非静态方法，需要对象实例化才存在");
        // say();  // 调用已存在的方法，没问题
    }
}

以上两者本质上的区别是：

静态方法是在类中使用staitc修饰的方法，在类定义的时候已经被装载和分配。
而非静态方法是不加static关键字的方法，在类定义时没有占用内存，只有在类被实例化成对象时，对象调用该方法才被分配内存。

实际参数

传递给被调用方法的值，预先创建并赋予确定值。

形式参数

用来接收调用该方法时传递的参数。只有在被调用的时候才分配内存空间，一旦调用结束，就释放内存空间。因此仅仅在方法内有效。

public class Add {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println(add(a, b));// 传入数据的变量叫实参
    }
    public static int add(int a, int b) { // 接收数据的变量叫形参
        return a + b;
    }
}

实参和形参的类型要对应！！

值传递(java) 和引用传递

值传递：传递对象的一个副本，即使副本被改变，也不会影响源对象，因为值传递的时候，实际上是将实参的值复制一份给形参。
引用传递：传递的并不是实际的对象，而是对象的引用，外部对引用对象的改变也会反映到源对象上，因为引用传递的时候，实际上是将实参的地址值复制一份给形参。

通过值传递参数

调用一个方法时候需要提供参数，你必须按照参数列表指定的顺序提供。

值传递： 形参是实参的拷贝，改变形参的值并不会影响外部实参的值。

如下：

public class Value {
    public static void main(String[] args) {
        int a = 1;
        int b = 2;
        System.out.println("交换之前：a="+a+",b="+b);
        swop(a,b);
        System.out.println("交换之后：a="+a+",b="+b);
    }

    private static void swop(int x, int y) {
        System.out.println("swop方法内交换前：x="+x+",y="+y);
        int temp = x;
        x = y;
        y = temp;
        System.out.println("swop方法内交换后：x="+x+",y="+y);
    }
}

结果

交换之前：a=1,b=2
swop方法内交换前：x=1,y=2
swop方法内交换后：x=2,y=1
交换之后：a=1,b=2

可以发现x是复制a的值，y是复制b的值。x,y交换并不影响a,b的值

通过引用传递参数

在调用函数时将实际参数的地址直接传递到函数中，那么在函数中对参数所进行的修改，将影响到实际参数。

案例1：

public class Quote2 {
    public static void main(String[] args) {
        StringBuffer stringBuffer = new StringBuffer("hello");
        System.out.println(stringBuffer);
        change(stringBuffer);
        System.out.println(stringBuffer);
    }

    private static void change(StringBuffer s) {
        s.append(" world");
    }
}

结果

hello
hello world

案例2：

public class Quote {
    public static void main(String[] args) {
        String str = "hello";
        System.out.println(str);
        change(str);
        System.out.println(str);
    }

    private static void change(String s) {
        s = "hello world";
    }
}

结果

hello
hello

为什么两种引用传递得到的结果不一致？难道java的传参机制特殊？

3.方法重载

重载就是在一个类中，有相同的函数名称，但形参不同的函数。

方法的重载规则：

方法名称必须相同。
参数列表必须不同(个数不同、或类型不同、或参数排列顺序不同等)。
方法的返回类型可以相同也可以不相同。
仅仅返回类型不同不足以称为方法的重载。

实现理论:

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

4.命令行传参

有时候你希望运行一个程序的时候再传递给它消息。这要靠传递命令行参数给main()函数实现。
- 命令行参数是在执行程序时候紧跟在程序名字后面的信息。

public class CommandLine{
    public static void main(String args[]){
        for(int i=0; i<args.length; i++){
            System.out.println("args["+i+"]:"+args[i]);
        }
    }
}

5.可变参数

java支持传递同类型的可变参数给一个方法。

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

public class Demo04{
    public static void main(String args[]{
        //调用可变参数的方法
        printMax(...numbles:34,3,3,2,56,5);
        printMax(new double[]{1,2,3});
    }
    public static void printMax(double... numbers){
        if(numbers.length == 0){
            System.out.println("No argument passed");
            return;
        }    
        double result=number[0];
        //排序！
        for(int i=1; i<numbers.length; i++){
            if(numbers[i] > result){
                result = numbers[i];
            }
        }
        System.out.println("The mzx value is "+ result);
}

6.递归

A方法调用B方法，很容易理解！
递归就是：A方法调用A方法！就是自己调用自己

利用递归乐意用简单的程序来解决一些复杂的问题。它通常把一个大型复杂的问题层层转化为一个与元问题相似的规模较小的问题来求解，递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算，大大减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。

递归结构包括两个部分：

递归头：什么时候不调用自身方法。如果没有头，将陷入死循环。
递归体：什么时候需要调用自身方法。

//递归练习
 
public class Recursion {
    public static void main(String[] args) {
        int n = 10; // 求n的阶层
        System.out.println(f(n));
    }
    public static int f(int n) {
        if (n <= 1) {
            return 1;
        }
        return n * f(n - 1);
    }
}

7.作业

写一个计算器，要求实现加减乘除功能，并且能够循环接收新的数据，通过用户交互实现。

问题

为什么说java只有值传递？

	区别	影响
值传递	会创建副本	改变形参不影响实参
引用传递	不会创建副本	改变形参会影响实参

首先明确两点 java 中不管是值对象还是引用对象都是值传递，在其他方法里面改变引用类型的值肯定是通过引用改变的。

当传递引用对象的时候传递的是复制过的对象句柄(引用)，注意这个引用是复制过的，也就是说又在内存中复制了一份句柄，

这时候有两个句柄是指向同一个对象的，所以你改变这个句柄对应空间的数据会影响外部的变量的，

虽然是复制的但是引用指向的是同一个地址，当你把这个句柄指向其他对象的引用时并不会改变原对象，

因为你拿到的句柄是复制过的引用。总结java中的句柄(引用)是复制过的，所以说java只有值传递。

总结

无论是值传递还是引用传递，其实都是一种求值策略(Evaluation strategy)。

在求值策略中，还有一种叫做按共享传递(call by sharing)。其实Java中的参数传递严格意义上说应该是按共享传递。

按共享传递，是指在调用函数时，传递给函数的是实参的地址的拷贝（如果实参在栈中，则直接拷贝该值）。在函数内部对参数进行操作时，

需要先拷贝的地址寻找到具体的值，再进行操作。如果该值在栈中，那么因为是直接拷贝的值，所以函数内部对参数进行操作不会对外部变

量产生影响。如果原来拷贝的是原值在堆中的地址，那么需要先根据该地址找到堆中对应的位置，再进行操作。因为传递的是地址的拷贝所以

函数内对值的操作对外部变量是可见的。

简单点说，Java中的传递，是值传递，而这个值，实际上是对象的引用。

而按共享传递其实只是按值传递的一个特例罢了。所以我们可以说Java的传递是按共享传递，或者说Java中的传递是值传递。