其他分享
首页 > 其他分享> > 静态字段与静态方法

静态字段与静态方法

作者:互联网

静态字段与静态方法

静态字段

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

harryid字段被设置为静态字段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来访问这个常量。

如果省略关键字staticPI就变成了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毫无关系。我们建议使用类名而不是对象来调用静态方法。

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

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

工厂方法

静态方法还有另外一种常见的用途。类似LocalDateNumberFormat的类使用静态工厂方法(factory method)来构造对象。你已经见过工厂方法LocalDate.nowLocalDate.ofNumberFormat类如下生成不同风格的格式化对象:

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类不利用构造器完成这些操作呢?这主要有两个原因:

程序示例

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

标签:静态方法,静态,huangzihan,int,字段,Employee,nextId,Huangzihan,public
来源: https://www.cnblogs.com/Huang-zihan/p/15183238.html