JavaSE----11.Java 内部类

11.Java 内部类

1、内部类

  • 可以将一个类的定义放在里另一个类的内部,这就是内部类。
  • 内部类分为四种:
    • 成员内部类
    • 静态内部类
    • 局部内部类
    • 匿名内部类
  • 案例:
    //我是一个外部类(外部是相对内部而言)

    public class Outer{

        //我是一个内部类
        
        class Inner{
            
        }
    }

2、成员内部类

    /**
    * 外部类、成员内部类的定义
    */
    public class Outer {

        private int outerVariable = 1;
        private int commonVariable = 2;
        private static int outerStaticVariable = 3;

        /**
        * 成员方法
        */
        public void outerMethod() {
            System.out.println("我是外部类的outerMethod方法");
        }

        /**
        * 静态方法
        */
        public static void outerStaticMethod() {
            System.out.println("我是外部类的outerStaticMethod静态方法");
        }

        /**
        * 成员内部类
        */
        public class Inner {

            private int commonVariable = 20;

            /**
            * 构造方法
            */
            public Inner() {
            }

            /**
            * 成员方法,访问外部类信息(属性、方法)
            */
            public void innerShow() {
                //当和外部类冲突时,直接引用属性名,是内部类的成员属性
                System.out.println("内部的commonVariable:" + commonVariable);
                //内部类访问外部属性
                System.out.println("outerVariable:" + outerVariable);
                //当和外部类属性名重叠时,可通过外部类名.this.属性名
                System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
                System.out.println("outerStaticVariable:" + outerStaticVariable);
                //访问外部类的方法
                outerMethod();
                outerStaticMethod();
            }
        }

        /**
        *	外部类访问内部类信息
        */
        public void outerShow() {
            Inner inner = new Inner();
            inner.innerShow();
        }

    }
    /**
    * 其他类使用成员内部类
    */
    public class Other {
        
        public static void main(String[] args) {
            //外部类对象
            Outer outer = new Outer();
            //创造内部类对象
            Outer.Inner inner = outer.new Inner();
            inner.innerShow();
        }
    }

3、静态内部类

    /**
    * 外部类、静态内部类定义
    */
    public class Outer {

        private int outerVariable = 1;

        /**
        * 外部类定义的属性(重名)
        */
        private int commonVariable = 2;

        private static int outerStaticVariable = 3;

        static {
            System.out.println("Outer的静态块被执行了……");
        }

        /**
        * 成员方法
        */
        public void outerMothod() {
            System.out.println("我是外部类的outerMethod方法");
        }

        /*
        *	静态方法
        */
        public static void outerStaticMethod() {
            System.out.println("我是外部类的outerStaticMethod静态方法");
        }


        /**
        * 静态内部类
        */
        public static class Inner {
            /**
            * 成员信息
            */
            private int innerVariable = 10;
            private int commonVariable = 20;

            static {
                System.out.println("Outer.Inner的静态块执行了……");
            }

            private static int innerStaticVariable = 30;

            /**
            * 成员方法
            */
            public void innerShow() {
                System.out.println("innerVariable:" + innerVariable);
                System.out.println("内部的commonVariable:" + commonVariable);
                System.out.println("outerStaticVariable:"+outerStaticVariable);
                outerStaticMethod();
            }

            /**
            * 静态方法
            */
            public static void innerStaticShow() {
                //被调用时会先加载Outer类
                outerStaticMethod();
                System.out.println("outerStaticVariable"+outerStaticVariable);
            }
        }

        /**
        * 外部类的内部如何和内部类打交道
        */
        public static void callInner() {
            System.out.println(Inner.innerStaticVariable);
            Inner.innerStaticShow();
        }
    }
    public class Other {

        public static void main(String[] args) {
            //访问静态内部类的静态方法,Inner类被加载,此时外部类未被加载,独立存在,不依赖于外围类。
            Outer.Inner.innerStaticShow();
            //访问静态内部类的成员方法
            Outer.Inner oi = new Outer.Inner();
            oi.innerShow();
        }
    }

4、局部内部类

    /**
    *	外部类、局部内部类
    */
    public class Outer {

        private int outerVariable = 1;
        private int commonVariable = 2;

        private static int outerStaticVariable = 3;

        public void outerMethod() {
            System.out.println("我是外部类的outerMethod方法");
        }

        /**
        * 静态外部方法
        */
        public static void outerStaticMethod() {
            System.out.println("我是外部类的outerStaticMethod静态方法");
        }

        /**
        * 成员方法,内部定义局部内部类
        */
        public void outerCreatMethod(int value) {

            boolean sex = false;

            /**
            * 局部内部类,类前不能有访问修饰符
            */
            class Inner {

                private int innerVariable = 10;
                private int commonVariable = 20;
                /**
                *	局部内部类方法
                */
                public void innerShow() {
                    System.out.println("innerVariable:" + innerVariable);
                    //局部变量
                    System.out.println("是否男性:" + sex);
                    System.out.println("参数value:" + value);
                    //调用外部类的信息
                    System.out.println("outerVariable:" + outerVariable);
                    System.out.println("内部的commonVariable:" + commonVariable);
                    System.out.println("外部的commonVariable:" + Outer.this.commonVariable);
                    System.out.println("outerStaticVariable:" + outerStaticVariable);
                    outerMethod();
                    outerStaticMethod();
                }
            }

            //局部内部类只能在方法内使用
            Inner inner = new Inner();
            inner.innerShow();
        }

        /**
        * 程序的入口
        */
        public static void main(String[] args) {
            Outer outer = new Outer();
            outer.outerCreatMethod(100);
        }
    }

5、匿名内部类

    //定义接口

    public interface IAnimal{
        void speak();
    }
    /**
    *	外部内、匿名内部类
    */
    public class Outer {
        
        public static void main(String[] args){
            //调用的speak()是重写后的speak方法。
            Outer.getInnerInstance("小狗汪汪汪!").speak();
        }
        
        public static IAnimal getInnerInstance(String speak){
            return new IAnimal(){
                @Override
                public void speak(){
                    System.out.println(speak);
                }};
        }
    }

原文地址:https://www.cnblogs.com/zhangliuping/p/11887853.html