Java语言——反射、枚举以及lambda表达式-51CTO.COM

一.反射

1.1 反射的基本情况

定义：Java在运行状态时，对于任意一个类，都能知道这个类的所有属性和方法。

这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制

用途：

1.在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用 Java的反射机制来获取所需的私有成员或是方法。

2. 反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。

1.2 反射中最重要的类

在讲解这些类之前，我们需要先构建一个类，方便进行反射的操作：

class Student{
//私有属性name
    private String name = "tq02";
//公有属性age
    public int age = 22;
//不带参数的构造方法
    public Student(){
    System.out.println("Student()");
    }
    private Student(String name,int age) {
    this.name = name;
    this.age = age;
    System.out.println("Student(String,name)");
    }
    
private void eat(){
    System.out.println("i am eat");
}
public void sleep(){
    System.out.println("i am pig");
}
private void function(String str) {
    System.out.println(str);
} 
 
@Override
public String toString() {
    return "Student{" +
    "name='" + name + '\'' +
    ", age=" + age +
    '}';
}
}

注：1.反射私有的构造方法、属性、方法时，Java具有安全性，因此我们需要使用.setAccessible("boolean");

2.使用Class类、Field、Constructor类时，需要处理异常。

1.2.1 Class类

在反射之前，第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，我们就可以修改部分类型信息。

使用Class获取类的三种方法：

第一种：使用Class.forName("类的全路径名“”); //静态方法

第二种：使用.class方法。

第三种：使用类对象的getClass()方法;

注：无论哪种方法获取，其实获取的都是同一个类。

代码实例 :

public class TestDemo {
public static void main(String[] args) {
//1.通过getClass获取Class对象
    Student s1 = new Student();
    Class c1 = s1.getClass();
 
//2.直接通过 类名.class 的方式得到,该方法最为安全可靠，程序性能更高
//这说明任何一个类都有一个隐含的静态成员变量 class
    Class c2 = Student.class;
 
//3、通过 Class 对象的 forName() 静态方法来获取，用的最多，
//但可能抛出 ClassNotFoundException 异常
    Class c3 = null;
    try {
//注意这里是类的全路径，如果有包需要加包的路径
    c3 = Class.forName("Student");
    } catch (ClassNotFoundException e) {
    e.printStackTrace();
    } 
 
//一个类在 JVM 中只会有一个 Class 实例,即我们对上面获取的
//c1,c2,c3进行 equals 比较，发现都是true
System.out.println(c1.equals(c2));
System.out.println(c1.equals(c3));
System.out.println(c2.equals(c3));
}

1.2.2 Field类

作用：可对类中属性进行操作

public static void reflectPrivateField() {
  try {
            Class<?> classStudent = Class.forName("Student");
                                                     //获取name成员变量
            Field field = classStudent.getDeclaredField("name");
            field.setAccessible(true);
            Student student= (Student)classStudent.newInstance();
//修改成员变量，将student中的name值改成"小明"；
            field.set(student, "小明");
            String name = (String) field.get(student);
            System.out.println("反射私有属性修改了name：" + name);
        } catch (Exception ex) {
            ex.printStackTrace();
        }
}

1.2.3 Constructor类

作用：对构造方法进行操作

代码实例：

//反射构造方法
    public static void reflect() {
       try {
           Class<?> c1 = Class.forName("Student");
           Constructor<?> c2= c1.getDeclaredConstructor(String.class,int.class);
           c2.setAccessible(true);
 
           c2.newInstance("汤琦",22);
       }catch(Exception ex)
       {
           ex.printStackTrace();
       }
    }

1.2.4 Method类

作用：对类中方法进行操作

实例代码：

public static void reflectPrivateMethod() {
        try {
            Class<?> c1 = Class.forName("Student");
            Method m1=c1.getDeclaredMethod("function", String.class);
            m1.setAccessible(true);
 
            Student fw=(Student) c1.newInstance();
            m1.invoke(fw,"给私有的function函数传的参数");
 
        }catch(Exception ex)
        {
            ex.printStackTrace();
        }
    }

1.3 反射优缺点

优点： 1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法

2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力

3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点： 1. 使用反射会有效率问题。会导致程序效率降低。

2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂

二.枚举

2.1 概念

在Java中，可以说是一个集合，从下标0开始的集合。注：枚举是jdk1.5以后引用的。

使用格式： public enum 类名{

常量1、常量2、常量3；

}

就是将class换成了enum

代码实例：

public enum TestEnum {
    RED,BLACK,GREEN,WHITE;//相当于集合，第一个常量下标值为0，第二个常量下标值为1......
    public static void main(String[] args) {
         TestEnum testEnum2 = TestEnum.BLACK;
         switch (testEnum2) {
         case RED: System.out.println("red"); break;
         case BLACK:System.out.println("black");break;
         case WHITE:System.out.println("WHITE");break;
         case GREEN:System.out.println("black");break;
         default:break;
}
}

2.2 枚举（enum）类方法

2.3 枚举的构造

枚举的构造方法默认是私有的。

public enum TestEnum {
    RED("red",1),BLACK("black",2),WHITE("white",3),GREEN("green",4);
    private String name;
    private int key;
/**
* 1、当枚举对象有参数后，需要提供相应的构造函数
* 2、枚举的构造函数默认是私有的 这个一定要记住
* @param name
* @param key
*/
    private TestEnum (String name,int key) {
        this.name = name;
        this.key = key;
    }
    public static TestEnum getEnumKey (int key) {
        for (TestEnum t: TestEnum.values()) {
        if(t.key == key) {
        return t;
        }
    } 
    return null;
}
    public static void main(String[] args) {
        System.out.println(getEnumKey(2));
    }
}

注：自己写的枚举类，默认继承与enum这个类的。

三.Lambda表达式

3.1 Lambda介绍

Lambda本质是匿名函数，基于数学中的λ演算得名，也可称为闭包（Closure）

语法格式：（parameters）->expression 或 (parameters)->{ statements;}

parameters:类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。

->：可理解为“被用于”的意思

方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。

常见表达式：

// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

3.2 函数式接口

定义：该接口有且只有一个抽象方法

注：如果某接口含有@FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。

代码实例：

@FunctionalInterface
interface NoParameterNoReturn {
	//注意：只能有一个方法
	void test();
}

3.3 使用lambda表达式

先建立几个接口：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
void test();
} 
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
} 
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
} 
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
} 
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
} 
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
}

Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法。

