方法参数有两种调用类型，一是按按值调用，表示方法接收的是调用者提供的值。二是引用调用，表示方法接收的是调用者提供的变量地址。方法可以修改传递引用所对应的变量值，而不能修改传递值调用所对应的变量值。

java程序设计语言 总是采用按值调用，也就是说，方法得到的是所有参数值的一个拷贝，特别是，方法不能修改传递给它的任何参数变量的内容。

public static void raiseSalary(int salary) {
        salary += 10000;
        System.out.println("按值传递:"+salary);
    }

    public static void main(String[] args){
        int salary = 30000;
        raiseSalary(salary);
        System.out.println("after raise:"+salary);
    }

执行程序：

按值传递:40000
after raise:30000

重载：

如果多个方法有相同的名字、不同的参数，便产生了重载。编译器通过用各个方法给出的参数类型与特定方法调用所使用的值类型进行匹配来挑选出相应的方法。

如果编译器找不到匹配的参数，就会产生编译错误，因为根本不存在匹配，或者没有一个比其他的更好。（这个过程被称为重载解析）。

调用另一个构造器：

关键字this引用方法的隐式参数，不过这个关键字还有另外一个含义。如果构造器的第一个语句形如this(...)，这个构造器将调用同一个类的另一个构造器。

public Employee(double s) {
    // calls Employee(String, double)
    this("Employee #" + nextId, s);
    nextId++;
}

当调用new Employee(60000)时，Employee(double)构造器将调用Employee(String, double)构造器。采用这种方式使用this关键字非常有用，这样对公共的构造器代码部分只编写了一次即可。

初始化数据域我们可以：

  • 在构造器中设置值
  • 在声明中赋值

实际上java还有第三种机制，称为初始化块。在一个类的声明中，可以包含多个代码块。只要构造类对象，这些块就会被执行。

class Employee {
    private static int nextId;
    private int id;
    private String name;
    private double salary;
    
    // object initialization block
    {
        id =  nextId;
        nextId++;
    }
    // ...
}

如果对类的静态域进行初始化的代码比较复杂，那么可以使用静态的初始化块。

// static initialization block
static{
    Random generator = new Random();
    nextId = generator.nextInt(10000);
}

// 静态初始化语句
private static int nextId = 1;

在类第一次加载的时候，将会进行静态域的初始化。与实例域一样，除非将它们显式地设置成其他值，否则默认的初始值是0、false或null。所有的静态初始化语句以及静态初始化块都将依照类定义的顺序执行。

import java.util.Random;

class Employee {
    private static int nextId;

    private int id;
    // instance field initialization
    private String name = "";
    private double salary;

    // static initialization block
    {
        Random generator = new Random();
        // set nextId to a random number between 0 and 9999
        nextId = generator.nextInt(10000);
    }
    // object initialization block
    {
        id = nextId;
        nextId++;
    }
    // three overloaded constructors
    public Employee(String n, double s) {
        name = n;
        salary = s;
    }
    public Employee(double salary) {
        // calls the Employee(String, double) constructor
        this("Employee #" + nextId, salary);
    }
    // the default constructor
    public Employee() {
        // name initialized to ""
        // salary not explicitly set -- initialized to 0
        // id initialized in initialization block
    }

    public String getName() {
        return name;
    }

    public double getSalary() {
        return salary;
    }

    public int getId() {
        return id;
    }
}
public class ConstructorTest {
    public static void main(String[] args) {
        // fill the staff array with three Employee objects
        Employee[] staff = new Employee[3];

        staff[0] = new Employee("Harry",40000);
        staff[1] = new Employee(60000);
        staff[2] = new Employee();

        // print out information about all Employee objects
        for (Employee e : staff) {
            System.out.println("name="+ e.getName() + ",id="+e.getId() + ",salary=" + e.getSalary());
        }
    }
}

执行程序：

name=Harry,id=5592,salary=40000.0
name=Employee #5593,id=50,salary=60000.0
name=,id=1173,salary=0.0

Process finished with exit code 0