Java数据结构与算法第十一课---反射、枚举以及lambda表达式

一 : 反射

1.定义

Java的反射（reflection）机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性，既然能拿到，那么，我们就可以修改部分类型信息；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射（reflection）机制。

2.用途

1. 在日常的第三方应用开发过程中，经常会遇到某个类的某个成员变量、方法或是属性是私有的或是只对系统应用开放，这时候就可以利用Java的反射机制通过反射来获取所需的私有成员或是方法 。
2. 反射最重要的用途就是开发各种通用框架，比如在spring中，我们将所有的类Bean交给spring容器管理，无论是XML配置Bean还是注解配置，当我们从容器中获取Bean来依赖注入时，容器会读取配置，而配置中给的就是类的信息，spring根据这些信息，需要创建哪些Bean，spring就动态的创建这些类。

3.反射相关的类

4.Class类(反射机制的起源)

4.1简介

Class类代表类的实体，在运行的Java应用程序中表示类和接口 .

Java文件被编译后，生成了.class文件，JVM此时就要去解读.class文件 .class也被JVM解析为一个对象，这个对象就是 java.lang.Class .这样当程序在运行时，每个java文件就最终变成了Class类对象的一个实例。我们通过Java的反射机制应用到这个实例，就可以去获得甚至去添加 , 改变这个类的属性和动作，使得这个类成为一个动态的类 .

4.2Class类的相关方法

4.2.1常用获得类相关的方法

4.2.2常用获得类中属性相关的方法

4.2.3获得类中注解相关的方法

4.2.4获得类中构造器相关的方法

4.2.5获得类中方法相关的方法

5.反射示例

5.1获得Class对象的三种方式

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

package reflectdemo;


class Student {
    //私有属性name
    private String name = "zhangsan";
    //公有属性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 {
    public static void main(String[] args) {
        Student student = new Student();

        Class<?> c1 = student.getClass();// 使用类对象的getClass方法

        Class<?> c2 = Student.class;// 使用.class方法
        
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");// 使用Class.forName("类的全路径名")
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

        System.out.println(c1.equals(c2));
        System.out.println(c1.equals(c3));
        System.out.println(c3 .equals(c2));
        
        /*
        * 三个class对象都相等,说明一个类对应一个class对象
        * */
    }
}

5.2反射的使用

package reflectdemo;

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

public class ReflectClassDemo {

    /**
     * 反射获取对象
     */
    public static void reflectNewInstance() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");
            Student student = (Student)c3.newInstance();
            System.out.println(student);
            student.sleep();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过反射,调用构造方法[公开和私有的都可以]
     */
    public static void reflectPrivateConstructor() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");

            Constructor<?> constructor =
                    c3.getDeclaredConstructor(String.class,int.class);

            //因为构造方法是私有的,所以将该属性设置为true,就认为可以调用私有的方法
            constructor.setAccessible(true);

            Student student = (Student)constructor.newInstance("laobai",20);

            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过反射,调用属性
     */
    public static void reflectPrivateField() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");
            Student student = (Student) c3.newInstance();

            Field field = c3.getDeclaredField("name");
            field.setAccessible(true);
            field.set(student,"laojin");
            System.out.println(student);

        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }

    /**
     * 通过反射,调用私有方法
     */
    public static void reflectPrivateMethod() {
        Class<?> c3 = null;
        try {
            c3 = Class.forName("reflectdemo.Student");
            Student student = (Student) c3.newInstance();
            Method method = c3.getDeclaredMethod("function", String.class);// 方法名,方法参数
            method.setAccessible(true);
            method.invoke(student,"我传一个参数试试！");// 调用的实例,参数
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
    }

    public static void main(String[] args) {
        //reflectNewInstance();
        //reflectPrivateConstructor();
        //reflectPrivateField();
        reflectPrivateMethod();
    }

}

6.反射优缺点

优点：

1. 对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法 ;
2. 增加程序的灵活性和扩展性，降低耦合性，提高自适应能力 ;
3. 反射已经运用在了很多流行框架如：Struts、Hibernate、Spring 等等。

缺点：

1. 使用反射会有效率问题。会导致程序效率降低。具体参考
2. 反射技术绕过了源代码的技术，因而会带来维护问题。反射代码比相应的直接代码更复杂 。

重点总结 :

