课堂笔记

枚举
什么是枚举（枚举就是一个常量集合）
枚举类型enum是一种新的类型，在JDK5.0加入，允许用常量来表示特定的数据片断，这些数据是分配时预先定义的值的集合，而且全部都以类型安全的形式来表示。
  在枚举类型没有加入到Java前，我们要想表达学量的集合，通常采用如下的方式：
public class Test{
public static final int A=1;
public static final int B=2;
public static final int C=3;
public static final int D=4;
public static final int E=5;
  }
  那么我们在使用的时候就采用如下代码：
  Test.A或者Test.B之类的代码。
  在使用这类带有整型常量的类时，该解决方案也许可行，但并不是非常有效。枚举就为处理上述问题提供了更好的方法。把上面的例子改成用枚举的方式：
public class Test{
public enum StudentGrade{
A,B,C,D,E,F
  };
  }
  可以采用如下的方式进行使用
public class Test{
public enum StudentGrade{
 A,B,C,D,E,F
   };
public static void main(String[] args){
System.out.println("学生的平均成绩为=="+StudentGrade.B);
   }
  }
  
 遍历枚举类型
public class Test15{
public enum StudentGrade{
 A,B,C,D,E,F
    };
public static void main(String[] args){
for(StudentGrade score:StudentGrade.values()){
System.out.println("学生成绩取值可以为=="+score);
     }
    }
   }
运行的结果：
学生成绩取值可以为==A
学生成绩取值可以为==B
学生成绩取值可以为==C
学生成绩取值可以为==D
学生成绩取值可以为==E
学生成绩取值可以为==F
values()方法返回了一个由独立的StudentGrade实例构成的数组。
  还有一个常用的方法：valueOf(String):功能是以字符串的形式返回某一个具体枚举元素的值，示例如下：
public class Test{
public enum StudentGrade{
 A,B,C,D,E,F
   };
public static void main(String[] args){
Test t = new Test();
StudentGrade score = StudentGrade.valueOf("A");
System.out.println("你的成绩是："+score);
   }
  }
  运行结果：你的成绩是：A
在switch中使用枚举类型
public class Test17{
public enum StudentGrade{A,B};
public static void main(String[] args){
Test17 t = new Test17();
StudentGrade score = StudentGrade.B;
 switch(score){
 case A:
 System.out.println("你的成绩是优秀A");
 break;
 case B:
 System.out.println("你的成绩是良好C");
 break;
 default:
 System.out.println("你的成绩是不及格");
 break;
  }
  }
  }
在这里，枚举值被传递到switch语句中，而每个case子句将处理一个特定的值。该值在提供时没有枚举前缀，这意味着不用代码写成case StudentGrade.A。只需将其害写成case A即可，编译器不会接爱有前缀的值。
 
枚举类型的特点
1、类型安全
枚举中申明创建了一个新的类型。它不同于其它的已有类型，包括原始类型和当前作用域内的其它的枚举类型。当你对方法的参数进行赋值操作的时候，整数类型和枚举类型是不能互换的（除非是你进行显式的类型转换），编译器将强制这一点
2、紧凑有效的枚举数值定义
3、运行的高效率
枚举的运行效率和原始类型的整数类型基本上一样高。在运行时不会由于使用了枚举而导致性能有所下降。

 

什么是 Java 中的类反射：
      Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说“自审”，并能直接操作程序的内部属性和方法。Java 的这一能力在实际应用中用得不是很多，但是在其它的程序设计语言中根本就不存在这一特性。例如，Pascal、C 或者 C++ 中就没有办法在程序中获得函数定义相关的信息。
Reflection 是 Java 被视为动态（或准动态）语言的关键，允许程序于执行期 Reflection APIs 取得任何已知名称之 class 的內部信息，包括 package、type parameters、superclass、implemented interfaces、inner classes, outer class, fields、constructors、methods、modifiers，並可于执行期生成 instances、变更 fields 內容或唤起 methods。
Java 类反射中所必须的类：
      Java 的类反射所需要的类并不多，它们分别是：Field、Constructor、Method、Class、Object，下面我将对这些类做一个简单的说明。
