【Groovy123】Groovy中的基本概念和设计思想

Groovy：

http://www.groovy-lang.org/

https://blog.csdn.net/weixin_33862993/article/details/86258972

https://www.cnblogs.com/zqlxtt/p/5741240.html

Gradle(Groovy实例)：

https://www.cnblogs.com/zqlxtt/tag/gradle/

https://www.jianshu.com/p/20f6695a9bd5

https://www.yiibai.com/gradle/gradle_tasks.html

其他概念：

反射

https://blog.csdn.net/jin_luo/article/details/79763938

https://segmentfault.com/a/1190000016105692

https://www.cnblogs.com/dabai123/p/11595178.html

https://www.cnblogs.com/zuzizai/p/7594368.html

1.1. 硬编码（正常方式）

RTTI假定在编译期，已经知道了所有的类型信息。在编码时，可以直接使用具体的类型信息，这是我们最常见的类型用法。在编译期，编译器通过容器、泛型保障类型系统的完整性；在运行时，由类型转换操作来确保这一点。

1.2. Reflect（反射方法）

Reflect允许我们在运行时获取并使用类型信息，它主要用于在编译阶段无法获得所有的类型信息的场景，如各类框架。

反射，可以通过一组特殊的API，在运行时，动态执行所有Java硬编码完成的功能（如对象创建、方法调用等）。相比硬编码，Java反射API要复杂的多，但其给我们带来了更大的灵活性。

实例化Class类对象(四种方法) ：

1）前提：若已知具体的类，通过类的class属性获取，该方法 
                    最为安全可靠，程序性能最高
       实例：Class clazz = String.class;
2）前提：已知某个类的实例，调用该实例的getClass()方法获
                    取Class对象
       实例：Class clazz = “www.atguigu.com”.getClass();
3）前提：已知一个类的全类名，且该类在类路径下，可通过
       Class类的静态方法forName()获取，可能抛出ClassNotFoundException
       实例：Class clazz = Class.forName(“java.lang.String”);
4）其他方式(不做要求)
ClassLoader cl = this.getClass().getClassLoader();
Class clazz4 = cl.loadClass(“类的全类名”);

/** RefelctDemo */

public class ReflectDemo {
    //获取构造方法 一共三种方式(框架程序员使用)
    @Test
    public void test1() throws Exception, Exception{
        Class clazz  =  Student.class;
        Constructor c = clazz.getConstructor(null);
        Student s = (Student)c.newInstance(null);
        System.out.println(s);
        
    }
    @Test
    public void test2() throws Exception, Exception{
        Class clazz  =  Student.class;
        Object object = clazz.newInstance();
        System.out.println(object.getClass().getName());
        
    }
    @Test
    public void test3() throws Exception, Exception{
        Class c =Class.forName("Reflect.Student");
        Student s =(Student) c.newInstance();
        System.out.println(s);
        
    }
    //获取有参数构造
    @Test
    public void test4() throws Exception, Exception{
    Class clazz =Student.class;
    //获取构造函数
    Constructor c = clazz.getConstructor(String.class);
    Student s =(Student)c.newInstance("赵日天");
    System.out.println(s.getName());
    }
    //获取私有的构造方法
    @Test
    public void test5() throws Exception, Exception{
        Class clazz =Student.class;
        Constructor an = clazz.getDeclaredConstructor(Date.class);
        //暴力反射
        an.setAccessible(true);
        Student s =(Student)an.newInstance(new Date());
        System.out.println(s.getData());
                
    }
}

动态代理

https://www.jianshu.com/p/7b5af86a9984

Java动态代理比代理更进一步，因为它可以动态的创建代理并动态的处理对所代理方法的调用。在动态代理上所做的所有调用都会被重定向到单一的调用处理器上。

JDK实现的动态代理

Proxy.java

InvocationHandler.java

闭包