Java —— static 关键字、static 内部类、枚举类

一、static 关键字

之前虽然知道静态方法只能操作静态变量，但有时写测试小程序时，main 方法中引用成员变量提示须为静态的，有点疑惑（忘了最基础的入口main 方法是静态的...）。在此，简单整理下，让我一次弄个明明白白！

先上结论：

只需记住一点，静态方法或静态类只能操作静态方法或静态成员属性（静态操作静态），其它情况随意！

理解含义：

main 方法中能使用的成员属性必须为静态的，所以main 或其它静态方法使用不到的属性，最好别定义为成员属性，因为他们并不能被该类直接操作，而是通过该类的其他普通方法操作（当然，普通java 实体类没此要求）。

测试代码：

public class StudyErrorAndException {

	private static String staticVar;
	private String normalVar;
	
	public static void main(String[] args) {
		
		staticMethod();
		normalMethod();//报错
	}
	
	private static void staticMethod(){
		
		staticVar = "";
		normalVar = "";//报错
	}
	private void normalMethod(){
		
		staticVar = "";
		normalVar = "";
	}
	
	protected static class InternalStaticClass{
		
		public InternalStaticClass(){
			System.out.println("创建静态内部类");
			staticVar = "";
			normalVar = "";//报错，静态内部类同样不能操作所属类的非静态方法
		}
	}
	protected class InternalNormalClass{
		
		public InternalNormalClass(){
			System.out.println("创建普通内部类");
			staticVar = "";
			normalVar = "";
		}
	}
}

二、静态内部类

先定义一个基础静态内部类：

public class StudyStatic {

	private static int staticVar;
	private static InternalStaticClass innerClass = new InternalStaticClass();
	private static InternalStaticClass innerClass2 = new InternalStaticClass();
	
	public static void main(String[] args) {
		
		System.out.println(innerClass.hashCode());
		System.out.println(innerClass2.hashCode());
	}
	
	protected static class InternalStaticClass{
		
		public InternalStaticClass(){
			
			staticVar++;
			System.out.println(staticVar);
		}
	}
}

打印结果：

1
2
366712642
1829164700

得出结论：

因为静态内部类只能操作静态成员属性，所以无论创建几次，虽然多个静态类实例不是同一个（哈希码不同），但其操作的变量是共享的（1变为了2）。

意外收获：

类作为成员属性时，若声明时创建，则属性必需为静态的才会真正创建，实践如下：

public class StudyStatic {

	//静态内部类不会真正创建
	private InternalStaticClass staticC1 = new InternalStaticClass();
	//静态内部类会真正创建
	private static InternalStaticClass staticC2 = new InternalStaticClass();
	//普通内部类不会真正创建
	private InternalNormalClass normalClass = new InternalNormalClass();
	
	public static void main(String[] args) {
		
	}
	
	protected static class InternalStaticClass{
		
		public InternalStaticClass(){
			
			System.out.println("静态内部类");
		}
	}
	protected class InternalNormalClass{
		
		public InternalNormalClass(){
			
			System.out.println("普通内部类");
		}
	}
}

提出疑问：

静态内部类和静态方法有啥区别？就自己目前理解来看，除了静态内部类具有类的概念外，与静态方法的作用没什么区别。即静态方法可能只是完成某一小个功能，而静态内部类是将某个大的业务抽象为了一个类，更便于管理。

三、enum 枚举类型

enum 枚举类型定义与类定义相似，enum类型本身就相当于类，不过比较特殊，相当于提供了几个个该类的实例，当然enum类型不能被实例化，但可以修改已经存在的枚举值。

示例代码：

public class TestEnum {

	public static void main(String[] args) {
		
		for(int i=0;i<MyEnum.values().length;i++){
			System.out.println(MyEnum.values()[i].getKey()+":"+
					MyEnum.values()[i].getValue());
		}
		MyEnum.Enum1.setKey(4);
		System.out.println(MyEnum.Enum1.getKey()+":"+MyEnum.Enum1.getValue());
	}

	public enum MyEnum{
		
		//多个个枚举值,注意名字并不是构造方法名
		Enum1(1,"One"),Enum2(2,"Two"),Enum3(3,"Three");
		
		//枚举值所包含的属性
		private int key;
		private String value;
		
		//构造方法
		MyEnum(int key,String value){
			this.setKey(key);
			this.setValue(value);
		}
		public int getKey() {
			return key;
		}
		public void setKey(int key) {
			this.key = key;
		}
		public String getValue() {
			return value;
		}
		public void setValue(String value) {
			this.value = value;
		}
	}
}

运行结果：

1:One
2:Two
3:Three
4:One

从第4个值可见，枚举值的属性是可以动态修改的。

要实现枚举功能，可实现Enumeration<T> 接口。该接口提供了两个方法hasMoreElements() 与nestElement() 方法。

示例代码：

import java.util.Enumeration;

public class TestEnum {

	public static void main(String[] args) {
		
		String[] myEnum = {"One","Two","Three","Four","Five"};
		Enumeration<String> e = new MyEnumeration(myEnum);//对于String数组对象myEnum进行枚举
		while(e.hasMoreElements()){
			System.out.println(e.nextElement());
		}
	}
}

class MyEnumeration implements Enumeration<String>{

	private String[] elements;
	private int index = 0;
	
	public MyEnumeration(){
		elements = null;
	}
	public MyEnumeration(String[] elements){
		this.elements = elements;
	}
	
	@Override
	public boolean hasMoreElements() {
		
		if(index < elements.length){
			return true;
		}else{
			return false;
		}
	}

	@Override
	public String nextElement() {
		
		if(elements!=null){
			index++;
		}
		return elements[index-1];
	}
}

运行结果：

One
Two
Three
Four
Five