静态字段与静态方法

静态字段

如果将一个字段定义为static，每个类只有一个这样的字段。而对于非静态的实例字段，每个对象都有自己的一个副本。例如，假设需要给每一个员工赋予唯一的标识码。这里给Employee类添加一个实例字段id和一个静态字段nextId：

class Employee
{
private static int nextId = 1;
private int id;
}


现在，每一个Employee对象都有一个自己的id字段，但这个类的所有实例将共享一个nextId字段。换句话说，如果有1000个Employee类对象，则有1000个实例字段id，分别对应每一个对象。但是，只有一个静态字段nextId。即使没有Employee对象，静态字段nextId也存在。它属于类，而不属于任何单个的对象。

程序示例

public class HuangZiHanTest
{
public static void main(String[] huangzihan_args)
{
Huangzihan_Employee huangzihan = new Huangzihan_Employee(1,2);
System.out.println(huangzihan.huangzihan_nextId());
System.out.println(huangzihan.huangzihan_id());
System.out.println();
Huangzihan_Employee Huangzihan = new Huangzihan_Employee(3,4);
System.out.println(Huangzihan.huangzihan_nextId());
System.out.println(Huangzihan.huangzihan_id());
}
}
class Huangzihan_Employee
{
private static int huangzihan_nextId = 1;
private int huangzihan_id;

public Huangzihan_Employee(int huangzihan_n, int huangzihan_i)
{
huangzihan_nextId = huangzihan_n;
huangzihan_id = huangzihan_i;
}

public int huangzihan_nextId()
{
return huangzihan_nextId;
}

public int huangzihan_id()
{
return huangzihan_id;
}
}


运行结果

1
2
3
4


注释

类字段

在一些面向对象程序设计语言中，静态字段被称为类字段。术语“静态”只是沿用了C++的叫法，并无实际意义。

下面实现一个简单的方法：

public void setId()
{
id = nextId;
nextId++;
}


假定为harry设置员工标识码：

harry.setId();


harry的id字段被设置为静态字段nextId当前的值，并且静态字段nextId的值加1：

harry.id = Employee.nextId;
Employee.nextId++;


程序示例

public class HuangZiHanTest
{
public static void main(String[] huangzihan_args)
{
Huangzihan_Employee huangzihan = new Huangzihan_Employee(1,2);
huangzihan.huangzihan_setId(1, 2);
}
}
class Huangzihan_Employee
{
private static int huangzihan_nextId = 1;
private int huangzihan_id;

public Huangzihan_Employee(int huangzihan_n, int huangzihan_i)
{
huangzihan_nextId = huangzihan_n;
huangzihan_id = huangzihan_i;
}

public void huangzihan_setId(int huangzihan_n, int huangzihan_i)
{
huangzihan_id = huangzihan_nextId;
huangzihan_nextId++;
System.out.println(huangzihan_nextId);
}
}


运行结果

2


静态常量

静态变量使用得比较少，但静态常量却很常用。例如，在Math类中定义一个静态常量：

public class Math
{
. . .
public static final double PI = 3.14159265358979323846;
. . .
}


在程序中，可以用Math.PI来访问这个常量。

如果省略关键字static，PI就变成了Math类的一个实例字段。也就是说，需要通过Math类的一个对象来访问PI，并且每一个Math对象都有它自己的一个PI副本。

你已经多次使用的另一个静态常量是System.out。它在System类中声明如下：

public class System
{
. . .
public static final PrintStream out = . . .;
. . .
}


前面曾经多次提到过，由于每个类对象都可以修改公共字段，所以，最好不要有公共字段。然而，公共常量（即final字段）却没问题。因为out被声明为final，所以，不允许再将它重新赋值为另一个打印流：

System.out = new PrintStream(...); //ERROR--out is final


注释

如果查看System类，就会发现有一个setOut方法可以将System.out设置为不同的流。你可能会感到奇怪，为什么这个方法可以修改final变量的值。原因在于，setOut方法是一个原生方法，而不是在Java语言中实现的。原生方法可以绕过Java语言的访问控制机制。这是一种特殊的解决方法，你自己编写程序时不要模仿这种做法。

静态方法

静态方法是不在对象上执行的方法。例如，Math类的pow方法就是一个静态方法。表达式

Math.pow(x, a)


会计算幂x^3。在完成运算时，它并不使用任何Math对象。换句话说，它没有隐式参数。

可以认为静态方法是没有this参数的方法（在一个非静态的方法中，this参数指示这个方法的隐式参数）。

Employee类的静态方法不能访问id实例字段，因为它不能在对象上执行操作。但是，静态方法可以访问静态字段。下面是这样一个静态方法的示例：

public static int getNextId()
{
return nextId; //returns static field
}


可以提供类名来调用这个方法：

int n = Employee.getNextId();


这个方法可以省略关键字static吗？答案是肯定的。但是，这样一来，你就需要通过Employee类对象的引用来调用这个方法。

程序示例

public class HuangZiHanTest
{
public static void main(String[] huangzihan_args)
{
int x = 2;
double a = Math.pow(x, 3);
System.out.println(a);

Huangzihan_Employee huangzihan = new Huangzihan_Employee();
int huangzihan_n = huangzihan.huangzihan_getNextId();
System.out.println(huangzihan_n);
}
}
class Huangzihan_Employee
{
private static int huangzihan_nextId = 3;

public static int huangzihan_getNextId()
{
return huangzihan_nextId;
}
}


运行结果

8.0
3


注释

可以使用对象调用静态方法，这是合法的。例如，如果harry是一个Employee对象，可以用harry.getNextId()代替Employee.getNextId()。不过，这种写法很容易造成混淆，其原因是getNextId方法计算的结果与harry毫无关系。我们建议使用类名而不是对象来调用静态方法。

