1. 反射

1.1 定义

java的.class文件在运行时会被编译为一个Class对象，既然是对象，那么我们就可以通过一定的方式取到这个对象，然后对于这个对象进行一系列操作（改变原本类的属性、方法）。

这个操作就是反射，反射会像一面照妖镜一样，将所有的类“照”出来，不管它是否是private的还是protected，都可以进行访问、创建、修改。

反射的一系列操作都是动态的。

1.2 用途（了解）

1. 在日常的第三方应用开发中，经常有某个属性或者方法只对于系统进行开放，这时可以利用反射进行获取。
2. 开发各种通用框架也可以用到。

1.3 反射出的基本信息

java程序中许多对象在运行时会出现两种类型：运行时类型(RTTI)和编译时类型，例如Person p = new Student()；这句代码中p在编译时类型为Person，运行时类型为Student。程序需要在运行时发现对象和类的真实 信息。而通过使用反射程序就能判断出该对象和类属于哪些类。

1.4 反射相关的类（重要）

类	说明
Class类	代表类的实体，在运行的java程序中表示类和接口
Field类	代表类的成员变量
Constructor类	代表类的构造方法
Method类	代表类的方法

1.5 获得Class对象的三种方式

package ReflectDemo;

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

public class ReflectDemo {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException, ClassNotFoundException {
        // 方式1
        Class<?> student1 = Student.class;
        // 方式2
        Class<?> student2 = Class.forName("ReflectDemo.Student");
        // 方式3
        Student studentTmp = new Student("",1);
        Class<?> student3 = studentTmp.getClass();

        // 验证是不是同一个Class对象
        System.out.println(student1 == student2);
        System.out.println(student1 == student3);
    }
}

三种方式：

1. 使用 “对象名.class” 进行获得
2. 使用 "Class.forName(“类的路径”)"进行获得
3. 使用 “已经构造出来的对象.getClass()” 进行获得

只有一个Class对象的原因:

所以通过反射只能得到同一个Class对象。

1.6 反射的使用——Class类中的相关方法（重要）

出现Declared就能够获取私有变量/方法。

1.6.1 常用获得类相关的方法

