关于内部类继承可以继承父类达到自己继承自己

不得不说JAVA很神奇，很多功能需要探索，这里我们可以通过内部类继承外部类的方法达到自己继承自己的目的

public class Main {

    public static void main(String[] args) {
        Seven s = new Seven();
        Seven.Inner si = s.new Inner();
        si.change();
        System.out.println("-------------------");

        Eleven e = new Eleven();
        InterEleven ie = e.make();
        ie.print();
        //! Eleven.Inner = e.make();
        System.out.println("-------------------");

        SevenRedo sr = new SevenRedo();
        sr.change();
        System.out.println(sr);
        System.out.println("-------------------");
        sr.doSth().change();                         //我们这里居然自己继承了自己
        System.out.println(sr.doSth());
        System.out.println("-------------------");
        sr.doSth().doSth().change();
        System.out.println(sr.doSth().doSth());
    }
}

class Seven {
    private void test() {System.out.println(a);}
    private int a = 0;
    class Inner {
        void change() {
            Seven.this.test();
            Seven.this.a = 2;
            Seven.this.test();
        }
    }
}

class SevenRedo {
    private void test() {System.out.println(a);}
    private int a = 0;
    void change() {System.out.println("Nothing");}
    SevenRedo doSth() {
        return new SevenRedo() {
            void change() {
                SevenRedo.this.test();
                SevenRedo.this.a = 2;
                SevenRedo.this.test();
            }
        };
    }
}

interface InterEleven {void print();};

class Eleven {
    // ! Eleven() {System.out.println("12");new ExtendsMe();}         //可以看到这里我们使用了内部类继承外部类的做法，在这种特定的设计下可以造成无限递归
    private class Inner implements InterEleven {
        public void print() {System.out.println("inner");}
    }
    /* !! class ExtendsMe extends Eleven {
        ExtendsMe() {super();}
    }*/
    InterEleven make() {return new Inner();}
}

----------------------------------2020.2.28-----------------------------------------------

 时隔半年多再回来看看，当时的理解好像有点问题：

class SevenRedo {
    private void test() {System.out.println(a);}
    private int a = 0;
    void change() {System.out.println("Nothing");}
    SevenRedo doSth() {
        return new SevenRedo() {                                            //由于这里创建的永远是一个SevenRedo类的继承，因此不论这个doSth迭代进行多少次都只是创建SevenRedo的继承，而不是说可以在生成的匿名类上做继承
            void change() {
                super.change();
                SevenRedo.this.test();
                SevenRedo.this.a = 2;
                SevenRedo.this.test();
            }
        };
    }
}

如同注释中写到的，其实不能做到一致迭代继承下去，而是不断地在SevenRedo上作新的匿名继承，因此继承的深度是没有变化的

在匿名类的change()中加入super.change()，这样一来如果可以迭代继承那么这个函数打印的结果将越来越多，但我们发现其实如同sevenRedo.doSth().doSth().change()的调用与sevenRedo.doSth().change()的调用在打印次数上没有变化，这也就证明了刚才的观点，应该是当时没有考虑清楚。

 

之后想用这种方式创建一个不断继承的类：

class SevenRedo{
    SevenRedo() {System.out.println(i++ +"  "+this);}

    protected class Pro extends SevenRedo {
        Pro() {super();System.out.println(SevenRedo.this);}
    }
    static int i = 0;
}

SevenRedo sr = new SevenRedo();
SevenRedo.Pro sro = sr.new Pro();
SevenRedo.Pro.Pro srpp = srp.new Pro();
System.out.println(srp.getClass());
System.out.println(srpp.getClass());

但是观察输出其实不行，SevenRedo.Pro.Pro srpp = srp.new Pro();这一句其实只是让srpp继承了srp的SevenRedo部分，因为Pro的定义说的很明确，只是继承自SevenRedo罢了，这是目前的一个理解，可能有误，还是要腾出时间学一下JVM。

运行时的图，发现后两次其实是一个类型：