Field 类：提供有关类或接口的属性的信息，以及对它的动态访问权限。反射的字段可能是一个类（静态）属性或实例属性，简单的理解可以把它看成一个封装反射类的属性的类。
Constructor 类：提供关于类的单个构造方法的信息以及对它的访问权限。这个类和 Field 类不同，Field 类封装了反射类的属性，而 Constructor 类则封装了反射类的构造方法。
Method 类：提供关于类或接口上单独某个方法的信息。所反映的方法可能是类方法或实例方法（包括抽象方法）。 这个类不难理解，它是用来封装反射类方法的一个类。
Class 类：类的实例表示正在运行的 Java 应用程序中的类和接口。枚举是一种类，注释是一种接口。每个数组属于被映射为 Class 对象的一个类，所有具有相同元素类型和维数的数组都共享该 Class 对象。
Object 类：每个类都使用 Object 作为超类。所有对象（包括数组）都实现这个类的方法。

实例：
import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
public class LoadMethod {
public Object Load(String cName,String MethodName,String[] type,String[] param){
Object retobj = null;
try {
//加载指定的Java类
Class cls = Class.forName(cName);
//获取指定对象的实例
Constructor ct = cls.getConstructor(null);
Object obj = ct.newInstance(null);
//构建方法参数的数据类型
Class partypes[] = this.getMethodClass(type);
//在指定类中获取指定的方法
Method meth = cls.getMethod(MethodName, partypes);
//构建方法的参数值
Object arglist[] = this.getMethodObject(type,param);
//调用指定的方法并获取返回值为Object类型
retobj= meth.invoke(obj, arglist);
}
catch (Throwable e) {
System.err.println(e);
}
return retobj;
}

   package cn.csdn.enumeration2;

 

public class Student {
 private String name;
 private Grade grade;
 public String getName() {
  return name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public Grade getGrade() {
  return grade;
 }
 public void setGrade(Grade grade) {
  this.grade = grade;
 }
 
 
 

课堂实例
//简单枚举
enum Grade{
  A,B,C,D;
  //A  相当于  public static Grade A = new Grade();
  private Grade(){
  
  }
}

/*
 * 1、枚举的声明
 * 2、枚举的对象的声明与使用  A 多个之间用逗号分隔
 *    //public  static 修饰
 * 3、枚举变量的声明
 */
  System.out.println(season.name()); //返回名称
  System.out.println(season.ordinal());//返回序列
  System.out.println(season.values().length); //返回数组并计算长度
  
      Season allentities[] = season.values(); //返回一个season的数组
      
      for(Season entity:allentities){
       System.out.println(entity);
      }
      
      Season ss = Season.valueOf(Season.class, "SPRING");
     System.out.println(ss.ordinal());

  package cn.csdn.reflect;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;

import org.junit.Test;

public class StudentTest {

 @Test
 public void test() throws ClassNotFoundException {
  // 1、加载类
  Class cls = Class.forName("cn.csdn.reflect.Student");
  System.out.println(cls);

  // 2、加载类
  Student stu = new Student();
  Class cls1 = stu.getClass();
  System.out.println(cls1);

  // 3、加载类
  Class cls2 = Student.class;
  System.out.println(Student.class);
 }

 // 解析：public Student()
 @Test
 public void test1() throws ClassNotFoundException, SecurityException,
   NoSuchMethodException, IllegalArgumentException,
   InstantiationException, IllegalAccessException,
   InvocationTargetException {
  // 1、加载类
  Class cls = Class.forName("cn.csdn.reflect.Student");
  // 2、通过无参数的构造器解析
  Constructor constructor = cls.getConstructor(null);
  // 3、创建类的实例
  Student entity = (Student) constructor.newInstance(null);
        //4、调用对象的方法
  entity.study();
  
 /* Student stu = new Student();
  stu.study();
  //cn.csdn.relfect.Student
*/ }

}

 

  //解析：public Student(String name,int age);
 @Test
 public void test2()throws Exception{
  //1、加载类
  Class cls = Class.forName("cn.csdn.reflect.Student");
  //2、通过带有参数的构造器解析
  Constructor constructor = cls.getConstructor(String.class,int.class);
  //3、创建类实例
  Student entity = (Student)constructor.newInstance("redarmy",90);
  //4、调用方法
  entity.study();
  System.out.println(entity.getName());
  
  
  
 }