方法	说明
getClassLoader()	获得类的加载器
getDeclaredClass()	返回一个数组，数组中包含该类中所有类和接口类的对象(包括私有的
forName(String className)	根据类名返回类的对象
getName()	获得类的完整路径名字

创建的Person测试类（包含public、private内部类，接口，各种属性）：

package ReflectDemo;

public class Person implements Comparable<Person>{
    public String name;
    private int id;
    private int age;

    @Override
    public int compareTo(Person o) {
        return o.age - this.age;
    }

    interface interfaceTest{};
    public class PublicInnerClass {}
    private class PrivateInnerClass {}

    public Person(String name, int id) {
        this.name = name;
        this.id = id;
    }

}

测试代码：

package ReflectDemo;

import java.lang.reflect.Array;
import java.util.ArrayList;
import java.util.Arrays;

public class ReflectTest {
    public static void main(String[] args) {
        Class<?> cls;
        try {
            cls = Class.forName("ReflectDemo.Person");
            /*// 获取Person类内部的public类、接口，返回一个数组
            Class<?>[] classes = cls.getClasses();*/

            // 获取Person类内部的包括private的类、接口，返回一个数组
            Class<?>[] classes = cls.getDeclaredClasses();
            System.out.println(Arrays.toString(classes));

            System.out.println(Person.class.getName());
        }catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
}

运行结果：

1.6.2 （重要）常用获得类属性的方法（以下与Field相关）

方法	说明
getField(String name)	获得某个公有属性（参数为属性名称）
getFields()	获得所有公共属性（返回值为Fields数组）
getDeclaredField(String name)	获得某个属性（参数为属性名称、不分权限）
getDeclaredFields()	获得某个属性（返回值为Fields数组、不分权限）

示例代码:

package ReflectDemo;

import java.lang.reflect.Field;
import java.util.Arrays;

public class ReflectDemo3 {
    public static void main(String[] args) throws NoSuchFieldException {
        Class<?> personClass = Person.class;

        // 获得公有属性
        Field name = personClass.getField("name");
        Field[] fields = personClass.getFields();

        System.out.println("获得某个公有属性");
        System.out.println(name);
        System.out.println("获得所有公有属性");
        for (Field field : fields) {
            System.out.println(field);
        }

        System.out.println("获得某个属性（不分权限）");
        //获得某个属性（不分权限）
        System.out.println(personClass.getDeclaredField("id"));

        System.out.println("获得所有属性（不分权限)");
        // 获得所有属性（不分权限）
        System.out.println(Arrays.toString(personClass.getDeclaredFields()));
    }
}

运行结果：

1.6.3 （了解）获得类中注解相关的方法

方法	说明
getAnnotation(Class annotationClass)	返回该类中与参数类型匹配的公有注解对象
getAnnotations()	返回该类所有的公有注解对象
getDeclaredAnnotation(Class annotationClass)	返回该类中与参数类型匹配的所有注解对象
getDeclaredAnnotations()	返回该类所有的注解对象

1.6.4 （重要）获得类中构造器相关的方法（以下方法返回值为Constructor相关）

方法	说明
getConstructor(Class… parameterTypes)	获得该类中与参数类型匹配的公有构造方法
getConstructors()	得该类的所有公有构造方法
getDeclaredConstructor(Class… parameterTypes)	获得该类中与参数类型匹配的构造方法
getDeclaredConstructors()	获得该类所有构造方法

代码：

package ReflectDemo;

import java.lang.annotation.Annotation;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.Arrays;

public class ReflectDemo4 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> personClass = Person.class;

        System.out.println("获得类中特定参数的公有构造方法");
        Constructor<?> personConstructor = personClass.getConstructor(String.class, int.class);
        System.out.println(personConstructor);

        System.out.println("使用特定参数的公有构造方法");
        System.out.println(personConstructor.newInstance("王五", 2023).toString());

        System.out.println("获得类中所有的公有构造方法");
        Constructor<?>[] personConstructors = personClass.getConstructors();
        System.out.println(Arrays.toString(personConstructors));


        System.out.println("获得类中所有的公有构造方法");
        Constructor<?>[] personConstructors2 = personClass.getDeclaredConstructors();
        System.out.println(Arrays.toString(personConstructors2));

        System.out.println("获得类中特定参数的、不分权限的构造方法");
        Constructor<?> personConstructor2 = personClass.getDeclaredConstructor(String.class);
        personConstructor2.setAccessible(true);// 必须设置为true，确认对这个私有方法进行操作
        System.out.println(personConstructor2);

        System.out.println(personConstructor2.newInstance("老六").toString());
    }
}

运行结果：

1.6.5 (重要)获得类中方法相关的方法（以下方法返回值为Method相关）

方法获取到后，需要使用invoke进行调用，第一个参数是这个方法作用的对象，后面的参数是要传到函数中的参数。

方法	说明
getMethod(String name, Class… parameterTypes)	获得该类某个公有的方法
getMethods()	获得该类所有公有的方法
getDeclaredMethod(String name, Class… parameterTypes)	获得该类某个方法
getDeclaredMethods()	获得该类所有方法

package ReflectDemo;

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

public class ReflectDemo5 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> personClass = Person.class;

        Constructor<?> perspnConstructor = personClass.getConstructor(String.class, int.class);
        Person p = (Person) perspnConstructor.newInstance("老七", 2023001);
        System.out.println(p.toString());

        Method setName = personClass.getMethod("setName", String.class);
        p.setName("老八");
        System.out.println(p.toString());

        Method eat = personClass.getMethod("eat");
        eat.invoke(p);// 无参函数调用

        Method swim = personClass.getDeclaredMethod("swim");
        swim.setAccessible(true);// 确认修改访问权限
        swim.invoke(p);
    }
}

运行结果：

1.5 反射优点和缺点

优点：

1. 能够获取本来访问受限的属性、方法。
2. 增强了程序的灵活性，降低耦合度
3. 已经运用在了很多流行的框架上，如：Struts、Hibernate、Spring 等等。

缺点：

1. 使用反射的代码效率较低。
2. 破坏程序封装性。
3. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

1.6 重要总结

1. 反射的意义

意义在于获取一些只对于系统开放的、不让外界看到的方法、属性。

1. 反射的重要类：

Field类，Constructor类，Method类，Class类。

1. 合理利用反射，不要轻易使用。

2. 枚举

将一组常量组织起来，同c语言的枚举相同，已经定义好的枚举中，常量就代表这个符号，这个符号也代表常量。

