/*
         * C++中的解释：
         *     当执行到下面的时候，系统会调用(call)B类的构造函数来分配内存空间，所分配的内存空间的地址保存在this指针里，
         * 所以在构造函数(分为有参和无参还有拷贝构造函数等)就是用于对象级别的(对象之间的拷贝，新建对象等)
         * 你也可以直接在其中之一的方法中直接调用构造函数来返回该对象类似于return *this;或者是return B();
         *             public B getInstance()
         *             {
         *                 return B();//return *this;
         *             }
         */
        B hb = new B();
        /*
         * c++中的解释:
         *     c++中重装了=运算符，当遇到=的时候都会调用拷贝构造函数来实现=的作用
         *         public B(const B& source)
         *         {
         *             this->c = source.c;
         *         }
         *
         *         public operater=(const B& source){
         *             return B(const B& source);
         *         }
         *        
         *         B b2 = hb;
         *         c++会自动将=右边的参数当做形参来传递给b2的拷贝构造函数 所以会有下列情况 当遇到=的时候会自动将hb当做参数来传递给operater=
         *      也就是const B& source = hb;当然不止是引用，也可以是指针，最好不要用对象的副本形式来传递。
         *         然后利用拷贝构造函数 从而达到复制的目的。这个是深拷贝的作用，所以说在c++中的构造函数不只是申请内存空间的作用，还有对象互拷贝
         *         的作用，也就是利用拷贝构造函数来实现的。所以如果我们使用=操作符的时候基本上都会发生析构。有时候无缘无故的发生了一次析构函数就是
         *         因为你使用了=号。如果是 int a =1; int b = a;是不是也要发生拷贝构造函数？
         */
        B b2 = hb; //并不是我们简单的认为修改指针的值
       
        /*
         * 通过反射修改java中私有的变量
         */
        try {
            java.lang.reflect.Field bfield = Class.forName("net.mzzo.labs.test.B").getDeclaredField("c");
            bfield.setAccessible(true);
            //获取修改前c的值
            System.out.println("修改前net.mzzo.labs.test.B中的c值："+bfield.getInt(hb));
            bfield.setInt(hb, 10);
            //获取修改后c的值
            System.out.println("修改net.mzzo.labs.test.B中的c值："+bfield.getInt(hb));
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (SecurityException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
       
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
       
        hb = null;
        System.out.println("hb被析构后："+b2.d); //验证了=的作用是 拷贝构造函数 的功劳
        //递归的使用
        main(null);

public class B {
    private int c = 0;
    public int d = 14;
}