Java编程思想：嵌套类

public class Test {
    public static void main(String[] args) {
//        Parcell11.test();
//        ClassInterface.Test.test();
        TestBed.Tester.test();
    }
}

/*
    嵌套类和普通的内部类还有一个区别。普通的内部类的字段和方法，只能放在类的外部
    层次上，所以普通的内部类不能有static数据和static字段，也不能包含嵌套类。但
    是嵌套类可以包含这些东西
 */
interface Content {
    int value();
}
interface Destination {
    String readLabel();
}
class Parcell11 {
    private static class ParcelContents implements Content {
        private int i = 11;
        @Override
        public int value() {
            return i;
        }
    }

    protected static class ParcelDestination implements Destination{
        String lable;

        public ParcelDestination(String lable) {
            this.lable = lable;
        }

        @Override
        public String readLabel() {
            return null;
        }

        //嵌套类中，允许有静态区域
        public static void f() {

        }
        static int x = 10;

        static class AnotherLevle {
            public static void f() {

            }
            static int x = 10;
        }
    }

    public static Destination destination(String s) {
        return new ParcelDestination(s);
    }

    public static Content content() {
        return new ParcelContents();
    }

    public static void test() {
        Content c =content();
        Destination d = destination("HHH");
    }
}

/*
    需求：
        如果你想创建某些公共代码，使得它们可以被某个接口的所有不同实现所公用，那么使
        用接口内部的嵌套类会显得很方便。放在接口中的任何类都自动地是public和static
        的。因为类是static的，只是将嵌套类置于接口的命名空间内，这并不违反接口的规则
        。你甚至可以在内部类中实现其外围接口。
 */
interface ClassInterface {
    void howdy();

    class Test implements ClassInterface {

        @Override
        public void howdy() {
            System.out.println("Howdy!");
        }

        public static void test() {
            new Test().howdy();
        }
    }
}

/*
    需求：
        我曾在这本书建议过，在每个类中都写一个main()方法，用来测试这个类。这样做有一个
        缺点，那就是必须带有已编译过的额外代码。但是可以使用嵌套来放置测试代码，嵌套类会
        生成一个字节码文件，发布时将字节码文件删除就好了
 */
class TestBed {
    public void f() {
        System.out.println("f()");
    }

    public static class Tester {
        public static void test() {
            TestBed t = new TestBed();
            t.f();
        }
    }
}

/*
    笔记：
        一个内部类被嵌套多少层并不重要——它能透明的访问所有它所嵌入的外部类的所有成员方法。
        同时，在不同的类里创建多层嵌套的内部类对象时，.new语法能产生正确的作用域，所以不必
        在调用构造器时限定类名。 

            ——这跟嵌套类没有半毛钱的关系
 */
class A1 {
    private void f() {

    }

    class A2 {
        private void g() {
            f();
        }

        private class A3 {
            private void h() {
                f();
                g();
            }
        }
    }
}

//测试一下如果外围类有同名方法会怎样
class B1 {
    private void f() {
        System.out.println("B1");
    }

    class B2 {
        private void f() {
            f();
            System.out.println("B2");
        }

        private class B3 {
            private void f() {
                f();
                f();
                System.out.println("B3");
            }
        }
    }
}

class MultiNestingAccess {
    public static void test() {

    }
}

原文地址：https://www.cnblogs.com/junjie2019/p/10545676.html