场景：错误状态码，消息类型，颜色的划分，状态机等等。

本质：继承自Enum这个类。（如同所有的对象都继承自Object类一样，都是隐式继承）

2.1 常用方法

方法	说明
values()	获得枚举类中所有的成员
ordinal()	获得成员在枚举类中的索引位置
name()	获得枚举成员的名称
valueOf()	将普通字符串转换为枚举实例
compareTo()	返回成员在定义时的顺序（将索引位置进行相减）

代码：

package EnumDemo;

public class Demo2 {
    public static void main(String[] args) {
        Color[] color = Color.values();

        for (Color color1 : color) {
            // ordinal的编号改变不了，这是枚举成员在类中的索引位置
            System.out.println(color1.ordinal() +" "+ color1.name());
        }

        // 将编号与name联系起来
        System.out.println(Color.getEnumKey(4));

        Color red = Color.RED;
        Color blue = Color.BLUE;
        System.out.println(red.compareTo(blue));// 索引位置相减
    }
}

运行结果：

枚举的构造方法默认是私有的！所以还可以在枚举类中加上自己定义的构造函数，直接在成员后面进行初始化。

package EnumDemo;

public enum Color {
 RED(4,"红色"),GREEN(5,"绿色"),BLUE(6,"蓝色");
 private int key;
 private String name;

 Color(int key, String name) {
     this.key = key;
     this.name = name;
 }

 public static Color getEnumKey(int key) {
     // 遍历整个枚举类看有没有key
     for (Color e : Color.values()) {
         if (key == e.key) {
             return e;
         }
     }
     return null;
 }
     // err,默认是私有的
//    public Color(int num, String color) {}
//    RED,GREEN,BLUE;
}

2.2 枚举的优缺点

优点：

1. 统一组织，便于管理常量，优于final
2. 简单安全
3. 枚举类有内置方法，书写更优雅

缺点：

1. 不可被继承，无法扩展

但是为单例模式提供了很好的思路。

2.3 枚举与反射

枚举既然安全性这么高，那么能不能通过反射获取到枚举类呢？做个实验验证一下。

package EnumDemo;

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

public class Demo3 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> enumClass = Color.class;

        Constructor<?> enumClassConstructor = enumClass.getDeclaredConstructor(int.class, String.class);
        enumClassConstructor.setAccessible(true);
        Color o = (Color) enumClassConstructor.newInstance(1, "黑色");
        System.out.println(o);
    }
}

运行结果：

报错提示我们并没有这个构造方法，但是我们的构造方法就是两个参数：

Color(int key, String name) {
    this.key = key;
    this.name = name;
}

是不是由于隐藏的super()？还需要参数给父类Enum进行初始化？

Enum类构造方法：

/**
 * Sole constructor.  Programmers cannot invoke this constructor.
 * It is for use by code emitted by the compiler in response to
 * enum type declarations.
 *
 * @param name - The name of this enum constant, which is the identifier
 *               used to declare it.
 * @param ordinal - The ordinal of this enumeration constant (its position
 *         in the enum declaration, where the initial constant is assigned
 *         an ordinal of zero).
 */
protected Enum(String name, int ordinal) {
    this.name = name;
    this.ordinal = ordinal;
}

插播:（在给出源码的时候，源码上的注解已经能够说明不能进行invoke构造了。）

确实，看来父类还需要两个参数进行构造，修改代码如下：

package EnumDemo;

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

public class Demo3 {
    public static void main(String[] args) throws NoSuchMethodException, InvocationTargetException, InstantiationException, IllegalAccessException {
        Class<?> enumClass = Color.class;
        // 函数的参数需要有四个，前两个是父类进行使用，后两个才是自己写的本身的参数
        Constructor<?> enumClassConstructor = enumClass.getDeclaredConstructor(String.class, int.class,int.class, String.class);
        enumClassConstructor.setAccessible(true);
        Color o = (Color) enumClassConstructor.newInstance(1, "黑色");
        System.out.println(o);
    }
}

运行结果：

看来参数传正确也不能够调用，报错指出不能够使用反射进行获取。

然后再返回来看源码中的注释部分:

枚举的源码注释:

** Sole constructor. Programmers can not invoke this constructor.* ** It is for use by code emitted by the compiler in response to* *** enum type declarations.