1. 反射的意义
2. 反射重要的几个类： Class类 、Field类、 Method类、 Constructor类
3. 学会合理利用反射，一定要在安全环境下使用

二 : 枚举

1 背景及定义

枚举是在JDK1.5以后引入的。主要用途是：将一组常量组织起来，在这之前表示一组常量通常使用定义常量的方式：

public static final int YANLONG = 1;
public static final int FENGYING = 2;
public static final int XUEAO = 3;

但是常量举例有不好的地方，例如：可能碰巧有个数字1，但是他有可能误认为是YANLONG，现在我们可以直接用枚举来进行组织，这样一来，就拥有了枚举类型 , 而不是普通的整形1 .

public enum TestEnum {
	YANLOGN,FENGYING,HEIXI,XUEAO;
}

优点：将常量组织起来统一进行管理 ;

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

本质：是java.lang.Enum 的子类，也就是说，自己写的枚举类，就算没有显示的继承Enum ，但是其默认继承了这个类。

2.枚举的使用

2.1switch语句

package enumdemo;


public enum TestEnum {
    //枚举对象
    YANLONG("炎龙侠",0),
    FENGYING("风鹰侠",1),
    HEIXI("黑犀侠",2),
    XUEAO("雪獒侠",3);

    public String armour;
    public int ordinal;

    //枚举的构造方法默认是私有的
    private TestEnum() {

    } 

    private TestEnum(String armour,int ordinal) {
        this.armour = armour;
        this.ordinal = ordinal;
    }

    public static void main(String[] args) {
        TestEnum testEnum = TestEnum.YANLONG;
        switch (testEnum) {
            case YANLONG:
                System.out.println("炎龙侠 升腾炎上就是焰火的力量");
                break;
            case FENGYING:
                System.out.println("风鹰侠 曲直屈伸就是巨木的力量");
                break;
            case HEIXI:
                System.out.println("黑犀侠 滋润掩藏但发出狂啸的力量");
                break;
            case XUEAO:
                System.out.println("雪獒侠 他有能刚能柔之金的力量");
                break;
            default:
                break;
        }
    }
}

在这里插入图片描述

2.2常用方法

Enum类的常用方法 :

示例一 :

package enumdemo;

public enum TestEnum {
    //枚举对象
    YANLONG("炎龙侠",0),
    FENGYING("风鹰侠",1),
    HEIXI("黑犀侠",2),
    XUEAO("雪獒侠",3);

    public String armour;
    public int ordinal;

    //枚举的构造方法默认是私有的
    TestEnum() {

    } 

    private TestEnum(String armour,int ordinal) {
        this.armour = armour;
        this.ordinal = ordinal;
    } 

    public static void main(String[] args) {
        TestEnum[] testEnums = TestEnum.values();
        for (int i = 0; i < testEnums.length; i++) {
            System.out.println(testEnums[i]+" -> "+ testEnums[i].ordinal());
            //testEnums[i].ordinal()输出枚举对象的序号,默认从0开始
        }
    }
}

Enum枚举类没有values()方法,却可以在枚举类中使用,为什么?

示例二 :

package enumdemo;

public enum TestEnum {
    //枚举对象
    YANLONG("炎龙侠",0),
    FENGYING("风鹰侠",1),
    HEIXI("黑犀侠",2),
    XUEAO("雪獒侠",3);

    public String armour;
    public int ordinal;

    //枚举的构造方法默认是私有的
    private TestEnum() {

    } 

    private TestEnum(String armour,int ordinal) {
        this.armour = armour;
        this.ordinal = ordinal;
    }

    public static void main(String[] args) {
        TestEnum test = TestEnum.valueOf("YANLONG");
        System.out.println(test);
        System.out.println(YANLONG.compareTo(FENGYING));// 比较的是序号
    }
}

3.枚举优缺点

4.枚举和反射

枚举是否可以通过反射,拿到实例对象呢?

我们刚刚在反射里面看到，任何一个类，哪怕其构造方法是私有的，我们也可以通过反射拿到他的实例对象，那么枚举的构造方法也是私有的，我们是否可以拿到呢？接下来，我们来实验一下：

package enumdemo;

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

