Java方法

Java 方法

什么是方法呢？

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

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

---

方法的定义

一般情况下，定义一个方法包含以下语法：

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

方法包含一个方法头和一个方法体。下面是一个方法的所有部分：

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

修饰符

访问修饰符->访问权限

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 修饰符，主要用于线程的编程。

返回值类型

void 关键字

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

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

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

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

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

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

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

方法的命名规则

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

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

参数列表

(参数类型 参数名)

可变参数

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

方法的可变参数的声明如下所示：

typeName... parameterName

public class Changeable {
    public static void main(String[] args) {
        changeableValue(0,1,2,3,1,2,3);
    }

    public static void changeableValue(int... i) {
        for (int o : i) {
            System.out.println(o);
        }
    }
}

方法调用

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

当程序调用一个方法时，程序的控制权交给了被调用的方法。

当被调用方法的返回语句执行或者到达方法体闭括号时候交还控制权给程序。

当方法返回一个值的时候，方法调用通常被当做一个值。例如：

int larger = max(30, 40);

如果方法返回值是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;
    }
}

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

通过值传递参数

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

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

如下：

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的传参机制特殊？

通过命令行传参

有时候你希望运行一个程序时候再传递给它消息。这要靠传递命令行参数给main()函数实现。

命令行参数是在执行程序时候紧跟在程序名字后面的信息。

实例

下面的程序打印所有的命令行参数：

public class Command {
    public static void main(String[] args) {
        for (String arg : args) {
            System.out.println(arg);
        }
    }
}

如果代码包含包名，需要到代码的具体路径下运行javac生成class文件。

然后回到src目录通过包名.类名执行程序。

构造方法

当一个对象被创建时候，构造方法用来初始化该对象。构造方法和它所在类的名字相同，但构造方法没有返回值。

通常会使用构造方法给一个类的实例变量赋初值，或者执行其它必要的步骤来创建一个完整的对象。

不管你是否自定义构造方法，所有的类都有构造方法，因为Java自动提供了一个默认构造方法，

默认构造方法的访问修改符和类的访问修改符相同(类为 public，构造函数也为 public；类改为 protected，构造函数也改为 protected)。

一旦你定义了自己的构造方法，默认构造方法就会失效。

方法的重载

重载：在一个类中，有相同的方法名，但形参列表不同的方法

规则：

• 方法名必须相同

• 参数列表必须不同（个数、类型、顺序）

• 方法的返回类型可同可不同

• 不能仅仅依据修饰符或者返回类型的不同来重载方法

Java编译器根据方法签名判断哪个方法应该被调用。

*递归

自己调用自己的方法！

递归结构包含两个部分：

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

/**
 * 递归练习
 */
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);
    }
}

方法的优点

• 使程序变得更简短而清晰。
• 有利于程序维护。
• 可以提高程序开发的效率。
• 提高了代码的重用性。

设计方法的原则：方法的本意是功能块，就是实现某个功能的语句块的集合。我们设计方法的时候，最好保持方法的原子性。

问题

为什么说java只有值传递？

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

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

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

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

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

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

总结

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

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

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

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

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

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

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

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

案例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

解释这段代码：形参 s 获取了 实参str 拷贝的地址，意味着有两个变量指向“hello”字符串。而String类型是不可变的，

s 修改字符串的值，其实是创建了一个新的字符串“hello world”，再指向它。这时候str还是指向原来的“hello”，所以打印的结果不变。