反射、枚举以及lambda表达式
目录
反射
定义
用途(了解)
反射基本信息
反射相关的类（重要）
编辑
Class类(反射机制的起源 )
Class类中的相关方法
反射示例
获得Class对象的三种方式
反射的使用
枚举
背景及定义
使用
枚举优点缺点
枚举和反射
Lambda表达式
背景
Lambda表达式的语法
函数式接口
Lambda表达式的基本使用
语法精简
变量捕获
匿名内部类
匿名内部类的变量捕获
Lambda的变量捕获
Lambda在集合当中的使用
Collection接口
forEach() 方法演示
List接口
Map接口
总结
反射
定义
Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息；这种动态获取信 息以及动态调用对象方法的功能称为java语言的反射(reflection)机制。
用途(了解)
1. 在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法
2. 反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无 论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的 就是类的信息，spring根据这些信息，需要创建那些Bean，spring就动态的创建这些类。
反射基本信息
Java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实信息。而通过使用反射程序就能判断出该对象和类属于哪些类。
反射相关的类（重要）
Class类(反射机制的起源 )
Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 ,被编译后的Java文件.class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加改变这个类的属性和动作，使得这个类成 为一个动态的类 .
Class类中的相关方法
反射示例
获得Class对象的三种方式
在反射之前，我们需要做的第一步就是先拿到当前需要反射的类的Class对象，然后通过Class对象的核心方法，达 到反射的目的，即：在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一能个对象， 都够调用它的任意方法和属性，既然能拿到那么，我们就可以修改部分类型信息。
第一种，使用 Class.forName("类的全路径名"); 静态方法。 前提：已明确类的全路径名。
第二种，使用 .class 方法。 说明：仅适合在编译前就已经明确要操作的 Class
第三种，使用类对象的 getClass() 方法
代码示例：
package reflect;
class Student{
//私有属性name
private String name = "bit"; //公有属性age
public int age = 18;
//不带参数的构造方法
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 + '}';
}
}
public class Test {
// 获得Class对象的三种方式
/**
* 1)class对象只有一种
* @param args
*/
public static void main(String[] args) {
// 1.第一种
Class<?> c1;
try {
c1 = Class.forName("reflect.Student");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
}
// 2.第二种
Class<?> c2;
c2 = Student.class;
// 3.第三种
Student student = new Student();
Class<?> c3 = student.getClass();
// 测试
System.out.println(c1.equals(c1));
System.out.println(c1.equals(c3));
System.out.println(c2.equals(c3));
}
}
反射的使用
代码示例：
package reflect;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
public class ReflectDome {
// 如何通过反射实例化一个对象
public static void reflectNewInstance(){
Class<?> c1;
try {
c1 = Class.forName("reflect.Student");
Student student = (Student) c1.newInstance();
System.out.println(student);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
// 反射一个私有的构造方法
public static void reflectPrivateConstructor(){
Class<?> c1;
try {
c1 = Class.forName("reflect.Student");
// 通过下一步拿到了这个构造方法
Constructor<Student> con = (Constructor) c1.getDeclaredConstructor(String.class,int.class);
con.setAccessible(true); // 你确定吗？“是的，我确定”
// 接下来怎么拿这个构造方法来实例化我的一个对象
Student student = con.newInstance("小云",20);
System.out.println(student);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
// 反射私有属性
public static void reflectPrivateField(){
// 1.无论哪种反射，第一步就是拿到我们的class对象
Class<?> c1;
try {
c1 = Class.forName("reflect.Student");
Field field = c1.getDeclaredField("name");
// 问你确定要可修改吗
field.setAccessible(true);
Student student = (Student) c1.newInstance();
System.out.println(student);
field.set(student,"小云云");
System.out.println(student);
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchFieldException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
// 反射私有的方法
public static void forName(){
Class<?> c1;
try {
c1 = Class.forName("reflect.Student");
Method method = c1.getDeclaredMethod("function",String.class);
method.setAccessible(true);
Student student = (Student) c1.newInstance(); // 实例化一个参数出来
method.invoke(student,"我是一个私有方法");
} catch (ClassNotFoundException e) {
throw new RuntimeException(e);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
public static void main(String[] args) {
reflectNewInstance();
System.out.println();
reflectPrivateConstructor();
System.out.println();
reflectPrivateField();
System.out.println();
forName();
}
}
枚举
背景及定义
枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：
public static final int RED = 1;
public static final int GREEN = 2;
public static final int BLACK = 3;但是常量举例有不好的地方，例如：可能碰巧有个数字1，但是他有可能误会为是RED，现在我们可以直接用枚举来进行组织，这样一来，就拥有了类型，枚举类型。而不是普通的整形1.
public enum TestEnum {
RED,BLACK,GREEN;
}优点：将常量组织起来统一进行管理
场景：错误状态码，消息类型，颜色的划分，状态机等等....
本质：是 java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承 Enum ，但是其默认继承了 这个类。
使用
1、switch语句
代码示例：
package Enumeration;
public enum TestEnum {
RED,WHITE,GREEN;
public static void main(String[] args) {
// 第一种使用方式
TestEnum testEnum = TestEnum.RED;
// 枚举可以作为switch的参数
switch (testEnum){
case RED:
System.out.println("红色");
break;
case WHITE:
System.out.println("白色");
break;
case GREEN:
System.out.println("绿色");
break;
}
}
}
2、常用方法
/**
* 枚举其他类型demo
*/
public static void main(String[] args) {
// 1.以数组的方法返回枚举中所有的类型
TestEnum[] testEnums1 = TestEnum.values();
System.out.println(Arrays.toString(testEnums1));
System.out.println("===================");
// 2.获取枚举成员的索引位置
int index1 = TestEnum.RED.ordinal();
System.out.println(index1);
int index2 = TestEnum.GREEN.ordinal();
System.out.println(index2);
System.out.println("===================");
// 3.将普通字符串转换为枚举实例
TestEnum testEnum2 = TestEnum.valueOf("RED");
System.out.println(testEnum2);
System.out.println("===================");
// 4.比较两个枚举成员在定义时的顺序
System.out.println(TestEnum.RED.compareTo(TestEnum.WHITE));
}刚刚说过，在Java当中枚举实际上就是一个类。所以我们在定义枚举的时候，还可以这样定义和使用枚举：
重要：枚举的构造方法默认是私有的
public enum TestEnum {
RED(1,"RED"),WHITE(2,"WHITE"),GREEN(3,"GREEN");
public String color;
public int ordinary;
// 这样子写就不默认不是默认的构造方法了
TestEnum(int ordinary,String color){
this.color = color;
this.ordinary = ordinary;
}
}枚举优点缺点
优点： 1. 枚举常量更简单安全 。
2. 枚举具有内置方法 ，代码更优雅
缺点： 1. 不可继承，无法扩展
枚举和反射
1.枚举是否可以通过反射，拿到实例对象呢？
我们刚刚在反射里边看到了，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那 么枚举的构造方法也是私有的，我们是否可以拿到呢？
测试代码：
package Enumeration;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
public class Constant {
public static final int RED = 1;
public static final int WHITE = 1;
public static final int GREEN = 1;
public static void main(String[] args) throws ClassNotFoundException {
Class<?> c = Class.forName("Enumeration.TestEnum");
// 通过反射获取私有方法
try {
Constructor<?> constructor = c.getDeclaredConstructor(int.class,String.class);
// 因为这里调用的是私有的方法，所以这个要先确认一下
constructor.setAccessible(true);
// 这是一个枚举对象，要接收一下
TestEnum testEnum = (TestEnum) constructor.newInstance(99,"hello");
System.out.println(testEnum);
} catch (NoSuchMethodException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
}
}
}
运行结果：
原因：我们所有的枚举类，都是默认继承与 java.lang.Enum ,说到继承，继承了什么？继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！而我们写的类，并没有帮助父类构造！那意思是，我们要在自己的枚举类里面，提供super吗？不是的，枚举比较特殊，虽然我们写的是 两个，但是默认他还添加了两个参数，哪两个参数呢？
Constructor<?> constructor = c.getDeclaredConstructor(String.class,int.class,int.class,String.class);
// 因为这里调用的是私有的方法，所以这个要先确认一下
constructor.setAccessible(true);
// 这是一个枚举对象，要接收一下
TestEnum testEnum = (TestEnum) constructor.newInstance("hello",99,88,"world");运行结果：
如上图所示，不能通过反射获取枚举类的实例
Lambda表达式
背景
Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure）
Lambda表达式的语法
基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }
Lambda表达式由三部分组成：
1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明 也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
2. ->：可理解为“被用于”的意思
3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不返回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。
函数式接口
要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法 。
注意：
1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只 有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。
代码展示：
@FunctionalInterface
interface NoParameterNoReturn{
void test();
}Lambda表达式的基本使用
1.无返回值无参数的
//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
void test();
} public static void main(String[] args) {
// 1)不用Lambda表达式调用
NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn() {
@Override
public void test() {
System.out.println("test");
}
};
noParameterNoReturn.test();
// 2)使用Lambda表达式
NoParameterNoReturn noParameterNoReturn1 = ()-> System.out.println("test(lambda)"); // 匿名内部类
noParameterNoReturn1.test();
}2.无返回值有一个参数的
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
void test(int a);
}/**
* 2.无返回值有一个参数的
*/
public static void main(String[] args) {
OneParameterNoReturn oneParameterNoReturn = (x) -> {
System.out.println(x);
};
oneParameterNoReturn.test(5201314);
}3.无返回值只有一个参数
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
void test(int a,int b);
} /**
* 3.无返回值有一个参数的
*/
public static void main(String[] args) {
MoreParameterNoReturn moreParameterNoReturn = (int x,int y)->{
System.out.println(x+y);
};
moreParameterNoReturn.test(10,20);
}4.有返回值无参数的
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
int test();
} /**
* 4.有返回值无参数的
*/
public static void main(String[] args) {
NoParameterReturn noParameterReturn = ()->{
System.out.println("云倩怡是一个大坏蛋！！");
return 520;
};
System.out.println(noParameterReturn.test());
}5.有返回值有一个参数的
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
int test(int a);
} /**
* 5.有返回值有一个参数的
*/
public static void main(String[] args) {
OneParameterReturn oneParameterReturn = (m)->{
return m/10;
};
System.out.println(oneParameterReturn.test(1314));
}6.有返回值有两个参数的
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
int test(int a,int b);
} /**
* 6.有返回值有两个参数的
*/
public static void main(String[] args) {
MoreParameterReturn moreParameterReturn = (m,n)->{
return m*n;
};
System.out.println(moreParameterReturn.test(2, 3));
}语法精简
1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
2. 参数的小括号里面只有一个参数，那么小括号可以省略
3. 如果方法体当中只有一句代码，那么大括号可以省略
4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。
变量捕获
Lambda 表达式中存在变量捕获 ，了解了变量捕获之后，我们才能更好的理解Lambda 表达式的作用域 。Java当中的匿名类中，会存在变量捕获。
匿名内部类
匿名内部类就是没有名字的内部类 。我们这里只是为了说明变量捕获，所以，匿名内部类只要会使用就好，那么下面我们来，简单的看看匿名内部类的使用就好了。
匿名内部类的变量捕获
在上述代码当中的变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的 你要保证在使用之前，没有修改。如上代码就是错误的代码。
Lambda的变量捕获
在Lambda当中也可以进行变量的捕获，具体我们看一下代码。
Lambda在集合当中的使用
为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。
Collection接口
forEach() 方法演示
代码展示：
/**
* Collection接口下的forEach()方法
* @param args
*/
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("abc");
list.add("小云");
// 第一种方法
list.forEach(new Consumer<String>() {
@Override
public void accept(String s) {
System.out.println(s);
}
});
// 第二种方法
System.out.println("================");
list.forEach(s-> System.out.println(s));
}List接口
sort( )方法的演示
sort方法源码：该方法根据c指定的比较规则对容器元素进行排序 。
代码展示：
/**
* List接口下的sort()方法
*/
public static void main(String[] args) {
List<String> list = new ArrayList<>();
list.add("hello");
list.add("abc");
list.add("小云");
System.out.println(list);
System.out.println("================");
// 第一种方法：匿名内部类
list.sort(new Comparator<String>() {
@Override
public int compare(String o1, String o2) {
return o1.length() - o2.length();
}
});
System.out.println(list);
System.out.println("================");
// 第二种方法：Lambda表达式
list.sort((o1, o2) -> {
return o1.length() - o2.length();
});
System.out.println(list);
System.out.println("================");
}Map接口
HashMap的forEach()
代码展示：
/**
* Map下的forEach()方法
*/
public static void main(String[] args) {
Map<String,Integer> map = new HashMap<>();
map.put("hello",3);
map.put("abc",5);
map.put("zhangsan",7);
System.out.println(map);
System.out.println("==============================");
// 第一种方法：匿名内部类
map.forEach(new BiConsumer<String, Integer>() {
@Override
public void accept(String s, Integer integer) {
System.out.println("key:" + s + "," + "val:" + integer);
}
});
System.out.println("==============================");
// 第二种方法：Lambda表达式
map.forEach((String s1,Integer interge1)->{
System.out.println("key:" + s1 +","+ "val:" + interge1);
});
System.out.println("==============================");
}总结
Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。
优点：
1. 代码简洁，开发迅速
2. 方便函数式编程
3. 非常容易进行并行计算
4. Java 引入 Lambda，改善了集合操作
缺点：
1. 代码可读性变差
2. 在非并行计算中，很多计算未必有传统的 for 性能要高
3. 不容易进行调试