Java学习笔记8---类的静态成员变量与静态成员方法的访问与调用方式

时间：2022-03-24 12:36:11

 (注：静态变量修改为静态成员变量，静态方法改为静态成员方法)

静态成员变量又称类变量，静态成员方法又称类方法，它们统称为静态成员或类成员。静态成员由static修饰，是属于整个类的，所有的对象共享这些静态成员。不需要创建任何对象，静态成员在类装载时就已初始化了，整个运行期间其内存位置不变，直到类卸载。鉴于静态成员的这些特性，访问静态成员变量以及定义或调用静态成员方法时与非静态成员也有不同之处。下面分别做出说明。

1.静态成员变量

  • 类的非静态成员方法、静态成员方法都可以直接访问静态成员变量
  • 其他类要访问某个类的静态成员变量，既可以通过实例名访问，也可以直接用类名来访问，推荐用类名访问的方式，这样能更直观的说明访问的变量是静态成员变量

2.静态方法

  • 不能直接访问非静态成员变量，也不能直接调用非静态成员方法，需要实例化一个对象，再通过该对象来访问要访问的非静态成员变量或要调用的非静态成员方法。也就是说，静态成员方法不能直接使用非静态成员。个人理解是，非静态成员变量是依托对象而存在的，当没有实例一个对象时，非静态成员变量是没有分配内存空间的，静态方法要使用非静态成员变量不知道要到哪里去找，当然就不能直接使用非静态成员变量了。而非静态成员方法有有可能访问非静态成员变量，所以也不能直接调用非静态成员方法了。
  • 其他类要调用某个类的静态成员方法，既可以通过实例名调用，也可以直接用类名来调用，推荐用类名调用的方式，这样能更直观的说明调用的方法是静态成员方法

 

3.下面以简单的代码验证上面的结论

定义了一个Person类，类的代码见最后面。

 

(1).类的静态成员方法和非静态成员方法都可以直接访问静态成员变量

  • 静态成员方法staticMethod访问了静态成员变量citizenship
  • 定义并使用了局部变量testY
  • 非静态成员方法informationPrint访问了静态成员变量citizenship

staticMethod()方法如下：

public static void staticMethod() {
		int testY = 20;

		System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access
		System.out.println("She's now " + testY + " years old");  //local variable access
	}

informationPrint()方法如下：

	public void informationPrint() {
		System.out.println("My name is " + getName());
		System.out.println("I am " + getAge() + " years old");

		if(getGender() == "female")
			System.out.println("I am a girl");
		else
			if(getGender() == "male")
				System.out.println("I am a boy");
			else
				System.out.println("Something is wrong!");
		System.out.println("My hobby is " + hobby);

		if(citizenship == "Chinese")
			System.out.println("I am a chinese");
		else
			if(citizenship == "US")
				System.out.println("I am an American");
			else
				System.out.println("Oh,something is wrong");
	}　

main()方法如下：

public static void main(String[] args) {
		Person xiaoxi = new Person("xiaoxi",29,"female","piano");

		xiaoxi.informationPrint();

		staticMethod();
	}

输出结果如下：

My name is xiaoxi
I am 29 years old
I am a girl
My hobby is piano
I am a chinese
She has applied for Chinese citizenship
She's now 20 years old

结果分析：

  • 静态成员方法可以直接访问静态成员变量
  • 静态成员方法可以自定义局部变量
  • 非静态成员方法可以直接访问静态成员变量

 

(2),静态成员方法不可以直接访问非静态成员变量

　[1].staticMethod直接访问静态成员变量citizenship，出现错误

  • 静态成员方法staticMethod访问了静态成员变量citizenship
  • 定义并使用了局部变量testY
  • 访问了非静态成员变量hobby

staticMethod()方法如下：

public static void staticMethod() {
		int testY = 20;

		System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access
		System.out.println("She's now " + testY + " years old");  //local variable access
		System.out.println("She doesn't like " + hobby); //nonstatic variable access
	}

main方法同上。

输出结果如下：

My name is xiaoxi
I am 29 years old
I am a girl
My hobby is piano
I am a chinese
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Cannot make a static reference to the non-static field hobby

	at human.Person.staticMethod(Person.java:99)
	at human.Person.main(Person.java:107)

结果分析：

  • 静态成员方法不能直接访问非静态成员变量，否则会出现“Cannot make a static reference to the non-static field hobby” 的错误。

 

　[2].staticMethod()创建一个对象testP，由testP访问非静态成员变量hobby，成功执行

 

  • 静态成员方法staticMethod使用了静态成员变量citizenship
  • 定义并使用了局部变量testY
  • 创建一个Person实例testP,并使用了testP的变量hobby

 

staticMethod()方法如下：

public static void staticMethod() {
		int testY = 20;
		Person testP = new Person();

		System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access
		System.out.println("She's now " + testY + " years old");  //local variable access
		System.out.println("She doesn't like " + testP.hobby); // nonstatic variable access via object instance testP
	}

main方法同上。

输出结果如下：

My name is xiaoxi
I am 29 years old
I am a girl
My hobby is piano
I am a chinese
She has applied for Chinese citizenship
She's now 20 years old
She doesn't like null

结果分析：

  • 静态成员方法要访问非静态成员变量，可以先实例化一个对象，再通过对象访问。

 

(3),静态成员方法不可以直接调用非静态成员方法

　[1].staticMethod()直接访问非静态成员方法informationPrint()，出现错误

  • 静态成员方法staticMethod使用了静态成员变量citizenship
  • 定义并使用了局部变量testY
  • 创建一个Person实例testP,并使用了testP的hoppy变量
  • 直接调用非静态成员方法informationPrint()