3.3.1 不使用Lambda表达式调用

public class TestDemo {
public static void main(String[] args) {
//接口使用匿名内部类
    NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
    @Override
    public void test() {
    System.out.println("hello");
    }
    };
noParameterNoReturn.test();
}

3.3.2 使用Lambda表达式

public class TestDemo {
  public static void main(String[] args) {
    NoParameterNoReturn noParameterNoReturn = ()->{
    System.out.println("无参数无返回值");
};
noParameterNoReturn.test();
    OneParameterNoReturn oneParameterNoReturn = (int a)->{
    System.out.println("一个参数无返回值："+ a);
};
oneParameterNoReturn.test(10);
 
    MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
    System.out.println("多个参数无返回值："+a+" "+b);
};
moreParameterNoReturn.test(20,30);
 
    NoParameterReturn noParameterReturn = ()->{
    System.out.println("有返回值无参数！");
    return 40;
};
//接收函数的返回值
int ret = noParameterReturn.test();
System.out.println(ret);
    OneParameterReturn oneParameterReturn = (int a)->{
    System.out.println("有返回值有一个参数！");
    return a;
};
ret = oneParameterReturn.test(50);
System.out.println(ret);
 
    MoreParameterReturn moreParameterReturn = (int a,int b)->{
    System.out.println("有返回值多个参数！");
    return a+b;
};
ret = moreParameterReturn.test(60,70);
System.out.println(ret);
}
}

3.3.3 二者区别

代码实例：

1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。

2. 参数的小括号里面只有一个参数，那么小括号可以省略

3. 如果方法体当中只有一句代码，那么大括号可以省略

4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

3.4 变量捕获

变量捕获，在匿名内部类中也存在，而类似匿名内部类的Lambda表达式，自然而然也存在。

3.4.1 匿名内部类的变量捕获

外，已经定义了a的值，因此匿名内部类直接捕获了外部的a变量。

3.4.2 Lambda变量捕获

如上图，使用直接捕获了外部的a变量。

注：无论是匿名内部类的变量捕获还是Lambda变量捕获，方法体里，不可修改外部变量的值。

总结

反射、枚举以及Lambda表达式很少使用，算是偏僻的知识点，因此不要求掌握，只要求熟悉。