两种情况下可以使用静态方法

在下面两种情况下可以使用静态方法：

• 方法不需要访问对象状态，因为它需要的所有参数都通过显式参数提供（例如：Math.pow）。

  
  



• 方法只需要访问类的静态字段（例如：Employee.getNextId）。

  
  

工厂方法

静态方法还有另外一种常见的用途。类似LocalDate和NumberFormat的类使用静态工厂方法（factory method）来构造对象。你已经见过工厂方法LocalDate.now和LocalDate.of。NumberFormat类如下生成不同风格的格式化对象：

NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance();
NumberFormat percentFormatter = NumberFormat.getPercentInstance();
double x = 0.1;
System.out.println(currencyFormatter.format(x)); // prints $0.10
System.out.println(percentFormatter.format(x)); // prints 10%


NumberFormat类不利用构造器的两个原因

为什么NumberFormat类不利用构造器完成这些操作呢？这主要有两个原因：

• 无法命名构造器。构造器的名字必须与类名相同。但是，这里希望有两个不同的名字，分别得到货币实例和百分比实例。

  
  



• 使用构造器时，无法改变所构造对象的类型。而工厂方法实际上将返回DecimalFormat类的对象，这是NumberFormat的一个子类。

  
  

程序示例

import java.text.NumberFormat;
public class HuangZiHanTest
{
public static void main(String[] huangzihan_args)
{
NumberFormat currencyFormatter = NumberFormat.getCurrencyInstance();
NumberFormat percentFormatter = NumberFormat.getPercentInstance();
double x = 0.1;
System.out.println(currencyFormatter.format(x));
System.out.println(percentFormatter.format(x));
}
}


运行结果

¥0.10
10%


main方法

需要注意，可以调用静态方法而不需要任何对象。例如，不需要构造Math类的任何对象就可以调用Math.pow。

同理，main方法也是一个静态方法。

public class Application
{
public static void main(String[] args)
{
// construct objects here
. . .
}
}


main方法不对任何对象进行操作。事实上，在启动程序时还没有任何对象。静态的main方法将执行并构造程序所需要的对象。

提示

每一个类可以有一个main方法。这是常用于对类进行单元测试的一个技巧。例如，可以在Employee类中添加一个main方法：

class Employee
{
public Employee(String n, double s, int year, int month, int day)
{
name = n;
salary = s;
hireDay = LocalDate.of(year, month, day);
}
. . .

public static void main(String[] args) // unit test
{
var e = new Employee("Romeo", 50000, 2003, 3, 31);
e.raiseSalary(10);
System.out.println(e.getName() + " " + e.getSalary());
}
. . .
}


如果想要独立地测试Employee类，只需要执行

java Employee


如果Employee类是一个更大型应用程序的一部分，就可以使用下面这条语句运行程序

java Application


Employee类的main方法永远不会执行。

下面中的程序包含了Employee类的一个简单版本，其中有一个静态字段nextId和一个静态方法getNextId。这里将三个Employee对象填入一个数组，然后打印员工信息。最后，打印出下一个可用的员工标识码来展示静态方法。

需要注意，Employee类也有一个静态的main方法用于单元测试。试试运行

java Employee


和

java StaticTest


执行两个main方法。

程序示例

/*
* 功能：
* @版本：1.02
* @时间：2021-07-16
* @作者：黄子涵
*
*/
public class HuangZiHanTest
{
public static void main(String[] huangzihan_args)
{
var huangzihan = new Huangzihan_Employee[4];

huangzihan[0] = new Huangzihan_Employee("huangzihan", 40000);
huangzihan[1] = new Huangzihan_Employee("Huangzihan", 60000);
huangzihan[2] = new Huangzihan_Employee("huang_zihan", 80000);
huangzihan[3] = new Huangzihan_Employee("Huang_zihan", 100000);

for(Huangzihan_Employee Huangzihan : huangzihan)
{
Huangzihan.huangzihan_setId();
System.out.println("名字=" + Huangzihan.huangzihan_getName() + ",ID=" +
Huangzihan.huangzihan_getId() + ",工资=" + Huangzihan.huangzihan_getSalary());
}

int huangzihan_n = Huangzihan_Employee.huangzihan_getNextId();
System.out.println("下一个有效的ID=" + huangzihan_n);
}
}
class Huangzihan_Employee
{
private static int huangzihan_nextId = 1;

private String huangzihan_name;
private double huangzihan_salary;
private int huangzihan_id;

public Huangzihan_Employee(String huangzihan_n, double huangzihan_s)
{
huangzihan_name = huangzihan_n;
huangzihan_salary = huangzihan_s;
huangzihan_id = 0;
}

public String huangzihan_getName()
{
return huangzihan_name;
}

public double huangzihan_getSalary()
{
return huangzihan_salary;
}

public int huangzihan_getId()
{
return huangzihan_id;
}

public void huangzihan_setId()
{
huangzihan_id = huangzihan_nextId;
huangzihan_nextId++;
}

public static int huangzihan_getNextId()
{
return huangzihan_nextId;
}

public static void main(String[] huangzihan_args)
{
var huangzihan_e = new Huangzihan_Employee("黄子涵", 50000);
System.out.println(huangzihan_e.huangzihan_getName() + "" + huangzihan_e.huangzihan_getSalary());;
}
}


运行结果

名字=huangzihan,ID=1,工资=40000.0
名字=Huangzihan,ID=2,工资=60000.0
名字=huang_zihan,ID=3,工资=80000.0
名字=Huang_zihan,ID=4,工资=100000.0
下一个有效的ID=5