staticMethod()方法如下：

	public static void staticMethod() {
		int testY = 20;
		Person testP = new Person();

		System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access
		System.out.println("She's now " + testY + " years old");  //local variable access
		//System.out.println("She doesn't like " + testP.hobby); //nonstatic variable access
		System.out.println("She doesn't like " + testP.hobby); // nonstatic variable access via object instance testP
		System.out.println("Her personal information is as follows:");
		informationPrint();
	}

main()方法同上。

输出结果如下：

My name is xiaoxi
I am 29 years old
I am a girl
My hobby is piano
I am a chinese
Exception in thread "main" java.lang.Error: Unresolved compilation problem: 
	Cannot make a static reference to the non-static method informationPrint() from the type Person

	at human.Person.staticMethod(Person.java:103)
	at human.Person.main(Person.java:111)

结果分析：

  • 静态成员方法不能直接调用非静态成员方法，否则会出现与直接访问非静态成员变量类似的错误，Cannot make a static reference to the non-static method informationPrint() from the type Person。

 

　[2].通过已有对象testP来调用informationPrint()方法，成功执行

  • 静态成员方法staticMethod使用了静态成员变量citizenship
  • 定义并使用了局部变量testY
  • 创建一个Person实例testP,并使用了testP的hoppy变量
  • 通过testP调用非静态成员方法informationPrint()

staticMethod()方法如下：

	public static void staticMethod() {
		int testY = 20;
		Person testP = new Person();

		System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access
		System.out.println("She's now " + testY + " years old");  //local variable access
		System.out.println("She doesn't like " + testP.hobby); // nonstatic variable access via object instance testP
		System.out.println("Her personal information is as follows:");
		//informationPrint();
		testP.informationPrint();
	}

main()方法同上。

输出结果如下：

My name is xiaoxi
I am 29 years old
I am a girl
My hobby is piano
I am a chinese
She has applied for Chinese citizenship
She's now 20 years old
She doesn't like null
Her personal information is as follows:
My name is null
I am 0 years old
Something is wrong!
My hobby is null
I am a chinese

结果分析：

  • 静态成员方法要调用非静态成员方法，可以先实例化一个对象，再通过该对象来调用。

 

(4).其他类通过类名直接调用类的静态成员变量和静态成员方法

  • 类TestMain通过类名Person直接调用了静态成员方法staticMethod()和静态成员变量citizenship

TestMain如下：

package human;

public class TestMain {

	public static void main(String[] args) {
		Person.staticMethod();	
		System.out.println("static variable \"citizenship\":" + Person.citizenship);

	}

}

输出结果如下：

She has applied for Chinese citizenship
She's now 20 years old
She doesn't like null
Her personal information is as follows:
My name is null
I am 0 years old
Something is wrong!
My hobby is null
I am a chinese
static variable "citizenship":Chinese

　　

附Person类：

package human;

public class Person {
	String name;
	int age;
	String gender;

	private String hobby;
	protected String residence;

	static String citizenship = "Chinese";

	public Person() {

	}

	public Person(String n, String g) {
		this.name = n;
		this.gender = g;
	}

	public Person(String n, int a, String g, String h) {
		this.name = n;
		this.age = a;
		this.gender = g;
		this.hobby = h;

		//test:静态变量初始化的时机是否在构造方法之前
	//	System.out.println("constructor:");
	//	System.out.println("change value of the static variable citizenship " + "\"" + citizenship + "\"");
	//	citizenship = "US";
	//	System.out.println(" to " + "\"" + citizenship + "\"");
	}	

	public Person(String n, int a, String g, String h, String r) {
		this.name = n;
		this.age = a;
		this.gender = g;
		this.hobby = h;
		this.residence = r;
	}	

	public void setName(String n) {
		this.name = n;
	}

	public void setAge(int a) {
		this.age = a;
	}

	public void setGender(String g) {
		this.gender = g;
	}

	public void setHobby(String h) {
		this.hobby = h;
	}

	public void setResidence(String r) {
		this.residence = r;
	}

	public String getName() {
		return this.name;
	}

	public int getAge() {
		return this.age;
	}

	public String getGender() {
		return this.gender;
	}

	public String getHobby() {
		return this.hobby;
	}

	public String getResidence() {
		return this.residence;
	}

	public void informationPrint() {
		System.out.println("My name is " + getName());
		System.out.println("I am " + getAge() + " years old");

		if(getGender() == "female")
			System.out.println("I am a girl");
		else
			if(getGender() == "male")
				System.out.println("I am a boy");
			else
				System.out.println("Something is wrong!");
		System.out.println("My hobby is " + hobby);

		if(citizenship == "Chinese")
			System.out.println("I am a chinese");
		else
			if(citizenship == "US")
				System.out.println("I am an American");
			else
				System.out.println("Oh,something is wrong");
	}

	public static void staticMethod() {
		int testY = 20;
		Person testP = new Person();

		System.out.println("She has applied for " + citizenship + " citizenship"); //static variable access
		System.out.println("She's now " + testY + " years old");  //local variable access
		System.out.println("She doesn't like " + testP.hobby); // nonstatic variable access via object instance testP
		System.out.println("Her personal information is as follows:");
		//informationPrint();
		testP.informationPrint();
	}

	public static void main(String[] args) {
		Person xiaoxi = new Person("xiaoxi",29,"female","piano");

		xiaoxi.informationPrint();

		staticMethod();
	}
}

　　

标签：

相关文章