2.5面向对象-static-枚举

static类级别的修饰符（被修饰的成员属于类）当用到一个类的时候（new 类名(…)），会将该类的字节码文件加载到元空间，在加载的时候，会将有static修饰的成员，优先加载到静态区。类加载的过程只会执行一次，只有一份。执行完毕后该static修饰的成员会被所有以该字节码文件为模板创建的对象所共享。

/*
举例说明：

设计一个学生类，其中有name-姓名 字段，是否应该加static 呢？

效果：加了static修饰的字段：该字段被该类所有对象共享：当一个对象修改了该字段，其他对象使用该字段，都是修改之后的值
*/
/
 *	学生类
 */
public class Student {
	/用static修饰name，会被所有用Student模板创建的对象共享*/
	static String name;
	public Student(String n) {
		name = n;//将传入的n赋值给成员变量name
	}
	public static void testStatic() {
		System.out.println("static修饰方法");
	}
	
	static class Inner{
	}
}

/
 *	static测试类
 */
public class StudentTest {

	public static void main(String[] args) {
		//调用有参构造，创建对象并且直接赋值
		Student stu1 = new Student("隔壁老王");
		//打印stu1的名字
		System.out.println(stu1.name);//隔壁老王
		
		//调用有参构造，创建对象并且直接赋值
		Student stu2 = new Student("隔壁老孙");
		//打印stu2的名字
		System.out.println(stu2.name);//隔壁老孙
		//重新打印stu1的名字
		System.out.println(stu1.name);//隔壁老孙（居然不是隔壁老王）
	}
}

1.3变量的重新分类

成员变量(也叫字段、属性) ：静态的（类变量）和非静态的（实例变量instance）

static int age; 类变量, 有static修饰的成员变量（字段）；

int age；实例变量,没有static修饰的成员变量（字段）；

局部变量：方法里边（定义，形参）、代码块

二、final修饰符

4.1 final概念

关键字，修饰符，表示最终的。就是一旦修饰一个成员，该成员就不能再被修改了。

4.2 final作用：

可以修饰：

外部类：太监类，不能被继承

实例变量：必须在声明的时候赋值或者在构造方法中赋值

类变量：必须在声明的时候赋值

实例方法：不能被子类重写

类方法：不能被子类重写

内部类：

局部变量：

不能修饰：

构造方法：


public class FinalTest {
	/** 实例变量	在堆中 */
	private final int A;
        private final int B = 1;// 声明的时候直接赋值
	
	/** 类变量	在静态区 */
	static final int C = 1;// 声明的时候直接赋值
	
	/**
	 * 构造方法，final不能修饰
	 */
	public FinalTest() {
		A = 1;//在构造方法中赋值
	}
	
	/**
	 * 实例方法，不能被重写
	 */
	public final void test() {
		
	}
	
	/**
	 * 类方法，不能被重写
	 */
	public static final void testStatic() {
		
	}
	
	/**
	 * 内部类，不能被继承
	 */
	final class Inner{
		
	}
	
	public static void main(String[] args) {
		final int a;// 在栈帧中
		a = 2;// 一旦被final修饰就不能再修改
		System.out.println(a);
		
//		a = 3;// 一旦被final修饰就不能再修改
	}
}

三、枚举

3.1枚举的引入：

需求：设计一个类专门用了表示性别（性别的取值比较固定：男、女、未知）

public class Gender {//表示性别类
//	public static final String MAN = "男";//MAN是String的一个对象
	//在Gender类中使用String类型，有侵入性问题。那么，能不能用Gender自己类型的对象表示一个男？ 可以
	public static final Gender MAN = new Gender();//MAN是Gender的一个对象
	
//	public static final String WOMEN = "女";//WOMEN是String的一个对象
	public static final Gender WOMEN = new Gender();//WOMEN是Gender的一个对象
	
//	public static final String UNKNOWN = "未知";//UNKNOWN是String的一个对象
	public static final Gender UNKNOWN = new Gender();//UNKNOWN是Gender的一个对象
	
	@Override
	public String toString() {
		/*
		 * 希望打印格式如下：
		 * 	是MAN打印男
		 * 	是WOMEN打印女
		 * 	是UNKNOWN打印未知
		 */
		if (this == MAN) {
			return "男";
		}else if (this == WOMEN) {
			return "女";
		}else{
			return "未知";
		}
	}
}

测试类：
/**
 *	测试性别，枚举引入
 */
public class GenderTest {
	public static void main(String[] args) {
		//调用全局常量方式，类名.常量名
		System.out.println(Gender.MAN);//男
		System.out.println(Gender.WOMEN);//女
		System.out.println(Gender.UNKNOWN);//未知
	}

}

这样就比较麻烦，有更简单的方法，枚举这就来了

3.2枚举概述：

3.2.1什么是枚举

枚举是JDK1.5引入的一种和类非常类似的新结构;

枚举的出现解决了哪些问题？

枚举类解决了一些取值比较固定的场景，简化了类中的常量字段。

3.2.2枚举的作用和使用场景

作用：简化类中的常量声明这种代码，是代码变得更加优雅

使用场景：vip、生肖、段位、QQ状态、血型、性别、星座、月份、礼拜..

3.2.3枚举的语法

① 声明语法：

public enum 枚举类名字{

字段

实例变量

实例方法

类方法

构造方法 - 枚举中的构造方法默认都是private修饰，不能够是public，protected修饰

构造方法作用：只能在当前枚举类中使用，就是给当前枚举类对象初始化实例变量的

}

语法：
public enum Gender {//表示性别类
//	MAN,//相当于一个常量public static final Gender = new Gender();
	MAN(),//MAN这里也可以这样写,这里就是在调用当前枚举类的无参构造
	WOMEN("女"),//这里就是在调用当前枚举类的String类型有参构造
	UNKNOWN,
	其他;//也可以写中文，但是不建议，建议写法：WOMEN("");
	private String name;//实例变量，属于每一个枚举对象，如：MAN,WOMEN..
	
	/**
	 * 无参构造
	 */
	Gender() {//默认有一个隐式的private修饰
		
	}
	
	/**
	 * 有参构造
	 */
	Gender(String name) {//默认有一个隐式的private修饰
		this.name = name;
	}
	
	@Override//实例方法
	public String toString() {
		if (this == MAN) {
			return "男";
		}else if (this == WOMEN) {
			return "女";
		}else{
			return "未知";
		}
	}
	
	/**
	 * 类方法
	 */
	public static void test() {
	
	}
}

② 枚举类编译完毕也同样生成字节码文件

③ 每一个自定义的枚举类型都(隐式的)继承于 Enum抽象类，因此我们的枚举对象可以调用到Enum中的方法的(看API )。但是不能显示的写出继承关系。