黑马程序员--Java基础加强--07枚举、反射、注释-优快云博客

本文深入探讨Java中的枚举和反射技术，介绍枚举的特点和使用方式，演示如何利用反射获取类的各种组件并进行操作，同时展示了自定义注解的过程。

----------------------Android培训、Java培训、java学习型技术博客、期待与您交流！ ----------------------

枚举

枚举：枚举是一种特殊的类，其中每个元素都是该类的一个实例对象。
作用：就是要让某一个类型的变量的取值只能为若干的固定值中的一个，否则，编译失败
特点：
1、构造方法是私有的。
2、每个元素分别用一个公有的静态成员变量表示。
3、可以有若干公有方法或抽象方法。
例子演示，及Enum类中部分方法演示：

public class EnumTest
{
	public static void main(String[] args) 
	{
		WeekDay day1 = WeekDay.MON;
		WeekDay day2 = WeekDay.SUN;

		sop(day1);//MON
		//返回枚举常量的名字
		sop(day1.name());//MON
		//返回枚举常量在声明时的位置
		sop(day1.ordinal());// 1
		//valueOf返回对应的枚举常量对象
		//toString返回枚举常量的名字
		sop(WeekDay.valueOf("SUN").toString());//SUN
		//返回枚举常量的个数
		sop(WeekDay.values().length);// 7
	}
	public enum WeekDay
	{
		//定义元素，并指定构造方法
		SUN(0),MON(1),TUE,WEN,THI,FRI,SAT;
		//私有的构造方法
		private WeekDay()
		{
			sop("first WeekDay");
		}
		private WeekDay(int day)
		{
			sop("second WeekDay");
		}
	}
	public static void sop(Object obj)
	{
		System.out.println(obj);
	}
}

反射
反射：就是把Java类中的各种成分映射成相应的java类。
作用：实现框架功能。
java程序中的各个java类属于同一类事物，描述这类事物的java类名就是Class。
Class类：没有构造函数。其实例对象对应的是类在内存中的字节码。

获取类字节码的方法：

1、类名.class

2、对象.getClass()
3、Class.forName("包名.类名")--当字符串对应的类不存在时会抛出ClassNotFoundException异常。
例子演示：

class GetClassTest
{
	public static void main(String[] args)throws Exception
	{
		Class clazz1 = String.class;
		System.out.println(clazz1);
		Class clazz2 = "abc".getClass();
		System.out.println(clazz2);
		Class clazz3 = Class.forName("java.lang.String");
		System.out.println(clazz3);
	}
}

代码演示反射：