public class Test {
    public static void main(String[] args) {
        Class<?> c = null;
        try {
            c = Class.forName("enumdemo.TestEnum");
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class);
            constructor.setAccessible(true);

            TestEnum testEnum = (TestEnum)constructor.newInstance("DIHU",23);
            System.out.println(testEnum);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

异常信息是： java.lang.NoSuchMethodException: enumdemo.TestEnum.(java.lang.String, int) ,什么意思 , 就是没有对应的构造方法 . 我的天呐！我们提供的枚举的构造方法就是两个参数分别是String 和int啊 ? 问题出现在哪里呢 ？

我们所有的枚举类，都是默认继承于java.lang.Enum ,说到继承，继承了什么？继承了父类除构造函数外的所有东西，并且子类要帮助父类进行构造！而我们写的类，并没有帮助父类构造！那意思是，我们要在自己的枚举类里面，提供super吗？不是的，枚举比较特殊，虽然我们写的是两个，但是默认他还添加了两个参数，哪两个参数呢？我们看一下Enum类的源码：

也就是说，我们自己的构造函数有两个参数一个是String , 一个是int，同时他默认后边还会给两个参数，一个是String , 一个是int . 即这里我们正确给的是4个参数 :

package enumdemo;

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

public class Test {
    public static void main(String[] args) {
        Class<?> c = null;
        try {
            c = Class.forName("enumdemo.TestEnum");
            Constructor<?> constructor = c.getDeclaredConstructor(String.class, int.class,
                    String.class, int.class);
            constructor.setAccessible(true);

            TestEnum testEnum = (TestEnum)constructor.newInstance("DIHU",23);
            System.out.println(testEnum);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        } catch (NoSuchMethodException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }
}

此时又又又报错了 ! 不过异常信息发生了变化 , 此时的异常信息显示，是我的一个方法newInstance() 报错了！没错，问题就是这里，我们来看一下这个方法的源码，为什么会抛出java.lang.IllegalArgumentException: 异常呢？

源码 :

引申问题 : 为什么枚举实现单例模式是安全的 ?

总结:

1. 枚举本身就是一个类，其构造方法默认为私有的，且都是默认继承于java.lang.Enum
2. 枚举可以避免反射和序列化问题
3. 枚举的优点和缺点

拓展 : 写一个单例模式 .

三 : Lambda表达式

1.背景

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。

2.基本语法

3.函数式接口

要了解lambda表达式 , 就要知道什么是函数式接口 . 函数式接口定义：一个接口有且只有一个抽象方法 .

注意：

1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口 ;
2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的 . 所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解 . 加上就会自动进行检测 .

@FunctionalInterface // 声明该接口为函数式接口,有且只有一个抽象方法
interface NoParameterNoReturn {
    void test();
}

4.Lambda表达式的基本使用

1.在使用比较器时 , 可以使用lambda表达式简化代码 .

    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o1-o2;
            }
        });
    }

使用lambda表示式简化后 :

    public static void main(String[] args) {
        PriorityQueue<Integer> priorityQueue2 = new PriorityQueue<>(((o1, o2) -> o1-o2));
    }

2.演示有/无返回值 , 无参/一个参数/两个参数的Lambda表达式的用法 :

2.1无返回值

package lambdademo;
import java.util.Comparator;
import java.util.PriorityQueue;


@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);
}

public class Test {

    public static void main3(String[] args) {
        //NoParameterReturn noParameterReturn = ()-> {return 10;};
        NoParameterReturn noParameterReturn = ()->10;
        int ret = noParameterReturn.test();
        System.out.println(ret);

        OneParameterReturn oneParameterReturn = a -> a;
        ret = oneParameterReturn.test(99);
        System.out.println(ret);

        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        ret = moreParameterReturn.test(99,1);
        System.out.println(ret);
    }


    public static void main2(String[] args) {
    //1无参
       //1.1常规写法
       NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
            @Override
            public void test() {
                System.out.println("无参 + 不带返回值 常规写法");
            }
        };
        noParameterNoReturn.test();

        //1.2写法优化:使用lambda表达式
        NoParameterNoReturn noParameterNoReturn2 = () -> {
            System.out.println("无参 + 不带返回值 使用lambda表达式");
        };
        noParameterNoReturn2.test();

        //1.3写法优化:省略花括号
        NoParameterNoReturn noParameterNoReturn3 = () -> System.out.println("无参 + 不带返回值 使用lambda表达式 省略花括号");
        noParameterNoReturn3.test();