唯一的构造器，程序员不能够激活这个构造器，它它供编译器在响应 enum类型声明时发出的代码使用。

newInstance()的源码：

结论：

1. 枚举类不能够使用反射获取实例。
2. 枚举可以避免反射和序列化。
3. 枚举简单安全、有内置函数、能够组织常量，便于管理，优于final

2.4 枚举与单例模式

package EnumDemo;

enum SingleEnum {
    INSTANCE;
    public SingleEnum getInstance() {
        return INSTANCE;
    }
}
public class Demo4 {
    public static void main(String[] args) {
        SingleEnum singleEnum1 = SingleEnum.INSTANCE;
        SingleEnum singleEnum2 = SingleEnum.INSTANCE;
        System.out.println(singleEnum2 == singleEnum1);
    }
}

用枚举实现单例模式简单优雅。

3. lambda表达式

3.1 背景

Lambda表达式是java SE 8中一个重要的新特性。它能够简化匿名内部类（函数式接口）的代码量，只关注怎么执行这个代码，而不是无用的创建过程。

3.2 语法

基本原则要遵循：

1. (parameters)->expresstion
2. (parameters)->{statements;}

lambda表达式由三部分组成：

1. parameters：参数部分，类似于普通方法当中的形参部分。

这里的参数可以明确声明，也可以省略，原则是：能推导出来，就能省略。

1. 比如参数只有一个，那么可以省略类型，同时也可以省略小括号()
2. 比如参数有多个，但是类型都一样，那么也可省略类型

1. ->：lambda表达式的标志性语法结构，可以理解为，“被用于”

2. 方法体：相当于普通方法的方法体，可以是表达式，也可以是代码块，同样，也可以省略。

可推导即可省略：

1. 如果这个方法只有一个return语句，那么就可以省略return，省略{}

3.2.1 函数式接口

是一个内部仅含一个抽象方法的接口。

注解：@FunctionalInterface

3.3 使用

package LambdaDemo;


public class demo1 {
    // 无返回值无参数
    @FunctionalInterface
    public 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);
    }
    public static void main(String[] args) {
        // 相当于已经覆写了这个接口的test方法
        NoParameterNoReturn a1 = ()-> System.out.println("无参数无返回值");
        a1.test();

        OneParameterNoReturn a2 = ((a)->{
            System.out.println("无返回值一个参数，参数为：" + a);
        });
        a2.test(1);

        MoreParameterNoReturn a3 = ((a,b) -> {
            System.out.println("无返回值多个参数，参数有：" + a + " "+ b);
        });
        a3.test(1,2);

        NoParameterReturn a4 = ()->{
            System.out.print("有返回值无参数，返回值为：");
            return 4;
        };
        System.out.println(a4.test());

        OneParameterReturn a5 = ((a)->{
            System.out.print("有返回值一个参数，参数为：" + a + "返回值为平方：");
            return a*a;
        });
        System.out.println(a5.test(5));

        MoreParameterReturn a6 = ((a,b)-> {
            System.out.print("有返回值多参数, 参数为：" + a +" "+ b+ "返回值为和：");
            return a+b;
        });

        System.out.println(a6.test(6, 7));
    }
}

运行结果：

3.3.1 精简规则

3.4 变量捕获

3.4.1 匿名内部类

匿名内部类就是没有名字的类，用过一次就用不了的类。比如创建线程的时候可以创建匿名内部类进行创建线程。举个例子：

package LambdaDemo;

class Test{
    public void func() {
        System.out.println("未被重写的func()方法");
    }
}
public class Demo2 {
    public static void main(String[] args) {
        Test t = new Test(){
            public void func() {
                System.out.println("重写func()");
            }
        };

        t.func();

        Test t2 = new Test();
        t2.func();
    }
}

运行结果：

这里就是创建了一个匿名的Test类，直接对类中的func()方法进行重写。因为只想要利用一下Test类中的func()方法。

3.4.2 匿名内部类的变量捕获

package LambdaDemo;

import javax.smartcardio.TerminalFactory;

class Test{
    public void func() {
        System.out.println("未被重写的func()方法");
    }
}
public class Demo2 {
    public static void main(String[] args) {
        int a = 100;
        Test t = new Test(){
            public void func() {
                System.out.println("重写func()");
//                a = 99;// err, 不允许改变变量
                System.out.println("捕获到变量，值为："+ a);
            }
        };
        t.func();

    }
}

