Java内部类

成员内部类

    public class OuterClass {
        private String name;
        private int age;
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        public class InnerClass {
            public InnerClass {
                name = "sysuzhyupeng";
                age = 26;
            }
            public void display(){
                System.out.println("name：" + getName() +"   ;age：" + getAge());
            }
        }
    }

内部类可以无限制地访问外围类的元素。

    public static void main(String[] args) {
        OuterClass outerClass = new OuterClass();
        OuterClass.InnerClass innerClass = OuterClass.new InnerClass();
        innerClass.display();
    }

在编译成功后，会出现这样两个class文件：OuterClass.class和OuterClass$InnerClass.class.
成员内部类也是最普通的内部类，它是外围类的一个成员，所以他是可以无限制的访问外围类的所有 成员属性和方法，尽管是private的，但是外围类要访问内部类的成员属性和方法则需要通过内部类实例来访问。
在成员内部类中要注意两点，第一：成员内部类中不能存在任何static的变量和方法；第二：成员内部类是依附于外围类的，所以只有先创建了外围类才能够创建内部类。

局部内部类

嵌套在方法中或者作用域的称为局部内部类

    public class Parcel5 {
        public Destionation destionation(String str){
            class PDestionation implements Destionation{
                private String label;
                private PDestionation(String whereTo){
                    label = whereTo;
                }
                public String readLabel(){
                    return label;
                }
            }
            return new PDestionation(str);
        }

        public static void main(String[] args) {
            Parcel5 parcel5 = new Parcel5();
            Destionation d = parcel5.destionation("sysuzhyupeng");
        }
    }

静态内部类

我们知道非静态内部类在编译完成之后会隐含地保存着一个引用，该引用是指向创建它的外围内，但是静态内部类却没有。没有这个引用就意味着：

• 它的创建是不需要依赖于外围类的。
• 它不能使用任何外围类的非static成员变量和方法。

看一下具体的栗子

    public class WebResult implements Serializable {
        private static final long serialVersionUID = -7353685364421612000L;
        /**
         * 响应码
         */
        private String code;
        /**
         * 响应提示
         */
        private String message;
        /**
         * 请求是否成功
         */
        private boolean success;
        /**
         * 响应数据
         */
        private Object data;

        public WebResult(ResultBuilder builder){
            this.code = builder.code;
            this.message = builder.message;
            this.success = builder.success;
            this.data = builder.data;
        }

        public String getCode() {
            return code;
        }

        public void setCode(String code) {
            this.code = code;
        }

        public String getMessage() {
            return message;
        }

        public void setMessage(String message) {
            this.message = message;
        }

        public boolean isSuccess() {
            return success;
        }

        public void setSuccess(boolean success) {
            this.success = success;
        }

        public Object getData() {
            return data;
        }

        public void setData(Object data) {
            this.data = data;
        }

        public static class ResultBuilder {
            /**
             * 响应码
             */
            private String code;
            /**
             * 响应提示
             */
            private String message;
            /**
             * 请求是否成功
             */
            private boolean success;
            /**
             * 响应数据
             */
            private Object data;

            public static ResultBuilder newInstance(){
                return new ResultBuilder();
            }
            // Instance的包装，如果不符合需求，再newInstance进行链式调用
            public static ResultBuilder newSuccessInstance(){
                return new ResultBuilder().success(true)
                    .message(XXError.SUCCESS.message)
                    .code(XXError.SUCCESS.code);
            }

            public static ResultBuilder newErrorInstance(){
                return new ResultBuilder().success(false);
            }

            public static ResultBuilder newErrorInstance(XXError error){
                return new ResultBuilder().success(false)
                    .message(error.message)
                    .code(error.code);
            }

            public static ResultBuilder newErrorInstance(String code, String msg){
                return new ResultBuilder().success(false)
                    .message(msg)
                    .code(code);
            }

            public ResultBuilder code(String code){
                this.code = code;
                return this;
            }

            public ResultBuilder message(String message){
                this.message = message;
                return this;
            }

            public ResultBuilder success(Boolean success){
                this.success = success;
                return this;
            }

            public ResultBuilder data(Object data){
                this.data = data;
                return this;
            }
            // 最后build的时候返回WebResult对象
            public WebResult build(){
                return new WebResult(this);
            }
        }

        @Override
        public String toString() {
            return JSON.toJSONString(this);
        }
    }

使用的时候

    return WebResult.ResultBuilder
                .newErrorInstance()
                .message(e.getMessage())
                .build();

匿名内部类

在做Swing编程中，我们经常使用这种方式来绑定事件。

    button.addActionListener(  
       new ActionListener(){  
             public void actionPerformed(ActionEvent e) {  
                 System.out.println("你按了按钮");  
             }  
       }
    );

1.事件必须要用到继承2.事件必须能访问到Swing。所以必须把事件写成内部类。