    //2.有1个参数 + 不带返回值
        //如果有1个参数 那么小括号可以省略  如果方法体只有一行代码 那么花括号可以省略
        OneParameterNoReturn oneParameterNoReturn = a -> System.out.println("有1个参数 + 不带返回值"+a);
        oneParameterNoReturn.test(10);

    //3.有2个参数 + 不带返回值
        MoreParameterNoReturn moreParameterNoReturn = (int a,int b) -> {System.out.println("有2个参数 + 不带返回值"+a+b);};
        moreParameterNoReturn.test(1,2);

        //参数类型如果都要省略 请同时省略
        MoreParameterNoReturn moreParameterNoReturn1 = (a,b) -> System.out.println("有2个参数 + 不带返回值 + 省略参数类型"+a+b);
        moreParameterNoReturn1.test(1,2);
    }

}

2.2有返回值

    public static void main(String[] args) {
        //有返回值,在->后填写返回值
        //NoParameterReturn noParameterReturn = ()-> {return 10;};
        NoParameterReturn noParameterReturn = ()->10;
        int ret = noParameterReturn.test();
        System.out.println("无参 " + ret);

        OneParameterReturn oneParameterReturn = a -> a;
        ret = oneParameterReturn.test(99);
        System.out.println("一个参数 " + ret);

        MoreParameterReturn moreParameterReturn = (a,b)->a+b;
        ret = moreParameterReturn.test(99,1);
        System.out.println("两个返回值 " + ret);
    }

5.变量捕获

5.1匿名内部类中的变量捕获

Lambda 表达式中存在变量捕获 . Java当中的匿名类中，会存在变量捕获 .

package InnerClass;
class Test {
    public void func() {
        System.out.println("func()");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类,且重写了func这个方法!");
            }
        };
    }
}

在上述代码当中的main函数当中，我们看到的就是一个匿名内部类的简单的使用 .

package InnerClass;
class Test {
    public void func() {
        System.out.println("func()");
    }
}

public class TestDemo {
    public static void main(String[] args) {
        int a = 10;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类,且重写了func这个方法!");
                System.out.println("捕获了变量a = " + a);
            }
        };
    }
}

在上述代码当中的变量a就是捕获的变量 . 这个变量要么是被final修饰，如果不是被final修饰的 你要保证在使用之前，没有修改 .

5.2Lambda中的变量捕获

不能修改变量a的值 , 否则会报错 ; 建议将a变量使用final进行修饰 .

6.Lambda在集合中的应用

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接 .

Collection接口的forEach() 方法演示 , 该方法在接口Iterable 当中，原型如下：

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

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

List接口的sort源码 :

public void sort(Comparator<? super E> c) {
	final int expectedModCount = modCount;
	Arrays.sort((E[]) elementData, 0, size, c);
	if (modCount != expectedModCount) {
		throw new ConcurrentModificationException();
	}
	modCount++;
}

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("yes");
        list.add("no");
        list.add("double");
        list.add("lambda");

        /*list.forEach(new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        });*/

        list.forEach(str->System.out.println(str));
        System.out.println("排序:");

        /*list.sort(new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.compareTo(o2);
            }
        });*/

        list.sort((o1,o2)->o1.compareTo(o2));

        list.forEach(str->System.out.println(str));

    }

HashMap的forEach()方法源码 :

default void forEach(BiConsumer<? super K, ? super V> action) {
		Objects.requireNonNull(action);
		for (Map.Entry<K, V> entry : entrySet()) {
		K k;
		V v;
		try {
			k = entry.getKey();
			v = entry.getValue();
		} catch(IllegalStateException ise) {
		// this usually means the entry is no longer in the map.
			throw new ConcurrentModificationException(ise);
		}
		action.accept(k, v);
		}
}

作用是对Map中的每个映射执行action指定的操作 .

使用Lambda表达式 :

    public static void main(String[] args) {
        HashMap<Integer, String> map = new HashMap<>();
        map.put(1, "yes");
        map.put(2, "no");
        map.put(3, "hello");
        map.put(4, "lambda");
       /* map.forEach(new BiConsumer<Integer, String>() {
            @Override
            public void accept(Integer integer, String s) {
                System.out.println("key:"+integer+" val: "+s);
            }
        });
*/
        map.forEach((key,val)->System.out.println("key:"+key+" val: "+val));
    }

7.总结

---

本文到此结束 !