黑马程序员_Java高新技术（上）

-------   
android培训、java培训、期待与您交流！ ----------
枚举
枚举就是要让某个类型的变量的取值只能为若干个固定值中的一个，否则，编译器就会报错。枚举可以让编译器在编译时就可以控制源程序中填写的非法值，普通变量的方式在开发阶段无法实现这一目标
枚举就相当于一个类，其中也可以定义构造方法、成员变量、普通方法和抽象方法。
枚举元素必须位于枚举体中的最开始部分，枚举元素列表的后要有分号与其他成员分隔。把枚举中的成员方法或变量等放在枚举元素的前面，编译器报告错误。
带构造方法的枚举
  构造方法必须定义成私有的
  如果有多个构造方法，该如何选择哪个构造方法？
  枚举元素MON和MON（）的效果一样，都是调用默认的构造方法

public class EnumTest {

public static void main(String[] args) {
for(WeekDay wd:WeekDay.values())
{
System.out.println(wd);
}
new EnumTest().judge(WeekDay.FALL);
WeekDay week =WeekDay.FALL;
System.out.println(week);
System.out.println(week.name());
System.out.println(week.ordinal());
System.out.println(WeekDay.valueOf("SUMMER"));
System.out.println(WeekDay.values());
System.out.println(WeekDay.values().length);
}
public void judge(WeekDay wd) {
switch (wd) {
case SPRING:
System.out.println("春天");
break;
case SUMMER:
System.out.println("夏天");
break;
case FALL:
System.out.println("秋天");
break;
case WINDER:
System.out.println("冬天");
break;
default:
System.out.println("无");
}
}

}
enum WeekDay {
SPRING,SUMMER,FALL,WINDER;
private WeekDay() //构造方法私有用private修饰
{
System.out.println("无参构造");
}
private WeekDay(int day) //构造方法私有
{
}
}

带方法的枚举
  定义枚举TrafficLamp
  实现普通的next方法
  实现抽象的next方法：每个元素分别是由枚举类的子类来生成的实例对象，这些子类采用类似内部类的方式进行定义
  增加上表示时间的构造方法
枚举只有一个成员时，就可以作为一种单例的实现方式
枚举红绿灯问题，枚举类型可以跟普通类一样实现一个接口，但是实现接口的时候要求枚举中的每个对象都必须单独覆写好接口中的抽象方法

public enum TrafficLamp {
RED(30){
@Override
public TrafficLamp nextLamp() {
return GREEN;
}
},
GREEN(45) {
@Override
public TrafficLamp nextLamp() {
return YELLOW;
}
},
YELLOW(5) {
@Override
public TrafficLamp nextLamp() {
return RED;
}
};
public abstract TrafficLamp nextLamp();

private int time;

private TrafficLamp(int time) {
this.setTime(time);
}

public int getTime() {
return time;
}

public void setTime(int time) {
this.time = time;
}
}

 
反射
反射就是把Java类中的各种成分映射成相应的java类
        反射技术可以对类进行解剖：JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；
这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。
反射的基本步骤：

1、获得Class对象，就是获取到指定的名称的字节码文件对象。

2、实例化对象，获得类的属性、方法或构造函数。

3、访问属性、调用方法、调用构造函数创建对象
    获取Class对象的几种方式：
方式一：
通过对象的getClass方法进行获取。
麻烦在于每次是不是都需要具体的类和该类的对象，以及调用getClass方法。
方式二：
任何数据类型都具备着一个静态的属性class，这个属性直接获取到该类型的对应Class对象。
比第一种简单，不用创建对象，不用调用getClass方法。
但是还是要使用具体的类，和该类中的一个静态属性class完成。      
方式三：
这种方式较为简单，只要知道的类的名称即可。
不需要使用该类，也不需要去调用具体的属性和行为。
就可以获取到Class 对象了