import java.lang.reflect.*;
class Demo
{
	public static void main(String[] args)throws Exception
	{
		//getConstructor();
		//getMethod();
		getField();
	}
	public static void getConstructor()throws Exception
	{
		//通过Student类的字节码来调用getConstructors()方法来获取Student类所有的构造函数
		Constructor[] constructors = Student.class.getConstructors();
		System.out.println(constructors.length);
		//定义一个StringBuilder来是输出更好看
		StringBuilder sbud = new StringBuilder();
		for(Constructor constructor : constructors)
		{
			//获取构造函数的名字
			sbud.append(constructor.getName().substring((constructor.getName().lastIndexOf("."))+1));
			sbud.append("(");
			//获取构造函数的参数列表
			Class[] clazzParameters = constructor.getParameterTypes();
			for(Class clazzParameter : clazzParameters)
			{
				sbud.append(clazzParameter.getName()+",");
			}
			if(clazzParameters!=null && clazzParameters.length!=0)
				sbud.delete(sbud.length()-1,sbud.length());
			sbud.append(")");
			System.out.println(sbud.toString());
			sbud.delete(0,sbud.length());
		}

		//根据构造函数的参数列表获取Student的某一个构造函数的反射
		Constructor<Student> constructorOfString = Student.class.getConstructor(String.class, int.class, String.class);
		//通过该反射调用 newInstance() 方法创建Student类的对象
		Student stu = constructorOfString.newInstance("lxh",24,"4110032040");
		System.out.println(stu);
	}
	public static void getMethod()throws Exception
	{
		//通过Student类的字节码来调用getgetMethods()方法来获取Student类所有的成员方法
		Method[] methods = Student.class.getMethods();
		//定义一个StringBuilder来是输出更好看
		StringBuilder sbud = new StringBuilder();
		for(Method method : methods)
		{
			//获取成员方法的名字
			sbud.append(method.getName());
			sbud.append("(");
			//获取成员方法的参数列表
			Class[] clazzParameters = method.getParameterTypes();
			for(Class clazzParameter : clazzParameters)
			{
				sbud.append(clazzParameter.getName()+",");
			}
			if(clazzParameters!=null && clazzParameters.length!=0)
				sbud.delete(sbud.length()-1,sbud.length());
			sbud.append(")");
			System.out.println(sbud.toString());
			sbud.delete(0,sbud.length());
		}

		Student stu = new Student();
		//通过方法名和方法的参数列表获取该方法的反射
		Method methodOfStudent = Student.class.getMethod("sayHolle");
		//通过该反射调用invoke()方法来达到该方法应有的效果
		methodOfStudent.invoke(stu);
	}
	public static void getField()throws Exception
	{
		//通过Student类的字节码来调用getDeclaredFields()方法来获取Student类所有的所有成员变量
		Field[] fields = Student.class.getDeclaredFields();
		//定义一个StringBuilder来是输出更好看
		StringBuilder sbud = new StringBuilder();
		for(Field field : fields)
		{
			//获取成员变量的类型
			sbud.append(field.getType().getName());
			//获取成员变量的名字
			sbud.append(" "+field.getName());
			System.out.println(sbud.toString());
			sbud.delete(0,sbud.length());
		}

		Student stu = new Student("lxh",24,"4110032040");
		//通过公有成员变量的名字来获取它的反射
		Field fieldOfStudent = Student.class.getField("id");
		//通过反射设置给成员变量的值
		fieldOfStudent.set(stu,"1234567");
		System.out.println(stu);
	}
}
//定义一个类用于演示反射
class Student
{
	private String name;
	private int age;
	public String id;
	public Student(){}
	public Student(String name, int age, String id)
	{
		this.name = name;
		this.age = age;
		this.id = id;
	}
	public void sayHolle()
	{
		System.out.println("say holle");
	}
	public String toString()
	{
		return name+".."+age+"..."+id;
	}
}

注释
注解：相当于一种标记，在程序中加入注解就等于为程序打上了一个标记。
加了标记，javac编译器，开发工具和其他程序就可以通过反射来了解类及各种元素上有无标记，从而去做相应的事。
标记可以加在包、类、方法、方法的参数以及局部变量上。
注解类：格式

@interface A
{
}
枚举 RetentionPolicy
枚举常量摘要 :
CLASS 编译器将把注释记录在类文件中，但在运行时 VM 不需要保留注释。
RUNTIME 编译器将把注释记录在类文件中，在运行时 VM 将保留注释，因此可以反射性地读取。
SOURCE 编译器要丢弃的注释。
@Retention:指示注释类型的注释要保留多久。
如果注释类型声明中不存在 Retention 注释，则保留策略默认为 RetentionPolicy.CLASS

枚举 ElementType
枚举常量摘要
ANNOTATION_TYPE 注释类型声明
CONSTRUCTOR 构造方法声明
FIELD 字段声明（包括枚举常量）
LOCAL_VARIABLE 局部变量声明
METHOD 方法声明
PACKAGE 包声明
PARAMETER 参数声明
TYPE 类、接口（包括注释类型）或枚举声明

@Target:指示注释类型所适用的程序元素的种类。
如果注释类型声明中不存在 Target 元注释，则声明的类型可以用在任一程序元素上。

例子演示：

import java.lang.reflect.*;
@MyAnnotation(value="abc")
class AnnotationDemo
{
	public static void main(String[] args) 
	{
		//判断在运行时AnnotationDemo内是否还有注释@MyAnnotation。
		if(AnnotationDemo.class.isAnnotationPresent(MyAnnotation.class))
		{
			//通过ItcastAnnotation的映射获取其对象
			MyAnnotation myAnno =
				(MyAnnotation)AnnotationDemo.class.getAnnotation(MyAnnotation.class);
			System.out.println(myAnno.value());
		}
	}
}

//自定义注释，设置其存在时间和位置
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.TYPE, ElementType.METHOD})
@interface MyAnnotation
{
	//设置属性，color为固定值
	String color() default "blue";
	String value();
}

----------------------Android培训、Java培训、java学习型技术博客、期待与您交流！ ----------------------

详细请查看：http://edu.youkuaiyun.com/