本文主要是介绍静态字段与静态方法，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！

静态字段与静态方法

静态字段

如果将一个字段定义为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

这篇关于静态字段与静态方法的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！