public class ReflectDemo {

public static void main(String[] args) throws ClassNotFoundException {

getObject_3();
}
//方式一：
public static void getObject_1(){

Person p = new Person();
Class clazz = p.getClass();

Person p1 = new Person();
Class clazz1 = p1.getClass();
System.out.println(p==p1);
System.out.println(clazz==clazz1);
}
//方式二：
public static void getObject_2() {

Class clazz = Person.class;
}
//方式三：
public static void getObject_3() throws ClassNotFoundException {
String className = "com.itheima.bean.Person";
Class clazz = Class.forName(className);

System.out.println(clazz);
}

反射的用法：

1）、需要获得java类的各个组成部分，首先需要获得类的Class对象，获得Class对象的三种方式：

Class.forName(classname) 用于做类加载

obj.getClass() 用于获得对象的类型

类名.class     用于获得指定的类型，传参用

2)、反射类的成员方法：

Class clazz = Person.class;

Method method = clazz.getMethod(methodName, new Class[]{paramClazz1, paramClazz2});

method.invoke();

3)、反射类的构造函数：

Constructor con = clazz.getConstructor(new Class[]{paramClazz1, paramClazz2,...})

con.newInstance(params...)

4)、反射类的属性：

Field field = clazz.getField(fieldName);

field.setAccessible(true);

field.setObject(value);

获取了字节码文件对象后，最终都需要创建指定类的对象：

创建对象的两种方式(其实就是对象在进行实例化时的初始化方式)：

1，调用空参数的构造函数：使用了Class类中的newInstance()方法。

2，调用带参数的构造函数：先要获取指定参数列表的构造函数对象，然后通过该构造函数的对象的newInstance(实际参数) 进行对象的初始化。

综上所述，第二种方式，必须要先明确具体的构造函数的参数类型，不便于扩展。所以一般情况下，被反射的类，内部通常都会提供一个公有的空参数的构造函数。

  如何生成获取到字节码文件对象的实例对象。

Class clazz = Class.forName("cn.itcast.bean.Person");//类加载

  直接获得指定的类型

clazz = Person.class;

   根据对象获得类型

Object obj = new Person("zhangsan", 19);

clazz = obj.getClass();

Object obj = clazz.newInstance();//该实例化对象的方法调用就是指定类中的空参数构造函数，给创建对象进行初始化。当指定类中没有空参数构造函数时，该如何创建该类对象呢？请看method_2();

public static void method_2() throws Exception {

Class clazz = Class.forName("cn.itcast.bean.Person");

  既然类中没有空参数的构造函数,那么只有获取指定参数的构造函数,用该函数来进行实例化。

  获取一个带参数的构造器。

Constructor constructor = clazz.getConstructor(String.class,int.class);

  想要对对象进行初始化，使用构造器的方法newInstance();

Object obj = constructor.newInstance("zhagnsan",30);

  获取所有构造器。

Constructor[] constructors = clazz.getConstructors();//只包含公共的

constructors = clazz.getDeclaredConstructors();//包含私有的

for(Constructor con : constructors) {

System.out.println(con);

}

}

反射指定类中的方法：

  获取类中所有的方法

public static vo
4000
id method_1() throws Exception {

Class clazz = Class.forName("cn.itcast.bean.Person");

Method[] methods = clazz.getMethods();//获取的是该类中的公有方法和父类中的公有方法。

methods = clazz.getDeclaredMethods();//获取本类中的方法，包含私有方法。

for(Method method : methods) {

System.out.println(method);

}

}

  获取指定方法

public static void method_2() throws Exception {

Class clazz = Class.forName("cn.itcast.bean.Person");

  获取指定名称的方法。

Method method = clazz.getMethod("show", int.class,String.class);

  想要运行指定方法，当然是方法对象最清楚，为了让方法运行，调用方法对象的invoke方法即可，但是方法运行必须要明确所属的对象和具体的实际参数

  Object obj = clazz.newInstance();

method.invoke(obj, 39,"hehehe");//执行一个方法

}

  想要运行私有方法

public static void method_3() throws Exception {

Class clazz = Class.forName("cn.itcast.bean.Person");

  想要获取私有方法。必须用getDeclearMethod();

Method method = clazz.getDeclaredMethod("method", null);

  私有方法不能直接访问，因为权限不够。非要访问，可以通过暴力的方式

  method.setAccessible(true);//一般很少用，因为私有就是隐藏起来，所以尽量不要访问

}

   反射静态方法

public static void method_4() throws Exception {

Class clazz = Class.forName("cn.itcast.bean.Person");

Method method = clazz.getMethod("function",null);

method.invoke(null,null);

}