结论：

1. 匿名内部类中的捕获的变量必须是final，或者与final等价（未经修改的变量）。

3.4.4 Lambda的变量捕获

package LambdaDemo;

@FunctionalInterface
interface Test2{
    abstract void func();
}

public class Demo3 {
    public static void main(String[] args) {
        int a = 100;
        Test2 t = (()->{
//            a = 99;// err
            System.out.println("重写func()");
            System.out.println(a);
        });
        t.func();
    }
}

结论与匿名内部类相同，方法体中只能由final或者等价于final 的变量存在。

4. Lambda在集合当中的使用

4.1 Collection接口

forEach**() 方法源码：**

default void forEach(Consumer action) { 
    Objects.requireNonNull(action); 
    for (T t : this) { 
        action.accept(t); 
    } 
}

该方法表示：对容器中的每个元素执行action指定的动作 。

使用示例：

package LambdaDemo;

import java.util.ArrayList;
import java.util.function.Consumer;

public class Demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("a");
        list.add("b");
        list.add("c");
        list.add("d");

        list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                // 使用accept方法对 list 中每个元素执行相同的操作
                System.out.print(s + " ");
            }
        });

        System.out.println("\r\n使用lambda表达式改写后：");
        list.forEach((s)-> System.out.print(s + " "));
    }
}

运行结果：

4.2 List接口

sort()方法的源码：

default void sort(Comparator<? super E> c) {
    Object[] a = this.toArray();
    Arrays.sort(a, (Comparator) c);
    ListIterator<E> i = this.listIterator();
    for (Object e : a) {
        i.next();
        i.set((E) e);
    }
}

该方法表示：对容器中的元素进行指定规则的排序。

使用示例：

package LambdaDemo;

import ReflectDemo.Person;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.function.Consumer;

public class Demo5 {
    public static void main(String[] args) {
        Person p1 = new Person("张三",2023);
        Person p2 = new Person("李四",2022);
        Person p3 = new Person("王五",2021);

        ArrayList<Person> list = new ArrayList<>();
        list.add(p1);
        list.add(p2);
        list.add(p3);

        list.sort(new Comparator<Person>() {
            @Override
            public int compare(Person o1, Person o2) {
                return o1.getId() - o2.getId();
            }
        });

        list.forEach(new Consumer<Person>() {
            @Override
            public void accept(Person person) {
                System.out.println(person);
            }
        });

        System.out.println();
        System.out.println("使用lambda表达式改写：");

        //int compare(T o1, T o2);
        list.sort((o1,o2)-> o1.getId() - o2.getId());
        //public void forEach(Consumer<? super E> action)
        list.forEach((p)-> System.out.println(p));
    }
}

运行结果：

4.3 Map接口

HashMap 的 forEach**()** 源码**：**

@Override
public void forEach(BiConsumer<? super K, ? super V> action) {
    Node<K,V>[] tab;
    if (action == null)
        throw new NullPointerException();
    if (size > 0 && (tab = table) != null) {
        int mc = modCount;
        for (int i = 0; i < tab.length; ++i) {
            for (Node<K,V> e = tab[i]; e != null; e = e.next)
                action.accept(e.key, e.value);
        }
        if (modCount != mc)
            throw new ConcurrentModificationException();
    }
}

使用示例：

package LambdaDemo;

import java.util.HashMap;
import java.util.function.BiConsumer;

public class Demo6 {
    public static void main(String[] args) {
        HashMap<String, Integer> map = new HashMap();

        map.put("张三",19);
        map.put("李四",22);
        map.put("王五",39);
        map.forEach(new BiConsumer() {
            @Override
            public void accept(Object o1, Object o2) {
                System.out.println(o1 +"："+ o2 + "岁了");
            }
        });

        System.out.println("\r\n用lambda表达式改写：");
        map.forEach((o1,o2)->System.out.println(o1 +"："+ o2 + "岁了"));
    }
}

运行结果：

4.4 结论

优点:

1. 代码简洁，开发迅速
2. 方便函数式编程
3. java引入lambda，方便了集合的一些操作
4. 非常容易进行并行计算

缺点:

1. 可读性极差
2. 不容易调试
3. 在非并行计算中，效率未必有普通for高